String类：引用数据类型
字符串—将一堆字符串起来的串
1，在java.lang包下，不用导入
默认继承Object类，没有任何继承关系
实现了三个接口：Serializable ， CharSequence ， Comparable < String >
2，找寻构造方法创建对象
String s1 = “abc”；直接将字符串常量赋值给String类型 （值存储在字符串常量池中）是以对象存储的
String s3 = new String（）；//通过无参数构造方法创建空的String对象，这个用处不大，一般用带参数的构造方法创建对象
String s2 = new String("abc");//通过String（“”）构造方法创建对象
String str = new String（byte[] byte); //将数组中的每一个元素转化成对应的char值，再组合成String字符串
---- byte[] value = new byte[]{65,97,48};
String str = new String(value);//将三个数字对应的unicode码输出
System.out.println(str);
String str = new String(char[] char);//将数组中的每一个char元素拼接成最终的String
---- char[] chars = new char[]{'A','a',90};
String str1 = new String(chars);
System.out.println(str1);
（构造方法重载）---String str = new String(char[] char,offset,count)//从offset位置开始的三个长度的字符组合成字符串
char[] chars1 ={'h','e','l','l','o'};
String string = new String(chars1,1,3);//从1号索引开始，长度为3的字符串
System.out.println(string);
String是一个非常特殊的引用数据类型，可以像基本类型一样创建赋值
常见的笔试题：== equals的区别
等等号可以比较基本类型，也可以比较引用类型，比较基本类型，比较值，比较引用类型，比较地址
equals（）只能比较引用类型（方法）默认比较地址， this==obj，如果想要修改其规则，可以重写equals（）方法
通常重写equals（）方法时会伴随着重写chasCode()方法 比如String Integer
String的不可变特性
Sting与StringBuffer区别
StringBuffer与StringBuilder的区别
String对象的存储
String中常用的方法
//String 是类，”abc“应该是对象 ，存储在字符串常量区里了
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1==s2);
System.out.println(s1==s3);
System.out.println(s3==s4);
//String类重写了继承自Object类的equals（）方法
//将原有比较==的方法改为比较字符值
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
4，String类的特性
不可变特性：在String类底层包含一个字符数组，private final char value[]；用来存储String中的每一个字符。
不可变体现在哪里？：final表示最终的不可改变的，基本数据类型值不能改变，引用数据类型，里面的地址不能改变，
修饰的数组则说明它的地址不能改变，数组的长度本身又是不能改变的。
数组中的元素是可以更改的，但是这个数组是private的，只能在本类中操作，所以我们没办法对它的值进行操作
String不可变特性体现在两个方面:
长度--final修饰的数组，数组长度本身不变，final修饰数组的地址也不变
内容--private修饰的属性，不能在当前类外部访问，里面的内容没办法更改。
*5，String类中常用的方法 （20+）
1，equals（Object obj）//比较两个字符串中的字面值是否相等 返回值是boolean类型的
string.equals(null);//equals默认比的是地址，重写以后更改为比字符串内容
equalsIgnoreCase();//忽略大小写比较
2，hashCode（）；以前的hashCode方法是native修饰的，看不到源码了。但是String的hashCode的源码不太一样，将其重写了
string.hashCode();//继承自Object方法，重写了，将当前字符串的每一个char元素拆开乘31+第一个元素的code值
//假如我们设置string的值为：”abc“
//int h = hash;
//h=0,h = h*31+a;
//h=(h*31+a)*31+b;
//h = ((h*31=a)*31)+b;
//这时候的出来的就是string字符串的hashcode值。
3，compareTo();参数是个String，返回值是int类型的 实现自comparable接口，实现了这个方法，按照字典（unicode编码）索引的顺序比较， 返回值是int
comparableIgnoreCase（）；//忽略大小写比较
String str1 = "abc";
String str2 = "ab";
boolean equals = str1.equals(str2);
System.out.println(str1.compareTo(str2));
//按照两个字符串长度较短的那个作为比较循环的次数
//挨个比较元素，直接用str1的某一个字去减str2的某一个字 str1[i] - str2[i] 循环内如果有结果就直接输出这个结果
//如果循环过后所有的字符都一样 就用长度减，len1 - len2 如果返回的是负数len1在前，len2在后， 返回时正 则相反
//返回0则表示两个字符串是一样的
4，toString（）；返回值时String类型
//继承自Object 重写了，不再输出类名@hashCode 输出的时字符串的字面值
5，charAt（int index）；//“abc” --0，a
//返回值是char 返回给定index对一个的char类型元素
6，codePointAt（int index）；“abc” --0，97
//返回值是char 返回给定index对应的char类型元素的code码
7，length（），返回字符串的长度，底层就是返回value数组的长度
String str = "abc";//实际应用:加密，将abc变成123
String result = "";
char c = str.charAt(0);//获取0号索引对应的char类型的元素
for (int i = 0; i < str.length(); i++) {
char c1 = str.charAt(i);
System.out.print(c1);
int value = str.codePointAt(i);
System.out.println(value);
result += (char) (value - 48); //密钥，U盾
}
System.out.println(result);
8，concat（String）：//将给定的参数字符串拼接在原字符串之后
String str = "abc";//相当于abc对象。
//String对象一旦创建 长度和内容是无法更改的，
//那么它是怎么拼接的呢？
str = str.concat("de");//体现了String对象的不可变特性
//创建一个新的String对象（在字符串常量池里） value属性 长度是4，会将刚才那个String对象value值依次取出来
//存入新对象属性里 e放在后面
System.out.println(str);
String str1 = "a"+"b"+"c"+"d";
System.out.println(str1);
//笔试中经常考 String中产生了几个String对象
//如果看字符串常量池 是7个对象
/*
* 1，char【】 value -- a
* 2，char【】 value -- b
* 3，char【】 value -- ab
* 4，char【】 value -- c
* 5，char【】 value -- abc
* 6，char【】 value -- d
* 7，char【】 value -- abcd
*
* */
String str = "a";
long time1 = System.currentTimeMillis();
for (int i = 1; i < 10000; i++) {
//str+=”a“；
str = str.concat("a");//利用concat拼接字符 一个String对象 自己的value属性频繁的创建新的小数组
//拼接的方式concat比+号的性能好很多
}
long time2 = System.currentTimeMillis();
System.out.println(time2 - time1);
//StringBuffer的性能比它们两个都高
9，contains（Char c ）
10，startsWith（）//判断是否以哪个元素开始
endsWith（）//判断是否以哪个元素结尾
/*String str = "哈哈哈.java";
boolean b = str.endsWith(".java");
System.out.println(b);
boolean d = str.startsWith("d");
System.out.println(d);*/
11，getBytes（）//将一个字符串转换成byte数组 返回值是byte【】 数组中的元素打印出来的是对应的code码
toCharArray();//将当前的字符串转换成字符数组 返回值是char【】数组 直接将数组中的元素打印出来
需要注意的是：如果字符串是“我爱你中国”，char数组里面的每一个元素刚好能存储一个字，
但是byte【】 的元素占用的是8个字节，但是一个汉字占用的是10个字节，所以我们在拆的时候用的是哪个方法，
组合的时候一定要用对应的构造器。
String str = "我爱你中国";
byte[] bytes = str.getBytes();
for (byte b :
bytes) {
System.out.println(b);
}
char[] chars = str.toCharArray();
for (char c :
chars) {
System.out.println(c);
}
12，indexOf（），lastIndexOf（）
indexOf（）；//用来找寻给定的元素，第一次在字符串中出现的索引位置，返回值是int类型
重载--indexOf（String str，int a）从a号索引开始往后查找第一次出现str的索引号，返回的是相对于整个字符串来说的索引号
--indexOf（int a，int b） 从b索引开始往后找a对应的code码在整个字符串内第一次出现的索引位置。若不存在返回-1
13，lastIndexOf（）；
找寻给定的元素在字符串中最后一次出现的索引位置，若不存在返回-1
14，isEmpty();//判断当前字符串是否为空，（判断的是length是否为0）
String str = "";
boolean value= str.isEmpty();
System.out.println(value);
//不能按照下面的方式写：
String str = null；
str.isEmpty();
//这么用是异常的，因为本身这个引用是没有指向的，你还用它调用方法，肯定会出异常。
15，replace（），replaceAll（） replaceFrist（）；
String str = "大鹏很帅气帅气帅气帅气帅气";
//参数为char类型的可以单个字直接换，将前面的字符换成后面的字符
String replace = str.replace('帅', '骚');
System.out.println(replace);
//参数为String类型的，将前面的字符串，换成后面的字符串
String s = str.replaceAll("帅气", "美丽");
System.out.println(s);
//将原来字符串内，所有跟前面元素相同的全部换成后面的元素
String s1 = str.replaceAll("帅气", "美丽");
System.out.println(s1);
//将原来字符串的第一次出现的前面的元素更换成后面的元素
String s2 = str.replaceFirst("帅气", "meili");
System.out.println(s2);
//如网络上出现骂人的现象，如果出现一个敏感字眼就可以自动转换为**。
16，split（String regex）；只要出现regex的参数，说明里面可以传递正则表达式。
方法重载--split（String regex，【int limit 限度，界限】）//按照给定的表达式，将原来的字符串拆分开
比如“a-b-c-d”,按照-拆分，返回的时一个String类型的数组。
String str = "a-b-c-d";
//将原字符串按照某个规则拆分
String[] split = str.split("-");
for (String str1 :
split) {
System.out.println(str1);
}
//将原字符串按照“-”拆分成3段
String[] split1 = str.split("-", 3);
for (String split0 :
split1) {
System.out.println(split0);
}
比如想做一个登录
String[] userBox = {"java-123","大鹏-345","小明-789"};
Scanner input = new Scanner(System.in);
System.out.println("请输入账号：");
String name = input.nextLine();
System.out.println("请输入密码：");
String password = input.nextLine();
boolean flag = false;
for (int i = 0; i < userBox.length; i++) {
String[] split = userBox[i].split("-");
if (split[0].equals(name)){
if (split[1].equals(password)){
System.out.println("登录成功");
flag = true;
}
break;
}
}
if(!flag){
System.out.println("账号或密码错误");
}
17，Stirng = substring（int beginIndex，【int endIndex】）；
截取当前字符串一部分从开始索引到结束索引 包头不包尾。
从beginIndex索引开始至endIndex结束截取
如果不写结束索引，则直接截取到字符串的最后索引位置
/*String str = "abcdefg";
str = str.substring(3,5);//从3号索引开始截取至5号索引结束，不包含5号索引的值【3，5）左闭右开。
System.out.println(str);*/
18，toLowerCase（） toUpperCase（）//将全部字符串转换大小写。全都转，返回值时String类型
String str = "abcdefg";
String s = str.toUpperCase();
System.out.println(s);
String s1 = str.toLowerCase();
System.out.println(s1);
19，trim（）；去掉字符串前后多余的空格 返回值时String类型的，只能去前面和后面的，中间的去不掉。比较密码的时候去掉前后空格再去比较
20，valueOf（）；将其它的基本类型元素转换成字符串。
21，boolean = matches（String regex）
regular有规律的 expression表达式
正则表达式
来源：CSDN
作者：TT_PI
链接：https://blog.csdn.net/qq_45581803/article/details/104105502