Java常用类-String类

Java常用类-String类
字符串相关的类：String

String类：代表字符串，Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
- String是一个final类，代表不可变的字符序列
  - 当字符串重新赋值时，需要重新指定内存区域，不能使用原有的value进行赋值
  - 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，也不能在原有的value上进行赋值
  - 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域进行赋值
  - 也就是说对String的任何修改都是重新的造一个
- 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改
- String内部定义了final char value[] 用于存储字符串数据
- String实现了Serializable接口，表示字符串是支持序列化的，实现了 Comparable接口，表示String可以比较大小
- 通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串的值是声明在字符串常量池中的
- 字符串常量池是不会存储相同内容的字符串
```
public void test1(){
        String s1 = "abc";//字面量的方式
        String s2 = "abc";

        System.out.println(s1 == s2);// ture , 比较的是s1和s2的地址值
        s1 = "hello";

        System.out.println(s1); // hello
        System.out.println(s2); // abc

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3); // abcdef
        System.out.println(s2 == s3); // false , 此时的s2和s3的地址值已经不同


        String s4 = "abc";
        String s5 = s4.replace('a' , 'd');
        System.out.println(s4); // abc
        System.out.println(s5); // dbc
    }
```
1. String的实例化方式
- 通过字面量定义的方式：此时的s1和s2的数据是声明在方法区的字符串常量池中
- 通过new + 构造器的方式：此时的s3和s4保存的地址，是数据在堆空间中开辟空间以后对应的地址值
```
  public void test2(){

        String s1 = "Java";
        String s2 = "Java";

        String s3 = new String("Java");
        String s4 = new String("Java");

        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // false
        System.out.println(s1 == s4); // false
        System.out.println(s3 == s4); // false



        Person p1 = new Person("Tom",18);
        Person p2 = new Person("Tom",18);
        System.out.println(p1.name.equals(p2.name)); // true , String重写了equals方法，此时比较的就是内容了
        System.out.println(p1.name == p2.name); // true , 两个对象里面还是字面量定义的方式赋值
    }
```
注：两个对象里面还是字面量定义的方式赋值

面试题

String s = new String("abc")方式创建对象，在内存中创建了几个对象？

两个，一个是堆空间的new的结构，一个是char[]对应的常量池中的数据 "abc"

2. 字符串的特性

重点：
- 常量与常量的拼接结果在常量池中，且常量池中不会存在相同内容的常量
- 只要其中一个是变量，结果就在堆中
- 如果拼接的结果调用intern()方法，返回值就是在常量池中
```
public void test3(){
        String s1 = "Java";
        String s2 = "Python";

        String s3 = "JavaPython";
        String s4 = "Java" + "Python";
        String s5 = s1 + "Python";
        String s6 = s1 + s2;

        System.out.println(s3 == s4); // true

        System.out.println(s3 == s5); // false
        System.out.println(s4 == s5); // false
        System.out.println(s3 == s6); // false

        String s7 = s5.intern();
        System.out.println(s7 == s3); //true
    
    }
```
特别注意：当 final String s1 = “java”，这个也就相当于一个常量了

3. 面试题：

good and best

这里可以参考之前的Java的值传递

若在scr前面加一个this，情况会是怎样？
```
package com.atguigui.exer;

/**
 * @author MD
 * @create 2020-07-12 9:41
 */
public class StringTest {

    String str = new String("good");
    char[] ch = {'t','e','s','t'};

    public void change(String str, char ch[]){
        this.str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);
        System.out.println(ex.ch);
        // test ok
        // best
        
    }
}
```
4. String常用的方法

注意String的不可变性，原字符不变
- int length()：返回字符串的长度： return value.length
- char charAt(int index)：返回某索引处的字符return value[index]
- boolean isEmpty()：判断是否是空字符串：return value.length == 0
- String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
- String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
- String trim()：返回字符串的副本，忽略前导空白和尾部空白
- boolean equals(Object obj)：比较字符串的内容是否相同
- boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
- String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
- int compareTo(String anotherString)：比较两个字符串的大小涉及到字符串排序
- String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从 beginIndex开始截取到最后的一个子字符串。
- String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
- boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
- boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
- boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
- boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true，也就是字符串A中是否包含字符串B
- int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
- int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
- int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
- int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
- 注：indexOf和lastIndexOf方法如果未找到都是返回-1
- String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
- String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
- String replaceAll(String regex, String replacement) ：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
- String replaceFirst(String regex, String replacement) ：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
- boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式
- String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
- String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
5. String与基本数据类型转换

String ---> 基本数据类型、包装类
- 调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 --- >字符串
- 调用String的valueOf(xxx)
```
public void test2(){
        String str = "123";
        
        int num = Integer.parseInt(str);
        
        String str1 = String.valueOf(num);
    }
```
String ---> char[] : 调用String的toCharArray()

char[] ---> String: 调用String的构造器
```
public void test3(){
        String str = "asdf123";

        char[] charArray = str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        String str1 = new String(charArray);
        System.out.println(str1);

    }
```
编码：String ---> byte[] :调用String的getBytes()
解码：byte[] ---> String : 调用String的构造器
```
/**
     * 编码：字符串 -->字节 (看得懂的---->看不懂的二进制数据)
     * 解码：字节 ---> 字符串(看不懂的二进制数据---->看得懂的)
     * @throws UnsupportedEncodingException
     */
    @Test
    public void test4() throws UnsupportedEncodingException {
        String str = "abc123你好";
        byte[] bytes = str.getBytes(); // 使用默认的字符集进行转换 UTF-8 编码
        System.out.println(Arrays.toString(bytes));

        String str1 = "abc123你好";
        byte[] bytes1 = str1.getBytes("gbk"); // 指定编码格式
        System.out.println(Arrays.toString(bytes1));


        System.out.println("---------------------");
        String str2 = new String(bytes); // 解码，使用的默认的格式
        System.out.println(str2);

        String str3 = new String(bytes1 , "gbk");// 解码，使用的指定的格式
        System.out.println(str3);
    }
```
6. StringBuffer、StringBuilder ？

面试题：对比String、StringBuffer、StringBuilder ？
- String(JDK1.0)：不可变字符序列，效率最低
- StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全同步
- StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全
- 底层都使用char[]存储
注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder 会改变其值
```
源码分析：
String str = new String(); // char[] value = new char[0];
String str1 = new String("abc"); // char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer(); // char[] value = new char[16];底层创建一个长度16的char型数组
StringBuffer sb1 = new StringBuffer("abc"); // char[] value = new char["abc".length()+16];
```
问题1：

注意这个是里面里面数据的长度，
```
public void test5(){
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1.length()); // 0

        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2.length()); // 3

    }
```
问题2：

扩容问题，如果要添加的数据放不下了，那就需要扩容数组，默认情况下，扩容为原来的2倍+2，将原有数组中的数据复制到新的数组中去

String -----> StringBuffer、StringBuilder : 调用StringBuffer、StringBuilder构造器就可以了

StringBuffer、StringBuilder -----> : 调用String的构造器

StringBuffer类的常用方法和StringBuilder类似
- StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
- StringBuffer delete(int start,int end)：删除指定位置的内容
- StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
- StringBuffer insert(int offset, xxx)：在指定位置插入xxx
- StringBuffer reverse() ：把当前字符序列逆转
- public int indexOf(String str)
- public String substring(int start,int end)
- public int length()
- public char charAt(int n )
- public void setCharAt(int n ,char ch)
总结：
- 增：append
- 删：delete
- 改：setCharAt，replace
- 查：charAt
- 插入：insert
- 长度：length
面试题：
```
 public void testStringBuffer(){
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);

        System.out.println(sb.length()); // 4

        System.out.println(sb); //  "null" 这个是字符串null

        StringBuffer sb1 = new StringBuffer(str); // 抛异常 NullPointerException
        System.out.println(sb1);
    }
```
相关阅读:
[树状数组]H千万别用树套树
 [可持久化权值线段树上二分] Just h-index
[大数] 组合数
 [模板]离散化
 [树状数组] Galahad
[可持久化权值线段树] hdu 6703 array
python Web抓取（二）selenium模块的使用、对浏览器的按键操作及错误处理
 python 调试大法-大笨蛋的笔记
 从终端运行python程序模块内变量的作用域、添加模块的搜索路径
 Python组织文件实践：查找大文件、用Mb、kb显示文件尺寸、计算程序运行时间
原文地址：https://www.cnblogs.com/mengd/p/13301810.html

Java常用类-String类

1. String的实例化方式

2. 字符串的特性

3. 面试题：

4. String常用的方法

5. String与基本数据类型转换

6. StringBuffer、StringBuilder ？