2w Wörter detaillierte Erklärung String, yyds

public class User{
    private Long id;
    private String userName;
    private String address;
    private String password;
    ....
}

//案例代码，来源于网络
public class StringDemo {
    public static void main(String[] args) throws Exception {
        String str1 = "Hello World";
        String str2 = "Hello World";
        String str3 = "hello world";
        String str4 = " hello world ";
        //返回字符串的长度
        System.out.println("r1: " + str1.length());
        //比较两个字符串的大小compareTo(返回的是int),0相等，复数小于，正数大于
        System.out.println("r2 : " + str1.compareTo(str2));
        //比较两个字符串的大小compareTo(返回的是int),0相等，复数小于，正数大于
        System.out.println("r3 : " + str1.compareTo(str3));
        //字符串比较compareToIgnoreCase，忽略大小写。0相等，复数小于，正数大于
        System.out.println("r4 : " + str1.compareToIgnoreCase(str3));
        //字符串查找indexOf，返回的是找到的第一个的位置，没找到返回-1。从0开始
        System.out.println("r5 : " + str1.indexOf("o"));
        //查找字符串最后一次出现的位置lastIndexOf
        System.out.println("r6 : " + str1.lastIndexOf("o"));
        //删除字符串中的一个字符,字符串从0开始的 substring(a, b)
        //返回指定起始位置（含）到结束位置（不含）之间的字符串
        System.out.println("r7 : " + str1.substring(0, 5) + str1.substring(6));

        //字符串替换,替换所有
        System.out.println("r8 : " + str1.replace("o", "h"));
        //字符串替换,替换所有
        System.out.println("r9 : " + str1.replaceAll("o", "h"));
        //字符串替换,替换第一个
        System.out.println("r10 : " + str1.replaceFirst("o", "h"));
        //字符串反转
        System.out.println("r11 : " + new StringBuffer(str1).reverse());
        //字符串反转
        System.out.println("r11’: " + new StringBuilder(str1).reverse());
        //字符串分割
        String[] temp = str1.split("\\ ");
        for (String str : temp) {
            System.out.println("r12 : " + str);
        }
        //字符串转大写
        System.out.println("r13 : " + str1.toUpperCase());
        //字符串转小写
        System.out.println("r14 : " + str1.toLowerCase());
        //去掉首尾空格
        System.out.println("r15 : " + str4.trim());
        //是否包含,大小写区分
        System.out.println("r16 : " + str1.contains("World"));
        //返回指定位置字符
        System.out.println("r17 : " + str1.charAt(4));
        //测试此字符串是否以指定的后缀结束
        System.out.println("r18 : " + str1.endsWith("d"));
        //测试此字符串是否以指定的前缀开始
        System.out.println("r19 : " + str1.startsWith("H"));
        //测试此字符串从指定索引开始的子字符串是否以指定前缀开始
        System.out.println("r20 : " + str1.startsWith("ll", 2));
        //将指定字符串连接到此字符串的结尾。等价于用“+”
        System.out.println("r21 : " + str1.concat("haha"));
        //比较字符串的内容是否相同
        System.out.println("r22 : " + str1.equals(str2));
        //与equals方法类似，忽略大小写
        System.out.println("r23 : " + str1.equalsIgnoreCase(str2));
        //判断是否是空字符串
        System.out.println("r24:  " + str1.isEmpty());

    }
}

/**
 * The {@code String} class represents character strings. All
 * string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * 这个String类代表字符串。java编程中的所有字符串常量。
 * 比如说："abc"就是这个String类的实例
 * <p>
 * Strings are constant; their values cannot be changed after they
 * are created. 
 * 字符串是常量，他们一旦被创建后，他们的值是不能被修改。（重点）
 * String buffers support mutable strings.
 * String缓存池支持可变的字符串，
 * Because String objects are immutable they can be shared. For example:
 * 因为String字符串不可变，但他们可以被共享。比如：
 * <blockquote><pre class="brush:php;toolbar:false">
 *     String str = "abc";
 * 

* is equivalent to: *

 *     char data[] = {'a', 'b', 'c'};
 *     String str = new String(data);
 * 

* Here are some more examples of how strings can be used: * String使用案例 * System.out.println("abc"); * String cde = "cde"; * System.out.println("abc" + cde); * String c = "abc".substring(2,3); * String d = cde.substring(1, 2); *

* The class {@code String} includes methods for examining * individual characters of the sequence, for comparing strings, for * searching strings, for extracting substrings, and for creating a * copy of a string with all characters translated to uppercase or to * lowercase. Case mapping is based on the Unicode Standard version * specified by the {@link java.lang.Character Character} class. * 这个String类包含了一些测评单个字符序列的方法，比如字符串比较，查找字符串， * 提取字符串，和拷贝一个字符串的大小写副本。 * 大小写映射的是基于Character类支持的Unicode的字符集标准版本。 *

* The Java language provides special support for the string * concatenation operator ( + ), and for conversion of * other objects to strings. * java语言提供了对字符串的特殊支持，如：可以通过"+"号来进行字符串的拼接操作， * 为其他类提供了与字符串转换的操作 * String concatenation is implemented * through the {@code StringBuilder}(or {@code StringBuffer}) * class and its {@code append} method. * 字符串的+号拼接操作是通过StringBuilder或者StringBuffer类的append()方法 * 来实现的 * String conversions are implemented through the method * {@code toString}, defined by {@code Object} and * inherited by all classes in Java. * 对象与字符串的转换操作是通过所有类的父类Object中定义的toString()方法来实现的 * For additional information on * string concatenation and conversion, see Gosling, Joy, and Steele, * The Java Language Specification. * *

Unless otherwise noted, passing a null argument to a constructor * or method in this class will cause a {@link NullPointerException} to be * thrown. * 除非有特殊说明，否则传一个null给String的构造方法或者put方法，会报空指针异常的 *

A {@code String} represents a string in the UTF-16 format * in which supplementary characters are represented by surrogate * pairs (see the section Unicode * Character Representations in the {@code Character} class for * more information). * 一个String 对象代表了一个UTF-16编码语法组成的字符串 * Index values refer to {@code char} code units, so a supplementary * character uses two positions in a {@code String}. *

The {@code String} class provides methods for dealing with * Unicode code points (i.e., characters), in addition to those for * dealing with Unicode code units (i.e., {@code char} values). * 索引值指向字符码单元，所以一个字符在一个字符串中使用两个位置， * String 类提供了一些方法区处理单个Unicode编码，除了那些处理Unicode代码单元。 * @since JDK1.0 */

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
 ....   
 }

 /** The value is used for character storage. */
// 来用存储String内容的
private final char value[];
// 存储字符串哈希值，默认值为0
private int hash; // Default to 0
// 实现序列化的标识
private static final long serialVersionUID = -6849794470754667710L;

/**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence.  Note that use of this constructor is
 * unnecessary since Strings are immutable.
 * 初始化新创建的String对象，时期表示空字符串序列。
 * 注意：这个构造方法的用法是没必要的，因为字符串是不可变的
 */
public String() {
        this.value = "".value;
}

 /**
  * Initializes a newly created {@code String} object so that it represents
  * the same sequence of characters as the argument; in other words, the
  * newly created string is a copy of the argument string. Unless an
  * explicit copy of {@code original} is needed, use of this constructor is
  * unnecessary since Strings are immutable.
  * 初始化创建的String对象，时期表示与参数相同的字符串序列。
  * 换句话说：新创建的字符串是参数自粗糙的副本。
  * 除非，如果需要original的显示副本，否则也是没有必要使用此构造方法的
  * 因为字符串是不可变的
  * @param  original
  *         A {@code String}
  */
 public String(String original) {
     this.value = original.value;
     this.hash = original.hash;
 }
//案例:  String str=new String("abc");

/**
 * Allocates a new {@code String} so that it represents the sequence of
 * characters currently contained in the character array argument. The
 * contents of the character array are copied; subsequent modification of
 * the character array does not affect the newly created string.
 * 分配一个新的{@code String}，以便它表示字符数组参数中当前包含的字符。这个
 * 复制字符数组的内容；随后修改字符数组不影响新创建的字符串。
 * @param  value
 *         The initial value of the string
 */
public String(char value[]) {
    //注:将传过来的char数组copy到value数组里
    this.value = Arrays.copyOf(value, value.length);
}
//Arrays类中的copyOf方法
public static char[] copyOf(char[] original, int newLength) {
    //创建一个新的char数组
    char[] copy = new char[newLength];
    //把original数组中内容拷贝到新建的char数组中
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    //返回新建的char数组
    return copy;
}

public String(StringBuffer buffer) {
   synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
   }
}

public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
            //hash算法，s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
            //使用{@codeint}算法，其中{@codes[i]}是<i> i</i>字符串的第个字符，
            //{@code n}是字符串，{@code^}表示指数运算。
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
}

public boolean equals(Object anObject) {
    //首先会判断是否是同一个对象
     if (this == anObject) {
         return true;
     }
    //判断是否为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) {
                 //不相等，直接返回false
                 if (v1[i] != v2[i])
                     return false;
                 i++;
             }
             return true;
         }
     }
     return false;
}

==比较基本数据类型，比较的是值
==比较引用数据类型，比较的是地址值

public String substring(int beginIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    int subLen = value.length - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    //如果beginIndex==0，返回的是当前对象，
    //否则这里是new的一个新对象，其实String中的很多函数都是这样的操作
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

/*
 * When the intern method is invoked, if the pool already contains a
 * string equal to this {@code String} object as determined by
 * the {@link #equals(Object)} method, then the string from the pool is
 * returned. Otherwise, this {@code String} object is added to the
 * pool and a reference to this {@code String} object is returned.
 */
public native String intern();

public class StringDemo {
    public static void main(String[] args) throws Exception {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab";
        String str4 = str1 + str2;
        String str5 = new String("ab");

        System.out.println(str5 == str3);//堆内存比较字符串池
        //intern如果常量池有当前String的值,就返回这个值,没有就加进去,返回这个值的引用
        System.out.println(str5.intern() == str3);//引用的是同一个字符串池里的
        System.out.println(str5.intern() == str4);//变量相加给一个新值，所以str4引用的是个新的
        System.out.println(str4 == str3);//变量相加给一个新值，所以str4引用的是个新的

    }
}

false
true
false
false

public int length() {
    return value.length;
}

public boolean isEmpty() {
    return value.length == 0;
}

public char charAt(int index) {
    //索引小于0或者索引大于字符数组长度，则抛出越界异常
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    //返回字符数组指定位置字符
    return value[index];
}

public byte[] getBytes() {
    return StringCoding.encode(value, 0, value.length);
}

public int compareTo(String anotherString) {
    //自身对象字符串长度len1
    int len1 = value.length;
    //被比较对象字符串长度len2
    int len2 = anotherString.value.length;
    //取两个字符串长度的最小值lim
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;
 
    int k = 0;
    //从value的第一个字符开始到最小长度lim处为止，如果字符不相等，
    //返回自身（对象不相等处字符-被比较对象不相等字符）
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    //如果前面都相等，则返回（自身长度-被比较对象长度）
    return len1 - len2;
}

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.
    //如果起始地址小于0或者（起始地址+所比较对象长度）大于自身对象长度，返回假
    if ((toffset < 0) || (toffset > value.length - pc)) {
        return false;
    }
    //从所比较对象的末尾开始比较
    while (--pc >= 0) {
        if (ta[to++] != pa[po++]) {
            return false;
        }
    }
    return true;
}
 
public boolean startsWith(String prefix) {
    return startsWith(prefix, 0);
}
 
public boolean endsWith(String suffix) {
    return startsWith(suffix, value.length - suffix.value.length);
}

public String concat(String str) {
    int otherLen = str.length();
    //如果被添加的字符串为空，返回对象本身
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

public String replace(char oldChar, char newChar) {
    //新旧值先对比
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        char[] val = value; 
 
        //找到旧值最开始出现的位置
        while (++i < len) {
            if (val[i] == oldChar) {
                break;
            }
        }
        //从那个位置开始，直到末尾，用新值代替出现的旧值
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            return new String(buf, true);
        }
    }
    return this;
}

public String trim() {
    int len = value.length;
    int st = 0;
    char[] val = value;    /* avoid getfield opcode */
 
    //找到字符串前段没有空格的位置
    while ((st < len) && (val[st] <= &#39; &#39;)) {
        st++;
    }
    //找到字符串末尾没有空格的位置
    while ((st < len) && (val[len - 1] <= &#39; &#39;)) {
        len--;
    }
    //如果前后都没有出现空格，返回字符串本身
    return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}

public static String valueOf(boolean b) {
   //如果b为true就返回"true"否则返回"false"
   return b ? "true" : "false";
}
public static String valueOf(char c) {
    //创建data[]数组 并把c添加进去
    char data[] = {c};        
     //创建一个新的String对象并进行返回
    return new String(data, true); 
}
public static String valueOf(int i) {
    //调用Integer对象的toString()方法并进行返回
    return Integer.toString(i);  
}
//Integer类中的toString(i)方法
public static String toString(int i) {
    //是否为Integer最小数，是直接返回
    if (i == Integer.MIN_VALUE)
       return "-2147483648";
    //这个i有多少位
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    //创建一个char数组
    char[] buf = new char[size];
    //把i内容方法char数组中区
    getChars(i, size, buf);
    //返回一个String对象
    return new String(buf, true);
}

public String[] split(String regex) {
    return split(regex, 0);
}
//使用到了正则表达式
public String[] split(String regex, int limit) {
      //....
    //源码有点多了，反正就是里面使用到了正则表达式，进行切分
    }

public class StringDemo {
   public static void main(String[] args) {
     String st1 = "abc";
     String st2 = "abc";
     System.out.println(st1 == st2);
     System.out.println(st1.equals(st2)); 
   }
}

true
true

String str1 = "abc";  // 在常量池中
String str2 = new String("abc"); // 在堆上