Java入门-06、String类、StringBuilder类

String类

String类代表字符串，Java程序中的所有字符串文字都被实现为此类的实例，也就是说，Java程序中所有的双引号字符串都是String类的对象

特点：

• 一旦创建，不会改变
• 不发生改变，因此被共享
• 等效于字符数组，底层原理是字节数组

字符串类的底层实现就是字符数组

常见的String构造方法：

1、public String()：无参构造方法，创建了一个空白的字符串对象不含任何内容

2、public String(char[] chs)：根据字符数组内容来创建字符串对象

3、public String(byte[] bys)：根据字节数组内容来创建字符串对象

4、String str = "字符串内容"；：直接赋值的方式创建字符串对象 

public class Test {
    public static void main(String[] args) {

        //无参构造方法，创建了一个空白的字符串对象不含任何内容
        String str =new String();
        System.out.println("str"+str);

        //public String(char[] chs)：根据字符数组内容来创建字符串对象
        char[] arr ={'a','b','c'};
        String str2 = new String(arr);
        System.out.println("str2"+str2);

        //public String(byte[] bys)：根据字节数组内容来创建字符串对象
        byte[] bys={56,57,58};
        String str3 = new String(bys);
        System.out.println("str3"+str3);

        //String str = "字符串内容"；：直接赋值的方式创建字符串对象 
        String str4 = "abc";
        System.out.println("str4"+str4);

    }
}

String对象的特点：

通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同但是地址值不同

以“”方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护。

public class Test {
    public static void main(String[] args) {
        //内容相同，但是地址值不同
        char[] chs={'a','b','c'};
        String c =new String(chs);
        String c1 =new String(chs);
        System.out.println(c==c1);//false
        
        //"abc"对象被共享，并在字符串池中维护
        String s= "abc";
        String s2="abc";
        System.out.println(s==s2);//true

    }
}

字符串类的方法：
1.获取字符串的长度：
      字符串对象.length()
2.拼接字符串：
      字符串对象1.concat(字符串对象2)
3.字符索引：
      根据位置找字符： charAt(int index)
      根据字符找位置： indexOf(字符串)
4.截取字符串：
      截取index后面的字符串：substring(int index)
      截取从begin开始到end之间的字符串：substring(int begin,int end)
5.将字符串转变成字符数组:
      public char[] toCharArray()
6.将字符串转变成新的字节数组:
      public byte[] getBytes()
7.字符串的替换:
      public String replace(String a,String b) 后者替换前者
8.字符串的分割：
      public String[] spilt(String regex) 将字符串中以字符regex进行切分

 public static void main(String[] args) {
        //获取字符串长度
        String s = "helloeqweqweqweqweqwdasaf";
        System.out.println(s.length());

        String s1 = "hello";
        String s2 = "world";
        s1 = s1.concat(s2);
        System.out.println(s1);

        //字符索引  注意不能越界访问
        //根据位置找字符： charAt(位置)
        String s3 = "helloworld";
        System.out.println(s3.charAt(1));//输出的是e
        System.out.println(s3.charAt(2));//输出的是l

        //根据字符找位置： indexOf(字符串)
        System.out.println(s3.indexOf("l"));//字符串中有3个'l'，仅显示首个l的位置
        System.out.println(s3.indexOf("wor"));//字符串中仅会显示字符串第一个字符的位置
        System.out.println(s3.indexOf("dd"));//找不到字符串，返回-1


        //截取字符串：substring(int index)
        String s4 = "HelloWorld!";
        String s5 = s4.substring(5);//从第五个开始到结尾的字符串 "World!"
        System.out.println(s5);
        //substring(int begin,int end)
        String s6 = s4.substring(2, 6);//从第二个开始到第六个，但是不包含第六个 ”lloW”
        System.out.println(s6);

        //将字符串转变字符数组  public char[] toCharArray()
        String s7 = "helloworld";
        char[] c = s7.toCharArray();
        for (int i = 0; i < c.length; i++) {
            System.out.println(c[i]);
        }

        //将字符串转变成新的字节数组 public byte[] getBytes()
        String s8 = "abc";
        byte[] b = s8.getBytes();
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }

        //字符串的替换 前面的字符串换成后面的字符串
        String s9 = "hellojava";
        String replace1 = s9.replace("hello", "Hello");
        System.out.println(replace1);
        String replace2 = s9.replace("hello", "***");//语言和谐

        //字符串的切分
        String s10 = "abc&def&ghi&java";
        String[] strArr = s10.split("&");//["abc","def","ghi","java"]
        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }

    }

大小写数字的统计

import java.util.Scanner;

public class Array {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();

        int smallCount = 0;
        int bigCount = 0;
        int numCount = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) >= 'A' & s.charAt(i) <= 'Z') {
                bigCount++;
            } else if (s.charAt(i) >= 'a' & s.charAt(i) <= 'z') {
                smallCount++;
            }
            if (s.charAt(i) >= '0' & s.charAt(i) <= '9') {
                numCount++;
            }
        }
        System.out.println("小写字母个数为：" + smallCount + "大写字母个数为：" + bigCount + " 数字个数" + numCount);
    }

}

字符串反转

import java.util.Scanner;

public class Array {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String s1 = new String();
        for (int i = s.length() - 1; i >= 0; i--) {
            s1 += s.charAt(i);
        }
        System.out.println(s1);
    }
}

字符串类的判断方法：
equals比较格式：字符串对象1.equals(字符串对象2)  区分大小写
      相等则返回 true
      不等则返回 false
equalsIgnoreCase比较格式：字符串对象1.equalsIgnoreCase(字符串对象2)  不分大小写
       为真则返回 true
       为假则返回 false

注意："=="不能够比较字符串对象1和字符串对象2的内容
因为字符串对象是引用类型，"=="该符号比较地址值，所以地址值不同返回false

如果是对基本类型做==比较的话，则是比较数据值是否相同

 public static void main(String[] args) {
        //观察下列结果
        String s = "hello";
        System.out.println(s.equals("hello"));
        System.out.println(s.equals("Hello"));

        System.out.println(s.equalsIgnoreCase("hello"));
        System.out.println(s.equalsIgnoreCase("HELLO"));

//      引用类型“==”比较地址值
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s1 == s2);//true   hello共享
        System.out.println(s1 == s3);//false  new创建了新的对象，地址值发生改变
        System.out.println(s1 == s4);//false  new创建了新的对象，地址值发生改变
        System.out.println(s3 == s4);//false  new创建了新的对象，地址值发生改变

    }

StringBuilder类

作用：如果对字符串进行拼接操作，每次拼接都会构建出一个新的String对象，几号是，又浪费内存空间，而这种操作还不可避免。这时可以通过Java提供的StringBuilder类来解决这个问题。

概述：StringBuilder是一个可变的字符串类，可以把它看成是一个容器（内容可变）

String和StringBuilder的区别：String内容是不可变得，StringBuilder内容是可变的

其常见构造方法：public StringBuilder() 无参构造方法，创建一个空白可变的字符串对象，不含有任何内容

public StringBuilder(String str) 根据字符串的内容来创建可变字符串对象

public class Array {
    public static void main(String[] args) {
        //public StringBuilder() 无参构造方法，创建一个空白可变的字符串对象，不含有任何内容
        StringBuilder stringBuilder = new StringBuilder();
        System.out.println("stringBuilder: " + stringBuilder);
        //public StringBuilder(String str) 根据字符串的内容来创建可变字符串对象
        StringBuilder stringBuilder1 = new StringBuilder("hello");
        System.out.println("stringBuilder1: " + stringBuilder1);

        //public StringBuilder append 添加数据，返回对象本身
        StringBuilder stringBuilder2 = stringBuilder.append("abc");
        System.out.println("stringBuilder: " + stringBuilder);
        System.out.println("stringBuilder2: " + stringBuilder2);
        System.out.println(stringBuilder == stringBuilder2);

        StringBuilder s = new StringBuilder();
        /* s.append("a");
        s.append("b");
        s.append("c");
        s.append(1);*/
        //链式编程
        s.append("a").append("b").append("c").append(1);
        System.out.println(s);

        //public StringBuilder reverse() 返回相反的字符序列
        StringBuilder reverse = stringBuilder1.reverse();
        System.out.println(reverse);
    }
}

StringBuilder和String的相互转换

1、StringBuilder--->String

public String toString()方法

2、String--->StringBuilder

public StringBuilder(String str)方法

public class Array {
    public static void main(String[] args) {

        // 1、StringBuilder--->String
        //public String toString()方法
        StringBuilder stringBuilder = new StringBuilder("hello");
        String s = stringBuilder.toString();
        System.out.println(s);

        //2、String--->StringBuilder
        //public StringBuilder(String str)方法
        String str = new String("str");
        StringBuilder stringBuilder1 = new StringBuilder(str);
        System.out.println(stringBuilder1);

    }
}