第一种:直接赋值方式,也叫字面量方式,创建的对象放在方法区的常量池中
String str = "hello";//直接赋值的方式
第二种:通过构造方法创建,创建的对象放在堆内存中
String str = new String("hello");//实例化方式
俩种方式的比较:==比较的是内存地址,s1,s2是字面量的声明方式,字符串常量池中不能有俩个相同地址的值,所以s1和s2是相同的,而new的方式在堆空间中,new一个对象就是一个对象的地址,不通用,所以结果就是true,false,false
@Test
    public void test2(){
        //此时s1和s2的数据javaEE声明在方法娶中的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";
        //通过new+ 构造器的方式:此时s3和s4保存的地址值,是数据在堆空间中开辟空间对应的地址值
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//false
    }
接下来是字符串拼接时的情况,s4是使用的字面量拼接方法,所以和s3是一样的,而s5这种有变量参与,也就被认为时new的方法,也就是在堆空间中存放,所以地址值和s3就不相同了,剩下的也就明了了,只要是new的情况,就会有一个新的对象,s5和s6也就不相同了
@Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
    }
总结:
1,通过字面量(区别new的方式)给一个字符串赋值时,此时的字符值声明在字符串常量池中
2,字符串常量池中不会储存相同内容的字符串的
3,String代表不可变的字符序列,简称不可变性,主要体现在以下三点
①,当对字符串重新赋值时,需要重新指定内存区域赋值,不能使用原有的value进行赋值
②,当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值
③,当调用String的replace()方法时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值
boolean equals(Object obj)://比较字符串的内容是否相同 boolean equalsIgnoreCase(String str):// 比较字符串的内容是否相同,忽略大小写 boolean startsWith(String str):// 判断字符串对象是否以指定的str开头 boolean endsWith(String str):// 判断字符串对象是否以指定的str结尾
public static void main(String[] args) { 
    // 创建字符串对象 
    String s1 = "hello";
    String s2 = "hello"; String s3 = "Hello"; 
    // boolean equals(Object obj):比较字符串的内容是否相同             
    System.out.println(s1.equals(s2)); //true 
    System.out.println(s1.equals(s3)); //false 
    System.out.println("-----------"); 
    // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写             
    System.out.println(s1.equalsIgnoreCase(s2)); //true     
    System.out.println(s1.equalsIgnoreCase(s3)); //true 
    System.out.println("-----------"); 
    // boolean startsWith(String str):判断字符串对象是否以指定的str开头 
    System.out.println(s1.startsWith("he")); //true 
    System.out.println(s1.startsWith("ll")); //false 
}  
int length()://获取字符串的长度,其实也就是字符个数 char charAt(int index)://获取指定索引处的字符 int indexOf(String str)://获取str在字符串对象中第一次出现的索引 String substring(int start)://从start开始截取字符串 String substring(int start,int end)://从start开始,到end结束截取字符串。包括start, 不包括end
public static void main(String args[]) {
    // 创建字符串对象
    String s = "helloworld";
    // int length():获取字符串的长度,其实也就是字符个数                 
    System.out.println(s.length()); //10 
    System.out.println("--------");
    // char charAt(int index):获取指定索引处的字符
    System.out.println(s.charAt(0)); //h
    System.out.println(s.charAt(1)); //e
    System.out.println("--------");
    // int indexOf(String str):获取str在字符串对象中第一次出现的索引
    System.out.println(s.indexOf("l")); //2 
    System.out.println(s.indexOf("owo")); //4 
    System.out.println(s.indexOf("ak")); //-1 
    System.out.println("--------");
    // String substring(int start):从start开始截取字符串     
    System.out.println(s.substring(0)); //helloworld 
    System.out.println(s.substring(5)); //world 
    System.out.println("--------");    
    
    // String substring(int start,int end):从start开始,到end结束截取字符串     
    System.out.println(s.substring(0, s.length())); //helloworld 
    System.out.println(s.substring(3, 8)); //lowor
}
char[] toCharArray():把字符串转换为字符数组 String toLowerCase():把字符串转换为小写字符串 String toUpperCase():把字符串转换为大写字符串 123
public static void main(String args[]) {
     // 创建字符串对象
    String s = "abcde";
    
    // char[] toCharArray():把字符串转换为字符数组
    char[] chs = s.toCharArray();
    for (int x = 0; x < chs.length; x++) {
        System.out.println(chs[x]);
    }
    System.out.println("-----------");
    // String toLowerCase():把字符串转换为小写字符串     
    System.out.println("HelloWorld".toLowerCase()); 
    // String toUpperCase():把字符串转换为大写字符串 
    System.out.println("HelloWorld".toUpperCase());
}
去除字符串两端空格:String trim() 按照指定符号分割字符串:String[] split(String str)
public static void main(String args[]) { 
// 创建字符串对象 
    String s1 = "helloworld"; 
    String s2 = " helloworld "; 
    String s3 = " hello world "; 
    System.out.println("---" + s1 + "---"); 
    System.out.println("---" + s1.trim() + "---"); 
    System.out.println("---" + s2 + "---"); 
    System.out.println("---" + s2.trim() + "---"); 
    System.out.println("---" + s3 + "---"); 
    System.out.println("---" + s3.trim() + "---"); 
    System.out.println("-------------------"); 
    // String[] split(String str) 
    // 创建字符串对象 
    String s4 = "aa,bb,cc"; 
    String[] strArray = s4.split(","); 
    for (int x = 0; x < strArray.length; x++) { 
        System.out.println(strArray[x]); 
    } 
}             
private static void testInsertAPIs(){
    StringBuilder sbuilder = new StringBuilder();
    // 在位置0处插入字符数组
    sbuilder.insert(0, new char[]{‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘});
    // 在位置0处插入字符数组。0表示字符数组起始位置,3表示长度
    sbuilder.insert(0, new char[]{‘A‘, ‘B‘, ‘C‘, ‘D‘, ‘E‘}, 0, 3);
    // 在位置0处插入StringBuilder对象
    sbuilder.insert(0, new StringBuilder("StringBuilder"));
    // 在位置0处插入Object对象。此处以HashMap为例
    HashMap map = new HashMap(); 
    map.put("1", "one"); 
    map.put("2", "two"); 
    map.put("3", "three");
    sbuilder.insert(0, map);
    System.out.printf("%s\n\n", sbuilder); 
} 
private static void testAppendAPIs() {
    StringBuilder sbuilder = new StringBuilder();
    // 追加字符数组 
    sbuilder.append(new char[]{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘});
    // 追加字符数组。0表示字符数组起始位置,3表示长度 
    sbuilder.append(new char[]{‘A‘,‘B‘,‘C‘,‘D‘,‘E‘}, 0, 3);
    // 追加StringBuilder对象 
    sbuilder.append(new StringBuilder("StringBuilder"));
    // 追加Object对象。此处以HashMap为例 
    HashMap map = new HashMap(); 
    map.put("1", "one"); map.put("2", "two"); 
    map.put("3", "three"); 
    sbuilder.append(map); 
    sbuilder.append(‘\n‘);
    System.out.printf("%s\n\n", sbuilder);
}
private static void testReplaceAPIs() {
    StringBuilder sbuilder;
    
    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.replace(0, 3, "ABCDE"); 
    System.out.printf("sbuilder=%s\n", sbuilder);
    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.reverse(); 
    System.out.printf("sbuilder=%s\n", sbuilder);
    sbuilder = new StringBuilder("0123456789"); 
    sbuilder.setCharAt(0, ‘M‘); 
    System.out.printf("sbuilder=%s\n", sbuilder);
    System.out.println();
}
private static void testIndexAPIs() {
    StringBuilder sbuilder = new StringBuilder("abcAbcABCabCaBcAbCaBCabc");             
    System.out.printf("sbuilder=%s\n", sbuilder); 
    
    // 1. 从前往后,找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")",   sbuilder.indexOf("bc"));
    // 2. 从位置5开始,从前往后,找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)", sbuilder.indexOf("bc", 5));
    // 3. 从后往前,找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")", sbuilder.lastIndexOf("bc"));
    // 4. 从位置4开始,从后往前,找出"bc"第一次出现的位置 
    System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)", sbuilder.lastIndexOf("bc", 4)); System.out.println(); 
}
String是字符串常量
StringBuffer是字符串变量(线程安全,效率低)
StringBuilder是字符串变量(线程不安全,效率高)
String S1 = “This is only a” + “ simple” + “ test”; StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
原文:https://www.cnblogs.com/xuan24/p/14020920.html