图灵日记之java奇妙历险记--String类

String常用方法

字符串构造

    public static void main(String[] args) {
    //使用常量串构造
        String a = "asdf";
        System.out.println(a);

        String b = new String();
        System.out.println(b);
	//直接newString对象
        String c = new String("ghjk");
        System.out.println(c);
	//使用字符数组进行构造
        char[] arr = {'a','b','c'};
        String e = new String(arr);
        System.out.println(e);

        String f = new String(arr,0,2);
        System.out.println(f);
    }

注意

1. String是引用类型,内部并不存储字符串
   

    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("efg");
        String s3 = s2;

    }

2. 在Java中""引起来的也是String类型对象

        System.out.println("abcd".length());

        String s4 = "";
        String s5 = null;

s4指向一个对象为空,s5不指向任何对象

String对象的比较

1. ==比较是否引用同一对象
   注意:
   对于内置类型,比较变量中的值;对于引用类型比较的是引用的地址

2. boolean equals(Object anObject) 方法:按照字典序比较
   String类重写父类Object中的equals方法,Object中equals默认按照==比较,重写如下:

    public boolean equals(Object anObject) {
    //判断引用的是不是同一个对象
        if (this == anObject) {
            return true;
        }
        //判断anObject是不是String类型的对象
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            //判断二者长度
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                //逐个比较字符
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

3. int compareTo(String s)方法:按照字典序进行比较
   先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

        String s1 = new String("abc");
        String s2 = new String("abe");
        System.out.println(s1.compareTo(s2));

如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

        String s1 = new String("abc");
        String s2 = new String("ab");
        System.out.println(s1.compareTo(s2));

4. int compareToIgnoreCase(String str) 方法:与compareTo方式相同,但是忽略大小写

        String s1 = new String("abc");
        String s2 = new String("ABc");
        System.out.println(s1.compareToIgnoreCase(s2));

字符串查找

char charAt(int index)

返回index位置上的字符,如果index为负数或者越界,抛出IndexOutOfBoundsException异常

        String s1 = new String("abcdef");
        System.out.println(s1.charAt(0));

        String s1 = new String("abcdef");
        for (int i = 0; i < s1.length(); i++) {
            System.out.print(s1.charAt(i));
        }

int indexOf(int ch)

返回ch第一次出现的位置，没有返回-1

        String s1 = new String("aaaaa");
        int index = s1.indexOf('a');
        System.out.println(index);

int indexOf(int ch, int fromIndex)

从fromIndex位置开始找ch第一次出现的位置，没有返回-1

    public static void main(String[] args) {
        String s1 = new String("aaaaa");
        int index = s1.indexOf('a',2);
        System.out.println(index);
    }

int indexOf(String str)

返回str第一次出现的位置，没有返回-1

        String s1 = "ababababcd";
        System.out.println(s1.indexOf("abcd"));

int indexOf(String str, int fromIndex)

从fromIndex位置开始找str第一次出现的位置，没有返回

        String s1 = "abcabcabc";
        System.out.println(s1.indexOf("abc",3));

int lastIndexOf(String str)

从后往前找，返回str第一次出现的位置，没有返回-1

        String s1 = "abcabcabc";
        System.out.println(s1.lastIndexOf("abc"));

int lastIndexOf(String str, int fromIndex)

从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

 String s1 = "abcabcabc";
        System.out.println(s1.lastIndexOf("abc",5));

int lastIndexOf(int ch)

从后往前找，返回ch第一次出现的位置，没有返回-1

        String s1 = "abcdefabcdef";
        System.out.println(s1.lastIndexOf('a'));

int lastIndexOf(int ch, int fromIndex)

从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1

        String s1 = "abcdefabcdef";
        System.out.println(s1.lastIndexOf('a',5));

转化

数值和字符串转化

数值转字符串

        String s1 = String.valueOf(11.1);
        System.out.println(s1);

字符串转数值

        int i = Integer.parseInt("123");

大小写转换

        String s1 = "abD";
        System.out.println(s1.toUpperCase());

字符串转数组

        String s1 = "abc";
        char[] chars = s1.toCharArray();

格式化

        String s2 = String.format("%d,%d",3,5);
        System.out.println(s2);

字符串替换

replace方法进行重载,对参数类型不同

String实现了CharSequence接口,所以CharSequence接口能够接收String类型的数据

String str = new String("abcd");
        System.out.println(str.replace("ab", "1234"));

字符串拆分

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

        String str = new String("a b c d");
        String[] strings = str.split(" ");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

        String str = new String("a b c d");
        String[] strings = str.split(" ",2);
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

注意事项:

1. 字符"|“,”*“,”+"都得加上转义字符，前面加上 “\” .

        String str2 = new String("1|2|3");
        String[] strings1 = str2.split("|");
        for (int i = 0; i < strings1.length; i++) {
            System.out.println(strings1[i]);
        }

        String str2 = new String("1|2|3");
        String[] strings1 = str2.split("\\|");
        for (int i = 0; i < strings1.length; i++) {
            System.out.println(strings1[i]);
        }

2. 而如果是 “” ，那么就得写成 “\\” .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

        String str = new String("ab&cd%ef&gh%ij");
        String[] strings = str.split("&|%");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

多次拆分

        String str = new String("ab&cd%ef&gh%ij");
        String[] strings = str.split("&");
        for (int i = 0; i < strings.length; i++) {
            String[] strings1 = strings[i].split("%");
            for (int j = 0; j < strings1.length; j++) {
                System.out.println(strings1[j]);
            }
        }

字符串截取

String substring(int beginIndex)
从指定索引截取到结尾

 		String str = new String("abcdef");
        System.out.println(str.substring(2));

String substring(int beginIndex, int endIndex)
截取部分内容

        String str = new String("abcdef");
        System.out.println(str.substring(0, 3));//下标取值范围前闭后开

其他操作方法

String trim()
去掉字符串中的左右空格,保留中间空格

        String str = new String("  ab cd ef  ");
        System.out.println(str.trim());

字符串的不可变性

String是一种不可变对象,字符串中的内容是不可改变的,字符串不可呗修改,是因为:

1. String类在设计时就是不可改变的,String类实现描述中已经说明了
   String类中的字符实际保存在内部维护的value字符数组中
   String类被final修饰,表明该类不能被继承
   value被final修饰,表明value自身的值不能改变,即不能引用其他字符数组,但是其引用空间中的内容可以修改

2. 所有及设计可能修改字符串内容操作都是创建一个新的对象,对新对象进行修改

final修饰类表示该类不能被继承,final修饰引用类型表明该引用变量不能引用其他对象,但是其引用对象中的内容是可以修改的

StringBuilder和StringBuffer

StringBuilder

由于String不可更改的特性,为了方便字符串修改,java又提供StringBuilder和StringBuffer类,这两个类大部分功能是相同的

String和StringBuilder最大的区别在于String的内容无法修改,而StringBuilder的内容可以修改.
注意:String和StringBuilder类不能直接转换
String变为StringBuilder:利用StringBuilder的构造方法或append()方法
StringBuilder变为String:调用toString()方法

String,StringBuffer,StringBuilder的区别
String的内容不可修改,StringBuffer与StringBuilder的内容可以修改
StringBuffer与StringBuilder大部分功能是相似的