Java初阶 ( String 类)

一、String 类的基础概念

1.1 Java 中的字符串

Java 中的字符串，其实是一个类

• final 表示这个 String类 无法被继承
• String 类关联了 java.io.Serializable, Comparable, CharSequence 这三个接口
• String是引用类型，内部并不存储字符串本身
  • String 中的成员变量是 char value[ ] 和 hash
• 在Java中“”引起来的也是String类型对象

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

1.2 字符串的构造

public class Test {
    public static void main(String[] args) {
        String name = "hello";
        System.out.println(name);    //和下面那个相比，只是省略了一些标识符而已，意义一样

        String name1 = new String("world");
        System.out.println(name1);

        char[] ch = {'a','b','c','d'};
        String name2 = new String(ch);
        System.out.println(name2);

    }
}

二、String 类的进阶概念

由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串

2.1 求字符串的长度

Java 当中，没有说过字符串是以 ‘\0’ 结尾的

public class Test {
    public static void main(String[] args) {
        String name = "hello";
        System.out.println(name.length());
    }
}

2.2 isEmpty()

public class Test {
    public static void main(String[] args) {
        String str4 = "";      //指向的对象中没有任何数据
        System.out.println(str4.isEmpty());    //如果里面没有数据就返回true，否则返回false
        String str5 = null;       //代表不指向任何对象
        System.out.println(str5.isEmpty());    //空指针异常
    }
}

2.3 字符串的比较

• 比较是否引用同一个对象
  注意：对于内置类型， == 比较的是变量中的值；对于引用类型==比较的是引用中的地址。
• boolean equals(Object anObject)方法：按照字典序比较
  字典序：字符大小的顺序
• int compareTo(String s) 方法: 按照字典序进行比较
  与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
  1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
  2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
• int compareToIgnoreCase(String str)
  方法：与compareTo方式相同，但是忽略大小写比较

public class Test{
    public static void main(String[] args) {
        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));    //String 里面自己重写了equals方法
        System.out.println("=========");
        String str3 = "abc";
        String str4 = "abc";
        System.out.println(str3 == str4);

        System.out.println("====");
        String str5 = "abcd";     //直接赋值，且存放的值是一样的情况下，会被认为指向的是同一块空间
        String str6 = "abCd";

        System.out.println(str5.compareTo(str6));    
        System.out.println(str5.compareToIgnoreCase(str6));
    }
}

2.4 字符串的查找

方法	功能
char charAt(int index)	返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常
int indexOf(int ch)	返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返 回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返 回-1

2.5 字符串的转换

• 数值和字符串转换

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("Hanmeimei", 18));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println("=================================");
        // 字符串转数字
        // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
        int data1 = Integer.parseInt("1234");
        int data2 = Integer.valueOf("1234");
        double data3 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);

    }
}

• 大小写转换

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        // 小写转大写
        System.out.println(s1.toUpperCase());
        // 大写转小写
        System.out.println(s2.toLowerCase());
    }
}

• 字符串转数组

public class Test {
    public static void main(String[] args) {
        String s = "hello";
        // 字符串转数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
        System.out.println();
        // 数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);
    }
}

• 格式化

public class Test {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2019, 9,14);
        System.out.println(s);
    }
}

2.6 字符串的替换

方法	功能
String replaceAll(String regex, String replacement)	把所有的regex都替换为replacement
String replaceFirst(String regex, String replacement)	把首个出现的regex替换为replacement

2.6 字符串的拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串

方法	功能
String[] split(String regex)	将字符串根据regex全部拆分
String[] split(String regex, int limit)	将字符串根据regex，拆分为limit组

• 注意事项:
  • 字符"|“，”*“，”+“，”."都得加上转义字符，前面加上 “\” .
    • 理解：一个 ‘.’ 需要一个’\’ 进行转义，但是要识别一个’\'，需要两个\\
  • 而如果是 “\” ，那么就得写成 “\\” .

public class Test {
    public static void main(String[] args) {
        String str2 = "192\\168\\0\\0\\1";     //用两个\\表示一个\
        String[] ret2 = str2.split("\\\\");   //表示的是\\
        for (int i = 0; i < ret2.length; i++) {
            System.out.println(ret2[i]);
        }
    }
}

• 如果一个字符串中有多个分隔符，可以用"|"作为连字符

public class Test {
    public static void main(String[] args) {
        String str2 = "name=zhangsan&age=18";
        String[] ret2 = str2.split("=|&");
        for (int i = 0; i < ret2.length; i++) {
            System.out.println(ret2[i]);
        }
    }
}

• 多次拆分

public class Test {
    public static void main(String[] args) {
        String str2 = "name=zhangsan&age=18";
        String[] ret2 = str2.split("&");
        for (int i = 0; i < ret2.length; i++) {
            String[] strings = ret2[i].split("=");
            for (String s : strings) {
                System.out.println(s);
            }
        }
    }
}

2.7 字符串的截取

方法	功能
String substring(int beginIndex)	截取指定位置开始的剩余字符串
String substring(int beginIndex, int endIndex)	截取[beginIndex,endIndex)内容

2.8 去掉字符串的左右空白字符

String trim()
trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).

public class Test {
    public static void main(String[] args) {
        String str = "   hell  oo  p   0   pppp";
        System.out.println(str.trim());
        System.out.println(str);    //是产生一个新的字符串，并没有在原字符串的基础上，进行修改
    }
}

2.9 StringBuilder和StringBuffer

• String、StringBuffer、StringBuilder的区别
  • String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
  • StringBuffer与StringBuilder大部分功能是相似的
  • StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

• String和StringBuilder类的转换
  • String和StringBuilder类不能直接转换
  • 下面是依靠方法进行转换的方法

public class Main {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();     //String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
        stringBuilder.append("12");
        System.out.println(stringBuilder);


        String ret = stringBuilder.toString();   //StringBuilder变为String: 调用toString()方法
        System.out.println(ret);
    }
}

方法	功能
StringBuff append(String str)	在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量
char charAt(int index)	获取index位置的字符
int length()	获取字符串的长度
int capacity()	获取底层保存字符串空间总的大小
void ensureCapacity(int mininmumCapacity)	扩容
void setCharAt(int index, char ch)	将index位置的字符设置为ch
int indexOf(String str)	返回str第一次出现的位置
int indexOf(String str, int fromIndex)	从fromIndex位置开始查找str第一次出现的位置
StringBuff insert(int offset, String str)	在offset位置插入：八种基类类型 & String类型 & Object类型数据
StringBuffer deleteCharAt(int index)	删除index位置字符
StringBuffer delete(int start, int end)	删除[start, end)区间内的字符
StringBuffer replace(int start, int end, String str)	将[start, end)位置的字符替换为str
String substring(int start)	从start开始一直到末尾的字符以String的方式返回
String substring(int start，int end)	将[start, end)范围内的字符以String的方式返回
StringBuffer reverse()	反转字符串
String toString()	将所有字符按照String的方式返回

三、字符串的不可修改性

3.1 原因

String是一种不可变对象. 字符串中的内容是不可改变，这个原因取决于String的内部定义

• String类中的字符实际保存在内部维护的value字符数组中
• final 表示不能修改这个引用的指向，且该类不能被继承
• String类并没有提供一个get()方法，或者set()方法，来访问这个字符串，所以这个内容是不可以被修改的

3.2 字符串的修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下

• 总结：
  • 待在对String类进行修改时，效率是非常慢的，会创建多个对象，所以不建议在循环里进行拼接
  • 如果要修改，尽量使用StringBuilder和StringBuffer