java基础详谈

骑猪看日落 2022-05-09 15:22 194阅读 0赞

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 比较合适  
\}  
\}