String类及该类中的方法[java]

目录

         ⛳️概述

⛳️String对象的两种创建方法

1.简化方式(也称之为字面量定义方式)

2.new+构造方法

⛳️String类中的常用方法

1.构造方法

2.判断功能

3.获取功能

4.转换功能

5.替换功能

6.去除字符串两空格

---

⛳️概述

字符串是由多个字符组成的一串数据，值一旦创建不可改变，一旦值改变就会创建一个新对象，java中所有字符串都是String类的实例.

1.String类是一个由final关键字修饰的类，不能被继承

2.为什么说值一旦创建不能修改？

• 我们只要在内存中为某一个字符串常量在内存中开辟了空间，并且将这个字符串常量存了进去，那么这个内存中就一直存的是这个字符串常量，一直不可以改变，直到这一片内存被回收为止

3.字符串类实现了Serializable接口

• 实现这个接口表示字符串是可以序列化的，简单来说序列化就是可以将其转换成字节流来传输

4.字符串类实现了Comparable接口

• 实现了Comparable接口表示字符串是可以比较大小的

5.String类内部定义了private final char value[];

• 值一旦创建不可改变，一旦值改变就会创建一个新对象，在底层其实就是创建了一个新的数组

• char数组用于存储字符串数据，这里的value数组是通过final关键字修饰的，也就说字符串其实是一个常量，一旦在内存中申请出一个空间并为其赋值之后这个空间中的字符串的值就不可以修改了，我们将这个性质称之为不可变性

注意：大量拼接时不建议使用string类型，因为每拼接一次就要创建一个对象

案例：

public class StringDemo {
    public static void main(String[] args) {
        //底层是char数组实现的,可以根据位置找内容，也可以根据内容找位置
        String s = "abc";//char[] c = {'a','b','c'}
                         //             0   1   2
               s+="cd";
    }
}

以debug模式运行(String@487是字符串对象的地址，value={char[3]@488}是里边数组的地址)：

值改变后，创建了一个新的char数组，也就是创建了一个新对象，不是在原来的上边加的：

⛳️String对象的两种创建方法：

1.简化方式(也称之为字面量定义方式)：

例如：

String s = "abc";

创建方式：

先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向该地址即可,不用重新创建.

• 也就是说，通过这种方式创建两个值一样的字符串对象时，这两个字符串对象其实是同一个对象，指向字符串常量池中的同一个对象

案例：

public class StringDemo1 {
    public static void main(String[] args) {
         /*1.简化的创建方式  
           先去字符串常量池中查找,有没有abc,如果没有就在字符串常量中创建一个对象(abc)，如果字符串常量池中已经存在abc，那么直接指向已有的对象即可
          */
         String s1 = "abc";
         String s2 = "abc";
         //== 引用类型比较的是地址值
         System.out.println(s==s1);//true 
         //equals比较内容
         System.out.println(s.equals(s1));//true
    }
}

指向的是同一个地址值：

2.new+构造方法：

都在堆中创建新对象，值存储在堆内存的对象中。

例如：

String s = new String("abc");

案例：

public class StringDemo2 {
    public static void main(String[] args) {
         /*2.new +构造方法
             凡是new 出来的,在内存空间中是独一无二的，即对象地址值不同
          */
         String s3 = new String("abc");
         String s4 = new String("abc");
         System.out.println(s3==s4);//false
         System.out.println(s3.equals(s4));//true
    }
}

指向的地址值不同：

创建方法图示：

注意：创建出来对象的值实际上还是同一个字符串常量池中的值，相当于套了一个对象的壳子，所以s、s1、s2、s3,char[]数组的值相同，==比较的是外面对象的地址，所以返回false

⛳️String类中的常用方法

1.构造方法：

①public String()

• 初始化一个新创建的 String 对象，使其表示一个空字符序列。

• 注意：由于字符串不可变的，所以无需使用此构造方法。

②public String(String str)

• 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本

• 由于 String 是不可变的，所以无需使用此构造方法

案例：

/*
 构造方法
 1.String();
  源码：public String() {
          this.value = "".value;
       }
  2.String("字符串");
   传进去一个字符串，用传进去的字符串为底层fina修饰的char数组直接进行赋值
*/
String s1 = new String();
String s2 = new String("abc");

③public String(byte[] bytes)

• 将byte[]数组转换为字符串(byte[]--->String)

案例：

public class StringDemo3 {
    public static void main(String[] args) {
        //UTF-8编码中，一个汉字占三个字节
        String s = "你好";
        //用public String(byte[] b)构造方法解码
        String s1 =  new String(b,"UTF-8");//解码
        System.out.println(s1);//你好
        //从位置3开始转，长度为3
        String s1 =  new String(b,3,3,"UTF-8");//解码
        System.out.println(s1);//好
    }
}

④public String(char[] value)

• 将char数组转换为字符串(char[]--->String)

案例：

public class StringDemo4 {
    public static void main(String[] args) {
        String s = "abcd";
        //将字符串转换为一个新的char数组
        char[] chars =  s.toCharArray(); 
        System.out.println(Arrays.toString(chars));//[a,b,c,d]
        //将char数组 转为字符串
        String s1 =  new String(chars); 
        System.out.println(s1);//abcd
    }
}

2.判断功能：

①boolean equals(Object obj)

• 比较字符串的内容是否相等

案例：

public class StringDemo3 {
    public static void main(String[] args) {
       String s1 = "abc";
       String s2 = new String("abC");
       //比较字符串内容是否相等
       System.out.println(s1.equals(s2));//false
    }
}

②boolean equalsIgnoreCase(String str)

• 此方法与equals()方法类似，不同在于此方法比较时忽略字符的大小写

案例：

public class StringDemo4 {
    public static void main(String[] args) {
       String s1 = "abc";
       String s2 = new String("abC");
       //比较字符串内容是否相等(忽略大小写)
       System.out.println(s1.equalsIgnoreCase(s2));//true
    }
}

③boolean contains(String str)

• 判断是否包含指定的子串

• 当且仅当此字符串中包含指定的char值序列时，返回true，否则返回false

案例：

public class StringDemo5 {
    public static void main(String[] args) {
       String s1 = "abc";
       //是否包含指定的子串
       System.out.println(s1.contains("c"));//true
    }
}

④boolean isEmpty()

• 判断字符串是不是空串

• return value.length==0

案例：

public class StringDemo6 {
    public static void main(String[] args) {
       String s1 = "abc";
       //判断是否为""
       System.out.println(s1.isEmpty());//false
    }
}

⑤boolean startsWith(String prefix)

• 判断此字符串是否是以指定的字符串开始

• 这里的字符串可以是空字符串，也可以是由多个字符构成的字符串

案例：

public class StringDemo7 {
    public static void main(String[] args) {
       String s1 = "abc";
       //判断是否以指定字符串开头
       System.out.println(s1.startsWith("ab"));//true
    }
}

⑥boolean endsWith(String suffix)

• 判断此字符串是否是以指定的字符串结尾

• 同样，这里的字符串可以是空字符串，也可以是由多个字符构成的字符串

案例：

public class StringDemo8 {
    public static void main(String[] args) {
       String s1 = "abc";
       //判断是否以指定字符串结尾
       System.out.println(s1.endsWith("bc"));//true
    }
}

⑦ int compareTo((String anotherString)

• 比较两个字符串大小

• 结果为负数时，当前对象小，参数对象大

• 结果为正数时，当前对象大，参数对象小

• 结果为0，两个字符串对象大小相同

案例：

public class StringDemo9 {
    public static void main(String[] args) {
       String s3 = "abc";
       String s4 = "efg";
       //字符串比大小
       System.out.println(s3.compareTo(s4));//-4(前边小，后边大)
    }
}

3.获取功能：

①int length()

• 返回字符串长度

• return value.length;

案例：

public class StringDemo10 {
    public static void main(String[] args) {
       String s = "abcdefgd";
       System.out.println(s.length());//8
    }
}

②char charAt(int index)

• 获取指定位置(索引)的字符

• return value[index];

案例：

public class CharAtDemo {
    public static void main(String[] args) {
       String s = "abcdefgd";
       //          01234567
       char c = s.charAt(4);
       System.out.println(c);//e
    }
}

③int indexOf(String str)

• 从前向后找，只找首次出现的位置，返回指定子字符串在此字符串中第一次出现的索引

• 如果可以找到的指定字符串，那么就输出这个指定字符串在此字符串中第一次出现的首字母的索引，如果找不到，那么这个时候就会返回 -1(返回-1是因为字符串的索引可能是从0开始的正整数，但是绝对不可能是负数，所以我们就用 -1来表示找不到这个字符串)

案例：

public class IndexOfDemo1 {
    public static void main(String[] args) {
       String s = "abcdefgd";
       //          01234567
       //从前向后找 只找首次出现的位置
       int index = s.indexOf("d");
       System.out.println(index);//3
    }
}

④int indexOf(String str,int fromIndex)

• 从指定的索引开始找此字符串中有没有出现这个特定的字符串

• 如果找不到也是返回 -1

• 这个方法可以用于去寻找一个字符串中出现了多少次另一个字符串

1. 第一次找---->返回索引---->第二次找的时候从前一次返回的索引加这个寻找的字符串的字符串的长度之后的值作为第二次的开始继续寻找，然后重复多次操作

案例：

public class IndexOfDemo2 {
    public static void main(String[] args) {
       String s = "abcdefgd";
       //          01234567
       //从前向后找 从指定位置开始
       int index1 = s.indexOf("d",index+1);
       System.out.println(index1);//7
    }
}

⑤String substring(int start)

• 返回一个截取的字符串

• 从指定的位置开始截取字符串，直接到最后一位，最终返回一个新的字符串对象

案例：

public class SubstringDemo1 {
    public static void main(String[] args) {
       String s1 = "abcdefgd";
       //           01234567
       //从指定的位置开始截取字符串，直接到最后一位，最终返回一个新的字符串对象
       String s2 =  s1.substring(3);
       System.out.println(s1);//abcdefgd 
       System.out.println(s2);//defgd
    }
}

⑥String substring(int start,int end)

• 返回一个截取的字符串

• 左闭右开截取

案例：

public class SubstringDemo2 {
    public static void main(String[] args) {
       String s1 = "abcdefgd";
       //           01234567
       //截取指定区间 包含开始位置，不包含结束位置
       String s3 = s1.substring(2,6);
       System.out.println(s3);//cdef
    }
}

4.转换功能：

①byte[] getBytes()

• String--->byte[]

• 这个方法中可以传输一个字符串实参，表示你想通过哪种编码集进行编码，但是这里会抛出一个异常，这个异常是因为担心用户输入一个没有的字符集，所以在这里就要将异常处理掉，要么使用try---catch---finally方式直接解决，要么用throws+异常类型将这个异常抛出

案例：

public class GetBytesDemo {
    public static void main(String[] args) {
       //平台中默认是utf-8编码，在utf-8编码中，一个汉字占3个字节
       String s = "你好";
       byte[] b = s.getBytes("UTF-8");//编码
       System.out.println(Arrays.toString(b));//[-28,-67,-96,-27,-91,-67]
       //用public String(byte[] b)构造方法解码
       String s1 =  new String(b,"UTF-8");//解码
       System.out.println(s1);//你好
       //从位置3开始转，长度为三
       String s1 =  new String(b,3,3,"UTF-8");//解码
       System.out.println(s1);//好
    }
}

②char[] toCharArray()

• String--->char[]

案例：

public class ToCharArrayDemo17 {
    public static void main(String[] args) {
       String s = "abcd";
       //将字符串转换为一个新的char数组
       char[] chars =  s.toCharArray(); 
       System.out.println(Arrays.toString(chars));//[a,b,c,d]
    }
}

③static String valueOf(char[] chs)

• char[]--->String

案例：

public class ValueOfDemo {
    public static void main(String[] args) {
       String s = "abcd";
       //将字符串转换为一个新的char数组
       char[] chars =  s.toCharArray(); 
       System.out.println(Arrays.toString(chars));//[a,b,c,d]
       //将char数组 转为字符串
       String s1 =  String.valueOf(chars);
       System.out.println(s1);//abcd
    }
}

④String toLowerCase()

• 使用默认语言环境，将String中所有的字符转为小写

案例：

public class ToLowerCase {
    public static void main(String[] args) {
       String s = "abcdEFG";
       //转小写
       System.out.println(s.toLowerCase());//abcdefg
    }
}

⑤String toUpperCase()

• 使用默认语言环境，将String中所有的字符转为大写

案例：

public class ToUpperCaseDemo20 {
    public static void main(String[] args) {
       String s = "abcdEFG";
       //转大写
       System.out.println(s.toUpperCase());//ABCDEFG
    }
}

⑥String concat(String str)

• 将指定的字符串连接到此字符串的结尾，可以将多个字符串连接起来

案例：

public class ConcatDemo {
    public static void main(String[] args) {
       String s = "abcd"
       // +可以连接其他类型,这个只能连接字符串 
       String s1 = s.concat("ww");  
       System.out.println(s1);//abcdww
    }
}

⑥Stirng[] split(String regex);

• 根据给定的正则表达式将此字符串拆分成一个字符串数组

• 这里的返回值为String [] (字符串数组)

案例：

public class SplitDemo1 {
    public static void main(String[] args) {
       String s = "ab&cde&efg";
       //按照指定的分隔符,将字符串拆分为数组
       String[] strings = s.split("&");
       System.out.println(Arrays.toString(strings));//[ab, cde, efg]
    }
}

⑦Stirng[] split(String regex，int limit);

• 将拆分范围内的符合给定的正则表达式的子字符串拆成一个字符串数组

• 这里的返回值也为字符串数组的形式

案例：

public class SplitDemo2 {
    public static void main(String[] args) {
       String s = "ab&cde&efg";
       //按照限制的长度拆分
       String[] s2 = s.split("&", 2);
       System.out.println(Arrays.toString(s2));//[ab, cde&efg]
    }
}

总结：

1.String与char[]之间的转换

• 虽然String的底层就是通过char[]数组存储的，但是有的时候我们还是要将字符串转换成char[]来操作

• eg：给字符串中的元素排序

直接对字符串中元素排序显然是有些困难的，这个时候我们就需要将这个字符串转换成一个char[]数组，再对char[]数组进行操作，现在就可以直接调用数组中的排序方法直接对char[]进行排序，排序完之后我们再将这个char[]数组转换成字符串，这样解决就变得很简单了

①String--->char[]

• 调用String中的toCharArray();

②char[]--->String

• 调用String中的构造方法new String(char[] chars)

• 调用String中的valueOf(char[] chars)方法(此方法是一个静态方法，直接通过String.来调用)

2.String与byte[]之间的转换

①String--->byte[] (这一过程也称为编码)

     调用String中的getBytes()方法

1. 这个方法中可以传输一个字符串实参，表示你想通过哪种编码集进行编码，但是这里会抛出一个异常，这个异常是因为担心用户输入一个没有的字符集，所以在这里就要将异常处理掉，要么使用try---catch---finally方式直接解决，要么用throws+异常类型将这个异常抛出

②byte[]--->String (这一过程也称为解码)

      调用String的构造器(String类中提供了很多的构造器，我们可以使用形参为byte[]的构造器来将byte[]数组转化为一个String类型的对象)

1. String构造器中提供了很多种重载的方法，这里除了有形参为byte[]的构造器，还有有两个参数的构造器，这个构造器中除了要输入这个byte[]之外，还要输入一个String类型的参数，这个String类型的参数就是指定的编码集，我们就可以用指定的编码进行解码

• 编码：字符串--->字节码(我们能看懂的转换成看不懂的)

• 计算机底层会继续将字节码转换为计算机能认识的二进制数据

• 解码：字节码--->字符吗(将看不懂的转换为可以看懂的)

3.常用编码

• UTF-8编码表中汉字是以三个字节存储的，GBK中汉字是以两个字节存储的

• 编码和解码的过程一般是要使用同类型的编码进行操作，否则可能会出现乱码，不过也有可能不会乱码

       那么什么时候不会乱码?

       当字符串内容都是ASCII码字符集中的符号时一般就不会乱码，因为大多数字符集最开始都是复制ASCII码字符集的，它们开头的前128位都是ASCII码字符，所以在使用大多数编码进行编码时，都不会出现乱码，因为它们在字符集中的编码都一样

5.替换功能：

①String replace(char old,char new)

• 返回一个新字符串，用newChar字符替换了原来字符串中的oldChar

②String replace(String old,String new)

• 把指定字符串替换成指定新的字符串返回

③String replaceAll(String regex, String replacement)

• 使用给定的replacement字符串替换此字符串中所有匹配给正则表达式的子字符串

• 这里的regex是正则的意思

④String replaceFirst(String regex, String replacement)

• 使用给定的replacement字符串替换此字符串中第一个匹配给正则表达式的子字符串

案例：

public class ReplaceDemo {
        public static void main(String[] args) {
            String o = "Hello World";
            String n = "O";
            //用新的内容替换全部旧的内容
            System.out.println(o.replace("o", "O"));//HellO WOrld
            System.out.println(o.replaceAll("l", "L"));//HeLLo WorLd
            //替换首个满足条件的内容
            System.out.println(o.replaceFirst("l","L"));//HeLlo World
        }
    }

6.去除字符串两空格：

String trim()

1. 返回字符串的副本，忽略前导空白和后导空白

2. 只删除字符串前后的空格，不删除中间的空格，要想去除中间的空格，可以使用上面替换功能中的replace()或方法replaceAll()

3. 可用于输入用户名查找时，如果客户在输入的名字前或名字后多输了空格，这个时候我们就需要通过这个方法来删除用户名前面和后面的空格，这样就能保证用户搜索的正确性

案例：

public class TrimDemo {
        public static void main(String[] args) {
           String s = " a bc ";
           String s1=s.trim();
           //只删除字符串前后的空格，不删除中间的空格
           System.out.println(s1);//ac
        }
}