【入门】Java数据类型 | String基础

/**
 * The {@code String} class represents character strings. All string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * {@code String}类表示字符串。Java程序中的所有字符串文本，例如{@code“abc”}，都是作为这个类的实例实现的。
 * Strings are constant; their values cannot be changed after they are created. 
 * Strings 是常量，它们的值在创建之后不能改变
 * String buffers support mutable strings. Because String objects are immutable they can be shared. For example:
 * String buffers 是可变的字符串，因为String 对象的不可变性，所以它们可以共享
 * 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. 
 * {@code String}类包含用于检查序列中单个字符的方法，这些方法主要用于comparing、searching、extracting substrings、创建一个副本
 * Case mapping is based on the Unicode Standard version specified by the {@link java.lang.Character Character} class.
 * 大小写映射基于在 java.lang.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.
 * 字符串的拼接是通过{@code StringBuilder}或者 {@code StringBuffer}的{@code append} 方法实现的
 * String conversions are implemented through the method {@code toString}, defined by {@code Object} and nherited by all classes in Java. 
 * 字符串转化是通过 {@code toString} 方法的，这个方法是定义在{@code Object} 类中的，并且被java所有的类继承了
 * For additional information on string concatenation and conversion, see Gosling, Joy, and Steele, <i>The Java Language Specification</i>.
 * 有关字符串连接和转换的其他信息可以查看The Java Language Specification，书我已经放在网上了(http://troubleclear.com/document/2981)
 * <p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor or method in this class will cause a {@link NullPointerException} to be thrown.
 * 除非另有说明，传递一个null 值给构造器或者其他方法会抛出NullPointerException 
 * <p>A {@code String} represents a string in the UTF-16 format
 * in which <em>supplementary characters</em> are represented by <em>surrogate
 * pairs</em> (see the section <a href="Character.html#unicode">Unicode
 * Character Representations</a> 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}.
 * 指定下标的位置对应着一个字符，因此补充字符在{@code String}中使用两个位置。
 * <p>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).
 * 除了{@code char}处理Unicode code字符外 {@code String} 也提供了这样的方法
 */

public final class String  implements java.io.Serializable, Comparable<String>, CharSequence {
 ... ... 
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

/** The value is used for character storage. */
private final char value[];
1.
2.

/** Cache the hash code for the string */
private int hash; // Default to 0
1.
2.

String str1 = "abc";
String str2 = "abc";
1.
2.

/**
 * The {@code String} class represents character strings. All
 * string literals in Java programs, such as {@code "abc"}, are
 * implemented as instances of this class.
 * <p>
 * Strings are constant; their values cannot be changed after they
 * are created. String buffers support mutable strings.
 * Because String objects are immutable they can be shared. For example:
 * ...
 */

public final class String { 
 private final char value[];
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

public final class BuerSting {
    private char value[];
    private int hash; // Default to 0

    public BuerSting(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
    public BuerSting(String original) {
        this.value = original.toCharArray();
        this.hash = original.hashCode();
    }

    public void setValue(char[] value) {
        this.value = value;
    }
    public void setValue(String value) {
        this.value = value.toCharArray();
    }

    @Override
    public String toString() {
        return "BuerSting{" +
                "value=" + Arrays.toString(value) +
                '}';
    }

    public static void main(String[] args) {
        BuerSting s = new BuerSting("aaa");
        System.out.println(s);
        s.setValue("sss");
        System.out.println(s);
    }
}
// 输出结果
BuerSting{value=[a, a, a]}
BuerSting{value=[s, s, s]}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

@Test
public void immutable() {
    String str = "hello";
    str.concat("world");
    System.out.println("Value of str:" + str);
}
// 输出结果
Value of str:hello
1.
2.
3.
4.
5.
6.
7.
8.

public class MyString {
    public static void main(String[] args) {
        String str1 = "i";
        String str2 = "i";
        String str2 = new String("i");
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str3.intern());
    }
}
// 运行结果
true
false
true
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

System.out.println(str1 == str3.intern());
//运行结果为true
1
2
1.
2.
3.
4.

/** 
 * Returns a canonical representation for the string object. 
 * 返回字符串对象的规范表示形式。
 * A pool of strings, initially empty, is maintained privately by the  class {@code String}. 
 * 一个字符串池，一开始是空的，由字符串类私有维护
 * 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. 
 * 当intern方法被调用的时候，如果串池中已经包含被equals方法认定相等的字符串，则串池中的字符串被返回
 * Otherwise, this {@code String} object is added to the  pool and a reference to this {@code String} object is returned. 
 * 否则当前String对象被加入串池，并且返回该字符串的引用
 * It follows that for any two strings {@code s} and {@code t},  {@code s.intern() == t.intern()} is {@code true}  if and only if {@code s.equals(t)} is {@code true}. 
 * 因此，对于任意两个字符串{@codes s}和{@code t}，{@codes s.intern（）==t.intern（）}是{@code true}当且仅当{@codes s.equals（t）}是{@code true}。
 * All literal strings and string-valued constant expressions are  interned. String literals are defined in section 3.10.5 of the <cite>The Java&trade; Language Specification</cite>. 
 * 所有的文字字符串和字符串值常量表达式都是内部的
 * @return  a string that has the same contents as this string, but is 
 *          guaranteed to be from a pool of unique strings. 
 */
 public native String intern();
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

String str4 = new String("helloChina");
System.out.println(str4.intern() == str4);//false
str4 = str4.intern();
String str5 = "helloChina";
String str6 = "helloZhonghua"
System.out.println(str4 == str5);//true
1.
2.
3.
4.
5.
6.

str6 = "helloHuaxia";
1.

String str7 = "good good" + " study";
String str8 = "good good study";
System.out.println(str7 == str8);
1.
2.
3.

String str7 = "good good study";
String str8 = "good good study";
1.
2.

String str9 = "good good ";
String str10 = str9 + "study";
system.out.println(str8 == str10);//false
1.
2.
3.

//str1 == "hello,world ";

//获取长度
str1.length()//12;

//截取位置2到5之间的字符串（包括位置2，不包括位置5，从0开始）
str1.substring(2,5);//"llo"

//判断是否含有字符串“ello”
str1.contains("ello");//true,通过indexOf实现

//获取ello在str1中的开始位置
str1.indexOf("ello");//1

//将字符串转化为字符串数据
str1.split(",");//["hello","world"]

//去掉字符串两侧空格
str1.trim();//"hello,world"
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.