Locale(zh_CN, en_US,…)
语言，zh，en等

国家/地区，CN，US等

其他变量(variant)(几乎不用)

Locale方法

getAvailableLocales()返回所有的可用Locale(即语言国家)
gctDefault()返回默认的Locale（本jdk的语言）

常量:一种不会修改的变量

Java没有constant关键字

不能修改，final

不会修改/只读/只要一份，static

方便访问public

Java中的常量

public static final
建议变量名字全大写，以连字符相连，如UPPER_BOUND

Java为很多基本类型的包装类/字符串都建立常量池

常量池:相同的值只存储一份，节省内存，

共享访问基本类型的包装类

Boolean，Byte，Short，Integer，Long，Character，Float，Double

  • Boolean: true, false
  • Byte : -128~127，Character : 0~127
  • Short, Int, Long: -128~127
  • Float，Double:没有缓存(常量池)

Java为常量字符串都建立常量池缓存机制

public class StringConstantTest {
	public static void main(String[]args) {
	String s1 = "abc";
	String s2 = "abc";
	String s3 = "ab" + "c";
 	//都是常量，编译器将优化，下同String s4 = "a" +"b" + "c";
	System.out.print1n(s1 == s2);//true
	System.out.print1n(s1 == s3);//true
	System.out.print1n(s1 == s4);//true
	}
}
//s1，s2...大家都指向同一块内存空间（”abc“）

基本类型的包装类和字符串有两种创建方式

常量式(字面量)赋值创建，放在栈内存(将被常量化)

  • Integer a = 10;
  • String b=“abc”;

new对象进行创建，放在堆内存(不会常量化)---new的对象会调用构造函数

  • Integer c = new Integer(10);
  • String d = new String(“abc”);
    //这两种创建方式导致创建的对象存放的位置不同（虽然都在堆内存）

栈读取速度快容量小，堆读取速度慢容量大

public class BoxClassTest {
	public static void main(String[]args){
	int i1 = 10;//常规变量
    Integer i2 = 10;//自动装箱,i2是Integer类对象，常量池，在栈内存
    System.out.print1n(i1 == i2);//true
    //自动拆箱  基本类型和包装类进行比较，包装类自动拆箱
    Integer i3 = new Integer(10);
    system.out.print1n(i1 == i3); //true
    //自动拆箱基本类型和包装类进行比较，包装类自动拆箱
        
    system.out.print1n(i2 == i3);//false
    //两个对象比较，比较其地址。
    //i2是常量，放在栈内存常量池中，i3是new出对象，放在堆内存中
        
    Integer i4 = new Integer(5);
    Integer i5 = new Integer(5);
    system.out.print1n(i1 =(i4+i5));//true
    system.out.print1n(i2 ==(i4+i5));//true
    system.out.print1n(i3 ==(i4+i5)); //true，i3与常量值比较，自动拆箱
   //i4和i5是两个(包装类Integer)对象。i4+i5将会自动拆箱,变换为两个int的加法，即5+5，所以i4+i5的结果为10，是int类型，不是Integer的对象。
	Integer i6 = i4 + i5; //+操作使得i4,i5自动拆箱，得到10，因此i6 == i2
        //i6是常量赋值的对象，在常量池
    System.out.print1n(i1 == i6);//true
	System.out.print1n(i2 == i6);//true
        //上述2者都是常量比较
    System.out.print1n(i3 == i6);//false
        //i3是堆内存的对像，i6是常量池的常量，地址不一样

}

-基本类型和包装类比较，将对包装类自动拆箱

对象比较，比较地址

加法+会自动拆箱

分析String类

常量赋值(堆内存)和new创建(栈内存)不是同一个对象

编译器只会优化确定的字符串，并缓存

public class stringNewTest {
    public static void main(String[] args) {
    string s1 = "abcdef";
    string s1 = "abc";
    string s2 = "abc";
    String s3 = new String( "abc" );
    String s4 = new String( "abc" );
    System.out.println(s1 == s2); //true常量池
    System.out.print1n(s1 == s3); //false一个栈内存，一个堆内存
    System.out.print1n(s3 == s4); //false两个都是堆内存
    System.out.print1n("============");
    String s5 = s1 + "def";//涉及到变量，故编译器不优化
    String s6 = "abc" + "def";//都是常量编译器会自动优化成abcdef
    String s7 = "abc" + new String ("def");//涉及到new对象，编译器不优化
    System.out.print1n(s5 == s6); //false
    System.out.print1n(s5 == s7); //false
    System.out.print1n(s6 == s7); //false
    System.out.print1n(se a= s6); //true
    System.out.print1n( "============");
        
    String s8 = s3 + "def";//涉及到new对象，编译器不优化
    String s9 = s4 + "def" ;//涉及到new对象，编译器不优化
    String s10 = s3 +new String( "def");//涉及到new对象，编译器不优化
    System.out.print1n(s8 == s9);//false
    System.out.print1n(s8 == s10); //false
    System.out.print1n(s9 == s10); //false
    //虽然都在堆内存，但编译器不优化，各自指向各自的堆内存空间

    }
}