打怪升级之小白的大数据之旅(十六)＜Java面向对象进阶之常用核心类String＞

最新推荐文章于 2022-04-29 19:47:28 发布

GaryLea

最新推荐文章于 2022-04-29 19:47:28 发布

阅读量191

点赞数

文章标签：字符串大数据编程语言 java

本文链接：https://blog.csdn.net/Li_G_yuan/article/details/115613366

版权

打怪升级之小白的大数据之旅(十六)

Java面向对象进阶之常用核心类String

上次回顾

上一章对面向对象基础内部类和异常的相关知识点进行了分享,至此,面向对象的基本已经全部完啦,今天开始对面向的进阶知识点进行分享,今天的重点就是对字符串String进行详细讲解

常用核心类及API

字符串String

概念

字符串String是我们学习的另一个引用数据类型,并且在大数据中会经常遇到,因为大数据中经常需要对字符串进行处理分析,所以大家要提前打好基础.
在java中,String表示字符串,它也是一个类,位于java.lang包下,java程序中所有的字符串字面量,都可以被看作是此类的实例,因为字符串太常用了,因此,java提供了简单的字符串字面量表示方式.如: “hello world”

字符串的特点

特点一: java字符串的重要特点就是字符串不可变

/*
这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。修改一个字符串变量值，相当于新生成一个字符串对象。
*/
// 字符串源码节选如下:
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    // 就是这里,它告诉我们,字符串实际上是一个final修饰的char[]型的数组
    private final char value[];
    ...

特点二:字符串对象的内部存储形式是一个char[]数组
正如特点一中的源码所示,它是一个char[]型的数组
但在java9之后,字符串变为byte[]数组

// 平时的字符串格式
String str = "abc";
// 内部的字符串存储
char[] data = {'a','b','c'};
String str = new(String(data))

特点三:字符串字面量是String类的实例,存储在字符串常量池中,相同的字符串字面量表示的对象在内存中只有一份

// 内存中只有一个"abc"对象被创建,同时被s1和s2共享
String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2);
// 结果:true

特点四:字符串String类型本身是final声明的,意味着我们不能继承String类,也因此不能重写它的方法

构造字符串对象

字符串的构造方法有两种,一种是使用构造方法,一种是使用’’+’'连接

使用构造方法
- public String() ：初始化新创建的 String对象，以使其表示空字符序列。
- String(String original)：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
- public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
- public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的String。
- public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
- public String(byte[] bytes,String charsetName) ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。
- 示例代码:
```
//字符串常量对象，推荐
String str = "hello";

// 无参构造，不推荐
String str1 = new String（）；

//创建"hello"字符串常量的副本，不推荐
String str2 = new String("hello");

//通过字符数组构造
char chars[] = {'a', 'b', 'c','d','e'};     
String str3 = new String(chars);
String str4 = new String(chars,0,3);

// 通过字节数组构造
byte bytes[] = {97, 98, 99 };     
String str5 = new String(bytes);
String str6 = new String(bytes,"GBK");
```
使用’’+’’
任意数据类型与字符串进行拼接,结果都是字符串
示例代码:

public static void main(String[] args) {
	intnum = 123456;
	String s = num + "";
	System.out.println(s);
	
	Student stu = new Student();
	String s2 = stu + "";//自动调用对象的toString()，然后与""进行拼接
	System.out.println(s2);
}

字符串的常用方法

常用方法

（1）boolean isEmpty()：字符串是否为空

（2）int length()：返回字符串的长度

（3）String concat(xx)：拼接，等价于+

（4）boolean equals(Object obj)：比较字符串是否相等，区分大小写

（5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写

（6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小

（7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写

（8）String toLowerCase()：将字符串中大写字母转为小写

（9）String toUpperCase()：将字符串中小写字母转为大写

（10）String trim()：去掉字符串前后空白符

我就不一一举例了,因为太简单了,我用一个混合的例子来说明上述方法的用法:

@Test
	public void test01(){
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		String word;
		while(true){
			System.out.print("请输入单词：");
			word = input.nextLine();
			if(word.trim().length()!=0){
				word = word.toLowerCase();
				break;
			}
		}
		System.out.println(word);
	}

	@Test
	public void test02(){
        //随机生成验证码，验证码由0-9，A-Z,a-z的字符组成
		char[] array = new char[26*2+10];
		for (int i = 0; i < 10; i++) {
			array[i] = (char)('0' + i);
		}
		for (int i = 10,j=0; i < 10+26; i++,j++) {
			array[i] = (char)('A' + j);
		}
		for (int i = 10+26,j=0; i < array.length; i++,j++) {
			array[i] = (char)('a' + j);
		}
		String code = "";
		Random rand = new Random();
		for (int i = 0; i < 4; i++) {
			code += array[rand.nextInt(array.length)];
		}
		System.out.println("验证码：" + code);
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		System.out.print("请输入验证码：");
		String inputCode = input.nextLine();
		
		if(!code.equalsIgnoreCase(inputCode)){
			System.out.println("验证码输入不正确");
		}
	}

查找

（11）boolean contains(xx)：是否包含xx

（12）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1

（13）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1

示例代码:

@Test
	public void test01(){
		String str = "我是不断努力学习大数据的数据汪,每天进步一丢丢,做个有趣的人;希望有朝一日可以拥有自己的团队,不说改变世界了,至少可以让自己更加优秀.我的第一个目标是拥有一套属于自己的小窝和小猫,拥抱大数据~拥抱未来的美好生活~~";
		System.out.println("是否包含大数据：" + str.contains("大数据"));
		System.out.println("大数据出现的第一次下标：" + str.indexOf("大数据"));
		System.out.println("大数据出现的最后一次下标：" + str.lastIndexOf("大数据"));
	}

字符串截取

（14）String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

（15）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

示例代码:

@Test
	public void test01(){
		String str = "helloworldjavaatguigu";
		String sub1 = str.substring(5);
		String sub2 = str.substring(5,10);
		System.out.println(sub1);
		System.out.println(sub2);
	}

	@Test
	public void test02(){
		String fileName = "快速学习大数据的秘诀.dat";
		//截取文件名
		System.out.println("文件名：" + fileName.substring(0,fileName.lastIndexOf(".")));
		//截取后缀名
		System.out.println("后缀名：" + fileName.substring(fileName.lastIndexOf(".")));
	}

和字符相关的方法

（16）char charAt(index)：返回[index]位置的字符

（17）char[] toCharArray()：将此字符串转换为一个新的字符数组返回

（18）String(char[] value)：返回指定数组中表示该字符序列的 String。

（19）String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。

（20）static String copyValueOf(char[] data)：返回指定数组中表示该字符序列的 String

（21）static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String

（22）static String valueOf(char[] data, int offset, int count) ：返回指定数组中表示该字符序列的 String

（23）static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

示例代码:

@Test
	public void test01(){
		//将字符串中的字符按照大小顺序排列
		String str = "helloworldjavaatguigu";
		char[] array = str.toCharArray();
		Arrays.sort(array);
		str = new String(array);
		System.out.println(str);
	}
	
	@Test
	public void test02(){
		//将首字母转为大写
		String str = "jack";
		str = Character.toUpperCase(str.charAt(0))+str.substring(1);
		System.out.println(str);
	}

编码与解码

（24）byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码进行编码

byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码

（25）new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码

示例代码:

/*
 * GBK，UTF-8，ISO8859-1所有的字符编码都向下兼容ASCII码
 */
public static void main(String[] args) throws Exception {
	String str = "中国";
	System.out.println(str.getBytes("ISO8859-1").length);// 2
	// ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
	System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
	System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节

	/*
	 * 不乱码：（1）保证编码与解码的字符集名称一样（2）不缺字节
	 */
	System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
	System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
	System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
}

开头与结尾

（26）boolean startsWith(xx)：是否以xx开头

（27）boolean endsWith(xx)：是否以xx结尾

示例代码:

@Test
	public void test2(){
		String name = "张三";
		System.out.println(name.startsWith("张"));
	}
	
	@Test
	public void test(){
		String file = "Hello.txt";
		if(file.endsWith(".java")){
			System.out.println("Java源文件");
		}else if(file.endsWith(".class")){
			System.out.println("Java字节码文件");
		}else{
			System.out.println("其他文件");
		}
	}

正则

（28）boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式

java中的常用正则表达式
字符类

格式	解释
[abc]	a、b或c(简单类)
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类

格式	解释
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

POSIX字符类

格式	解释
\p{Lower}	小写字母字符：[a-z]
\p{Upper}	大写字母字符：[A-Z]
\p{ASCII}	所有 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十进制数字：[0-9]
\p{Alnum}	字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	标点符号：!"#$%&’()*+,-./:;<=>?@[]^_`{
\p{Blank}	空格或制表符：[ \t]

边界匹配器

格式	解释
^	行的开头
$	行的结尾

Greedy数量词

格式	解释
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次

Logical 运算符

格式	解释
XY	X 后跟 Y
X	Y
(X)	X,作为捕获组

特殊构造（非捕获）

格式	解释
(?:X) X	作为非捕获组
(?=X) X	通过零宽度的正 lookahead
(?!X) X	通过零宽度的负 lookahead
(?<=X) X	通过零宽度的正 lookbehind
(?<!X) X	通过零宽度的负 lookbehind
(?>X) X	作为独立的非捕获组

常用的一些正则表达式用法:

应用场景	表达式
1.验证用户名和密码，要求第一个字必须为字母，一共6~16位字母数字下划线组成	`（^[a-zA-Z]\w{5,15}$）`
2.验证电话号码：xxx/xxxx-xxxxxxx/xxxxxxxx	`（^(\d{3,4}-)\d{7,8}$）`
3.验证手机号码	`( ^(13[0-9]\|14[5\|7]\|15[0\|1\|2\|3\|5\|6\|7\|8\|9]\|18[0\|1\|2\|3\|5\|6\|7\|8\|9])\d{8}$ )`
4.验证身份证号	`(^\d{15})\|(^\d{18})\|(^\d{17}(\d\|X\|x)$)`
5.验证Email地址	`(^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$)`
6.只能输入由数字和26个英文字母组成的字符串	`(^[A-Za-z0-9]+$)`
7.整数或者小数	`(\[0-9]+(.[0-9]+){0,1}$)`
8.中文字符的正则表达式	`([\u4e00-\u9fa5])`
9.金额校验(非零开头的最多带两位小数的数字)	`(^([1-9][0-9]*)+(.[0-9]{1,2})?$)`
10.IPV4地址	`(((\d{1,2})\|(1\d{1,2})\|(2[0-4]\d)\|(25[0-5]))\.){3}((\d{1,2})\|(1\d{1,2})\|(2[0-4]\d)\|(25[0-5]))`

正则我也用一个模拟的实际案例来演示了:

@Test
	public void test1(){
		//简单判断是否全部是数字，这个数字可以是1~n位
		String str = "12a345";
		
		//正则不是Java的语法，它是独立与Java的规则
		//在正则中\是表示转义，
		//同时在Java中\也是转义
		boolean flag = str.matches("\\d+");
		System.out.println(flag);
	}
	
	@Test
	public void test2(){
		String str = "123456789";
		
		//判断它是否全部由数字组成，并且第1位不能是0，长度为9位
		//第一位不能是0，那么数字[1-9]
		//接下来8位的数字，那么[0-9]{8}+
		boolean flag = str.matches("[1-9][0-9]{8}+");
		System.out.println(flag);
	}

	@Test
    public void test03(){
        //密码要求：必须有大写字母，小写字母，数字组成，6位
        System.out.println("Cly892".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("1A2c45".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
        System.out.println("Clyyyy".matches("^(?=.*[A-Z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//false
    }

替换

（29）String replace(xx,xx)：不支持正则

（30）String replaceFirst(正则，value)：替换第一个匹配部分

（31）String repalceAll(正则， value)：替换所有匹配部分

示例代码:

	@Test
	public void test4(){
		String str = "hello244world.java;887";
		//把其中的非字母去掉
		str = str.replaceAll("[^a-zA-Z]", "");
		System.out.println(str);
	}

拆分

（32）String[] split(正则)：按照某种规则进行拆分

示例代码:

@Test
	public void test4(){
		String str = "张三.23|李四.24|王五.25";
		//|在正则中是有特殊意义，我这里要把它当做普通的|
		String[] all = str.split("\\|");
		
		//转成一个一个学生对象
		Student[] students = new Student[all.length];
		for (int i = 0; i < students.length; i++) {
			//.在正则中是特殊意义，我这里想要表示普通的.
			String[] strings = all[i].split("\\.");//张三,  23
			String name = strings[0];
			int age = Integer.parseInt(strings[1]);
			students[i] = new Student(name,age);
		}
		
		for (int i = 0; i < students.length; i++) {
			System.out.println(students[i]);
		}
		
	}
	
	@Test
	public void test3(){
		String str = "1Hello2World3java4atguigu5";
		str = str.replaceAll("^\\d|\\d$", "");
		String[] all = str.split("\\d");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
	}
	
	@Test
	public void test2(){
		String str = "1Hello2World3java4atguigu";
		str = str.replaceFirst("\\d", "");
		System.out.println(str);
		String[] all = str.split("\\d");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
	}
	
	
	@Test
	public void test1(){
		String str = "Hello World java atguigu";
		String[] all = str.split(" ");
		for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}
	}

字符串的内存分析

在java中,使用常用的定义方式时(String s1=“abc”),字符串abc是存放在字符串常量池中的,而且只会存一份,这里前面也提过了,下面,我们根据案例来详细介绍一下字符串在内存中的存储逻辑:

@Test
    public void test1(){
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        
    }
	@Test
	public void test02(){
		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
		String s6 = "hello" + "world";//常量+常量，编译期经过优化，跟s3完全相同的情况。
		
		System.out.println(s3 == s4);//false
		System.out.println(s3 == s5);//false
		System.out.println(s3 == s6);//true
	}	
	
	@Test
	public void test03(){
		final String s1 = "hello";
		final String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是常量，"world"常量，常量+ 常量 结果在常量池中
		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是常量，常量+ 常量 结果在常量池中
		String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
		
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//true
		System.out.println(s3 == s6);//true
	}
	
	@Test
	public void test04(){
		String s1 = "hello";
		String s2 = "world";
		String s3 = "helloworld";
		
		String s4 = (s1 + "world").intern();//如果常量池已经有“helloworld”，直接返回，否则把拼接结果的引用放到常量池中
		String s5 = (s1 + s2).intern();
		
		System.out.println(s3 == s4);//true
		System.out.println(s3 == s5);//true
	}

在这里插入图片描述
根据案例与上面的内存图,就可以得出如下结论:

常量+常量：结果是常量池
常量与变量或变量与变量：结果是堆
intern方法有jvm版本的区别，这里不再深入分析，jdk8中执行原理是如果字符串常量池有内容相同的字符串则直接返回，否则把堆中创建的字符串引用放入字符串常量池，返回此引用，总之所有版本都是通过字符串常量池返回的内容
这里提一下intern方法
- 如果字符串常量池里存在一个和当前字符串对象等价的字符串对象(equals==true认为相同),那么返回字符串常量池里那个对象.如果不存在,把当前字符串对象存进常量池, 返回当前字符串对象.
按照我的理解,不要去深究它(我们是学大数据,这个知识点不重要,有需求的可以去问问度娘哈)

可变长字符序列

可变长字符序列有两个类,StringBuilder与StringBuffer
StringBuilder与StringBuffer的主要作用有两个:

就是解决字符串不可变的问题,它的原理就是将字符串转换为数组对象,然后对这个数组进行操作
因为String对象虽然可以共享常量对象,但是对于频繁的字符串修改和拼接工作,效率又低又占用内存,因此,使用StringBuilder与StringBuffer就可提高效率

StringBuffer：老的，线程安全的（因为它的方法有synchronized修饰），效率低

StringBuilder：线程不安全的，效率高

常用的API，StringBuilder、StringBuffer的API是完全一致的

API	作用
StringBuffer append(xx)	拼接，追加
StringBuffer insert(int index, xx)	在[index]位置插入xx
StringBuffer delete(int start, int end)	删除[start,end)之间字符
StringBuffer deleteCharAt(int index)	删除[index]位置字符
void setCharAt(int index, xx)	替换[index]位置字符
StringBuffer reverse()	反转
void setLength(int newLength)	设置当前字符序列长度为newLength
StringBuffer replace(int start, int end, String str)	替换[start,end)范围的字符序列为str
int indexOf(String str)	在当前字符序列中查询str的第一次出现下标
int indexOf(String str, int fromIndex)	在当前字符序列[fromIndex,最后]中查询str的第一次出现下标
int lastIndexOf(String str)	在当前字符序列中查询str的最后一次出现下标
int lastIndexOf(String str, int fromIndex)	在当前字符序列[fromIndex,最后]中查询str的最后一次出现下标
String substring(int start)	截取当前字符序列[start,最后]
String substring(int start, int end)	截取当前字符序列[start,end)
String toString()	返回此序列中数据的字符串表示形式

老样子,使用一个案例来演示一下API的使用:

Test
	public void test6(){
		StringBuilder s = new StringBuilder("helloworld");
		s.setLength(30);
		System.out.println(s);
	}
	@Test
	public void test5(){
		StringBuilder s = new StringBuilder("helloworld");
		s.setCharAt(2, 'a');
		System.out.println(s);
	}
	
	
	@Test
	public void test4(){
		StringBuilder s = new StringBuilder("helloworld");
		s.reverse();
		System.out.println(s);
	}
	
	@Test
	public void test3(){
		StringBuilder s = new StringBuilder("helloworld");
		s.delete(1, 3);
		s.deleteCharAt(4);
		System.out.println(s);
	}
	
	
	@Test
	public void test2(){
		StringBuilder s = new StringBuilder("helloworld");
		s.insert(5, "java");
		s.insert(5, "chailinyan");
		System.out.println(s);
	}
	
	@Test
	public void test1(){
		StringBuilder s = new StringBuilder();
		s.append("hello").append(true).append('a').append(12).append("atguigu");
		System.out.println(s);
		System.out.println(s.length());
	}

扩展知识点

我来填一下java基础中遗留的一个坑(字符编码)
字符编码的发展经过了五个阶段: 出生->发展->扩张->制定标准->融合

出生 ASCII码

计算机刚发明的时候只是为了解决数字计算的问题,后来随着日常需要,人民发现,计算机还可以做更多的事情,比如文本的处理,但因为计算机只认识数(0和1),因此必须要制定一个标准,告诉计算机,人类的文本都有哪些,于是ASCII字符集诞生了,也就是现在称为ASCII码的东东
那时候的字符编解码系统非常简单，就是简单的查表过程。其中：
- 0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)
- 32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字。
- 65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。

发展 OEM字符集的衍生

当计算机开始发展起来的时候，人们逐渐发现，ASCII字符集里那可怜的128个字符已经不能再满足他们的需求了。人们就在想，一个字节能够表示的数字（编号）有256个，而ASCII字符只用到了0x00~0x7F，也就是占用了前128个，后面128个数字不用白不用，因此很多人打起了后面这128个数字的主意。可是问题在于，很多人同时有这样的想法，但是大家对于0x80-0xFF这后面的128个数字分别对应什么样的字符，却有各自的想法。这就导致了当时销往世界各地的机器上出现了大量各式各样的OEM字符集。不同的OEM字符集导致人们无法跨机器交流各种文档

扩张多字节字符集(MBCS)和中文字符集

上面我们提到的字符集都是基于单字节编码，也就是说，一个字节翻译成一个字符。这对于拉丁语系国家来说可能没有什么问题，因为他们通过扩展第8个比特，就可以得到256个字符了，足够用了。但是对于亚洲国家来说，256个字符是远远不够用的。因此这些国家的人为了用上电脑，又要保持和ASCII字符集的兼容，就发明了多字节编码方式，相应的字符集就称为多字节字符集（Muilti-Bytes Charecter Set）。例如中国使用的就是双字节字符集编码

制定标准 ANSI标准、国家标准、ISO标准

不同ASCII衍生字符集的出现，让文档交流变得非常困难，因此各种组织都陆续进行了标准化流程。例如美国ANSI组织制定了ANSI标准字符编码（注意，我们现在通常说到ANSI编码，通常指的是平台的默认编码，例如英文操作系统中是ISO-8859-1，中文系统是GBK），ISO组织制定的各种ISO标准字符编码，还有各国也会制定一些国家标准字符集，例如中国的GBK，GB2312和GB18030。
随着字符集在发展时的遗留问题越发突出,各国在使用不同的字符集时不得不安装对应地区的字符集,于是各个地区都制定了其自己的标准

融合

虽然通过安装不同的字符集可以暂时解决这个问题,但这种方法治标不治本,随着使用普及计算机的国家越来越多,字符集也越来越多,为了解决这个问题,我们需要一个全人类达成共识的巨大字符集,于是Unicode字符集诞生了
Unicode字符集涵盖了目前人类使用的所有字符，并为每个字符进行统一编号，分配唯一的字符码（Code Point）

总结

本章主要对String这个常用类进行了介绍,String的方法很多,遇到遗忘的用法,随时度娘即可.下一章为大家带来其他的几个常用类,数学/日期/系统相关和数组工具类.好了,今日分享到此结束,老样子,欢迎大家后台吐槽~~

GaryLea

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
打怪升级之小白的大数据之旅(十六)＜Java面向对象进阶之常用核心类String＞

打怪升级之小白的大数据之旅(十六)Java面向对象进阶之常用核心类上期回顾常用核心类及API字符串String字符串String在大数据中会经常遇到,因为大数据中经常需要对字符串进行处理分析,所以大家要提前打好基础StringBuilder&StringBuffer数学相关类日期时间API系统相关类数组工具类...
复制链接

扫一扫