Java基础知识总结~持续学习中

 

 

JVM

 

W3C JAVA教程

JAVA考古学

 

String tmpImgPath = ProPertiesUtil.getValue("/abc.properties", "tmp_img_path");  
String path = ServletActionContext.getServletContext().getRealPath(tmpImgPath);  
imgFilePath = path + File.separator + fileName;// 新生成的图片 

 

BigDecimal discountAmount = new BigDecimal(vou.getStringValue("nAmount"));


相减：
totalAmount = totalAmount.subtract(new BigDecimal(vou.getStringValue("nAmount")));


相加：
tmpTotalAmount = shoppingCartAmount.add(new BigDecimal("10"));


相乘后保留2位小数：
BigDecimal mallPriceDecimal = new BigDecimal(NumUtil.doubleOutPut(nMallPrice * cdoGood.getIntegerValue("lNum"), 2));

public static  String  doubleOutPut(double  v,Integer num){
	if ( v == Double.valueOf(v).intValue()){
		return  Double.valueOf(v).intValue() +  "" ;
	}else {
		BigDecimal b =  new  BigDecimal(Double.toString(v));
		return  b.setScale(num,BigDecimal.ROUND_HALF_UP ).toString();
	}
}

比较大小：

BigDecimal tmpTotalAmount = shoppingCartAmount;
//与商品未使用任何优惠时金额比较
if(tmpTotalAmount.compareTo(currentAvailableAmount) > 0){
	//需支付剩余金额
	totalAmount = tmpTotalAmount.subtract(currentAvailableAmount);
	discountAmount = currentAvailableAmount;
}else if(tmpTotalAmount.compareTo(currentAvailableAmount) == 0){
	//支付金额为0
	totalAmount = tmpTotalAmount.subtract(currentAvailableAmount);
	discountAmount = currentAvailableAmount;
}else{
	//支付金额为0
	//支付后购物卡还剩余
	totalAmount = new BigDecimal("0.00");
	discountAmount = tmpTotalAmount;
}

 

public static int getRandom(int num) {
		return (int) Math.round(Math.random() * num);
	}

 

encrypt = encrypt.replaceAll("\\s|\\r|\\n|\\t", "");


public class StringUtils {
 
    public static String replaceBlank(String str) {
        String dest = "";
        if (str!=null) {
            Pattern p = Pattern.compile("\\s*|\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }
        return dest;
    }
    public static void main(String[] args) {
        System.out.println(StringUtils.replaceBlank("just do it!"));
    }
    /*-----------------------------------
 
    笨方法：String s = "你要去除的字符串";
 
            1.去除空格：s = s.replace('\\s','');
 
            2.去除回车：s = s.replace('\n','');
 
    这样也可以把空格和回车去掉，其他也可以照这样做。
 
    注：\n 回车(\u000a) 
    \t 水平制表符(\u0009) 
    \s 空格(\u0008) 
    \r 换行(\u000d)*/
}

 

 

 

StringBuffer 和StringBuilder中的两个函数：

//int indexOf(String str) ：返回当前StringBuffer对象中，第一个满足str子串的位置。
//int indexOf(String str, int fromIndex) ：从fromIndex开始查找，返回第一个满足str子串的位置。
		
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
System.out.println("sb.indexOf(\"is\") = " + sb.indexOf("is"));  //2
System.out.println("sb.indexOf(\"is\", 4) = " + sb.indexOf("is", 4));   //5
System.out.println("sb.indexOf(\"is\", 4) = " + sb.indexOf("is", 7));   // -1
        
//StringBuffer insert(int offset, String str)
//在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。  
      
StringBuffer sf = new StringBuffer("..{..}) public class MySrvRequest {");
int classIdx = sf.indexOf("public class ");
if(classIdx > 0){
      sf.insert(sf.indexOf("{", classIdx), " implements java.io.Serializable");
}
System.out.println(sf.toString());
//..{..}) public class MySrvRequest  implements java.io.Serializable{

 

 

 2.保留2位小数：

 

import java.text.DecimalFormat;
DecimalFormat df=new DecimalFormat("0.00");
Double x = 83.3333333333;
x=Double.parseDouble(df.format(x)); 

 3.group by 和 order by

 

ORDER BY 用于对数据按指定的列和方法排序。

select * from syscolumns order by id asc, colorder desc;
指示查询出的结果 按 id 正序排列， colOrder 逆序排列。

GROUP BY 用于汇总统计。 HAVING 用途和 WHERE类似，但用于对 GROUP BY 的结果进行过滤。
select id, count(id) from syscolumns group by id;
这条语句以 id 进行汇总，统计出每个不同的 id 出现的个数。

select id, count(id) from syscolumns group by id having count(1) > 10;
这条语句以 id 进行汇总，统计出每个不同的 id 出现的个数，但 having 后的条件指定了只显示 count(id) 大于 10 的数据。。

先Group by ，后 Order by

 4.日期

获取当前时间：

1.
SimpleDateFormat tempDate = new SimpleDateFormat("yyyy-MM-dd" + " " + "hh:mm:ss");
String datetime = tempDate.format(new java.util.Date());

2.
Calendar now=Calendar.getInstance();
String time=now.get(Calendar.YEAR)+"-"+(now.get(Calendar.MONTH)+1)+"-"+now.get(Calendar.DAY_OF_MONTH)+" "+now.get(Calendar.HOUR_OF_DAY)+":"+now.get(Calendar.MINUTE)+":"+now.get(Calendar.SECOND);
 

3.Date curDate= new Date(System.currentTimeMillis());

SimpleDateFormat format = new  SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ); //24小时制
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//12小时制

  a.获取年、月、日：

String year=String.valueOf(c.get(Calendar.YEAR));
String month=String.valueOf(c.get(Calendar.MONTH)+1);			
String day=String.valueOf(c.get(Calendar.DAY_OF_MONTH));

 

b.Calendar和Date的转化

(1) Calendar转化为Date

Calendar cal=Calendar.getInstance();
Date date=cal.getTime(); 

 
(2) Date转化为Calendar

Date date=new Date();
Calendar cal=Calendar.getInstance();
cal.setTime(date); 

 

 

c.计算一年中的第几星期

(1)计算某一天是一年中的第几星期

Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.MONTH,1);
cal.set(Calendar.DAY_OF_MONTH, 3);
int weekno=cal.get(Calendar.WEEK_OF_YEAR);

 

(2)计算一年中的第几星期是几号

SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal=Calendar.getInstance();
cal.set(Calendar.YEAR, 2006);
cal.set(Calendar.WEEK_OF_YEAR, 1);
cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
System.out.println(df.format(cal.getTime()));
输出:
2006-01-02 

 d:

 

  1天内（注意为add ）：

Calendar c=Calendar.getInstance();	 		
c.add(Calendar.DAY_OF_MONTH, -1);  //得到前一天的时间
startDateStr=sf.format(c.getTime());

endDateStr=sf.format(java.util.Calendar.getInstance().getTime()); 推荐使用这种方法获取当前时间，不推荐使用new Date()

  3天内：

Calendar c=Calendar.getInstance();	 		
c.add(Calendar.DAY_OF_MONTH, -3);  //得到前3天的时间
startDateStr=sf.format(c.getTime());

  近1月：

Calendar c=Calendar.getInstance();
c.add(Calendar.MONTH, -1);
startDateStr=sf.format(c.getTime());		

 到当前时间的前几年的时间：

 Calendar   c   =   Calendar.getInstance();   
  c.add(Calendar.YEAR, -5);//得到前5年  
  SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  String mDateTime=formatter.format(c.getTime());  
  String strStart=mDateTime.substring(0, 16);//2002-10-24 09:30 

 

 

本月（注意为set ）：

Calendar c=Calendar.getInstance();
c.set(Calendar.DATE,1); //把日期设为当月第一天		 	    
startDateStr=sf.format(c.getTime());		

 上月：

 

Calendar c2=Calendar.getInstance();
 c2.add(Calendar.MONTH,-1);
 c2.set(Calendar.DATE,1);	 	    
 startDateStr=sf.format(c2.getTime());

 

判断是否是月末最后一天

public static boolean isMonthEnd(Date date) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(date);
    return calendar.get(Calendar.DATE) == calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
}

// int	getActualMaximum(int field) 
//          给定此 Calendar 的时间值，返回指定日历字段可能拥有的最大值。
// int	getActualMinimum(int field) 
//          给定此 Calendar 的时间值，返回指定日历字段可能拥有的最小值。

 

判断是否是当月第一天

public boolean isFirstDay(){
	Calendar c = Calendar.getInstance();
	int today = c.get(c.DAY_OF_MONTH);
	return today == 1;
}

 

//2018-04-14
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar cal2=Calendar.getInstance();  
		cal2.set(Calendar.YEAR, 2018);  
		cal2.set(Calendar.MONTH,03);  
		cal2.set(Calendar.DAY_OF_MONTH, 14);  
		String curMonday1 = sdf.format(cal2.getTime());
		System.out.println(curMonday1);
		
		//当周周一 2018-04-09
		cal2.set(cal2.DAY_OF_WEEK, cal2.MONDAY);
		String curMonday2 = sdf.format(cal2.getTime());
		System.out.println(curMonday2);
		
		
		//上周周日 2018-04-08
		//Calendar cal2 = Calendar.getInstance();
		//cal2.set(cal2.DAY_OF_WEEK, cal2.MONDAY);
		cal2.add(cal2.DAY_OF_MONTH, -1);
		String curMonday3 = sdf.format(cal2.getTime());
		System.out.println(curMonday3);
		
		//上周周一 2018-04-02
		cal2.add(cal2.DAY_OF_MONTH, -6);		
		String curMonday4 = sdf.format(cal2.getTime());
		System.out.println(curMonday4);

 

 

5.文本域input的不可编辑属性 disabled 和  readonly  区别

 

都可以实现都可以实现input的不可编辑，但有区别...


disable 属性 -- 表示已经失效的输入域

readonly 属性 -- 表示只读(只能看到,不能修改)的输入域(框)

 

<input type="checkbox" value="2"  name="fav" disabled="disabled" />

<input type="text"  name="notinput" readonly="readonly" /> 

 

   /**是否闰年  
    */  
  public boolean isLeapYear(int year) {
      return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);     }

 具体日期操作：

http://www.360doc.com/content/09/0820/17/236102_5085810.shtml

可将选中的代码拖动到QQ聊天窗口中复制

6.File协议

　　 表示本地文件传输协议，File协议主要用于访问本地计算机中的文件 ，就如同在Windows资源管理器中打开文件一样。
　　 应用：要使用File协议，基本的格式如下：file:///文件路径，比如要打开F:盘flash文件夹中的1.swf文件，那么可以在资源管理器或IE地址栏中键入：file:///f:/flash/1.swf并回车。

3个斜杠代表本地

 

9.什么时候用Thread.getContextClassLoader()

     需要动态加载很多类和资源的时候 .

       通常当你需要动态加载资源的时候 , 你至少有三个 ClassLoader 可以选择 :

²        系统类加载器或叫作应用类加载器 (system classloader or application classloader)

²        当前类加载器

²        当前线程类加载器

 

10.instanceof 运算符
指出对象是否是特定类的一个实例。

String s = "I AM an Object!";
boolean isObject = s instanceof Object;

public double calculate(Bill bill) {
　　if (bill instanceof PhoneBill) {
　　//计算电话账单
　　}
}

 11、java环境配置(都放下面)：

CLASSPATH   .;%JAVA_HOME%\lib

JAVA_HOME   C:\Program Files\Java\jdk1.6.0_22

Path  .;%JAVA_HOME%\bin

 

 

13.JDK1.5的新特性

“JDK1.5”（开发代号猛虎）的一个重要主题就是通过新增一些特性来简化开发 ，这些特性包括泛型，for-each循环，自动装包/拆包，枚举，可变参数,　静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。

自动装包/拆包

自动装包/拆包大大方便了基本类型数据和它们包装类地使用。
自动装包：基本类型自动转为包装类.(int　>>　Integer)
自动拆包：包装类自动转为基本类型.(Integer　>>　int)
在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类。

 

这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.

int　a　=　3;
Collection　c　=　new　ArrayList();
c.add(a);//自动转换成Integer.

Integer　b　=　new　Integer(2);
c.add(b　+　2);

 枚举：

public　enum　Color
{
　　　Red,
　　　White,
　　　Blue
}

 然后可以这样来使用Color　myColor　=　Color.Red.
枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如

for　(Color　c　:　Color.values())
　　　System.out.println(c);

带构造函数的枚举：

public enum Color {

	RED("红色"),BLUE("蓝色"),GREEN("绿色");
	
	private final String name;

	public  String getName() {
		return name;
	}
	private Color(String name){
		this.name=name;
	}
}

 

System.out.println("Color.RED.name():"+Color.RED.name());         //RED
System.out.println("Color.RED.toString():"+Color.RED.toString()); //RED
System.out.println(Color.RED.getName());    //红色

 Color.RED.name()

 Color.RED.toString(); 得到的都是RED

1、Color枚举类是特殊的class，其枚举值(RED,BLUE...)是Color的类对象(类实例)：Color c=Color.RED ;
而且这些枚举值都是public static final的，也就是我们经常所定义的常量，因此枚举类中的枚举值最好全部大写 。
2、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域。但是，枚举类的构造器有很大的不同：
(1) 构造函数只是在构造枚举值的时候被调用。
(2) 枚举构造函数只能私有private ，绝对不允许有public构造器。这样可以保证外部代码无法新构造枚举类的实例。因为我们知道枚举值是public static final的常量而已 但枚举类的方法和数据域可以允许外部访问。

 

/**
 * 
 * 服务器类型
 * 
 */
public enum ServerType {
	
	JBoss("server/default/deploy","client,common"), WebLogic("",""), GlassFish("","");
	
	private String deployPath;
	
	private String libClassPath;
	
	private ServerType(String deployPath, String libClassPath){
		this.deployPath = deployPath;
		this.libClassPath = libClassPath;
	}
	
	public String getDeployPath(){
		return this.deployPath;
	}
	
	public String getLibClassPath(){
		return this.libClassPath;
	}
}

 ServerType serverType = ServerType.JBoss;

String deployPath = serverType.getDeployPath();
String libClassPath = serverType.getLibClassPath();

 

enum 的语法结构尽管和 class 的语法不一样，但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。

可以把 enum 看成是一个普通的 class，它们都可以定义一些属性和方法，不同之处是：enum 不能使用 extends 关键字继承其他类，因为 enum 已经继承了 java.lang.Enum（java是单一继承）。

 

可变参数：

当不能确定一个方法的入口参数的个数时，以往版本的Java中，通常的做法是将多个参数放在一个数组或者对象集合中作为参数来传递，1.5版本以前的写法是：

int sum(Integer[] numbers)　　
{　　
　　int nSum = 0;　　
　　for(int i: numbers)　　
　　nSum += i;　　
　　return nSum;　　
}

 在别处调用该方法　　
sum(new Integer[] {12,13,20});

 

而在1.5版本中可以写为：

	public static int sum(Integer... number){
		int nSum=0;
		for(int i : number){
			nSum+=i;
		}		
		return nSum;		
	}

 在别处调用该方法

		System.out.println("sum():"+sum(12,13,14));
		System.out.println("sum():"+sum(12,13));

静态导入：

要使用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
不过，过度使用这个特性也会一定程度上降低代码地可读性。

import　static　java.lang.Math.*;
…….
r　=　sin(PI　*　2);　//无需再写r　=　Math.sin(Math.PI);

 

14.o1.CompareTo(o2);

整形间比较会返回1、-1、0

如：

	public static void main(String[] args) {
		//Integer num1;
		//num1 = new Integer("24");
		//Integer num2;
		//num2 = new Integer("34");
		Integer num2=12; //不可使用 int num2=12;因compareTo(T t)中的T是类，所以必须用包装类
		Integer num1=11;
		System.out.println(num2.compareTo(num1));
//1 		System.out.println("------------------");
		System.out.println(num1.compareTo(num2));
//-1	}

 字符串间比较：

 

       "abcd" .compareTo( "adef" )== -2

       "abc" .compareTo( "abcdef" )== -3

       "abc" .compareTo( "abc" ) == 0

 

简单 字符串的排序 。（例如使用 compareTo 进行姓名的排序）

 

//需要进行排序的字符串
String[] array = new String[] { "lilei", "libai", "james", "poly",
				"wobfei" };
//使用简单的循环排序
		for (int i = 0; i < array.length ; i++) {
			for (int j = i + 1; j < array.length-1; j++) {
				if (array[i].compareTo(array[j]) > 0) {
					String temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}

   

使用上面针对 String 的排序以后，字符串的内容将会是：

james  libai  lilei  poly  wobfei

该例子来源(稍作了修改)：http://wobfei.iteye.com/blog/743123

 

15.编码习惯

add、saveAdd

edit、saveEdit

 

16、Math.round();

 

Math.round(m) = (int)Math.floor(a + 0.5f)

Math.ceil(x):比x大的最小值。
Math.round(x)：四舍五入。
Math.floor(x):比x小的最大值。

 

jdk说得很明白了，
-11.5+0.5=-11   Math.floor(-11)=-11
-11.3+0.5=-10.8   Math.floor(-10.8)=   -11
-11.8+0.5=-11.3   Math.floor(-11.3)=   -12

 

 

17、重写

关于重写，遵循以下的规则：

（1）重写方法必须和被重写方法具有相同的参数列表， 返回类型必须和被重写方法的返回类型相同或者是返回类型的子类型 。

（2）重写方法的访问控制修饰符不能比被重写方法更严格（比如一个在父类中声明为public的方法重写成一个protected的方法）。

 

 

18.

class Test {
	void test(int i) {
		System.out.println("I am an int." + i);
	}

	void test(String s) {
		System.out.println("I am a string.");
	}

	public static void main(String args[]) {
		Test t = new Test();
		char ch = 'y';
		t.test(ch);
	}
	//结果为：I am an int.121
}

 

19.JDBC的主要任务是什么？（三个）

1、建立与数据库的连接。
2、向数据库发起查询请求。
3、处理数据库返回结果。

 

20.TreeSet的构造函数

TreeSet();

TreeSet(Collection c);//构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序 进行排序。

TreeSet(Comparator comparator);//构造一个新的空 TreeSet，它根据指定比较器进行排序。

public class NameComparator implements Comparator<Name>{
    
    public int compare(Name n1,Name n2){
        if(n1.getName().compareTo(n2.getName())>0) return -1;
        if(n1.getName().compareTo(n2.getName())<0) return 1;
        
        return 0;
    }
    
    public static void main(String[] args) {
        Set<Name> set = new TreeSet<Name>(new NameComparator());
        
        Name n1 = new Name("ray");
        Name n2 = new Name("tom");
        Name n3 = new Name("jame");
        set.add(n1);
        set.add(n2);
        set.add(n3);
        
        Iterator it = set.iterator();
        while(it.hasNext()){
            Name s = (Name)it.next();
            System.out.print(s.getName()+",");
        }
        System.out.println("一共有对象："+set.size()+"个");
    }
}//打印结果是：tom,ray,jame,一共有对象：3个

 客户端排序时因为java.util.Comparator<Type>接口提供了具体的排序方式，<Type>指定了被比较对象的类型，Comparator有个compare(Type x,Type y)的方法，用于比较两个对象的大小。

 

21.Object中的hashcode()和equals()

   在Java中任何一个对象都具备equals(Object obj)和hashcode()这两个方法，因为他们是在Object类中定义的。
equals(Object obj)方法用来判断两个对象是否“相同”，如果“相同”则返回true，否则返回false。
hashcode()方法返回一个int数，在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。
    接下来有两个个关于这两个方法的重要规范(我只是抽取了最重要的两个,其实不止两个)：
规范1： 若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该 相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。
规范2： 如果equals(Object obj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。
     根据这两个规范，可以得到如下推论：
1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等 。
2、如果两个对象不equals，他们的hashcode有可能 相等。
3、如果两个对象hashcode相等，他们不一定 equals。
4、如果两个对象hashcode不相等，他们一定不 equals。

 

http://www.iteye.com/topic/800929

 

22.序列化

序列化的对象要实现Serializable接口,
Serializable接口没有需要实现的方法，
implements Serializable只是为了标注该对象是可被序列化的，
然后 使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象 ，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

实现序列化（保存到一个文件）的步骤
a）Make a FileOutputStream            
      FileOutputStream fs = new FileOutputStream("foo.ser");    
b）Make a ObjectOutputStream          
      ObjectOutputStream os =  new ObjectOutputStream(fs);   
c）write the object
     os.writeObject(myObject1);  
     o s.writeObject(myObject2);  
     os.writeObject(myObject3);  
d) close the ObjectOutputStream
     os.close();  

 

 

23、计划任务：

java.util.Timer

timer.schedule(...);

http://www.blogjava.net/georgehill/archive/2005/06/09/5793.aspx

http://www.klstudio.com/post/187.html

 

 

24.Split

在java.lang包中有String.split()方法，返回是一个数组
我在应用中用到一些，给大家总结一下，仅供大家参考：
1、如果用“.”作为分隔的话，必须是如下写法：String.split("\\."),这样才能正确的分隔开，不能用String.split(".");
2、如果用“|”作为分隔的话，必须是如下写法：String.split("\\|"),这样才能正确的分隔开，不能用String.split("|");
“.”和“|”都是转义字符，必须得加"\\";
3、如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“acount=? and uu =? or n=?”,把三个都分隔出来，可以用String.split("and|or");

java转义字符

     \"：双引号 
     \'：单引号 
     \\：反斜线

 

25.作用范围：

this.context.setAttribute(MyConstants.CONTINENTS_KEY, continentlist);
public static final String CONTINENTS_KEY="CONTINENTS";
jsp页面中可以直接使用 CONTINENTS（${CONTINENTS }） ，而无需context.getAttribute("");

 

  <body>
    <% request.setAttribute("name","xiaoming") ;%>    
    <input type="text" value="${name}"/>
  </body>

 

26.数组转为list

List stooges = Arrays.asList("Larry", "Moe", "Curly");  

  此时stooges中有有三个元素。注意：此时的list不能进行add操作，否则会报 “java.lang.UnsupportedOperationException”，Arrays.asList()返回的是List,而且是一个定长的List，所以不能转换为ArrayList，只能转换为AbstractList
 原因在于asList()方法返回的是某个数组的列表形式,返回的列表只是数组的另一个视图,而数组本身并没有消失,对列表的任何操作最终都反映在数组上. 所以不支持remove,add方法的

   String[] arr = {"1", "2"};  
   List list = Arrays.asList(arr);  

 

其他方式：

String[] strArray = new String[] { "aa", "bb" };
		List<String> list = new ArrayList<String>(Arrays.asList(strArray));
		list.add("cc");
		System.out.println(list);

 结果：[aa, bb, cc]

 

27、使用ResourceBundle读取properties文件

有时候有些简单的配置文件可以没必要使用xml，其实ResourceBundle类就已经做的很好的。它甚至可以搜索到classpath里的jar文件中一些properties文件。

例如在jar文件中的根目录放置一个文件：test.properties，然后只要这个jar文件在classpath里。就可以使用这样的语句来获得一些属性：

ResourceBundle rb = ResourceBundle.getBundle("test");
  String s = rb.getString("FirstKey");
  System.out.println(s);

  28、HttpClient学习

public class TestHttpClient {

	public static void main(String[] args) {
		String url = "http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-1.jpg|http://images.gta-travel.com/HH/Images/HX/HKGA/HKGA-REG-2.jpg";
		String[] urlArr = url.split("\\|");
		String fileName = "D:\\httpClient";		
		
		HttpClient client = new HttpClient();      
		GetMethod method = new GetMethod(urlArr[1]);		
			// 使用 GET 方法 ，如果服务器需要通过 HTTPS 连接，那只需要将下面 URL 中的 http 换成 https 
		
		FileOutputStream output = null;
		try {
			client.executeMethod(method);
			File showFile = new File(fileName + ".jpg");			
			
			output = new FileOutputStream(showFile);
			output.write(method.getResponseBody()); //method.getResponseBody()为byte[]类型
			output.flush();
		} catch (HttpException e) {			
		} catch (IOException e) {			
		} finally {			
			if (output != null) {
				try {
					output.close();
					output = null;
				} catch (IOException e) {					
				}
			}
		}
	}
}

 

http://www.blogjava.net/Alpha/archive/2007/01/22/95216.html

 

29、栈、堆

1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.
2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）
3. 堆：存放所有new出来的对象。
4. 静态域 ：存放静态成员（static定义的）
5. 常量池 ：存放字符串常量和基本类型常量（public static final）。
6. 非RAM存储：硬盘等永久存储空间
这里我们主要关心栈，堆和常量池，对于 栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定 ，具有很大的灵活性。
对于字符串：其对象的引用都是存储在栈中的，如果是 编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中 。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

 

7、方法区

方法区在JVM中也是一个非常重要的区域，它与堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

 

在Class文件中除了类的字段、方法、接口等描述信息外，还有一项信息是常量池，用来存储编译期间生成的字面量和符号引用。

 

在方法区中有一个非常重要的部分就是运行时常量池，它是每一个类或接口的常量池的运行时表示形式，在类和接口被加载到JVM后，对应的运行时常量池就被创建出来。当然并非Class文件常量池中的内容才能进入运行时常量池，在运行期间也可将新的常量放入运行时常量池中，比如String的intern方法。

 

在JVM规范中，没有强制要求方法区必须实现垃圾回收。很多人习惯将方法区称为“永久代”，是因为HotSpot虚拟机以永久代来实现方法区，从而JVM的垃圾收集器可以像管理堆区一样管理这部分区域，从而不需要专门为这部分设计垃圾回收机制。不过自从JDK7之后，Hotspot虚拟机便将运行时常量池从永久代移除了。

 

JVM的内存区域划分

深入理解JVM之JVM内存区域与内存分配

 

 

 

new String("China");
对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。

 

对于成员变量和局部变量：成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。
形式参数是局部变量，局部变量的数据存在于栈内存中 。栈内存中的局部变量随着方法的消失而消失。
成员变量存储在堆中的对象里面 ，由垃圾回收器负责回收

http://www.iteye.com/topic/634530

 

===============================================================================

浅析java内存模型--JMM(Java Memory Model)

 Java运行时数据区分为下面几个内存区域：

 

1.PC寄存器/程序计数器：

 

　　严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。

 

2.Java栈 Java Stack：

 

　　Java栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的Java栈，在这个Java栈中又会包含多个栈帧(Stack Frame)，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。

 

　　由于Java栈是与线程对应起来的，Java栈数据不是线程共有的，所以不需要关心其数据一致性，也不会存在同步锁的问题。

 

　　在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机可以动态扩展，如果扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常。在Hot Spot虚拟机中，可以使用-Xss参数来设置栈的大小。栈的大小直接决定了函数调用的可达深度。

 

3.堆 Heap:

 

　　堆是JVM所管理的内存中国最大的一块，是被所有Java线程锁共享的，不是线程安全的，在JVM启动时创建。堆是存储Java对象的地方，这一点Java虚拟机规范中描述是：所有的对象实例以及数组都要在堆上分配。Java堆是GC管理的主要区域，从内存回收的角度来看，由于现在GC基本都采用分代收集算法，所以Java堆还可以细分为：新生代和老年代；新生代再细致一点有Eden空间、From Survivor空间、To Survivor空间等。

 

4.方法区Method Area:

 

　　方法区存放了要加载的类的信息（名称、修饰符等）、类中的静态常量、类中定义为final类型的常量、类中的Field信息、类中的方法信息，当在程序中通过Class对象的getName.isInterface等方法来获取信息时，这些数据都来源于方法区。方法区是被Java线程锁共享的，不像Java堆中其他部分一样会频繁被GC回收，它存储的信息相对比较稳定，在一定条件下会被GC，当方法区要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息。方法区也是堆中的一部分，就是我们通常所说的Java堆中的永久区 Permanet Generation，大小可以通过参数来设置,可以通过-XX:PermSize指定初始值，-XX:MaxPermSize指定最大值。

 

5.常量池Constant Pool:

 

　　常量池本身是方法区中的一个数据结构。常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定，并保存在已编译的.class文件中。一般分为两类：字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候，根据方法名找到方法的引用，并以此定为到函数体进行函数代码的执行。引用量包含：类和接口的权限定名、字段的名称和描述符，方法的名称和描述符。

 

6.本地方法栈Native Method Stack:

 

　　本地方法栈和Java栈所发挥的作用非常相似，区别不过是Java栈为JVM执行Java方法服务，而本地方法栈为JVM执行Native方法服务。本地方法栈也会抛出StackOverflowError和OutOfMemoryError异常。

===============================================================================

 Java 内存模型

浅析java内存模型--JMM(Java Memory Model)

全面理解JAVA内存模型

2.1 Java 内存模型的基本原理

Java 内存模型，由于 Java 被设计为跨平台的语言，在内存管理上，显然也要有一个统一的 模型。系统存在一个主内存 (Main Memory) ， Java 中所有变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存 (Working Memory) ，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。

因为当线程处于不同的cpu中时，它各自的变量保存在各自cpu的寄存器或者高速缓存中，这样回事的变量对于其它线程暂时不可见。

 

2.2 Volatile 的内存工作原理

Volatile 是保证多个线程之间变量可见性的，也就是说一个线程对变量进行了写操作，另外一个线程能够获取它最新的值。

它的工作原理是，它对写和读都是直接操作工作主存的。（这个可以通过操作字节码看到）

 

2.3 Synchronized 的内存操作模型 :

Synchronized, 有两层语义，一个是互斥，一个是可见性。在可见性上面，它的工作原理有点不同：当线程进入同步块时，会从主存里面获取最新值，然后当线程离开同步块时，再把变量的值更新到主存。

http://tomyz0223.iteye.com/blog/1001778

评论

3 楼 springdata_springmvc 2015-07-29  

java程序语言学习教程 地址http://www.zuidaima.com/

2 楼 dk05408 2015-01-21  

1 楼 daAoBaMapigu 2015-01-13  

[/color][color=red]