java字符序列_字符序列(CharSequence)

字符序列(CharSequence)

1、相关接口

java.lang.CharSequence 接口

java.lang.Appendable接口

java.lang.Comparable接口

java.io.Seralization 接口

2、java.lang.String

2.1、概念：String 是个类 character strings 才是字符串

1、在 Java 语言中 直接使用 “” 引起来的多个字符就是 字符串 (character strings)2、在 Java 源代码中 直接使用 “” 引起来的字符串 都是 java.lang.String 的实例3、String 类 是个 不可变类 将来创建的 每个 String 实例 都是不可变的对象【Strings are constant】

[Java 8及之前]public final class String {private char[] value; // 使用 char 数组保存字符序列}

[Java 9 之后]public final class String {private final byte[] value; // 使用 byte 数组保存字节序列}字节序列是字符序列根据某种编码转换而来

通过 "" 双引号来创建字符串

java.lang.String 类的主要字段 Java 11

public final class String implements Serializable, Comparable, CharSequence {

private final byte[] value;

private final byte coder;

private int hash;

public String(String original) {

this.value = original.value;

this.coder = original.coder;

this.hash = original.hash;

}

}

String t = new String("abc123");

首先通过 "abc123" 来创建 String 的实例

这个实例在 String 常量池中

// 三个字段

byte[] value：0xA1B2C3 // 通过创建堆内存的 byte[] 来存取 "abc123" 数组变量value 存放数组的引用

byte coder：0

int hash：-1424436592

堆内存的 byte[]

{97,98,99,49,50,51} // 假设地址为 0xA1B2C3

当我们在堆内存中 new String( s ) 这时调用 String 类的构造方法

public String(String original) {

this.value = original.value;

this.coder = original.coder;

this.hash = original.hash;

}

将 常量池的值复制一份过来

但 String t = new String("abc123");

变量 t 存放的是 一个堆中的地址

如果 String s1 = "abc123"; 和 String s2 = "abc123";

这里的 s1 和 s2 存放的是常量池实例的地址 是相同的

2.2、new String( s ) 的内存图

注但凡是出现了 "" 引起来的内容，这部分内容一定放在 String 常量池中

String t = new String("abc123");

创建一个 “abc123” 对应 String 实例 并添加到常量池中

在堆内存创建 String 实例 并将 "abc123" 的 value / hash / coder 拷贝到新创建的 String 实例中

3、String 的部分实例变量

private final byte coder;

private int hsah;

private final byte[] value;

4、String 内部的一些方法

构造方法

public String(byte[] bytes)

public String(byte[] bytes, int offset, int length)

public byte[] getBytes()

等等一些重载方法

类变量

static final byte LATIN1 = 0；

static final byte UTF-16 = 1;

类方法

valueOf()

将 基本数据类型的值 转化为 字符串形式 valueOf(boolean|int|long|float|double|char)

format

join

实例方法

1、char charAt(int) 获取指定索引的单个字符2、int length() 获取字符串长度3、public boolean contains(CharSequence s) 判断指定的字符序列是否存在于 当前字符串中4、int indexOf(int ch) 查询指定字符 在当前字符串中 首次出现的位置 存在返回索引 不存在 -15、int indexOf(String s)6、int lastIndexOf(int ch)7、int lastIndexOf(String s)

package CharSequence;

/**

* 1、char charAt(int) 获取指定索引的单个字符

* 2、int length() 获取字符串长度

* 3、public boolean contains(CharSequence s) 判断指定的字符序列是否存在于 当前字符串中

* 4、int indexOf(int ch) 查询指定字符 在当前字符串中 首次出现的位置 存在返回索引 不存在 -1

* 5、int indexOf(String s)

* 6、int lastIndexOf(int ch)

* 7、int lastIndexOf(String s)

* */

public class StringTestA {

public static void main(String[] args) {

​

final String s = "今天天气好晴朗处处好风光好风光";

for (int i = 0; i < s.length(); i++) {

char ch = s.charAt(i);

System.out.print(ch);

System.out.print(i

}

// 因为 String 类实现了 CharSequence接口

CharSequence cs = "好风光"; // 所以用 CharSequence 类型的引用变量指向了 String 实例是可以的

boolean z = s.contains(cs);

System.out.println(z);

​

// 整个字符串中的每个字符的索引 一样 从 ”左“ 开始统计 与数组相同

int index = s.indexOf('天');// 获取 天 在变量 s 所指向的字符串首次出现的位置(索引)

System.out.println(index);

​

index = s.indexOf("好风光");

System.out.println(index); // 获取 好风光 在变量 s 所指向的字符串首次出现的位置(索引) 好的位置

​

int lastIndex = s.lastIndexOf('天'); // 获取 天 在变量 s 所指向的字符串最后出现的位置(索引)

System.out.println(lastIndex);

​

lastIndex = s.lastIndexOf("好风光"); // 获取 好风光 在变量 s 所指向的字符串最后出现的位置(索引) 还是好的位置

System.out.println(lastIndex);

​

}

}

​

indexOf( int ch , int from )

int indexOf( String s , int from )

int lastIndexOf( int ch , int from )

int lastIndexOf( String s , int from )

package CharSequence;

​

/**

* 1、 int indexOf( int ch , int from )

* 从 当前字符串中 指定位置(from) 开始寻找 指定字符 ( ch ) 首次出现的位置，若存在即返回该索引，否则返回 -1

* 2、int indexOf( String s , int from )

* 从 当前字符串中 指定位置(from) 开始寻找 指定字符串 ( s ) 首次出现的位置，若存在即返回该索引，否则返回 -1

* 3、int lastIndexOf( int ch , int from )

* 从 当前字符串中 指定位置(from) 开始反向寻找 指定字符 ( ch ) 最后一次出现的位置，若存在即返回该索引，否则返回 -1

*         即获取在 from 处及其之前 ch 最后一次出现的位置是什么

*         ( 反向寻找的顺序是 from 、from - 1 、from - 2 、........ )

* 4、int lastIndexOf( String s , int from )

* 从 当前字符串中 指定位置(from) 开始反向寻找 指定字符串 ( s ) 最后一次出现的位置，若存在即返回该索引，否则返回 -1

* 即获取在 from 处及其之前 s 最后一次出现的位置是什么

*/

public class StringTestB {

​

public static void main(String[] args) {

final String s = "http://www.ecut.edu.cn:8080/soft/java/beginner/string/test.html" ;

int index ;

int last ;

index = s.indexOf( '/' ) ;

last = s.lastIndexOf( '/' );

System.out.println( index + " , " + last );

System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );

index = s.indexOf( '/' , 10 ); // 从 索引 10 开始 向后寻找 '/' 字符首次出现的位置

last = s.lastIndexOf( '/' , 37 ); // 从 索引 37 处开始 反向寻找 '/' 字符 最后一次出现的位置

System.out.println( index + " , " + last );

}

​

}

​

1、String concat(String) 将当前字符串 与 参数给定的字符串拼接起来 并返回一个新的 字符串2、String toUpperCase()3、String toLowerCase()4、equalsIgnoreCase() 忽略大小写5、a.contentEquals(b) 用于比较参数指定的 字符序列 是否与当前String

package CharSequence;

/**

* 1、String concat(String) 将当前字符串 与 参数给定的字符串拼接起来 并返回一个新的 字符串

* 2、String toUpperCase()

* 3、String toLowerCase()

* 4、equalsIgnoreCase() 忽略大小写

* 5、a.contentEquals(b) 用于比较参数指定的 字符序列 是否与当前String

*/

​

public class StringTestC {

public static void main(String[] args) {

String s = "abc";

​

String x = s.concat("123");

System.out.println(s); // "abc"

System.out.println(x); // "abc123"

​

System.out.println("~~~~~~~~");

​

String t = s.toUpperCase();

​

final String a = "hello";

final String b = "Hello";

​

System.out.println(a.equals(b)); // String 重写后的 equals 比较大小

System.out.println(a.equalsIgnoreCase(b)); // true 忽略大小写

System.out.println(a.contentEquals(b)); // 区分大小写

​

System.out.println("~~~~~~~~~~~~");

// 用于比较两个字符串的 “大小”

System.out.println(a.compareTo(b)); //

// 相等 返回 0 否则 非0整数

System.out.println(a.compareToIgnoreCase(b)); //

}

}

​

1、int length()boolean isEmpty() 是否为空 value.length 是否为0boolean isBlank() 用于判断 是否为空 (空白 仅仅包含了 空格 tab 等字符)String trim() 剔除首尾空白 不包括 中间的空白

package CharSequence;

/**

* 1、int length()

* boolean isEmpty() 是否为空 value.length 是否为0

* boolean isBlank() 用于判断 是否为空 (空白 仅仅包含了 空格 tab 等字符)

* String trim() 剔除首尾空白 不包括 中间的空白

* */

public class StringTestD {

public static void main(String[] args) {

​

String s = ""; // 空串 不是 空格 不是 制表符(Tab) 也不是 null 和 /u0000

System.out.println(s);

System.out.println("length:" + s.length());

System.out.println("empty:" + s.isEmpty());

​

System.out.println("~~~~~~~~~~~~~~");

String t = "           "; // 有空格 和 tab

System.out.println("length:" + s.length());

System.out.println("empty:" + s.isEmpty());

System.out.println("is blank" + t.isBlank());

​

String x = "   ecut ";

String trim = x.trim(); // 删除首尾空白 不包括中间的空白返回新的 String 实例

System.out.println(x.length());

System.out.println(trim.length());

​

}

}

​

1、boolean startsWith(String) 对应的字符串 是否以 参数 字符串 开始

2、boolean endsWith(String) 对应的字符串 是否以 参数 字符串 结束

package CharSequence;

​

import java.util.Arrays;

​

/**

* 1、boolean startsWith(String) 对应的字符串 是否以 参数 字符串 开始

* 2、boolean endsWith(String) 对应的字符串 是否以 参数 字符串 结束

*

* */

​

public class StringTestE {

public static void main(String[] args) {

​

String path = "D:/java-beginner/char-sequence/StringHelper.java";

​

System.out.println(path.startsWith("D:")); // true path 对应的字符串 是否以 D: 开始

System.out.println(path.endsWith(".java")); // true

System.out.println("~~~~~~~~~~~");

​

System.out.println(path.startsWith("/",10)); // 从 10 开始 是否 是 以 / 开始的

​

​

char[] array = new char[10];

String str = "沧海一声笑滔滔两岸潮";

// 将 str 所指向的 String 实例中 所包含的字符串[5,10) 之间的字符 拷贝到 数组 array 中

str.getChars(5,10,array,5);

System.out.println(Arrays.toString(array));

​

String substring = str.substring(5); // [5,length() - 1]

System.out.println(substring);

​

}

}

5、代码解释 String 实例的创建过程

package CharSequence;

/**

* 1、在 Java 语言中 直接使用 “” 引起来的多个字符就是 字符串 (character strings)

* 2、在 Java 源代码中 直接使用 “” 引起来的字符串 都是 java.lang.String 的实例

* 3、String 类 是个 不可变类 将来创建的 每个 String 实例 都是不可变的对象【Strings are constant】

*

*   [Java 8及之前]

*   public final class String {

*       private char[] value; // 使用 char 数组保存字符序列

*   }

*

*   [Java 9 之后]

*   public final class String {

*       private final byte[] value; // 使用 byte 数组保存字节序列

*   }

*   字节序列是字符序列根据某种编码转换而来

*

* */

​

public class StringTest2 {

public static void main(String[] args) {

​

// 变量 s 直接引用了 字符串常量池中的 String实例

String s = "中国是世界上最伟大的国家，没有之一";

// 变量 t 引用的是在 堆内存重新创建的 String 实例

String t = new String("中国是世界上最伟大的国家，没有之一");

​

System.out.println(s == t);

System.out.println(s.equals(t)); // true String 重写后的 equals

​

}

}

​

6、编码 和 解码

编码(encode)：将字符串按照某种字符集 转换成字节序列

例如：比如 “中国”==UTF-8==>{-28, -72, -83, -27, -101, -67}

解码( decode )：将字节序列按照某种字符集 转换成字符串

例如：比如 {-28, -72, -83, -27, -101, -67}==UTF-8==>“中国”

7、常用字符集

ISO-8859-1 别名：LATIN1

Big5：繁体中文

GBK：简体中文 每个字符占两个字节

Unicode：万国码

范围是 U+0000-U+10FFFF

Java 语言中 char 类型的范围：U+0000-U+FFFF

UTF-8

UTF-8 是 Unicode 的一种可变长字符编码

将字符串中的字符编码为字符序列后 每个字符占用 1 - 4个字节

汉字节本都占用 3 个字节

8位元指的是一个单位为 8 位

UTF-16

UTF-16

UTF-16BE

UTF-16LE

UTF-32

UTF-32

UTF-32BE

UTF-32LE

8、String 内部的 byte 数组编码格式

package CharSequence;

​

import java.nio.charset.Charset;

import java.util.Arrays;

/** 1、在 String 实例内部封装的 byte 数组中存储的字节序列是字符串 按照 UTF-16LE 编码 编码后的字节序列

* 2、在通过 String 实例的 getBytes 方法获取字节序列时，可以确定任意字符集

* 3、将一组字节序列构成 String 实例时 必须指定 将 字符串编码为字节序列时所采用的的字符串 才能保证不乱码

*

* */

public class StringTest9 {

public static void main(String[] args) {

final String s = "中国威武";

​

StringHelper.perspective(s);

System.out.println("~~~~~~~~~~~");

Charset utf = Charset.forName("UTF-16LE"); // 16 bit

​

byte[] bytes = s.getBytes(utf); // UTF-16

System.out.println(Arrays.toString(bytes));

​

byte[] array = {45, 78, -3, 86, 1, 90, 102, 107};

String x = new String(array,utf); //不使用 UTF-16LE 会乱码

System.out.println(x);

​

​

}

}

​