Java基础知识_day8_(字符串)

Java基础知识_day8_(String,StringBuilder,StringBuffer)

1. String类

String 类代表字符串。Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现;
字符串是常量；它们的值在创建之后不能更改;
字符串的本质是一个字符数组.

1.1 String类构造方法

String(String original):把字符串数据封装成字符串对象;
String(char[] str):把字符数组的数据封装成字符串对象;
String(char[] value,int index,int count):把字符数组中的一部分数据封装成字符串对象,index是开始的索引值,count是字符的个数;
public String(byte[] bytes):通过使用平台的默认字符集解码指定的byte数组,构造一个新的String.该构造方法会先将整形数转换为字符,然后将字符组合成为一个字符串.

注意事项

# 注意事项:
    字符串是一种较为特殊的引用数据类型,直接输出字符串对象输出的是该对象中的数据;
# 通过构造方法和直接赋值方式创建的字符串对象区别:
    构造方法创建的字符串对象是在堆内存中该对象指向方法区中常量池中的具体的字符串,直接赋值创建的字符串对象是在方法区的常量池.
# ==:比较的是两个值是否相等;
    基本数据类型是比较的类型的值是否相等;
    引用数据类型是比较的类型的地址值是否相等;

案例代码

public class StringDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        // s1和s2指向方法区中常量池中的同一个字符串对象,所以输出的地址值相同
        System.out.println((s1==s2));   // true
        s1 = "helloWorld";
        // 将s1的值重新赋值,相当于是在常量池中重新创建一个字符串对象,则结果是false
        System.out.println((s1==s2));   // false
        // 由于s1指向的字符串对象发生改变,但是s2还是指向之前的那个字符串,所以s2输出结果不变
        System.out.println(s2);         // hello
        String s3 = new String("hello");
        String s4 = s3; 
        // 将s4也指向堆内存中那个字符串对象,则此时s3和s4的地址值相等
        System.out.println(s3==s4);     // true
        // 将s3指向一个新的字符串,相当于是s3指向了常量池中的字符串对象
        s3 = "helloworld";
        // s3指向常量池中的字符串对象,s4是指向堆内存中的字符串实体,通过实体再指向常量池中的字符串
        // 则s3和s4的地址值不同
        System.out.println(s3==s4);     // false
        // s3和s4指向的字符串对象不同,则输出的字符串不同
        System.out.println(s3);         // helloworld
        System.out.println(s4);         // hello

        byte[] bys = { 97, 98, 99, 100, 101 };
        String s = new String(bys);
        System.out.println(s); // abcde
        System.out.println(s.length()); // 5
        /*
         * 字符串拼接: 字符串如果是变量相加,是先开辟内存空间,再进行拼接;
         * 字符串如果是常量相加,是先将字符串拼接,然后在方法区的常量池中进行查找,如果有就直接返回,否则创建.
         */
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2); // false
        System.out.println(s3.equals(s1 + s2)); // true
        System.out.println(s3 == "hello" + "world"); // true
        System.out.println(s3.equals("hello" + "world")); // true
    }
}

1.2 String类的判断功能

boolean equals(Object obj):比较两个字符串的内容是否相同,其中参数可以是任意object的子类对象;
boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写;
boolean startsWith(String str):判断字符串对象是否以指定的str开头;
boolean endsWith(String str):判断字符串对象是否以指定的str结尾;
public boolean contains(String s):判断大的字符串中是否包含小字符串s,如果有返回true;
public boolean isEmpty():当且仅当length()为0时返回true;
    注意:字符串的值为空(s="")和空字符串(字符串对象为空,s=null)是不同概念.

1.3 String类的获取功能

int length():获取字符串的长度,就是字符的个数;
char charAt(int index):获取指定索引处的字符,索引值必须存在,否则会报索引越界异常;
int indexOf(String str):获取字符串str在字符串对象中首次出现的索引,如果不是单个字符,则返回str中第一个字符的索引,如果不存在返回-1;
String substring(int start):从Start索引处截取到结束的子串;
String substring(int start, int end):从Start(包含)索引处截取到end索引(不包含)为止的子串;
public int indexOf(int ch,int fromIndex)返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索;
public int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始.

案例代码

public class StringDemo3 {
    public static void main(String[] args) {
        String s = "HelloSomnus";
        // int length()
        System.out.println(s.length());
        // char charAt(int index)
        System.out.println(s.charAt(7));    // m
        // System.out.println(s.charAt(12));    // java.lang.StringIndexOutOfBoundsException异常
        // int indexOf(String str)
        System.out.println(s.indexOf("S")); //  5
        System.out.println(s.indexOf("Som"));   //  5 是str字符串首字母首次出现的索引
        System.out.println(s.indexOf("h")); //  -1表示字符串不存在
        // String substring(int start)
        System.out.println(s.substring(5));     // Somnus
        // System.out.println(s.substring(13)); // java.lang.StringIndexOutOfBoundsException异常
        // String substring(int start, int end)
        System.out.println(s.substring(5, 8));  // Som,包含开始索引,不包含结束索引
    }
}

1.4 String类转换功能

char[] toCharArray():把字符串转换为字符数组;
String toLowerCase():把字符串转换为小写字符串;
String toUpperCase():把字符串转换为大写字符串;
public byte[] getBytes(String charsetName):将字符串转换为字节数组;
public static String valueOf(char[] data):将字符数组转换为字符串(静态方法);
public static String valueOf(int i):返回int参数的字符串表示形式.该表示形式恰好是单参数的Integer.toString方法返回的结果; 
public String concat(String str):将指定字符串连接到此字符串的结尾.如果参数字符串的长度为0,则返回此String对象.

案例代码

public class StringDemo4 {
    public static void main(String[] args) {
        String s = "helloWorld";
        // char[] toCharArray()
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }
        // String toLowerCase()
        String s1 = s.toLowerCase();
        System.out.println(s1);
        // String toUpperCase()
        String s2 = s.toUpperCase();
        System.out.println(s2);
    }
}

1.5 String类的其他功能

// 替换
 public String replace(char oldChar,char newChar):返回一个新的字符串,它是通过用newChar替换此字符串中出现的所有oldChar得到的;
public String replace(String target,String replacement)使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串;
// 比较:
public int compareTo(String anotherString):按字典顺序比较两个字符串,如果参数字符串等于此字符串,则返回值0;如果此字符串按字典顺序小于字符串参数,则返回一个小于0的值;如果此字符串按字典顺序大于字符串参数,则返回一个大于0的值;
// 去除
String trim():取出字符串两端的空格,返回字符串对象;
// 分割
String[] split(String str):按照指定str分割字符串,结果为字符串数组.

案例代码

public class StringDemo5 {
    public static void main(String[] args) {
        String s = "aabbcc";
        String[] s1 = s.split("b"); // 按照b字符进行分割
        System.out.println(s1.length);
        for (int i = 0; i < s1.length; i++) {
            System.out.println(s1[i].length());
            System.out.println(s1[i]);
        }
    }
}

2. StringBuilder类

StringBuilder:是一个可变长的字符串,属于字符串缓冲区类.
StringBulider也是一种较为特殊的引用数据类型,直接输出的是该对象中的数据;
String与StringBuilder的区别

String的内容是固定的(在常量池中一旦生成无法改变);
StringBuilder是可变长度的字符串;
String使用+做字符串拼接时会产生较多的中间字符串,效率较低并浪费空间.

2.1 StringBuilder类构造方法

StringBuilder():构造一个不带任何字符的字符串生成器,其初始容量为 16 个字符;
StringBuilder(String str):构造一个字符串生成器,并初始化为指定的字符串内容.

2.2 StringBuilder类成员方法

public int capacity():返回当前容量(容器的理论容量).容量指可用于最新插入字符的存储量,超过这一容量便需要再次分配;
public int length():返回长度(字符数),已经存储的字符个数;
public StringBuilder append(任意类型):将参数追加到此对象值得后面,返回其本身.

2.3 String与StringBuilder之间的转换

# StringBuilder --> String: StringBuilder对象通过其toString方法转换为String对象.
# String --> StringBuilder:通过StringBuilder的构造方法可以得到String对象.

2.4 案例代码

public class StringBuilderDemo {
    public static void main(String[] args) {
        // 空参构造方法
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1.capacity()); // 16初始化时分配的容量
        System.out.println(sb1.length());   // 空字符,代表当前没有存储字符
        // 有参构造方法,将初始值设为指定字符串
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println(sb2.capacity()); // 21代表当前的容量,总会有16个字节的空余空间
        System.out.println(sb2.length());   // 5代表当前存储的字符个数
        // public StringBuilder append(任意类型),返回值为其本身,故可以链式编程
        sb2.append("world");
        sb2.append(12.34);
        System.out.println(sb2);    // helloworld12.34
        sb2.append("somnus").append(3.14).append(true);
        System.out.println(sb2);    // helloworld12.34somnus3.14true
        // public StringBuilder reverse()
        sb2.reverse();
        System.out.println(sb2);    // eurt41.3sunmos43.21dlrowolleh
    }
}

3. StringBuffer类

Stringbuffer:线程安全的可变字符序列.一个类似于 String 的字符串缓冲区.但不能修改.
虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容.

3.1 StringBuilder类构造方法

public StringBuffer():构造一个其中不带字符的字符串缓冲区,其初始容量为16个字符;
public StringBuffer(int capacity):构造一个不带字符,但具有指定初始容量的字符串缓冲区;
public StringBuffer(String str):构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容.该字符串的初始容量为16加上字符串参数的长度.

3.2 StringBuffer类的添加功能

public StringBuffer append(String str):将指定的字符串追加到此字符序列,按顺序追加String变量中的字符,此序列将增加该变量的长度.如果str为null,则追加4个字符 "null".
public StringBuffer insert(int offset,String str):将字符串插入此字符序列按顺序将String参数中的字符插入此序列中的指定位置,将该位置处原来的字符向后推,此序列将增加该参数的长度.如果str为null,则向此序列中追加4个字符"null".

3.3 StringBuffer类的删除功能

public StringBuffer deleteCharAt(int index):移除此序列指定位置上的char,返回本身.
public StringBuffer delete(int start,int end):移除此序列的子字符串中的字符,该子字符串从指定的start处开始,一直到索引end-1处的字符,如果不存在这种字符,则一直到序列尾部.如果start等于end,则不发生任何更改,返回本身.

3.4 StringBuffer类的获取功能

public String substring(int start):返回一个新的String,它包含此字符序列当前所包含的字符子序列;
public String substring(int start,int end):返回一个新的String,它包含此序列当前所包含的字符子序列.该子字符串从指定的start处开始,一直到索end-1处的字符.

3.5 StringBuffer类的其他功能

// 获取长度
public int length():返回长度（字符数）。 
public int capacity():返回当前容量.容量指可用于最新插入的字符的存储量,超过这一容量就需要再次进行分配. 
// 替换
public StringBuffer replace(int start,int end,String str):使用str替换从Start开始到end-1处的字符串,如果替换的长度不等于str的长度,则先将原始字符串中Start开始到end-1处的字符删除,将str字符添加到Start索引处.返回本身.
// 反转功
public StringBuffer reverse():将此字符序列用其反转形式取代,返回本身.  

4. String,StringBuilder和StringBuffer的区别

# String是长度不可变的,后两者的内容是可以变的;
# StringBuffer是线程安全,数据安全,效率低;
# StringBuilder是线程不安全的,数据不安全,效率高.

5. String,StringBuilder和StringBuffer类型变量作为参数传递的区别

# String作为形式参数传递:效果和基本类型传递相同;
# StringBuilder和StringBuffer作为形式参数:
 * 使用=赋值时,形参的改变不影响实参;使用具体的方法操作时,形参的改变会影响实参的改变.

案例代码

public class MyStringBuffer {
    public static void main(String[] args) {
        // String作为参数
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1+"..."+s2); // hello...world
        method1(s1, s2);
        System.out.println(s1+"..."+s2); // hello...world
        // StringBuffer作为参数
        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("World");
        System.out.println(sb1+"..."+sb2); // hello...World
        method(sb1,sb2);
        System.out.println(sb1+"..."+sb2); // hello...WorldWorld
    }
    // String作为参数
    public static void method1(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
    // StringBuffer作为参数
    public static void method(StringBuffer sb1, StringBuffer sb2) {
        // StringBuffer作为参数
        sb1 = sb2; // 进行=赋值时,实参的值不会改变
        sb2.append(sb2); // 使用方法进行操作会改变实参的值
    }
}