第一种:直接赋值方式,也叫字面量方式,创建的对象放在方法区的常量池中
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