（JAVA）String类之比较方法

/*
字符串：
一、概述：
    1.字符串在JAVA中，使用""表示
    2.java.lang.String类
    3.只要写""就是字符串对象。不需要new

二、空参构造器
    new Sting();
        private final char value[];
        public String() {
        this.value = "".value;
    }
三、String类一个参数构造器：字节数组
    采用平台（操作系统）默认字符集解码数组--编码表GBK
    byte[] = {};
    将字节数组转成字符串
     public String(byte bytes[]) {
        this(bytes, 0, bytes.length);
    }
四、String类两个参数构造器：指定一个编码表【I/O更新】

五、String类三个参数构造器：字节数组，开始下标，获取几个
java.lang.String @Contract(pure = true)
public String(@NotNull byte[] bytes,
              int offset,
              int length)
六、String类一个参数构造器：字符数组
public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
七、String类三个参数构造器：字符数组，开始下标，获取几个
    public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count <= 0) {
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }
八、String类三个参数构造器：整数数组，开始下标，获取几个（基本不用）
九、    String类三个参数构造器：字符串（基本不用）
public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

十、字符串一旦创建，就是常量，不能修改。
"abc"是对象---不能改变
s 是引用型变量
s 的指向对象可以改变

十一、在堆中，如果
String s1 = new String('a','b','c');
String s2 = new String('a','b','c');
System.out.println(s1==s2);-------true

但
String s3 = new String("abc");
String s4 = "abc";
System.out.println(s1==s2);-------Fals:创建对象不同

String s5 = "efg";
System.out.println(s4==(s4+s5));---- f-------常量与变量相加，不知道结果，重新建立空间，比较的是内存地址
System.out.println(s4==("abc"+"def"));---- t------常量与常量相加，比较的是具体数值

十二、比较方法equals()：必须一模一样才叫相等，是继承Object类之后重写的
    比较数组中的每一个字符
      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;
    }
十三、比较字符串是否相等，忽略大小写:是StrinG自己的，非继承重写
boolean equalsIgnoreCase(String s)

十四、判断一个字符串中是否包含另一个字符串
   public boolean contains(CharSequence s) {
        return indexOf(s.toString()) > -1;
    }
十五、判断字符串中是否包含空字符串
    public boolean isEmpty() {
        return value.length == 0;
    }
十六、判断字符串是不是以另一个字符串开头
    public boolean startsWith(String prefix) {
        return startsWith(prefix, 0);
    }
       public boolean startsWith(String prefix, int toffset) {
        char ta[] = value;
        int to = toffset;
        char pa[] = prefix.value;
        int po = 0;
        int pc = prefix.value.length;
        // Note: toffset might be near -1>>>1.
        if ((toffset < 0) || (toffset > value.length - pc)) {
            return false;
        }
        while (--pc >= 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
        return true;
    }

判断字符串是不是以另一个字符串结尾
    public boolean endsWith(String suffix) {
        return startsWith(suffix, value.length - suffix.value.length);
    }



 */

1.空指针异常

 

public class StringDome {
    public static void main(String[] args) {
        method_1();

    }

    public static void method_1() {
        String s1 = "abcde";
        String s2 = new String("abcde");
        String s3 = null;
        String s4 = "ABCDE";
        String s5 = "ab";
        String s6 = "";
        System.out.println(s1.equals(s2));
        //System.out.println(s3.equals(null));
        System.out.println(s1.equalsIgnoreCase(s4));
        System.out.println(s1.contains(s5));
        System.out.println(s6.isEmpty());
        System.out.println(s1.startsWith("a"));
        System.out.println(s1.endsWith("d"));


    }