String类和StringBuilder中常用知识和“+“号和append方法的区别

String类

字符串的比较(equals(区分大小写)

public boolean equals(Object anObject)

        String s1="abc";
        String s2="abc";
        boolean b = s1.equals(s2);  **//true**
        
        String s1="Abc";
        String s2="abc";
        boolean b = s1.equals(s2);  **//false**
		
		//作用: 将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。
		//返回: 如果给定对象表示的 String 与此 String 相等，则返回 true；否则返回 false
		//注:   若类型不同 但内容相同也是false

字符串的比较 equalsIgnoreCase(忽略大小写) )

public boolean equalsIgnoreCase(String anotherString)

        String s1="ABC";
        String s2="abc";
        boolean b = s1.equalsIgnoreCase(s2);  **//true**
        
         //作用: 将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的
         //返回: 如果参数不为 null，且这两个 String 相等（忽略大小写），则返回 true；否则返回 false。
         //注:   若类型不同 但内容相同也是false

字符串的长度(length)

public String substring(int beginIndex)

		public int length( )
		String s1="das9das'da?";
		System.out.println(s1.length());  //11 
		//作用      返回此字符串的长度。长度等于字符串中 Unicode 代码单元的数量   
		//返回:     此对象表示的字符序列的长度。

字符串数组转化为字符数组(toCharArray)

public char[] toCharArray()

        String s1 = "1314qwe";           **//不能直接用for循环遍历**
        char[] c = s1.toCharArray();
        for (int i = 0; i < s1.length(); i++) {
            System.out.println(c[i]);     **//1 3 1 4 q w e**
        }
		//作用: 将此字符串转换为一个新的字符数组。 
		//返回: 一个新分配的字符数组，它的长度是此字符串的长度，它的内容被初始化为包含此字符串表示的字符序列

字符串截取(首)(substring)

public String substring(int beginIndex)

		String s1="das9das'da?";
        System.out.println(s1.substring(6));   **//s'da?**   
        //作用: 截取到末尾       beginIndex: 开始位置的索引
		//返回：指定的子字符串

字符串截取(首,末)(substring)

public String substring(int beginIndex,int endIndex)

        String s1="aa786867";
        String s2 = s1.substring(3, 5);
        System.out.println(s2);           **//86**
        //作用: 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
		//返回:指定的子字符串。
        //定义对象接受 注意长度为 (endIndex-behinIndex) 返回末尾是endIndex-1 

字符换替换(replace)

public String replace(CharSequence target, CharSequence replacement)

        String s1="aaaaa";
        String s2 = s1.replace("aaa", "m");
        System.out.println(s2);        **//maa**
		//作用: 替换(旧值,新值) 
        //使用指定的字面值替换序列,替换此字符串所有匹配字面值目标序列的子字符串。该替换从字符串的开头朝末尾执行，例如，用 "b" 替换字符串 "aaa" 中的 "aa" 将生成 "ba" 而不是 "ab"。 
		//返回: 所得 String    定义变量接受

字符串切割

public String[] split(String regex)

		String s1="a+a+7+8+6+6+7";
        String[] s2 = s1.split("\\+");
        System.out.println(Arrays.toString(s2));  **// a,a,7,8,6,6,7**
		//作用: 切割字符串    传入一个String regex 切割的标准  若没有达到指定效果regex前加//(俩条斜杠)
		//返回: 字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的 \
    	//正则表达式

StringBuilder类

传入字符串

public StringBuilder append(任意类型)

public StringBuilder append(任意类型)
    //参数将被转换成字符串,添加数据,返回自己
    //数组也可以
    	StringBuilder  sb=new StringBuilder();
        StringBuilder sb1=sb.append("fsfds");
        StringBuilder sb2=sb.append("dasda");
        StringBuilder sb3=sb.append("45335");
        System.out.println(sb1);
        System.out.println(sb2);
        System.out.println(sb3);         //三个打印出来的内容相同 fsfdsdasda45335
        System.out.println(sb1==sb2);
        System.out.println(sb3==sb2);
        System.out.println(sb1==sb3);    //地址比较都为true
			//对象指向同一个内存空间

		//引出链式编程
	    StringBuilder  sb=new StringBuilder();
        StringBuilder sb1 = sb.append("dasda").append("dfg").append("fdsf");
        System.out.println(sb1);
		//若返回的结果是对象(类型)就可以继续向下调用方法,用链式编程
 	  	//举例substring

字符串反转

public StringBuilder reverse()

		public StringBuilder reverse()
		//作用: 反转字符串
     	StringBuilder s1=new StringBuilder("你好世界");
        StringBuilder b =s1.reverse();
        System.out.println(b);                          	**//界世好你**
        StringBuilder c = b.reverse().append("//到此一游");
        System.out.println(c);          				  **//你好世界//到此一游**

字符长度

public int length()

public int length()
    //作用: 返回长度字符数
    //返回: 此对象表示的当前字符序列的长度
    	StringBuilder s1=new StringBuilder();
        StringBuilder s2 = s1.append("你好世界");
        StringBuilder b =s2.reverse();
        System.out.println(b);                          //界世好你
        StringBuilder c = b.reverse().append("//到此一游");
        System.out.println(c);          //你好世界//到此一游
        int length1 = s2.length();
        int length2 = c.length();
        System.out.println(length1);   //10
        System.out.println(length2);   //10
         //在一个字符串缓冲区的对象字符长度应该是一样的

缓冲区内容转字符串类型

	public String toString()
	 //作用: 返回此序列中数据的字符串表示形式。将分配一个新的 String 对象，并将它初始化，以包含当前由此对象	表示的字符串序列。然后返回此 String。对此序列的后续更改不影响该 String 的内容。
    //返回: 返回一个String类型的对象  此字符序列的字符串表示形式。
	//作用: 将缓冲区内容转换为字符串类型,就可以调用String中的方法
     

String 转 StringBuilder

		String s1= sc.next();
		StringBuilder sb1=new StringBuilder(s1);
		// 一个可变的字符序列
		//它比 StringBuffer 要快
		//在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串.
		//*提高字符串的操作效率
		//字符串的缓冲区,可以理解为容器,这个容器可以存储任意类型,但进入容器后转化为字符串类型
		//StringBuilder与StringBuffer (二者的构造方法和方法相同)
		//StringBuffer多线程更加安全,但效率可能会慢
		//StringBuilder可能不安全,但效率可能更快

使用“+”运算符和使用StringBuilder类的append方法的区别

使用“+”运算符和使用StringBuilder类的append方法的区别在于它们对字符串的处理方式不同1。当你使用“+”运算符连接两个字符串时，它会调用String.Concat方法，每次都返回一个新的字符串对象1。而StringBuilder类的append方法则是将指定的字符串附加到原始字符串中，而不会返回新的字符串对象。
在效率方面，如果你只是连接两个小字符串，例如string s = “a” + “b”;那么使用“+”运算符可能会更快1。然而，当你需要在循环中连接多个字符串时，使用StringBuilder类会更高效。

使用“+”运算符连接字符串：
string s = "Hello" + "World" + "!";
使用StringBuilder类的append方法连接字符串：
StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append("World");
sb.Append("!");
string s = sb.ToString();
在这个例子中，使用“+”运算符的代码更加简洁，但是每次连接字符串时都会创建一个新的字符串对象。
而使用StringBuilder类的append方法则会将指定的字符串附加到原始字符串中，而不会返回新的字符串对象。
因此，在循环中连接多个字符串时，使用StringBuilder类会更高效。