java基础
public static void main(String[] args) {
Integer integer=new Integer(123);
Integer integer2=new Integer(123);
System.out.println(integerinteger2);
Integer integer1=Integer.valueOf(123);
Integer integer3=Integer.valueOf(123);
System.out.println(integer1integer3);
System.out.println(integer==integer1);
/**
* Integer.valueOf()方法实现比较简单,判断缓冲池中是否存在Integer对象,有就直接返回一个。
* public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
/
/
* java1.8中缓冲池的默认大小为-128~127之间。
* 测试下:
/
/*
* static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
*/
Integer newIn=new Integer(555);
System.out.println(newIn);
/**
* 发现缓冲池的大小是可以改变的。
*/
/*
* 编译器在自动装箱的时候重新创建new对象 与某些大牛写的好像不一样哎
*/
Integer m=456;
Integer n=456;
System.out.println("这"+(m==n));//输出false
/**
* 基本类型对应的缓冲池如下:
boolean values true and false
all byte values 所有字节值
short values between -128 and 127
int values between -128 and 127
char in the range \u0000 to \u007F
在使用这些基本类型对应的包装类型时,就可以直接使用缓冲池中的对象。
*/
}
public static void main(String[] args) {
/**
* Java 的参数是以值传递的形式传入方法中,而不是引用传递。
*/
/*
* float 与 double
*/
/*
* Java 不能隐式执行向下转型,因为这会使得精度降低。
*/
//float x=1.1;
//这回报错的,1.1是double类型,不可以隐式的向下转型
float x=1.1f;//这样就对了
//int 与 short
short s1=1;
//s1=s1+1;//同上
//但是使用 += 或者 ++ 运算符可以执行隐式类型转换。相当于 s1=(short) s1+1
s1+=1;
s1++;
}
public static void main(String[] args) {
/*
* String 字符串不可变 线程安全
* StringBuffer and StringBuilder 可变
* StringBuffer线程安全,内部使用synchronized进行同步
* StringBuilder不安全但是StringBuilder效率高
*/
}
public static void main(String[] args) {
//String被声明为final不可继承。内部使用char数组,数组也是final修饰,意味着初始化后不可引入其他数组,并且没有改变value
//的方法,因此String 不可变。
/*
* 源代码:
* public final class String
implements java.io.Serializable, Comparable, CharSequence {
该值用于字符存储。
private final char value[];
*/
/*
* String 不可变的好处。
*1存储hash值:作为hashmap的键不可变。
*2 String pool(字符串常亮池) 的需要,如果有就直接使用,因为不可变
*3安全性。 网络传输时候,如果字符串可变,那么得到的就不一定是真实值。
*4 线程安全。
*/
}
public static void main(String[] args) {
/*
* 字符串常量池(String Pool)保存着所有字符串字面量(literal strings),这些字面量在编译时期就确定。
* 不仅这样,还可以使用String 的interm方法将字符串添加到StringPool中
* 当一个字符串调用 intern() 方法时,如果 String Pool 中已经存在一个字符串和该字符串值相等(使用 equals() 方法进行确定),
* 那么就会返回 String Pool 中字符串的引用;否则,就会在 String Pool 中添加一个新的字符串,并返回这个新字符串的引用。
/
/
* 下面示例中,s1 和 s2 采用 new String() 的方式新建了两个不同字符串,而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
* intern() 首先把 s1 引用的字符串放到 String Pool 中,然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。
/
“abc”.intern();
“bcd”.intern();
String s6=new String(“abc”);
System.out.println(s6.equals(“abc”));
System.out.println(s6==“abc”);
String s1 = new String(“aaa”);
String s2 = new String(“aaa”);
System.out.println(s1 == s2); // false
String s3 = s1.intern();
String s4 = s1.intern();
System.out.println(s3 == s4); // true
/
* String aaa=“ss”;
* 这种方式直接放到常量池中
/
/*
* 在 Java 7 之前,String Pool 被放在运行时常量池中,它属于永久代。
* 而在 Java 7,String Pool 被移到堆中。这是因为永久代的空间有限,
* 在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
/
new String(“adf”);
/*
* 使用这种方式一共会创建两个字符串对象(前提是 String Pool 中还没有 “adf” 字符串对象)。
“adf” 属于字符串字面量,因此编译时期会在 String Pool 中创建一个字符串对象,指向这个 “adf” 字符串字面量;
而使用 new 的方式会在堆中创建一个字符串对象。
*/
}
public static void main(String[] args) {
//java7 开始 switch 判断语句可以使用String
//switch 不支持 long,是因为 switch 的设计初衷是对那些只有少数的几个值进行等值判断,
//如果值过于复杂,那么还是用 if 比较合适
}
}