chapter3 字符串String的相关知识

1.字符串的定义

①直接定义字符串是指使用双引号表示字符串中的内容。(个人觉得这个好像更常用）
直接定义的几种形式如下图：

即：1）String str = "Hello java ";
2）String str; str = “Hello java”;
②使用 String 类定义
1）String str = new String(String original);
例如：
String str1 = new String(“Hello Java”);
String str2 = new String(str1);

2)String str = new String(char[] value);
分配一个新的字符串，将参数中的字符数组元素全部变为字符串。该字符数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。

例如：

public static void main(String[] args){
      char[] ch = {'H','e','l','l','e'};
      String str = new String(ch);//新建字符串
      ch[1] = 'd';
      System.out.println(Arrays.toString(ch));
      System.out.println(str);
}

结果为：

表明了通过这种方式也可以定义一个字符串，将参数中的字符数组元素全部变为字符串，后面更改字符数组时，没有使字符串发生改变，如上面的结果即可证明。
3）String(char[] value,int offset,int count);
分配一个新的 String，它包含来自该字符数组参数一个子数组的字符。offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度,而最终的字符串就是这个从offset下标开始算起的，长度为count的子字符串。该子数组的内容已被赋值，后续对字符数组的修改不会影响新创建的字符串。
例如：

public static void main(String[] args){
      char[] ch = {'H','e','l','l','e'};
      String str = new String(ch,1,4);//新建字符串，其中使从原来的字符串数组中下标为1的字符串算起，长度为4的子字符串
      ch[1] = 'd';
      System.out.println(Arrays.toString(ch));
      System.out.println(str);
 }

结果为：

2.字符串的基本用法

2.1字符串的长度.length()

int length = string.length();

2.2字符串的拼接：

“+”运算符优势是可以连接任何类型数据拼接成为字符串，而 concat 方法只能拼接 String 类型字符串。

1）用“+”进行拼接
String str = “hello” +“java”;-----结果：hellojava
String str = “” + 2; -----结果：2
但是这里有一个地方值得提出：
请看下面的例子：

String str1 = "" + 1 + 2 + 3;//输出123
String str2 = 1 + 2 + 3 + "";//输出6
String str3 = "hello!" + 1 + 2 + 3;//输出hello!123
String str4 = 1 + 2 + 3 + "hello!";//输出6hello!
String str5 = 1 + 2 + 3 + "hello!" + 1 + 4;//输出6hello!14

由此可以得出一个规律：在利用“+”进行拼接的时候，如果对应的数字在字符串前面的时候，那么这些数字会进行加法运算之后再进行拼接，否则，如果数字再字符串的后面，那么就是直接拼接，而没有进行加法运算。

2）用concat方法进行拼接，实现了将一个字符串连接到另一个字符串的后面，其格式为：字符串 1.concat(字符串 2);
例如：

String str = "hello";
//注意将字符串world拼接到str，之后还要将其赋值给str，否则下面输出str时，就是hello,而不是helloWorld
str.concat("world");
System.out.println(str);//输出hello
str = str.concat("world");
System.out.println(str);//输出helloworld

2.3 字符串的大小写的转换

toLowerCase():向小写转换
toUpperCase():向大写转换

String str = "HelLo";
//将字符串转换成大写，但是调用方法之后，要将其赋给str，否则下面输出str是HelLo，而不是想要的HELLO
str.toUpperCase();
System.out.println(str);//输出HelLo
str = str.toUpperCase();
System.out.println(str);//输出HELLO

为什么调用方法之后还要赋值给str呢？我们可以查看toUpperCase()方法，就知道这个方法有返回值。因此转换小写也是这样的道理，上面的拼接concat()亦是如此。

2.4 去除首尾的空格

字符串中存在的首尾空格一般情况下都没有任何意义，如字符串“ Hello ”，但是这些空格会影响到字符串的操作，如连接字符串或比较字符串等，所以应该去掉字符串中的首尾空格，这需要使用 String 类提供的 trim() 方法。
trim(）方法代码：

例子：

   String str = " HelLo ";
   System.out.println(str.length());//输出7
   str.trim();//注意调用方法之后，如果不赋值给str，那么下面输出的依然是7，而不是5，因为这个方法返回的去掉空格之后的字符串
   System.out.println(str.length());//输出7
   str = str.trim();
   System.out.println(str.length());//输出5

2.5 提取子字符串

①字符串.substring(int index);这个方法获得的是从下标index开始算起，到字符串最后的子字符串。
②字符串.substring(int index，int lastIndex);这个方法获得的是从下标index开始算起，到字符串lastIndex之间的子字符串，注意并没有包括lastIndex这个下标的字符。

2.6 字符串的比较

①equals()方法
字符串.equals(字符串2);这个是要考虑大小写的比较，返回值的是true/false，如果相同，那么返回true，否则返回false。
忽略大小写的比较：字符串.equalsIgnoreCase(字符串2)

注意equals与==的区别：
==对于基本类型来说，他比较的是两个基本类型的值是否相等；
对于引用类型来说，他比较的是两个引用类型的地址是否相同（也就是他们存放的地址是否相等）。
equals()方法来说，如果没有重写Object的equals方法，那么它的作用和==是一样的，都是比较两个引用类型的地址是否相同，但是如果它的包装类例如String、Integer等重写了Object的equals方法，那么此时比较的是两个对象的内容是否相同，即使两个对象的地址不同，但是内容相同，那么返回的是true。


因此涉及到字符串的比较，要用equals，而不是用。

②compareTo() 方法
用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。compareTo() 方法的语法格式如下：str.compareTo(String otherstr);
compareTo()方法的代码：

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

通过上面的代码，可以知道，从第一对不相同的字符开始比较，然后返回这两个字符的Unicode的差，如果差大于0，表明了前面的字符串排在后面，因为是根据字典排序嘛，小于0，表示前面的字符串排在前面，等于0，那么表明两个字符串相同。

提示：如果两个字符串调用 equals() 方法返回 true/false，那么调用 compareTo() 方法会返回 整形int，如果两个字符串相同，那么如果调用equals方法返回的是true，而如果调用compareTo方法返回的是0。

2.7字符串的替换

replace(string oldChar,String newChar); – 将字符串中的所有oldChar都替换成为newChar
replaceAll(String regexp,String string)； – 将字符串中所有匹配正则表达式regexp的都替换成为string
replaceFirst(String regexp,String string)； – 将字符串中第一个匹配正则表达式regexp的替换成为string

2.8 字符串的查找

1)indexOf(String string) – 在字符串中查找string首次出现的下标，并将其返回

2)lastIndexOf(String string) – 在字符串中查找string最后一次出现的下标，并将其返回

当然在这两个方法中还可以添加参数，表示从哪里开始查找，然后在哪里结束，这里就不写了。

3.字符串与其他类型的转换

①String 与如int、double等类型的转换：

String—> int:在 String 转换 int 时，String 的值一定是整数，否则会报数字转换异常（java.lang.NumberFormatException）。
1)int num = Integer.parseInt(str);-----字符串变成其他的基本类型，那么将包装类变成相应的类型，同时将parseInt中的Int变成相应的基本类型。比如double num = Double.parseDouble(str);
2)先将字符串转成它的包装类，然后再调用这个包装类的静态方法intValue方法，从而将包装类转换成对应的基本类型。
即 1)Integer integer = Integer.valueOf(str);,这一步也可以这样:Integer integer = new Integer(str);
2)int num = integer.intValue();

int---->String:
1)String str = String.valueOf(num);
2)String str = “”+num;（num都是整形）
3)String str = Integer.toString(num);----如果是其他基本类型转换成String,那么就是包装类变成相应的类型。比如：String str = Double.toString(num),此处的num是double型
4）利用工具类Arrays的toString方法，从而将对应的数组转换成为一个字符串。

②字符串与数组的转换：

字符串转数组：
1）调用方法split(),从而将字符串转化成为字符串数组。
2）调用方法toCharArray()，从而将字符串转换成为字符数组。
3) 调用方法getBytes()，从而将字符串转换成Byte类型的数组。

数组转换成为字符串：
1）如果是字符数组，那么直接利用上面字符串定义方法，从而得到字符串，即String str = new String(char[] ch);
2）如果是Byte类型数组，那么直接利用上面字符串定义方法，从而得到字符串，即String str = new String(byte[] b);
2）如果是int型、double型等数组没有方法直接转换的，那么通过遍历数组，然后通过“+”，将其拼接，从而得到一个字符串。

4.StringBuffer、StringBuilder

4.1StringBuffer

在 Java 中，除了通过 String 类创建和处理字符串之外，还可以使用 StringBuffer 类来处理字符串。StringBuffer 类可以比 String 类更高效地处理字符串。因为 StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。

StringBuffer 类提供了 3 个构造方法来创建一个字符串，如下所示：
①StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
②StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
③StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。
第一种创建方法：

StringBuffer str1 = new StringBuffer();//初始长度是16
System.out.println(str1.capacity());//输出初始容量16
str1.append("asfgghhhjjkk");
System.out.println(str1);//字符串长度12，没有超出初始容量
System.out.println(str1.length());//第一次添加长度没有超过初始容量时
str1.append("dfgghhhhhhh");//再次添加字符使长度大于16，并没有发生报错，说明当字符串的长度大于16时，自动添加容量
System.out.println(str1);
System.out.println(str1.length());//再次添加字符，从而超过初始容量
System.out.println(str1.capacity());//输出自动添加容量后的容量

结果：

4.2 String、StringBuilder、StringBuffer三者的区别

①String 类是不可变类，即一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。Java 提供了两个可变字符串类 StringBuffer 和 StringBuilder，中文翻译为“字符串缓冲区”。

②StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，但是执行速度相对于StringBuilder慢，而 StringBuilder 则没有实现线程安全功能，所以性能略高，执行速度较快。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。

有些地方遗漏或者写错的，请大家指正哈！