SE1

main方法中声明的变量
方法中声明的所有变量都在栈里
所有引用变量放栈里？
+加法有意思
底层做一个字符串的合并
这个结构又出现一遍
扩容数组


String s1= "ABC";
String s2 = s1;
s1 =s1+"DEF";
System.out.println(s1);
System.out.println(s2);
 "DEF"就变成内存垃圾，当然因为DEF是字符串字面量，它不会回收，它会放在缓存池里面
 字符串变量的值（对象的地址）在改变
 字符串对象没有改变
 Java字符串中任何一个字符对应16位（2个字节）的定长Unicode编码






String常量池
静态字符串（字面量/常量/常量连接的结果）在常量池中创建，并尽量使用同一个对象，重用静态字符串(家里的碗重复使用)
字面量：1 直接写死的 “ABC” 123  5 3.14
               "ABC" 字符串字面量
             2    Java为了性能，优化了字符串“字面量 ”对象
             将字符串对象引用缓存到了常量池
 3      使用相同字符串“字面量”时候，替换为相同的字符串对象引用
 4           字符串常量作为字面量优化    字面量连接的结果作为字面量优化
 public static final String s ="ABC";
 System.out.println(S==s1);//true
String s7 ="A"+"B"+'C';-------------------------‘c’是字符类型，是字符字面量，前面"A"，"B"是字符串字面量
那这些字面量连接完了，它也当字符串字面量。为什么？Java编译器在编译期间，能算的先算了117分钟


 5  其他通过new运算，或者字符串变量连接的结果是新字符串对象，不参与常量池优化


所有字符串都是缓存的？NO
==用于比较两个变量的值是否相等
int  a = 5;
int b = 5;
boolean  l   = a == b;


/**
* String字面量的缓存重用现象
*/
String s1 = "ABC";
String s2 =s1;
System.out.println(s1==s2);//true-----这个true表示什么意思？s1和s2的地址值是一样的
//s1==s2返回true表示s1和s2中的地址值是相等的，也说明s1和s2引用了同一个对象


String s3="ABC";我要定义一个字符串，假设是s3，让它也等于字面量ABC
那这个时候，Java会怎么做呢？第一次创建ABC的时候，java会把ABC的引用放在常量池里面，缓存起来
再用的时候，去常量池去找，用旧的
String s3="ABC";




System.out.println(s1==s3);//true
凡是这种字面量，java会在堆里面创建一个数据结构（常量池）
常量池存引用，这个引用引用了字符串对象
String s4 ="A";
String s5 ="BC";
String s6 = s4+s5;//字符串连接结果不参与优化，优化的是字面量
System.out.println(s1==s6);//false




String s8 = new String("ABCD");
对于字符串，可以：
String s = "abcd";
System.out.println(s.length());  //打印字符串长度
对于数组，length不是方法，而是属性，应该这样：
String[] aa = {"abc", "123"};
System.out.println(aa.length);  //注意，没有括号了，呵呵。
满意请采纳！
追问
那到底是可以还不是不可以啊。。。
追答
对于字符串，可以; 对于数组，不可以！
因为数组没有length()方法，只有length属性。
一个字符，一个char,两个byte
substring 2个方法
trim   去除字符串两端的空白  如果字符串前后没有空白，则返回字符串本身  
                                   空白：包括空格，Tab,回车，换行 
indexof 2个方法
lastindexof
charAt
startsWith 检查字符串开头是什么  logo.png 如果检查空串，总是返回true 和字符串自己比较，返回true
sendsWith 检查字符串结尾是什么




StringBuilder 
动态数组
append('') append("")2个方法 append(String)
insert(位置，一个字符串)
delete(开始，结束) delete(5,5+3)
replace(开始，结束，要替换的新的字符串) -----所有的开始和结束都包含开始不包含结束
length()有效字符个数
capacity()数组大小
返回StringBuilder--当前对象--就可以直接点---函数式编程
String做输出
StringBuilder专门做计算
StringBuilder的操作性能好于String
s1 = s1+"A";//数组复制
+法实际上在底层借助StringBuilder做计算，先创建一个对象 new StringBuilder(s1)，然后再调用append方法，最后转成一个字符串交给s1
转完字符串以后，新创建StringBuilder对象就被当内存垃圾扔掉了
s1 = s1+"A";又来一次，每次都会创建StringBuilder对象，内存都会多一个内存垃圾
s1= new StringBuilder(s1).append("A").toString


public static void test(int  n){
              long t1=System.nanoTime();
String s1="";
for(int i =0;i<n;i++){
         s1= s1+"A"；
}
long t2=System.nanoTime();
System.out.println(t2-t1);
}
 


何时使用StringBuilder优化String连接


String  s1= "A"+"bcd"+"DEF";------------------静态字符串连接，不需要StringBuilder优化
//2写在一行上的字符串连接，不用StringBuilder
       Java编译器会自动将一行上的字符串连接 优化为一个StringBuilder对象
       3多行多次操作字符串时候需要优化
//案列：将一个整数数组连接为一个字符串------------------{1,6,8,9,10}连接为"[1,6,8,9,10]"
int[] arr = {1,6,8,9,10};
String str ="["+arr[0];
for(int i =1;i<arr.length;i++){
str =str+","+arr[i];
}
str+="]";
System.out.println(str);






       String s3 ="ABC":
       String s4 ="def";
       String s5="EFG";
       String ss =s3+s4+s5;----------------------------ss = new StringBuilder(s3).append(s4).append(s5).toSttring();
 System.out.println(s1);
String s2 = new StringBuilder("A").append("bcd").append("DEF").toString();










//正确的写法: 使用一个StringBuilder
StringBuilder buf=new StringBuilder("[");
buf.append(arr[0]);
for(int i=1; i<arr.length; i++){
buf.append(", ").append(arr[i]);
}
buf.append("]");
String str2 = buf.toString();
System.out.println(str2);