Java--String类

前言：

在之前的学习中，学习了和了解了一些类的基本使用，例如object类等等，但是我们用String这个引用或者说这个类其实我们已经用了好久，只不过没有具体分析过！

对于String类，它可以引用一个字符串，在C语言中没有一个类型是字符串类型。

接下来就来探究一下String类带给我们的一些方法。

常用方法：

1、构造方法：

字符串的构造方法常见的有三种：

public class Test1 {
    public static void main(String[] args) {
        //方式一：
        String str = "abcd";
        //方式二：
        String str1 = new String("abcd");
        //方式三：
        char[] arr = {'a','b','c','d'};
        String str2 = new String(arr);
    }
}

由于String是引用类型，自己本身不存储数据，在String类中实例变量如下：

      String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;

如上这段代码是s1和s3是引用同一个对象的，画图解释：

注意：

在Java中用" "引起来的也是String类型!！

字符串的比较：

字符串的比较有四种情况：

1.比较String类型是否引用同一个对象：

也就是用"=="比较两个引用的地址是否相同：

    public static void main(String[] args) {
        //对于基本变量“==”是比较两个值是否相等
        int a = 10;
        int b = 20;
        int c = 10;
        System.out.println(a == b);//fasle
        System.out.println(a == c);//true

        //对于String引用类型，比较地址
        String s1 = new String("abcd");
        String s2 = new String("abcd");
        String s3 = s1;
        System.out.println(s1 == s2);//false
        System.out.println(s1 == s3);//true
        System.out.println(s2 == s3);//false
    }

我们从结果也能看出！

但是！！！，这时候有一个问题：我用直接引用的方式，也就是不new直接引用一个字符串结果是否还是一样的呢？
    public static void main(String[] args) {
        String s1 ="abcd";
        String s2 = "abcd";
        String s3 = s1;
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s2 == s3);
    }
结果是：

三个true，难道说此时没有在比较地址？还是说没有在堆区开辟新的空间？
要谈就这个问题和"常量池"有关，放在后边的讲解中！

2.equals方法按照字典序比较两个字符串

也就是比较两个字符串中的每一个字符是不是都是一样的，如果一样就返回true，如果不一样就返回false!

String类中的该方法时继承Object类中的equals方法，如果我们想要有自己的equals方法也可以重写。

    public static void main(String[] args) {
        String s1 = new String("abcde");
        String s2 = new String("abcde");
        String s3 = new String("abc");
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//false
    }

此时可以看出结果，equals方法可以比较两个字符串里面的字符是不是一样的。

我们可以拿到equals的源码：

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        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;
    }

这个源码是Object类中的方法，被继承之后可以使用，这个源码的特点：

1、当两个引用类型引用同一个对性的时候，也就是地址相同时，直接返回true

2、检查两个引用的类型是否一样，如果不一样直接返回false。

3. this和 anObject 两个字符串的长度是否相同，是继续比较，否则返回 false

4、将字符串放入字符数组中，逐一比较每个字符的Ascall值是否一样。

3.compareTo方法按照字典序比较

这个方法比起equals方法更加精细化二了，equals方法只能告诉你两个字符串相不相等，

但是compareTo方法能够告诉你如果不相等那个字符串大。

    public static void main(String[] args) {
        String s1 = new String("abcdef");
        String s2 = new String("abc");
        String s3 = new String("efg");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2));
        System.out.println(s1.compareTo(s3));
        System.out.println(s1.compareTo(s4));
    }

注意：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

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

源码如下：

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;
    }

4、compareToIgnoreCase方法：

与compareTo方式相同，但是忽略大小写比较。

    public static void main(String[] args) {
        String s1 = new String("abcdef");
        String s2 = new String("abc");
        String s3 = new String("efg");
        String s4 = new String("AbcdEf");
        System.out.println(s1.compareToIgnoreCase(s2));
        System.out.println(s1.compareToIgnoreCase(s3));
        System.out.println(s1.compareToIgnoreCase(s4));
    }

结果是：

发现s1和s4在大小写上有区别，但是该方法可以忽略大小写，直接比较!

字符串的查找：

返回index位置上字符：

也就是找到对应位置上的字符：

    public static void main(String[] args) {
        String s = "abcdefghhigkl";
        System.out.println(s.charAt(1));
        System.out.println(s.charAt(3));
        System.out.println(s.charAt(20));
    }

注意事项：

如果index为负数或者越界，抛出IndexOutOfBoundsException异常

返回字符第一次出现的位置：

    public static void main(String[] args) {
        String s = "abcdefghhigkl";
        System.out.println(s.indexOf('e'));
        System.out.println(s.indexOf('c'));
        System.out.println(s.indexOf('z'));
    }

注意事项：

1. 如果index在字符串中没有则返回-1。

2.参数index需要传字符，内部是用整形接收字符的ASCALL码值。

返回从指定位置开始第一次对应字符出现的位置：

    public static void main(String[] args) {
        String s = "abcdefghhigkl";
        System.out.println(s.indexOf('a',0));
        System.out.println(s.indexOf('a',2));
        System.out.println(s.indexOf('l',99));
    }

返回指定字符串的位置：

该方法可以返回指定字符串第一次出现的位置：

    public static void main(String[] args) {
        String s = "abcdefghhigkl";
        System.out.println(s.indexOf("igk"));
        System.out.println(s.indexOf("l"));
        System.out.println(s.indexOf("abcd"));
    }

如果没有就返回-1。

从后往前找对应字符串，返回对应位置：

    public static void main(String[] args) {
        String s = "abcdefghhigkl";
        System.out.println(s.lastIndexOf('d'));
        System.out.println(s.lastIndexOf('l'));
    }

其效果和indexOf一样的。

当然它同样也有一些重载的方法，这里就不一一列举了！！

转化：

数值转字符串：

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Test1 {
    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(13,"xiaoming"));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

字符串转数值：

    public static void main(String[] args) {
        String s1 = new String("12345");
        String s2 = new String("123.45");
        int a = Integer.parseInt(s1);
        double b = Double.parseDouble(s2);
        System.out.println(a);
        System.out.println(b);
    }

大小写转换：

    public static void main(String[] args) {
        String s1 = "abcde";
        String s2 = "HAHAHA";
        String s3 = "abcDEF";
        System.out.println(s1.toUpperCase());//小写转大写
        System.out.println(s2.toLowerCase());//大写转小写
        System.out.println(s3.toUpperCase());//小写转大写
        System.out.println(s3.toLowerCase());//大写转小写
    }

字符串转数组：

    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 static void main(String[] args) {
        String s = "helloworld!";
        System.out.println(s.replaceAll("l", "_"));
        System.out.println(s.replaceFirst("l", "_"));
        System.out.println(s.replaceAll("hel","_"));
    }

注意：

如果字符串中没有对应要替换的对象就返回原来的字符串！

字符串拆分：

String[] split(String regex) 将字符串全部拆分

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

    public static void main(String[] args) {
        String s = "abc def ghi";
        String[] s1 = s.split(" ");
        for (String s2:s1) {
            System.out.println(s2);
        }
    }

String[] split(String regex, int limit) 将字符串以指定的格式，拆分为limit 组

    public static void main(String[] args) {
        String s = "abc def ghi";
        String[] s1 = s.split(" ",2);
        for (String s2:s1) {
            System.out.println(s2);
        }
    }

特殊：

拆分如下字符串：

    public static void main(String[] args) {
        String s = "192.182.1.13";
        String[] s1 = s.split(".");
        for (String x:s1) {
            System.out.println(x);
        }
    }

打印结果却不对劲。

注意：

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

2. 而如果是 "\" ，那么就得写成 "\\\\" .

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

可以这样写：

    public static void main(String[] args) {
        String s = "192.182.1.13";
        String[] s1 = s.split("//.");
        for (String x:s1) {
            System.out.println(x);
        }
    }

多次拆分：

String str = "name=zhangsan&age=18" ;
String[] result = str.split("&") ;
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=") ;
System.out.println(temp[0]+" = "+temp[1]);
}

字符串截取：

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

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

    public static void main(String[] args) {
        String s = "helloworld!!";
        System.out.println(s.substring(3));
        System.out.println(s.substring(3,8));
    }