String类：
一．String类的概述及特点：
1.字符串在Java中属于引用类型（类类型），需要用一个类来描述
2.String继承Object类，且被final修饰，所以String类为最终类，不能被其他类继承
3.书写的字符串就是String类的一个实例对象，字符串是常量，保存的位置在方法区的字符
串常量池中，他们在被创建后不能被修改
4.当打印给定字符串的String类时，出现的是字符串，而非字符串地址，说明String类的
toString方法复写了Object类的toString方法
二．String类的构造方法：
1.格式：String s = new String();如果传入字节数组参数，就可以实现数组转换成字符串
* 演示String类的构造方法
*/
public class StringConstructor {
public static void main(String[] args) {
method();
}
//演示把字节数组转成字符串对象
public static void method() {
byte[] b = {97,98,99,100,101};
//把字节数组中的数字对应的字符转成字符串对象
String s = new String(b);
System.out.println(s);
}
}
2.面试题：
//面试题目
public static void method() {
/*
* String s = new String("abcde");
* 有2个对象，第一个是通过new关键字创建出来的对象，在堆中
* 第二个是双引号引用的字符串对象在方法区的字符串常量池中
*/
String s = new String("abcde");
String s2 = "abcde";
System.out.println(s);
System.out.println(s2);
System.out.println(s == s2);
}
三．String类常用方法
1.获取指定位置上的字符：
charAt();需要对象调用
public class Test{
public static void main(String[] args) {
String s="abcdefg";
//获取2位置的字符
char ss=s.charAt(2);
System.out.println(ss);
}
}
2.字符串转成数组：
2.1.字符串转换成字节数组：
getBytes();数组对象调用
public class Test {
public static void main(String[] args) {
String s = "abcdefg";
byte[] ss = s.getBytes();
for (int i : ss) {
System.out.println(i);
}
}
}
2.2.字符串转换成字符数组：
toCharArray();需要String对象调用
public class Test {
public static void main(String[] args) {
String s = "abcdefg";
char[] ss=s.toCharArray();
for (char c : ss) {
System.out.println(c);
}
}
}
2.3.大小写转换
toLowerCase();将所有字符转换成小写
toUpperCase();将所有字符转换成大写
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
String s1=s.toLowerCase();
String s2=s.toUpperCase();
System.out.println(s1);
System.out.println(s2);
}
}
2.4.字符串获取功能
length()：返回字符串的长度
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
String s1=s.toLowerCase();
String s2=s.toUpperCase();
System.out.println(s1);
System.out.println(s2);
}
}
2.5获取其中一部分字符串：
String substring(int beginIndex);
从beginIndex索引开始，大于之后的字符串，返回一个新的字符串，他是此字符串的子字符串
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
String s1=s.substring(2);
System.out.println(s1);
}
}
String substring(int beginIndex,int endsIndex);
截取此字符串中的一段子字符串，从beginIndex索引开始到endsIndex索引结束，
生成一个新的字符串
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
String s1=s.substring(2,4);
System.out.println(s1);
}
}
2.6.获取指定的字符或者字符串在字符串中的位置，如果是字符串，则已首个字符的位置获取
int indexOf(int ch);
int lastIndexOf(int ch);从后往前，第一次出现字符的索引
ch为指定字符，结果返回一个int型数字，为字符出现的索引，如果结果显示为-1，则说明指定字符在字符串中没有找到
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
int index=s.indexOf('c');
System.out.println(index);
}
}
int indexOf(int ch,int beginindex);
从beginIndex索引开始查找字符ch，找到后记录其索引位置返回int型数字，同样如果是-1则说明没有找到
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
int index=s.indexOf('A',3);
System.out.println(index);
}
}
int indexOf(String str);
从字符串的开始查找，如果找到字符串str，记录其第一位字符的索引位置，并返回其索引值，同样如果没有找到，则返回一个-1
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
int index=s.indexOf("Bd");
System.out.println(index);
}
}
int indexOf(String str ,int beginIndex);
从beginIndex索引开始查找，一旦找到指定的字符串，则返回指定字符串的首个字符的索引，如果没有找到的，则返回-1
public class Test {
public static void main(String[] args) {
String s = "ABCabc";
int index=s.indexOf("ab",0);
System.out.println(index);
}
}
注：同理有相应的lastIndexOf();
2.7.按字典顺序比较两个字符串的大小
int compareTo(String anotherString);
原理：从第一个字符开始比较，以减法比较，如果结果为正，说明此字符大，如果两个字符相同则继续往下比较，直到比到最后一位；如果前面相同，结果返回的是多的位数值，则位数多的大，如果都相同，则结果返回0,依次往下比较
public class Test {
public static void main(String[] args) {
String s = "abc";
String s1="abcde";
int result=s.compareTo(s1);
System.out.println(result);
}
}
2.8.比较两个字符串是否相同
boolean equals(Object another);比较此字符串与指定对象
public class Test {
public static void main(String[] args) {
String s = "abc";
String s1="ABC";
boolean result=s.equals(s1);
System.out.println(result);
}
}
boolean equalsIgnoreCase(String anotherString); 比较不区分大小写
public class Test {
public static void main(String[] args) {
String s = "abc";
String s1="ABC";
boolean result=s.equalsIgnoreCase(s1);
System.out.println(result);
}
}
2.9.判断字符串中是否包含指定的数据
boolean contains(CharSequence s);
判断字符串是否含有指定的数据，如果有，则返回true，如果没有的话，返回false
public class Test {
public static void main(String[] args) {
String s = "abcsssdsdssd";
String s1="snab";
boolean result=s.contains(s1);
System.out.println(result);
}
}
3.0.判断字符串是否以指定的字符开始
boolean startsWith(String str);
boolean startsWith(String str,int beginIndex);
判断字符串是否以指定的字符串str开始，返回一个boolean型
public class Test {
public static void main(String[] args) {
String s = "abcsssdsdssd";
String s1="ab";
boolean result=s.startsWith(s1);
System.out.println(result);
}
}
boolean endsWith(String str);
字符创是否以指定字符结尾
public class Test {
public static void main(String[] args) {
String s = "abcsssdsdssd";
String s1="csss";
boolean result=s.endsWith(s1);
System.out.println(result);
}
}
3.1.判断字符串是否为空
boolean isEmpty();
当且仅当length()为0时返回true
public class Test {
public static void main(String[] args) {
String s ="";
boolean result=s.isEmpty();
System.out.println(result);
}
}
3.2将其他数据转换成字符串的格式
static String valueOf(需要转换的对象);
都是静态的，直接使用String类名调用
public class Test {
public static void main(String[] args) {
int num=102002;
String s=String.valueOf(num);
System.out.println(s);
}
}
3.3.对字符串使用指定内容进行切割
String[] split(String regex);
使用指定字符串regex对字符串进行切割，返回的是字符串数组
public class Test {
public static void main(String[] args) {
String s="qwsaertydsafdsafddsagfddd";
String[] arr=s.split("sa");
for(String s1:arr){
System.out.println(s1);
}
}
}
3.4.去除字符串两端的空格
String trim();
public class Test {
public static void main(String[] args) {
String s=" sss ss ";
String s1=s.trim();
System.out.println(s1);
}
}
3.5.练习：将字符串按照长度递减截取
public class Test {
public static void main(String[] args) {
String s = "abcde";
// 控制共计能够截取的次数
for (int i = 0; i < s.length(); i++) {
// 提供每次截取的过程中，需要截取出多少个子串
// j提供截取的开始位置，k截取的结束位置
for (int j = 0, k = s.length() - i; k <= s.length(); j++, k++) {
String sub = s.substring(j, k);
System.out.print(sub + "\t");
}
System.out.println();
}
}
}
字符串缓冲区：
一．字符串缓冲区的定义
1.介绍
缓冲区：临时的存储空间(容器)，主要用来临时存储数据，最后将临时空间的数据统一处理。在新创建或者获取原有字符串子串的同时，字符串常量池中会产生大量的垃圾字符串，为了避免这样的问题，Java提供一个临时存放的空间，如果需要对字符串进行处理，就先将字符串放到临时的容器中，在容器中对其操作，，最后取出结果。
字符串缓冲区主要有四个方法功能：
1.增：给容器中添加数据add 、put 、append 、insert
2.删：从容器中删除数据delete、remove
3.改：修改容器中的数据set
4.查：查询容器中的数据get
2.Java中两个缓冲容器对象：StringBuffer、StringBuilder
StringBuffer：可以保存Java中任何数据类型的数据，最后会将所有数据都装换成字符串。默认16个字符空间
2.1.增加方法：
append();
可以给StringBuffer添加各种类型的数据，特点是每次调用都会在StringBuffer
的末尾添加数据
insert(int index,需要添加的数据);
从index下标开始添加数据
public class Test {
public static void main(String[] args) {
//需要先创建StringBuffer对象
StringBuffer sb=new StringBuffer();
//调用append方法，向容器中添加数据；任意数据类型都可以
//最后都会转换成字符串
sb.append(true);
sb.append(123);
sb.append('a');
System.out.println(sb);
//insert也是添加数据的方法，不过需要指定具体的下标添加，
//且需要保证指定的下边原来有数据,插入数据后，原有下标的
//数据往后移
sb.insert(3,"asd");
//如果小标超过最大的，则会编译报错，越界
sb.insert(30, "sss");
System.out.println(sb);
}
}
2.2.删除方法:
delete(int start,int end);移除字符串从start到end的索引的字符串（不包括end）
deleteCharAt(int index);移除指定索引处的字符
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append(true);
sb.insert(2,"ss");
//删除2到4的字符串
sb.delete(2, 4);
//删除下标2的字符
sb.deleteCharAt(2);
System.out.println(sb);
}
}
2.3.修改方法：
void setCharAt(int index,char ch);
将指定下标处的字符修改为指定为ch
void setLength(int newLength);
设置字符序列的长度
void capacity();
获取容器的容量
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcdefg");
//将下标为3的字符修改为w
sb.setCharAt(3, 'w');
//设置容器有效字符长度
sb.setLength(50);
System.out.println(sb);
//获取容器的容量
System.out.println(sb.capacity());
//获取字符串的长度
System.out.println(sb.length());
}
}
2.4.查询方法：
getChars(int beginIndex,int endIndex,char[] save,int c=saveIndex);
beginIndex:从StringBuffer中开始复制的小标
endIndex:复制的结束下标（不包括）
save：用来存储的字符数组，提前定义
saveIndex：从将要存储的字符数组的这个下标开始
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("abcdefgqwertr");
//定义一个长度为10的字符数组，用来存储需要查询的字符
char[] save=new char[10];
//查询StringBuffer中下标0-6的字符串，
//存储到字符数组save中，且从save数组的1下标开始
sb.getChars(0, 7, save, 1);
//字符数组转换成字符串
String ss=new String(save);
System.out.println(ss);
}
}
2.5.反转容器中的数据：
reverse();
将容器中的字符串反转顺序;
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append(123);
//反转容器中的字符串
System.out.println(sb.reverse());
}
}
StringBuilder: 方法与StringBuffer的方法完全相同，为了保证字符串缓冲区的安全和 效率所以设计了两个类缓冲区
两者的区别：
1. StringBuffer能个保证多个程序在操作此容器的时候，其他操作需要等待正在操作的程序，不能同时操作，可以保证数据的安全
2. Stringbuilder 不管是否有程序正在操作此容器，都可以直接进行操作，实现多程序操作，提高了对容器操作的效率
2.6.练习：
public class Test {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "java";
show(s1, s2);
System.out.println(s1 + "," + s2);
System.out.println("-----------------------");
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("java");
show(sb1, sb2);
System.out.println(sb1 + "," + sb2);
}
public static void show(String s1, String s2) {
s2.replace('a', 'o');
s1 = s2;
}
public static void show(StringBuffer sb1, StringBuffer sb2) {
sb1.append(sb2);
sb1 = sb2;
}
}
运行结果：
hello,java
-----------------------
hellojava,java
正则表达式：
一．正则表达式的概念：
预先制定好一个正确的可以判断字符串的规则，通过这个规则使用常见的字符，数字，大小括号等组合在一起，书写的一个表达式。
核心:掌握符号的组合都代表什么意思
规则：需要匹配的字符与正则规则字符一一对应，如果一个字符位上有多个要求可以使用中括号，比如：”[ab][0-9][a-z]”:表示有三个字符，第一个是a或b，第二个为0到9任意一个，第三位是a到z中的任意一位。
具体的组合规则：
.表示通配符
[0123456789] 等价于[0-9] 等价于\d
二．正则的功能：
匹配、切割、替换、获取
2.1.匹配
boolean matches(String regex);
告知是否匹配给定的正则表达式
public class Test{
public static void main(String[] args) {
String email="Baron123@163.com";
method(email);
}
public static void method(String s){
String regex="\\w{6,12}@\\w+(\\.\\w+){1,3}";
boolean b=s.matches(regex);
System.out.println(b);
}
}
2.2正则中组的概念
如果我们在后面会重复使用某个规则，就可以用小括号进行封装，这样用小括号封装的规则称为组
在程序中使用小括号封装某个正则规则之后，在当前的封装组的后面是可以直接使
用这个组的规则。但是建议
在书写正则的时候，尽量少的封装组，因为组太多，会让规则变的十分复杂。
“((A)(B(C)))”
上面的组共计有4 个组：
第一组是：((A)(B(C)))
第二组是：(A)
第三组是：(B(C))
第四组是：(C)
区分组的方式：从混合的组中，从左往右找左小括号。
2.3.切割
将字符串按照一定的正则表达式进行切割，且用字符串数组接受切割后的字符串
例1：使用指定的重复叠词切割：
public class Test{
public static void main(String[] args) {
//使用叠词a进行切割
String str="qawkaaajsdjaaaaaakekjdnaaaaaasjchuifcaaaxgsdce";
String regex="a{2,}";
String[] s=str.split(regex);
for (String arr : s) {
System.out.println(arr);
}
}
}
例2：使用不同的叠词进行切割：
public class Test{
public static void main(String[] args) {
//使用叠词a进行切割
String str="qa!!!wkajsd@@@jazk$$$jjchu%%%ifcaxgsdaaaaaace";
//如果要在当前正则表达式中想引用前面一存在的组，那么可以用：\\组号，进行引用
String regex="(.)\\1{2,}";
String[] s=str.split(regex);
for (String arr : s) {
System.out.println(arr);
}
}
}
2.4.替换
将字符串中的一部分不需要的字符使用我们需要的字符进行替换。
replaceAll(String regex,String regex);
使用正则表达式将我们不需要的字符替换掉，需要对象调用此方法。
public class Test {
public static void main(String[] args) {
String str = "我我我我爱爱爱传智播客，我我我爱我们的的的的老老老老师";
String regex = "(.)\\1+";
String s = str.replaceAll(regex, "$1");
System.out.println(s);
}
}
注：如果想要使用正则的组不在同一表达式，则使用$组号，调用那个组
例：隐藏电话号码的中间四位
打印结果：153****1556
public class Test {
public static void main(String[] args) {
String str = "15370131556";
String regex = "(1[34578][0-9])[0-9]{4}([0-9]{4})";
String s = str.replaceAll(regex, "$1****$2");
System.out.println(s);
}
}
2.5.获取
如果需要使用正则的获取功能，需要先将正则封装成一个正则对象，再使用匹配器技术从字符串中抓取所需要的数据，需要使用Pattern类中的编译方法，将正则表达式编译成一个Pattern类实例对象。
例1：获取一句话中单词长度为3的单词
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
public static void main(String[] args) {
String str="wo ming tian bu shang ke,ni ke yi lai wo jia";
String regex="\\b[a-z]{3}\\b";
Pattern p=Pattern.compile(regex);
Matcher matcher=p.matcher(str);
while(matcher.find()){
System.out.println(matcher.group());
}
}
}
例2：
获取字符创中的手机号码：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
public static void main(String[] args) {
String s="qwopwiqos13312341234sjld13634567890sssf";
String regex="1[34578][0-9]{9}";
method(s,regex);
}
//获取正则表达式的字符的方法
public static void method(String s,String regex){
Pattern p=Pattern.compile(regex);
Matcher m=p.matcher(s);
while(m.find()){
System.out.println(m.group());
}
}
}
三．正则总结
正则表达式：主要是对字符串进行操作。
. 表示任意字符
\d 表达式数字字符
\w 字母、数字、下划线
\b 单词边界
^ 行开始
$ 行结束
？ 当前字符可以出现零次或一次
*当前字符可以出现零次或多次
+当前字符可以出现一次或多次
{} 表示当前的规则可以出现的次数
[] 当前位置上可以出现的多个字符串内容
() 对已经存在的正则规则进行分组本正则中使用\\组号其他地方使用$组号
如果需要获取字符串中的内容，先需要把正则编译成Pattern 对象，然后使用matcher 方法让正则对象和需要
匹配的字符串进行关联，得到一个Matcher 匹配器对象，在使用匹配器对象中的find 方法进行匹配，然后使用
group 从字符串中把匹配到的内容截取出来。
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
