【JavaSE篇】——String的常用方法(全面知识覆盖）

字符串常用方法

🎈字符串构造

🎈字符串长度(length)

🎈字符串是否为空(empty)

🎈String对象的比较

🌈==比较是否引用同一个对象(boolean）

🌈boolean equals(Object anObject) 方法：按照字典序比较

🌈int compareTo(String s) 方法: 按照字典序进行比较

🌈int compareToIgnoreCase(String str) 方法

🎈字符串查找(indexOf)

🌈charAt(int index)返回数组某一个下标字符

🌈indexOf(int ch)返回字符在字符串中第一次出现的索引

🎓indexOf(int ch,int fromIndex)从指定索引开始找返回第一次出现字符索引

🎓indexOf(String str)返回子字符串第一次出现的索引

🎓indexOf(String str,int fromIndex)从指定索引开始找返回第一次出现字符串索引

🎈字符串转化

🌈 数值和字符串转化

🎓数值-》字符串

🎓字符串-》数值

🌈类和字符串转换

🌈大小写转换(toLower/UpperCase)

🌈字符串和数组转化(tocharArray)

🎓字符串-》数组(toCharArray)

🎓数组-》字符串

🌈格式化(format)

🎈字符串替换(replace)

🌈replace(char oldChar,char newChar)将所有oldChar改成newChar

🌈老子字符串转换成新子字符串(只改变一个）

🌈repalceAll 将所有的老子字符串改成新子字符串

🌈repalceFirst 将第一个出现的老子字符串改成新子字符串(只改一个）

🎈字符串拆分(Split)

🌈split(String regex)通过regex分隔开

🌈split(String regex,int limit)通过regex分隔开最多分成limit组

🌈多次拆分(双层循环)

🎈字符串截取(substring)

🎈消除左右空格（trim)

🎈是否包含字符或者字符串(contains)

🎈是否以某个子字符串结尾 endsWith

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。

字符串常用方法

在字符串当中的库函数，基本上只要改变，都是返回一个新的字符串。

🎈字符串构造

        //使用常量构造字符串
        String s1="clizyf";
        System.out.println(s1);

        //直接new String对象
        String s2=new String("clizyf");
        System.out.println(s2);

        //使用字符数组进行构造
        char[] s3={'c','l','i','z','y','f'};
        System.out.println(s3);

【注意】

String是引用类型，内部并不存储字符串本身 ，在 String 类的实现源码中， String 类实例变量如下：

我们可以看到String类下有俩个成员变量，一个是hash值，还有一个在String中有一个属性private final char value[];用于存放字符串内容，实际上字符串的本质还是字符串数组，value[]就是那个对应的字符串数组。

🎈字符串长度(length)

字符串串的长度其实底层就是String对象所指向的value所指向的对象数组的长度，不包含'\0'

 String s1=new String("hello");
        System.out.println(s1.length());

我们看到字符串长度是5，在java中不记'\0'。有几个字符长度就是几个。

在Java中“”引起来的也是String类型对象

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

🎈字符串是否为空(empty)

字符串是否为空主要看的是字符串中的数组的长度是否是0，如果是0就空，不是0就不空。

        String s1=new String("hello");
        System.out.println(s1.isEmpty());//false

        String s2=new String("");
        System.out.println(s2.isEmpty());//true

🎈String对象的比较

🌈==比较是否引用同一个对象(boolean）

注意：对于内置类型， == 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。

  public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
    // 对于基本类型变量，==比较两个变量中存储的值是否相同
        System.out.println(a == b); // false
        System.out.println(a == c); // true
    // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1 == s2); // false
        System.out.println(s2 == s3); // false
        System.out.println(s1 == s4); // true
    }

对于 基本类型 变量，==比较两个变量中存储的值是否相同

对于 引用类型 变量，==比较两个引用变量引用的是否为同一个对象

我们就根据引用类型变量来展开讨论。

// s1和s2引用的是不同对象 s1和s3引用的是同一对象
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;

总结：我们new就是一个新的对象，都是指向了不同的地址。（==比较的是地址）

🌈boolean equals(Object anObject) 方法：按照字典序比较

字典序：字符大小的顺序

String 类重写了父类 Object 中 equals 方法， Object 中 equals 默认按照 == 比较， String 重写 equals 方法后，按照如下规则进行比较，比如： s1.equals(s2)

  public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }

总结：equals方法比较的是对象的内容（虽然对象的地址不同，但是对象内的内容都是hello，那么就是相等）

==和equals的区别

public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
    System.out.println(s1 == s2); // false
    System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
    System.out.println(s1.equals(s2)); // true
    System.out.println(s1.equals(s3)); // false
}

== 引用的都是不同的对象，返回肯定是false，如果是指向的是同一个对象，那么返回true.(我觉得能返回true的都是存在赋值，一个已经创建的对象赋值给新创建的。

String s1=new String("hello");

String s2=s1; //这时候我们可以知道俩者用在==上是true。

equals主要看的是对象中的内容是否相等。不是引用同一个对象都没事。

🌈int compareTo(String s) 方法: 按照字典序进行比较

与 equals 不同的是， equals 返回的是 boolean 类型，而 compareTo 返回的是 int 类型。具体比较方式：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

 public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

🌈int compareToIgnoreCase(String str) 方法

与 compareTo 方式相同，但是忽略大小写比较

public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}

这个不计大小写在实际开发中常见，比如我们在输入验证码的时候，我们看到字母有大写也有小写，我们都可以输入大写或者都可以输入小写，都是没有问题的。可能后台的代码就显示了不分大小写。

🎈字符串查找(indexOf)

🌈charAt(int index)返回数组某一个下标字符

    public static void main(String[] args) {
        String s=new String("clizyf");
        for (int i = 0; i < s.length(); i++) {
            char ch=s.charAt(i);
            System.out.print(ch+"  ");
        }
    }

         String s=new String("clizyf");
        System.out.println(s.charAt(1));//‘l’

🌈indexOf(int ch)返回字符在字符串中第一次出现的索引

🎓indexOf(int ch,int fromIndex)从指定索引开始找返回第一次出现字符索引

🎓indexOf(String str)返回子字符串第一次出现的索引

🎓indexOf(String str,int fromIndex)从指定索引开始找返回第一次出现字符串索引

int lastIndexOf(int ch) 从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex) 从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str) 从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex) 从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

这些和indexOf是一样的操作，不同之处就是last代表从后往前找。

🎈字符串转化

这里我们看到valueOf重载了不同类型的参数，万物都是可以转换的，只用字符串接受，都是可以转换成字符串的。

🌈 数值和字符串转化

🎓数值-》字符串

//数字转字符串
String s=String.valueOf(123);
System.out.println(s);

定义一个字符串接受数字，数字就转换成字符串了。

🎓字符串-》数值

  public static void main(String[] args) {
        //字符串转数字
        int a=Integer.parseInt("123");
        System.out.println(a);

        long b=Long.parseLong("123");
        System.out.println(b);

        double c=Double.parseDouble("222");
        System.out.println(c);
    }

Integer、Double等是Java中的包装类型

🌈类和字符串转换

   String s1=String.valueOf(new Student("chenle",18));
        System.out.println(s1);

class Student{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

我们看到底层的代码valueOf调用的是类里的toString()。

🌈大小写转换

    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
    // 小写转大写
        System.out.println(s1.toUpperCase());
    // 大写转小写
        System.out.println(s2.toLowerCase());
    }

🌈字符串和数组转化(tocharArray)

🎓字符串-》数组(toCharArray)

    public static void main(String[] args) {
        String s1="zyficl";
        char[] arr=s1.toCharArray();
        System.out.println(Arrays.toString(arr));
    }

🎓数组-》字符串

    public static void main(String[] args) {
        String s1="zyficl";
        char[] arr=s1.toCharArray();//字符串转数组
        String s2=new String(arr);//数组转字符串
        System.out.println(s2);
    }

arr数组拷贝给new String 指向的对象value指向的数组，然后进行拷贝给s2。

🌈格式化(format)

    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2019, 9,14);
        System.out.println(s);
    }

🎈字符串替换(replace)

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

🌈replace(char oldChar,char newChar)将所有oldChar改成newChar

    public static void main(String[] args) {
        String s="asjdiodhasodhioas";
        String ret=s.replace('a','p');//将'a'代替成'p'
        System.out.println(ret);
    }

🌈老子字符串转换成新子字符串(只改变一个）

🌈repalceAll 将所有的老子字符串改成新子字符串

🌈repalceFirst 将第一个出现的老子字符串改成新子字符串(只改一个）

🎈字符串拆分(Split)

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

🌈split(String regex)通过regex分隔开

        String s="abcdabca&cabchabc";
        String[] ret=s.split("&");

我们需要通过字符串数组接收，进行分隔开俩个数组。

🌈split(String regex,int limit)通过regex分隔开最多分成limit组

        String s="abcdabca&cab&cha&bc";
        String[] ret=s.split("&",2);

limit可以随意设置，指的是最少分隔多少组。

注意事项 :

1. 字符"|","*","+"，"." 都得加上转义字符，前面加上 "\\" .

否则是个空串。

2. 而如果是 "\" ，那么就得写成 "\\\\" .（\\相当于一个\)

3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符
 String str = "name=zhangsan&age=18" ;
        String[] str1=str.split("=|&");
        for (String x:str1){
            System.out.print(x+"  ");
        }

🌈多次拆分

    String str2 = "name=zhangsan&age=18" ;
        String[] str3=str2.split("&");
        for(String x:str3){
            System.out.println(x);
        }

从这段代码可以分出两部分，这时候我们可以”=“继续拆分。

 String str2 = "name=zhangsan&age=18" ;
        String[] str3=str2.split("&");
        for(String x:str3){
            String[] ss=x.split("=");
            for (String y:ss){
                System.out.println(y);
            }
        }

再通过=接收，用一个字符串数组接收，就可以实现多次拆分。

🎈字符串截取(substring)

从beginIndex位置开始截取到最后

   public static void main(String[] args) {
        String str="zyficl";
        String ret=str.substring(3);
        System.out.println(ret);
    }

从beginIndex位置开始到endIndex结束截取

         String str="zyficl";
        String s=str.substring(0,2);
        System.out.println(s);

在java中都是左闭右开的，我们从0位置到2位置，实则是[0,2),2的下标取不到。

🎈消除左右空格（trim)

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).

   public static void main(String[] args) {
        String s="i love zyf     ";
        String m="zyfzyfzyf";
        System.out.println(s+m);
    }

我们看到这里并没有去除右边空格。

String trim() 去掉字符串中的左右空格,保留中间空格

    public static void main(String[] args) {
        String s="i love zyf     ";
       String ss=s.trim();
        String m="zyfzyfzyf";
        System.out.println(ss+m);
    }

🎈是否包含字符或者字符串(contains)

   public static void main(String[] args) {
        String s=" abc hello ";
        boolean ss=s.contains("hello");
        System.out.println(ss);
    }

🎈是否以某个子字符串结尾 endsWith

   public static void main(String[] args) {
        String s="hellodasdsad";

        boolean ss1=s.endsWith("sa");
        System.out.println(ss1);   //false

        boolean ss=s.endsWith("sad");
        System.out.println(ss);    //true
    }