java字符串

已于 2023-05-01 09:59:10 修改
阅读量2.3k 收藏 26
点赞数 4
分类专栏： 笔记 java基础 文章标签： java jvm 数据结构
于 2022-09-14 23:32:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51779342/article/details/126860046
版权

java字符串

java字符串

一、String类

概述：字符串是由多个字符组成的一串数据（字符序列），它可以看成是一个字符数组。Java程序中的所有字符串面值（如：“abc”）都可以看成是一个字符串对象。

String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的。

一）特点

  • String类被final修饰，不可被继承
  • 字符串是不可变序列，是常量，一旦被赋值，就不能被改变。（其值不能改变，但是String类型的引用所指向的地址值可以发生改变）
  • 字符串字面值存放在方法区中的字符串常量池，字符串常量池中一定不存在两个相同的字符串
public static void main(String[] args) {
   String name = "zhangsan";
    /**
     * 重新赋值时，并不是直接在原地址上覆盖zhangsan，而是在字符串池中
     * 找到（创建）lisi，然后把lisi的地址赋值给name，从而实现新的赋值过程
     */
    name = "lisi";
}

注意：当我们重新赋值时，并不是直接修改他的字面值，因为字面值是不可改变的，而是通过重新开辟一个空间，把新空间的地址赋值给变量，这就是不可变性

二）构造方法

方法描述
String();无参构造
String(byte[] bytes);把字节数组转换成字符串
String(byte[],int offset,int length);把字节数组的一部分转换成字符串
String(char[] value);把字符数组转换成字符串
String(char[] value,int offset,int count);把字符数组的一部分转换成字符串
String(String original);把字符串常量转换成字符串

示例：

// 直接创建
String s = "abc";// 创建一个字符串对象abc，放在方法区字符串常量池中
// 通过构造器传字符串的创建
String s1 = new String("abc");// 在堆中创建一个字符串对象，然后在常量池中找到并返回abc对象
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);// 在堆中创建一个字符串对象，然后在常量池中找到并返回abc对象
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);// 在堆中创建一个字符串对象，然后在常量池中找到并返回abc对象

注意：字符串直接赋值的方式是先到方法区的字符串常量池里面查找，如果有就直接返回，如果没有就创建并返回。

String str = “abc”；与String str2 = new String(“abc”);的区别
  • String str = “abc”：可能创建一个或者不创建对象。直接到方法区的字符串常量池里面查找，如果abc 在字符串池中存在, str直接指向这个内存地址；如果abc在字符串池中不存在，会在java字符串池中创建一个String对象abc，然后str指向这个内存地址，无论以后用这种方式创建多少个值为abc的字符串对象，始终指向的都是该内存地址，即以""方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一 个 String 对象，并在字符串池中维护。
  • String str = new String(“abc”)：至少会创建一个对象，也有可能创建两个。因为用到new关键字，肯定会在堆中创建一个String对象，如果字符池中已经存在abc，则不会再字符串池中创建一个String对象，如果不存在，则会在字符串常量池中也创建一个对象。

在这里插入图片描述

三）常用方法

方法名描述
int length()返回字符串的长度
char charAt(int index)根据下标获取字符
int indexOf(String str)查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
int indexOf(int ch,int fromIndex); 查找指定字符在指定位置后第一次出现处的索引
int indexOf(String str,int fromIndex); 查找指定字符串在指定位置后第一次出现处的索引
char[] toCharArray()将字符串转换成数组。
byte[] getBytes();把字符串转换为字节数组
static String valueOf(...); String类的valueOf方法可以把任意类型的数据转换为字符串
String trim(）去掉字符串前后的空格
String toLowerCase();把字符串转换为小写
String toUpperCase()把字符串转换为大写
String replace(String oldString,String newString)把字符串中的子字符串替换为新的子字符串，原字符串不变
String[] split(String str)根据str做拆分,如空格符或给定正则表达式的匹配拆分此字符串
String concat(String str);把字符串进行拼接
String subString(int beginIndex,int endIndex)在字符串中截取出一个子字符串,范围[beginIndex,endIndex),包含开始，不含结束
boolean equals(Object obj);比较字符串的内容是否相同，区分大小写
boolean equalsIgnoreCase(String str);比较字符串的内容是否相同，忽略大小写
int compareTo(String str);按字典顺序比较两个字符串
boolean contains(String str)判断当前字符串中是否包含str
boolean startsWith(String str);判断字符串是否以某个指定的字符串开头
boolean endsWith(String str)判断字符串是否以str结尾
boolean isEmpty();判断字符串内容是否为空
native String intern();直接指向常量池

new String()的一些参考：

演示：

System.out.println("---------字符串方法的使用 1-------------");
        //字符串方法的使用
        //1、length();返回字符串的长度
        //2、charAt(int index);返回某个位置的字符
        //3、contains(String str);判断是否包含某个子字符串
        String content = "java是世界上最好的java编程语言,java真香";
        System.out.println(content.length()); // 26
        System.out.println(content.charAt(content.length() - 1)); // 香
        System.out.println(content.contains("java")); // true
        System.out.println(content.contains("php")); // false

        System.out.println("--------字符串方法的使用 2--------------");
        //字符串方法的使用
        //4、toCharArray();返回字符串对应的数组
        //5、indexOf();返回子字符串首次出现的位置
        //6、lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java")); // 0
        System.out.println(content.indexOf("java", 4)); // 11
        System.out.println(content.lastIndexOf("java"));// 20

        System.out.println("------------字符串方法的使用3------------------");

        //7、trim();去掉字符串前后的空格
        //8、toUpperCase();//把小写转成大写 toLowerCase();把大写转成小写
        //9、endWith(str);判断是否已str结尾,startWith(str);判断是否已str开头
        String content2 = "   hello World   ";
        System.out.println(content2.trim()); // hello World
        System.out.println(content2.toUpperCase()); // HELLO WORLD
        System.out.println(content2.toLowerCase()); // hello world
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java")); // true
        System.out.println(filename.startsWith("hello")); // true

        System.out.println("------------字符串方法的使用4------------------");

        //10、replace(char old,char new); 用新的字符或字符串替换旧的字符或字符串
        //11、split();对字符串进行拆分
        //12、S.substring(开始，结束)  截取某段字符
        System.out.println(content.replace("java", "php"));
        String s = "java is the best,  programing language";
        System.out.println(s.substring(5,16)); // is the best
        // 根据空格分隔字符串
        String[] arr = s.split(" ");
        for (String i : arr) {
            System.out.println(i);
        }
        System.out.println("---------------");
        // 根据空格和逗号分隔，中括号表示选择，可以选择空格或逗号分隔
        String[] arr2 = s.split("[ ,]");
        for (String i : arr2) {
            System.out.println(i);
        }
        System.out.println("---------------");
        /**
         *  根据空格和逗号分隔，中括号表示选择，可以选择空格或逗号分隔，
         *   +号表示可以出现多个空格或逗号
         */
        String[] arr3 = s.split("[ ,]+");
        for (String i : arr3) {
            System.out.println(i);
        }

        //补充两个方法equals 、compareTo();比较大小
        System.out.println("---------补充---------");
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";//97
        String s4 = "ayzawe";//120
        System.out.println(s3.compareTo(s4));

        String s5 = "abc";
        String s6 = "abc";
        System.out.println(s5.compareTo(s6));
intern()
/**
 * intern：先用equals方法判断字符串常量池中是否存在指定字符串，存在则直接返回常量
 *        池中的字符串地址，如果字符串池中没有该字符串，则创建一个然后返回地址
 * 即：无论过程多么复杂，intern方法最终返回的一定是字符串常量池中的字符串地址
 */
String s1 = "a";
String s2 = new String("a");
System.out.println(s1 == s2);// false
System.out.println(s1 == s2.intern());// true
System.out.println(s2 == s2.intern());// false
System.out.println(s1 == s1.intern());// true

注意内容为空与字符串为空的区别：

字符串内容为空：String str = "";

字符串对象为空：String str = null;（对象为空，无法调用方法：空指针异常）

String类拼接

重要规则：常量相加，发生在常量池中；变量相加，发生在堆中

  • 如果两个字符串变量相加，先开辟空间，再做拼接。
  • 如果两个字符串常量相加，先做拼接，然后在字符串常量池里面查找，如果有就直接返回，如果没有就创建并返回
String a = "hello";
String b = "World";
String s = "hello" + "World";//常量相加，直接在常量池中创建对象
String s1 = a + b; // 变量相加，要先在堆中运算，最后在常量池中创建字符串对象
String s2 = a.concat(b); // 变量相加，要先在堆中运算，最后在常量池中创建字符串对象
a += "World";// 变量相加，要先在堆中运算，最后在常量池中创建字符串对象
字符串转数字

使用各包装类的parseXxx()静态方法，但是在使用时要注意字符串必须是纯数字

String i = "150";
System.out.println(Integer.parseInt(i)); // 150

String i = "150s";
System.out.println(Integer.parseInt(i));//Exception in thread "main" java.lang.NumberFormatException: For input string: "150s"//数字格式化错误，150s中含有非数字字符
字符串转boolean

字符串转换成boolean类型时，true就是true，非true为false

public static void main(String[] args) {
    String i = "true";//为true
    System.out.println(Boolean.parseBoolean(i));//true
    String i1 = "false";//为false
    System.out.println(Boolean.parseBoolean(i1));//false
    String i2 = "ksajd";//非true
    System.out.println(Boolean.parseBoolean(i2));//false
}
字符串比较
==
  • 比较基本数据类型：比较的是具体的值
  • 比较引用数据类型：比较的是对象地址值（相当于把对象地址当做值来比较）
equals

Object.equals()的实现方式也是==，但是String重写了equals方法，所以是比较两个字符串内容是否相同（区分大小写）

public class Test {
    public static void main(String[] args) {
        String s = "a";
        String s1 = "a";
        String s2 = "A";
        System.out.println(s.equals(s1));// true
        System.out.println(s2.equals(s1)); // false
        /**
         * p1.name.equals(p2.name):由于String类重写了equals方法，所以比较的是内容
         * p1.name == p2.name：虽然在堆中是两个对象地址，但是p1.name与p2.name指向
         *          的字符串都存储在字符串常量池中，所以返回相同的地址
         * p1.name == "张三"：p2.name指向的就是字符串常量池中的张三
         */
        Person p1 = new Person();
        p1.name = "张三";
        Person p2 = new Person();
        p2.name = "张三";
        System.out.println(p1.name.equals(p2.name)); // true
        System.out.println(p1.name == p2.name); // true
        System.out.println(p1.name == "张三"); // true
    }
}
class Person {
    String name;
}

在这里插入图片描述

== 与 equals的异同：
  • 相同点：equals的实现也是==，即如果不重写equals方法，它与 == 的结果一致
  • 不同点：

1）== 可以比较基本数据类型和引用类型，equals方法只能比较引用数据类型

2）== 比较的是内存地址，equals方法经过重写之后比较的是内存空间中的内容

四）练习

1、键盘录入一个字符，统计字符串中大小写字母及数字字符个数

//键盘录入一个字符串数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串数据：");
String s = sc.nextLine();
//定义三个统计变量，初始化值都是0
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
//遍历字符串，得到每一个字符
for(int x=0; x<s.length(); x++) {
    char ch = s.charAt(x);
    //拿字符进行判断
    if(ch>='A'&&ch<='Z') {
    	bigCount++;
    }else if(ch>='a'&&ch<='z') {
    	smallCount++;
    }else if(ch>='0'&&ch<='9') {
    	numberCount++;
    }else {
   		System.out.println("该字符"+ch+"非法");
    }
}
//输出结果
System.out.println("大写字符："+bigCount+"个");
System.out.println("小写字符："+smallCount+"个");
System.out.println("数字字符："+numberCount+"个");

2、已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示

import java.util.Scanner;
/*
思路：
1:已知用户名和密码，定义两个字符串表示即可
2:键盘录入要登录的用户名和密码，用 Scanner 实现
3:拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用
equals() 方法实现
4:用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
*/
public class Test {
    public static void main(String[] args) {
        //已知用户名和密码，定义两个字符串表示即可
        String username = "tom";
        String pwd = "123";
        //用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for (int i = 0; i < 3; i++) {
            //键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();
            System.out.println("请输入密码：");
            String pwd = sc.nextLine();
            //拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，
            if (name.equals(username) && pwd.equals(pwd)) {
                System.out.println("登录成功");
                break;
            } else {
                if (2 - i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

3、键盘录入一个字符串，使用程序实现在控制台遍历该字符串

import java.util.Scanner;
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:遍历字符串，首先要能够获取到字符串中的每一个字符
public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
3:遍历字符串，其次要能够获取到字符串的长度
public int length()：返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
4:遍历字符串的通用格式
*/
public class Test {
    public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        for(int i=0; i<line.length(); i++) {
            System.out.println(line.charAt(i));
        }
    }
}

五）常见面试题

创建了几个对象
第一题
/**
 * 一开始，s指向hello，所以在字符串池中创建了一个hello对象
 * 将s的指向改为hi，此时又在池中创建了一个hi对象，所以创建了两个对象
 */
String s = "hello";
s = "hi";

在这里插入图片描述

第二题
        /**
         * 创建了一个对象
         * 两个常量相加，编译器会做出优化：由于编译器会判断创建出来的
         * 对象是否有引用指向，为了节约空间，编译器不允许创建垃圾对象，
         * 所以会在底层做出优化，即将多步合成一步，这将避免空间浪费，所
         * 以    String s = "hello" + " zhangsan";
         * 等价于 String s = "hello zhangsan";
         */
        String s = "hello" + "zhangsan";
第三题
        String s = "hello";// 创建了一个hello对象
        String s1 = "zhangsan"; // 创建了一个zhangsan对象
        /**
         * 在jdk1.8中：
         * 1、首先创建一个StringBuilder对象st
         * 2、调用append方法将hello对象添加到st对象：st.append("hello");
         * 3、调用append方法将zhangsan对象添加到st对象：st.append("zhangsan");
         * 4、调用st的toString方法，将StringBuilder类型转换为String类型
         * 5、将结果返回给s2
         * 所以，s2最终直接指向的是堆中的String对象，而不是常量池中的hellozhangsan对象
         *  创建了3个对象：hello、zhangsan、hellozhangsan
         */
        String s2 = s + s1;

在这里插入图片描述

注意：上述是在JDK1.8中的创建过程，JDK17中有所不同

public static void main(String[] args) {
    String s = "hello";
    s += "World";
    System.out.println(s);
}

过程分析：
// 首先跳转DirectMethodHandle.internalMemberName(Object mh) 
static Object internalMemberName(Object mh) {
    return ((DirectMethodHandle)mh).member;
}

// 再跳转首先跳转DirectMethodHandle$Holder.invokeStatic(Object var0, Object var1, Object var2)
static Object invokeStatic(Object var0, Object var1, Object var2) {
    Object var3 = DirectMethodHandle.internalMemberName(var0);
    return MethodHandle.linkToStatic(var1, var2, (MemberName)var3);
}

// 再跳转StringConcatHolder.simpleConcat(Object first, Object second)
static String simpleConcat(Object first, Object second) {
    String s1 = stringOf(first); // first = "hello"
    /*
        static String stringOf(Object value) {
            String s;
             //判断传入的第一个参数是否为null，不为null返回该字符串，即 "hello"
             //若第一个参数为null，则将null转换为字符串并返回，即返回  "null"
            return (value == null || (s = value.toString()) == null) ? "null" : s;
        }
      */
    String s2 = stringOf(second); // second = "world"
    // 判断是否为空字符串，即 "",注意空字符串 "" 与 null的区别
    if (s1.isEmpty()) {
        // 创建第二个参数为字符串对象
        return new String(s2);  
    }
    if (s2.isEmpty()) {
        // 创建第一个参数为字符串对象
        return new String(s1);
    }
    // 
    long indexCoder = mix(initialCoder(), s1); //获取第一个参数的长度 s1 = "hello"
	    /*
	    	// String.COMPACT_STRINGS = true
	    	// LATIN1 = 0
	    	static long initialCoder() {
	        	return String.COMPACT_STRINGS ? LATIN1 : UTF16;
	    	}
	    */
		/*
	    static long mix(long lengthCoder, String value) {
	    	// 获取字符串长度
	        lengthCoder += value.length();
	        if (value.coder() == String.UTF16) {
	        	/*
	        		 //COMPACT_STRINGS = true
	        		 // coder = 0
	                 byte coder() { // 确定编码长度
	                    return COMPACT_STRINGS ? coder : UTF16;
	                 }
	             */
	             
	            lengthCoder |= UTF16;
	        }
	        return checkOverflow(lengthCoder); // 检查是否溢出
		        /*
				private static long checkOverflow(long lengthCoder) {
		            if ((int)lengthCoder >= 0) {
		                return lengthCoder; // 返回字符串长度
		            }
		            throw new OutOfMemoryError("Overflow: String length out of range");
		    		}
		    	*/
	    	
	    	}
	    */
        
    indexCoder = mix(indexCoder, s2);// 加上第二个参数的长度
    byte[] buf = newArray(indexCoder); // 创建一个新的数组
		/*
	        static byte[] newArray(long indexCoder) {
	            byte coder = (byte)(indexCoder >> 32);
	            int index = (int)indexCoder;
	            return (byte[]) UNSAFE.allocateUninitializedArray(byte.class, index << coder);
	        }
		*/

    indexCoder = prepend(indexCoder, buf, s2);
		/*
			private static long prepend(long indexCoder, byte[] buf, String value) {
	        indexCoder -= value.length(); // 10 - 5
	        if (indexCoder < UTF16) {
	            value.getBytes(buf, (int)indexCoder, String.LATIN1);
	            /*
	            void getBytes(byte[] dst, int dstBegin, byte coder) {
	                if (coder() == coder) {
	                    System.arraycopy(value, 0, dst, dstBegin << coder, value.length);
	                } else {    // this.coder == LATIN && coder == UTF16
	                    StringLatin1.inflate(value, 0, dst, dstBegin, value.length);
	                }
	            }
	            */
	
	        } else {
	            value.getBytes(buf, (int)indexCoder, String.UTF16);
	        }
	        	return indexCoder;
	    	}
		*/
        
    indexCoder = prepend(indexCoder, buf, s1);
    return newString(buf, indexCoder);
		/*
			static String newString(byte[] buf, long indexCoder) {
	            // Use the private, non-copying constructor (unsafe!)
	            if (indexCoder == LATIN1) {
	                return new String(buf, String.LATIN1);
	            } else if (indexCoder == UTF16) {
	                return new String(buf, String.UTF16);
	            } else {
	                throw new InternalError("Storage is not completely initialized, " + (int)indexCoder + " bytes left");
	            }
	        }
		*/
}

二、可变字符串

概述：每次对字符串进行拼接操作，都会构建一个新的String对象，既耗时又浪费空间，而可变字符串就可以解决这个问题。

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用可变字符串类。

可变字符串分为java.lang.StringBuffer类和java.lang.StringBuilder类

StringBuilder与StringBuffer的直接父类是AbstractStringBuilder，而且他们的数据也是存放在AbstractStringBuilder类中的char[] value数组中，这里的value数组没有使用final修饰，且value的值是存放在堆中的，所以StringBuffer和StringBiulder才是可变的，注意：StringBuffer和StringBiulder都是final修饰的类，所以不可继承

在这里插入图片描述

StringBuffer类

概念：可变长字符串，JDK1.0提供，运行效率慢、线程安全。可在内存中创建可变的缓冲空间，存储频繁改变的字符串，线程安全的可变字符序列。其所有成员方法都使用synchronized关键字修饰，所以是线程安全的

StringBuffer与String的区别：
  • String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低 //private final char value[];
  • StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高 //char[] value; 这个放在堆.
  • 在使用StringBuffer做字符串拼接，不会浪费太多的资源
构造方法：

public StringBuffer(); 无参构造方法，其初始容量为 16 个字符

public StringBuffer(int capacity); 指定容量的字符串缓冲区对象

public StringBuffer(String str); 指定字符串内容的字符串缓冲区对象

成员方法：

int capacity(); 返回当前容量 – 理论值

int length(); 返回长度（字符数） – 实际值

（1）添加功能
  • StringBuffer append(String str); 把字符串添加到字符串缓冲区，并返回字符串缓冲区本身

注意：该方法被多次重载，可以把任意类型的数据添加到字符串缓冲区

  • StringBuffer insert(int offset,String str); 在指定位置把字符串插入到字符串缓冲区，并返回本身

    注意：该方法被多次重载，可以在指定位置把任意类型的数据插入到字符串缓冲区

（2）删除功能

  • public StringBuffer deleteCharAt(int index); 删除指定位置的字符，并返回本身

  • public StringBuffer delete(int start,int end); 删除从指定位置开始到指定位置结束的内容，并返回本身

    注意：包含start，但是不包含end

（3）替换功能
  • public StringBuffer replace(int start,int end,String str); 从start开始到end结束用str替换，并返回本身
  • public void setCharAt(int index,char ch); 将给定索引处的字符设置为ch
（4）反转功能

public StringBuffer reverse();

（5）截取功能
  • public String substring(int star);
  • public String substring(int star,int end);

注意：截取功能和前面的几个功能有所不同，其返回值是String类型，但本身并没有发生改变，即字符串本身并没有

        String a = "hello World !";
        String s = a.substring(5, a.length() - 1);
        System.out.println("原字符串：" + a); // 原字符串：hello World
        System.out.println("截取的字符串：" + s); //截取的字符串： World
String和StringBuffer的相互转换：
（1）String -> StringBuffer
  • 构造方法：public StringBuffer(String str); //返回才是StringBuffer对象，str不变
  • append方法：public StringBuffer append(String str);
（2）StringBuffer -> String

  • 构造方法：public String（StringBuffer sb）;

  • toString方法：public String toString();

    备注：StringBuilder已经覆盖重写了Object当中的toString方法。

StringBuffer与数组的区别：

两者都可以看作是一个容器，用来放置数据：

  • StringBuffer的数据最终是一个字符串数据
  • 数组可以放置多种类型的数据，但同一个数组中的数据必须是同一类型的
String和StringBuffer作为参数传递：
  • String是常量值，一种特殊的引用类型，当它作为参数传递时，效果和基本数据类型作为参数传递一样
  • StringBuffer作为参数传递，当它用来调用方法时，其形式参数的改变直接影响实际参数的改变

StringBuilder类

可变长字符串，JDK5.0提供，运行效率快、线程不安全，其方法和属性与StringBuffer几乎完全一致，只是没有使用synchronized关键字修饰，java.lang.StringBuilder 是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。 默认16字符空间，超过自动扩充

使用时机

字符串缓冲区被单个线程使用的时候，即单个线程的时候使用StringBuilder效率较高，多个线程的时候使用StringBuffer比较安全

线程安全（多线程内容）

安全 -- 同步 -- 数据是安全的
不安全 -- 不同步 -- 效率高一些

安全和效率两者不可兼得，需要根据需求有所取舍：

安全：银行网站，医院网站
效率：新闻网站，论坛
String,StringBuffer和StringBuilder的区别：

（1）String的内容和长度都是不可变的，而StringBuffer和StringBuilder的内容和长度都是可变的

（2）StringBuffer是同步的，数据安全，但效率低；而StringBuilder是不同步的，效率高，但不安全（多线程情况）

注意：StringBuilder和StringBuffer没有重写Object的equals方法

二者的方法基本相同，StringBuilder线程不安全，但是效率高，StringBuffer线程安全，效率低，单线程使用StringBuilder，他们都比String效率高，比较节省内存

测试StringBuffer与StringBuilder与String之间的效率
public class TestStringBuilder {
    public static void main(String[] args) {
        /**
         * 测试String类与StringBuilder的效率
         */
        StringBuilder str = new StringBuilder("abc");
        String str1 = new String("abc");
        /**
         * 测试string与StringBuilder的效率
         */
        long r = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time = System.currentTimeMillis();//获取当前系统时间
        //测试string
        for (int i = 0; i < 500; i++) {
            str1 = str1 + i;
            //System.out.println(str1.hashCode());
        }
        long r1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time1 = System.currentTimeMillis();//获取当前系统时间
        System.out.println("运行时间：" + (time1 - time));
        System.out.println("占用空间：" + (r - r1));

        long r3 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time3 = System.currentTimeMillis();//获取当前系统时间
        //测试StringBuilder
        for (int i = 0; i < 500; i++) {
            str.append(i);
            //System.out.println(str.hashCode());
        }
        long r4 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
        long time4 = System.currentTimeMillis();//获取当前系统时间
        System.out.println("运行时间：" + (time4 - time3));
        System.out.println("占用空间：" + (r3 - r4));
    }
}
32、链式调用

连续调用。该方法的核心是调用了return this，把自己返回了，只要是返回自己，就可以连续调用

StringBuilder str = new StringBuilder();
str.insert(0, "张").insert(1, "三").reverse().reverse();
System.out.println(str);//输出三张



public StringBuilder reverse() { // 反转字符串
    super.reverse();
    return this;//返回自己
}

public StringBuilder insert(int offset, String str) {
    super.insert(offset, str);//在指定位置插入字符串
    return this;//返回自己
}
渴望成长
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java输出5个字符串中最长的字符串
05-30
java输出5个字符串中最长的字符串.
Java中的字符串
Gefangenes的博客
05-30 6727
Java字符串就是Unicode字符序列。Java里没有内置的字符串类型，而是在标准的类库中提供了一个预定义类，String。每个用双引号""括起来的都是String类的一个实例。字符串是日常开发中最常用， Java字符串的一个重要特点就是字符串不可变2.1 直接定义字符串//或者String str;2.2 通过使用 String 类的构造方法来创建字符串//① String() 初始化新创建的 String对象，使其表示空字符序列。
Java 1.1.3 修改字符串、不可变字符串
Running Snail
07-28 245
修改字符串 String类没有提供用于修改字符串的方法。如果希望将 greeting 的内容修改为“ Help!”， 不能直接地将 greeting的最后两个位置的字符修改为 ‘ p’ 和 ‘ ！ 。这对于 C 程序员来说，将会感到无从下手 。如何修改这个字符串呢？ 在 Java中实现这项操作非常容易。 首先提取需要的字符， 然后再拼接上替换的字符串： < font color=red>color greeting = greeting.substring(0, 3) + "p!"; //上面
Java字符串 String StringBuffer
xinyuan的专栏
11-22 826
Java字符串
Java字符串
daimenglaoshi的博客
07-08 1995
字符串，字符串常量池
java字符串相似度算法
09-03
主要介绍了java字符串相似度算法,是Java实现比较典型的算法,具有一定参考借鉴价值,需要的朋友可以参考下
java 字符串转16进制 16进制转字符串 将两个ASCII字符合成一个字节；
04-23
java 字符串转16进制 16进制转字符串 将两个ASCII字符合成一个字节； java 字符串转16进制 16进制转字符串 将两个ASCII字符合成一个字节； java 字符串转16进制 16进制转字符串 将两个ASCII字符合成一个字节； java ...
java 字符串相减(很简单的一个方法)
09-05
本篇文章是对java中关于字符串相减的一个简单的方法进行了介绍，需要的朋友参考下
java字符串转数组实用代码
02-10
java字符串转数组实用代码
java字符串的合并
09-06
合并两个字符串，如：str1 ="001,002,003,004,006",str2 = "001,002,005" 合并后应该是"001,002,003,004,005,006"。
java怎么输出字符串_java输出字符串，怎么样输出字符串?
热门推荐
weixin_39965490的博客
02-12 1万+
下面要给大家讲的就是java输出字符串的问题，那么java怎样输出字符串呢?具体要怎样操作?一起来了解一下。一般在java编程的过程当中，经常会使用System.out.println();来输出字符串。来看一下System.out.println();首先是System，System是一个类，它继承于根类Object。其次是out，out的话是类PrintStream类实例化的一个对象，并且还是...
java字符串如何输出_java字符串如何输出
weixin_42565755的博客
02-21 5780
在Java编程中，我们常常用 System.out.println(); 来输出字符串。System.out.println();System是一个类，继承自根类Objectout是类PrintStream类实例化的一个对象，且是System类的静态成员变量println()是类PrintStream的成员方法，被对象out调用package Number;public class Frust {...
Java字符串格式输出
郑在努力~
11-14 4550
Java字符串格式输出eg: System.out.println(String.format(“%tQ”, new Date())); 占位符 作用 示例 结果 %d 十进制整数，int范围内 123 123 %o 八进制整数 123 173 %x 十六进制整数 123 7b %e 指数形式 123333.333333333
Java—输出字符串
qq_45885219的博客
09-12 1105
Java—输出字符串 Description 在屏幕上输出一行信息：This is a C program. Input 无输入数据。 Output 输出字符串This is a C program. Sample Output This is a C program. public class Main { public static void main(String[] args) { // TODO Auto-generated method stub System.out.print("Th
java 字符串处理
最新发布
05-01
Java字符串处理的常见操作包括字符串连接、查找子串、比较字符串、分割字符串、替换字符串、转换大小写等等。以下是一些常见的字符串处理方法： 1. 字符串连接：使用“+”操作符将两个或多个字符串连接起来。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值