JAVA——String

目录

String

String字符串的存储原理

 String类的构造方法

总结：

 String；类中常用的方法

1(掌握). char charAt(int index)   

2（了解） . int compareTo(String anotherString) 

3（掌握）.boolean contains(CharSequence s)

4（掌握）. boolean endsWith(String suffix)

5（掌握）.boolean equals(Object anObject)

6（掌握）.boolean equalsIgnoreCase(String anotherString)

7（掌握）.byte[] getBytes() 

8（掌握）.int indexOf(String str)

9（掌握）.boolean isEmpty() 

10（掌握）. int length()

11（掌握）.int lastIndexOf(String str)

12（掌握）. String replace(CharSequence target, CharSequence replacement)

13（掌握）.String[] split(String regex)

14（掌握）.boolean startsWith(String prefix)

15（掌握）. String substring(int beginIndex)

16（掌握）.String substring(int beginIndex, int endIndex)

17(掌握).char[] toCharArray()

18（掌握）.String toLowerCase()

19（掌握）.String toUpperCase();

20（掌握）. String trim();

21（掌握）. valueOf(Object obj);

研究Println()方法

 StringBuffer

 为何使用StringBuffer

 StringBuffer初始化

append()方法

优化StringBuffer的性能

StringBuffer和StringBuilder的区别

总结

面试题

---

String

String字符串的存储原理

关于Java JDK中内置的一个类：java.lang.String

    1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。
    2、在java中随便使用双引号括起来的都是String对象。例如："abc"，"def"，"hello world!"，这是3个String对象。
    3、java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab"
    4、在JDK当中双引号括起来的字符串，例如："abc" "def"都是直接存储在“方法区”的“字符串常量池”当中的。

        为什么SUN公司把字符串存储在一个“字符串常量池”当中呢。因为字符串在实际的开发中使用太频繁。为了执行效率，所以把字符串放到了方法区的字符串常量池当中。

    // 这两行代码表示底层创建了3个字符串对象，都在字符串常量池当中。
        String s1 = "abcdef";
        String s2 = "abcdef" + "xy";

        // 分析：这是使用new的方式创建的字符串对象。这个代码中的"xy"是从哪里来的？
        // 凡是双引号括起来的都在字符串常量池中有一份。
        // new对象的时候一定在堆内存当中开辟空间。
        String s3 = new String("xy");

也就是说String s1 = "abc"; s1里保存的不是"字符串"，而是"abc"字符串的内存地址 。

        String s1 = "hello";
        // "hello"是存储在方法区的字符串常量池当中
        // 所以这个"hello"不会新建。（因为这个对象已经存在了！）
        String s2 = "hello";
        // == 双等号比较的是变量中保存的内存地址。
        System.out.println(s1 == s2); // true

如果仅是单纯比较字符串，可以直接用 == 比较。

但如果此时字符串变量指向的是一个对象，不可用 == 比较，因为比较的对象的内存地址是不同的。

        String x = new String("xyz");
        String y = new String("xyz");
        // 分析结果是true还是false？
        // == 双等号比较的是不是变量中保存的内存地址？是的。
        System.out.println(x == y); //false

 通过这个案例的学习，我们知道了，字符串对象之间的比较不能使用“==”
 "=="不保险。应该调用String类的equals方法。
 String类已经重写了equals方法，以下的equals方法调用的是String重写之后的equals方法。

System.out.println("testString".equals(k)); // 建议使用这种方式，因为这个可以避免空指针异常。

 String类的构造方法

String类中有很多种构造方法

 创建字符串对象最常用的一种方式

        String s1 =  "hello world!";

s1这个变量中保存的是一个内存地址。
按说以下应该输出一个地址。
但是输出一个字符串，说明String类已经重写了toString()方法。

System.out.println(s1);//hello world!
System.out.println(s1.toString()); //hello world!

---

这里只掌握常用的构造方法。

        byte[] bytes = {97, 98, 99}; // 97是a，98是b，99是c
        String s2 = new String(bytes);

        // 前面说过：输出一个引用的时候，会自动调用toString()方法，默认Object的话，会自动输出对象的内存地址。
        // 通过输出结果我们得出一个结论：String类已经重写了toString()方法。
        // 输出字符串对象的话，输出的不是对象的内存地址，而是字符串本身。
        System.out.println(s2.toString()); //abc
        System.out.println(s2); //abc

---

String(字节数组,数组元素下标的起始位置,长度)，将byte数组中的一部分转换成字符串。

这里的97,98,99是ASCII码值。

        byte[] bytes = {97, 98, 99}; // 97是a，98是b，99是c
        String s3 = new String(bytes, 1, 2);
        System.out.println(s3); // bc

String(byte[] bytes, int offset, int length, String charsetName)           通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。

---

String(字符数组,数组元素下标的起始位置,长度) 

        // 将char数组全部转换成字符串
        char[] chars = {'我','是','中','国','人'};
        String s4 = new String(chars);
        System.out.println(s4);//我是中国人
        // 将char数组的一部分转换成字符串
        String s5 = new String(chars, 2, 3);
        System.out.println(s5);//中国人

String(char[] value, int offset, int count)           分配一个新的 String，它包含取自字符数组参数一个子数组的字符。

总结：

•  第一个：String s = new String(" ");
•  第二个：String s = " "; 最常用
•  第三个：String s = new String(char数组);
•  第四个：String s = new String(char数组,起始下标,长度);
•  第五个：String s = new String(byte数组);
•  第六个：String s = new String(byte数组,起始下标,长度);

---

 String；类中常用的方法

1 （掌握）. char charAt(int index)   

 返回指定索引处的char值。（Returns the char value at the specified index. An index ranges from 0 to length() - 1）

        //1（掌握）.char charAt(int index)
        char c = "中国人".charAt(1); // "中国人"是一个字符串String对象。只要是对象就能“点.”
        System.out.println(c); // 国

---

2（了解） . int compareTo(String anotherString) 

 字符串之间比较大小不能直接使用 > < ，需要使用compareTo方法。

拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。

        int result = "abc".compareTo("abc");
        System.out.println(result); //0（等于0） 前后一致  10 - 10 = 0

        int result2 = "abcd".compareTo("abce");
        System.out.println(result2); //-1（小于0） 前小后大 8 - 9 = -1

        int result3 = "abce".compareTo("abcd");
        System.out.println(result3); // 1（大于0） 前大后小 9 - 8 = 1

        // 拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。
        System.out.println("xyz".compareTo("yxz")); // -1

---

3（掌握）.boolean contains(CharSequence s)

 判断前面的字符串中是否包含后面的子字符串。

    System.out.println("HelloWorld.java".contains(".java")); // true
    System.out.println("http://www.baidu.com".contains("https://")); // false

---

4（掌握）. boolean endsWith(String suffix)

判断当前字符串是否以某个子字符串结尾。

    System.out.println("test.txt".endsWith(".java")); // false
    System.out.println("test.txt".endsWith(".txt")); // true
    System.out.println("fdsajklfhdkjlsahfjkdsahjklfdss".endsWith("ss")); // true

---

5（掌握）.boolean equals(Object anObject)

比较两个字符串必须使用equals方法，不能使用“==” 。

System.out.println("abc".equals("abc")); // true

compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小。

---

6（掌握）.boolean equalsIgnoreCase(String anotherString)

判断两个字符串是否相等，并且同时忽略大小写。

System.out.println("ABc".equalsIgnoreCase("abC")); // true

---

7（掌握）.byte[] getBytes() 

 将字符串对象转换成字节数组

    byte[] bytes = "abcdef".getBytes();
        for(int i = 0; i < bytes.length; i++){
            System.out.println(bytes[i]);
        }    // 97 98 99 100 ……

---

8（掌握）.int indexOf(String str)

判断某个子字符串在当前字符串中第一次出现处的索引（下标）。 

System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java")); // 6

---

9（掌握）.boolean isEmpty() 

 判断某个字符串是否为“空字符串”。

        String s1 = "";
        System.out.println(s1.isEmpty()); //true
        String s2 = "a";
        System.out.println(s2.isEmpty()); //false    

---

10（掌握）. int length()

 面试题：判断数组长度和判断字符串长度不一样
 判断数组长度是length属性，判断字符串长度是length()方法

System.out.println("abc".length()); // 3

System.out.println("".length()); // 0

---

11（掌握）.int lastIndexOf(String str)

判断某个子字符串在当前字符串中最后一次出现的索引（下标）

System.out.println("oraclejavac++javac#phpjavapython".lastIndexOf("java")); //22

---

12（掌握）. String replace(CharSequence target, CharSequence replacement)

 替换。 String的父接口就是：CharSequence

String定义的源代码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{
      . . . . . .
    }

测试程序：

        String newString = "http://www.xxx.com".replace("http://", "https://");
        System.out.println(newString); //https://www.xxx.com
        // 把以下字符串中的“=”替换成“:”
        String newString2 = "name=zhangsan&password=123&age=20".replace("=", ":");
        System.out.println(newString2); //name:zhangsan&password:123&age:20

---

13（掌握）.String[] split(String regex)

 拆分字符串,以" regex "为分隔符拆分

    String[] ymd = "1980-10-11".split("-"); //"1980-10-11"以"-"分隔符进行拆分。
        for(int i = 0; i < ymd.length; i++){
            System.out.println(ymd[i]);
        }    // 1980  10  11

---

14（掌握）.boolean startsWith(String prefix)

 判断某个字符串是否以某个子字符串开始。

        System.out.println("http://www.xxx.com".startsWith("http")); // true
        System.out.println("http://www.xxx.com".startsWith("https")); // false

---

15（掌握）. String substring(int beginIndex)

截取字符串。参数是起始下标。

System.out.println("http://www.xxx.com".substring(7)); //www.xxx.com

---

16（掌握）.String substring(int beginIndex, int endIndex)

beginIndex起始位置（包括）
endIndex结束位置（不包括）

[左闭右开)

System.out.println("http://www.xxx.com".substring(7, 10)); //www

---

17(掌握).char[] toCharArray()

将字符串转换成char数组 

    char[] chars = "我是中国人".toCharArray();
        for(int i = 0; i < chars.length; i++){
            System.out.println(chars[i]);
        }    //我    是    中    国    人

---

18（掌握）.String toLowerCase()

转换为小写。 

System.out.println("ABCDefKXyz".toLowerCase());

---

19（掌握）.String toUpperCase();

转换为大写。 

System.out.println("ABCDefKXyz".toUpperCase());

---

20（掌握）. String trim();

去除字符串前后空白

System.out.println("           hello      world             ".trim());
//hello      world 

---

21（掌握）. valueOf(Object obj);

String中只有一个方法是静态的，不需要new对象。

作用：将“非字符串”转换成“字符串”。

        // 这个静态的valueOf()方法，参数是一个对象的时候，会自动调用该对象的toString()方法吗？
        String s1 = String.valueOf(new Customer());
        //System.out.println(s1); // 没有重写toString()方法之前是对象内存地址 com.bjpowernode.javase.string.Customer@10f87f48
        System.out.println(s1); //我是一个VIP客户！！！！

class Customer {
    // 重写toString()方法

    @Override
    public String toString() {
        return "我是一个VIP客户！！！！";
    }
}

---

研究Println()方法

println源码：

public void println(Object x) {
    String s = String.valueOf(x);
    synchronized (this) {
        print(s);
        newLine();
    }
}

通过源代码可以看出：为什么输出一个引用的时候，会调用toString( )方法!!!!

本质上System.out.println()这个方法在输出任何数据的时候都是先转换成字符串，再输出。

 " String s = String.valueOf(x); " 

---

 StringBuffer

 为何使用StringBuffer

思考：我们在实际的开发中，如果需要进行字符串的频繁拼接，会有什么问题？

因为java中的字符串是不可变的，每一次拼接都会产生新字符串。
这样会占用大量的方法区内存。造成内存空间的浪费。

String s = "abc";
s += "hello";
就以上两行代码，就导致在方法区字符串常量池当中创建了3个对象：
"abc","hello","abchello"

如果以后需要进行大量字符串的拼接操作，建议使用JDK中自带的：

java.lang.StringBuffer
java.lang.StringBuilder

 StringBuffer初始化

// 创建一个初始化容量为16个byte[] 数组。（字符串缓冲区对象）
StringBuffer stringBuffer = new StringBuffer();

append()方法

拼接字符串：（append是追加的意思。）

        stringBuffer.append("a");
        stringBuffer.append("b");
        stringBuffer.append("d");
        stringBuffer.append(3.14);
        stringBuffer.append(true);
        // append方法底层在进行追加的时候，如果byte数组满了，会自动扩容。
        stringBuffer.append(100L);

        System.out.println(stringBuffer.toString());//abd3.14true100

优化StringBuffer的性能

在创建StringBuffer的时候尽可能给定一个初始化容量。
最好减少底层数组的扩容次数。预估计一下，给一个大一些初始化容量。
关键点：给一个合适的初始化容量。可以提高程序的执行效率。 

// 指定初始化容量的StringBuffer对象（字符串缓冲区对象）
        StringBuffer sb = new StringBuffer(100);
        sb.append("hello");
        sb.append("world");
        sb.append("hello");
        sb.append("kitty");

        System.out.println(sb);//helloworldhellokitty

---

StringBuffer和StringBuilder的区别

 java.lang.StringBuffer
java.lang.StringBuilder

StringBuffer中的方法都有：synchronized关键字修饰。表示StringBuffer在多线程环境下运行是安全的。

public synchronized StringBuffer reverse()

public synchronized String toString() 

public synchronized int indexOf) . . . 

StringBuilder中的方法都没有：synchronized关键字修饰，表示StringBuilder在多线程环境下运行是不安全的。 

public StringBuilder append

public StringBuilder insert

public StringBuilder replace

    StringBuffer是线程安全的。
    StringBuilder是非线程安全的。

总结

1、String类。
    1.1、对String在内存存储方面的理解：
        第一：字符串一旦创建不可变。
        第二：双引号括起来的字符串存储在字符串常量池中。
        第三：字符串的比较必须使用equals方法。
        第四：String已经重写了toString()和equals()方法。

    1.2、String的构造方法。
        String s = "abc";
        String s = new String("abc");
        String s = new String(byte数组);
        String s = new String(byte数组, 起始下标, 长度);
        String s = new String(char数组);
        String s = new String(char数组, 起始下标, 长度);
    
    1.3、String类常用的21个方法。

2、StringBuffer/StringBuilder
    2.1、StringBuffer/StringBuilder可以看做可变长度字符串。
    2.2、StringBuffer/StringBuilder初始化容量16.
    2.3、StringBuffer/StringBuilder是完成字符串拼接操作的，方法名：append
    2.4、StringBuffer是线程安全的。StringBuilder是非线程安全的。
    2.5、频繁进行字符串拼接不建议使用“+”

面试题

1、String为什么是不可变的？
    我看过源代码，String类中有一个byte[]数组，这个byte[]数组采用了final修饰，
    因为数组一旦创建长度不可变。并且被final修饰的引用一旦指向某个对象之后，不
    可再指向其它对象，所以String是不可变的！
        "abc" 无法变成 "abcd"

2、StringBuilder/StringBuffer为什么是可变的呢？
    我看过源代码，StringBuffer/StringBuilder内部实际上是一个byte[]数组，
    这个byte[]数组没有被final修饰，StringBuffer/StringBuilder的初始化
    容量我记得应该是16，当存满之后会进行扩容，底层调用了数组拷贝的方法
    System.arraycopy()...是这样扩容的。所以StringBuilder/StringBuffer
    适合于使用字符串的频繁拼接操作。