一、字符串
1.字符串简介:
由若干个字符组成的一个有序的序列。在Java中,使用String这个类来描述字符串。
1) java.lang.String 使用final修饰,不能被继承
2) 字符串底层封装的是字符数组及其针对数组的操作方法
3) 字符串一旦创建,对象永远无法改变,但字符串引用可以重新赋值
4) 字符串在内存中采用Unicode编码方式,任何一个字符对应两个字节的定长编码
5) 字符串的索引值从0开始
2.字符串常量池
JVM为了提升性能和减少内存开销,避免重复重复创建字符串,其维护了一种特殊的内存空间,即字符串常量池。当需要使用静态字符串(字面量、常量,变量连接的结果)时,先去检查字符串常量池是否存在该字符串,若存在,则直接返回该字符串的引用地址;若不存在,则在字符串常量池中创建字符串对象,并返回对象的引用地址。
内存位置:
在 JDK 1.7 之前,运行时常量池(包括字符串常量池)存放在方法区。
在 JDK 1.7 时,字符串常量池被从方法区转移至 Java 堆中,注意并不是运行时常量池,而是字符串常量池被单独转移到堆,运行时常量池剩下的东西还是方法区中。
在 JDK 1.8 时,此时字符串常量池还在堆中。
3.常用构造器
* 1.String()
* 初始化一个新创建的空字符序列的字符串对象
* 2.String(String str)
* 新创建一个对象,初始化值为str
* 3.String(byte[] bytes)
* 使用默认编码集,解码byte数组,构建一个字符串对象
* 4.String (byte[] bytes,String charsetName)
* 使用指定编码集charsetName 解码byte数组,构建一个字符串对象
* 5.String(byte[] bytes,int offset,int length)
* 使用默认编码集解码byte的数组,从offset开始,length个元素,构建一个字符串对象
* 6.String(char[] value)
* 初始化一个字符串对象,使其字符序列包含参数的元素
String string = new String("初始化对象");
System.out.println(string);
byte[] bytes = {97,98,99,100,101,102,103,104,105,106,107};
//编码集对应的字符为 : abcdefghijk
String string1 = new String(bytes);
System.out.println(string1);
//指定编码集为UTF-8,解码数组bytes
String string2 = new String(bytes, UTF_8);//鵡鵢鵣鵤鵥鵦鵧鵨鵩鵪鵫
System.out.println(string2);
//获取从索引为2开始,长度为5的字符串
string2 = new String(bytes,2,5);//cdefg
System.out.println(string2);
//将字符集存入到字符串中
char[] value = {'q','w','e','r','t','y'};
String string3 = new String(value);
System.out.println(string3);
4.常用方法:
length() : 获取字符对象的字符个数;
indexOf : 返回指定字符在字符串中第一次出现的索引。
subString 获取字符串
trim : 截掉两端空格
charAt : 获取字符
startWith 和 endWith : 获取头部相应字符或尾部相应字符,返回值是boolean类型的
toUpperCase() 、toLowerCase()将字符串全部换成大写或小写
valueOf():将其他类型转换为字符串类型
String[] str = {"1,2,3,4,5,6,7,8"};
Strings ss = new Strings(str,8);
System.out.println(ss.toString());
System.out.println(ss.toString(str));
String str1 = " laknadosandj aldkfn ";
String str2 = "问苍茫大地,谁主沉浮";
System.out.println(str1);
//获取字符的长度
System.out.println(str1.length());
//获取字符串只填一个值表示开始字符的位置
System.out.println(str1.substring(4));
//获取字符串,分别代表开始值和结束值
System.out.println(str1.substring(4,8));
//将整个字符串添加到当前字符串的后面
System.out.println(str1.concat(str2));
//startsWith和endsWith返回值是boolean类型的
System.out.println(str1.startsWith(" l"));
System.out.println(str2.endsWith("沉浮"));
//消除字符串首尾的空格符
System.out.println(str1.trim());
//替换 前面的是要被替换掉的内容,后面的是替换的内容
System.out.println(str1.replace("l","WWW"));
//获取字符第一次出现的位置
System.out.println(str1.indexOf('l'));
//获取相应字符最后一次出现的位置
System.out.println(str1.lastIndexOf('l'));
char[] ch = str1.toCharArray();
System.out.println(ch);
equals 与 ==的区别
equals:是一个方法通常用于比较对象的内容是否相等;
注意:
1.自反性:对任意引用x,x.equals(x)的返回值一定为true;
2.对称性:对于任意引用x,y当且仅当y.equals(x)的返回值为true时,x.equals(y)的返回值一定为true;
3.传递性:如果x.euqals(y)=true,y.equals(z)=true,则x.equals(z)=true;
4.非空性:任何非空的引用值x,x.equals(null)的返回值一定为false.
== :是比较两个对象的内存地址是否相等。简而言之,如果两个对象的引用指向同一块内存区域,==比较的结果就是true;否则,结果为false。这种比较通常用于检查两个引用是否指向同一个对象,而非检查对象的内容是否相同。
/*
equals 和 == 的区别
equals : 比较的是两字符串的内容是否相同,底层还是用的是==
== : 比较两端的值是否指向的是同一个对象,比较的是内存地址
*/
String S1 = new String("hello");
String S2 = new String("hello");
String S3 = "hello";
String S4 = "hello";
String S5 = "hella";
System.out.println(S1 == S2);//false
System.out.println(S1 == S3);//false
System.out.println(S4 == S3);//true
System.out.println(S3.equals(S4));//true
System.out.println(S1.equals(S2));//true
System.out.println(S1.equals(S3));//true
System.out.println(S1.equals(S5));//false
二、StringBuilder 和 StringBuffer
1.常用构造器
StringBuilder() : 构造一个不带任何参数的构造器,初始容量为16个字符;
StringBuilder(String str) : 初始化值为指定的字符串内容;
2.常用方法:
append():将指定字符串追加到字符串之后
insert(int index ,String str):将指定字符串插入到字符串的指定索引处
delete():删除字符串中的一部分
reverse():将字符串进行反转
toString():将StringBuilder转化为字符串类型
replace():替换字符串的指定部分
StringBuilder stringBuilder = new StringBuilder("你好,世界");
String str = new String();
str = "hello";
//添加字符串到原字符串stringBuilder的后面
stringBuilder.append(str);
stringBuilder.append(" world");
System.out.println(stringBuilder);
//添加字符元素到指定位置
stringBuilder.insert(5," ");
System.out.println(stringBuilder);
//reverse 是StringBuilder的方法,只能StringBuilder类型的变量才能调用;
//将字符串进行反转
System.out.println(stringBuilder.reverse());
//System.out.println(str.reverse());
stringBuilder.reverse();
//将StringBuilder类型转换为字符串类型
System.out.println(stringBuilder.toString());
//替换字符串的指定部分,输入的是区间
System.out.println(stringBuilder.replace(5,9,"----"));
//删除指定位置的字符,输入的是区间
System.out.println(stringBuilder.delete(11,15));
3.StringBuilder 和 StringBuffer的区别
1.StringBuilder是可变字符串,如果进行字符串的计算,选择StringBuilder速度会更快,性能更好,因为他是多线程的;
2.StringBuilder是final修饰的类型,不能被继承;
3.StringBuilder没有重写equals方法和toString方法;
4.StringBuilder是线程的,同步处理,性能较慢。
三、正则表达式
1.基本语法
1).常用方法
* boolean matches(String regex) : 是否匹配正则表达式
* String[] split(String regex) : 对匹配上的字符串进行切割,匹配的字符作为分割线
* replaceAll() : 替换掉匹配上的内容
2).预定义字符集
* \d : 表示匹配数字字符中的任意一个
* \D : 表示匹配除了数字字符串中的任意一个
* \w : 表示匹配单词字符中的任意一个 a-z,A-Z,0-9
* \W : 表示匹配除了单词字符中的任意一个
* \s : 匹配空格,制表符,退格符,换行符等中的任意一个,
* \S : 匹配除了\s中的内容中的任意一个
* . : 用于匹配任意一个字符
3).字符集合
* [ ]:表示匹配中括号里的任意一个字符;
* [asd]:表示匹配a,s,d,中的任意一个
* [^asd]:表示匹配除了a,s,d,中的任意一个,其他的都行
4).数量词
* X* : 匹配0个或一个以上
* X? : 匹配0个或一个
* X+ : 匹配一个以上
* X{n} :匹配n个
* X{n,} : 匹配n个以上
* X{n,m} : 匹配n个以上m个以下
5).分组()
在正则表达式上可以使用()来进行对一些字符分组,并可以使用逻辑运算符|来进行选择匹配
reg:
String regex = "(135|137)[\\d]{8}" //匹配手机号是135或者是137开头的
6).^和$
* ^ :表示严格从头匹配
* & : 表示匹配到结尾
2.常用方法
//需要定义一个Matcher 类型的变量来调用以下变量
* matcher : 整个字符串必须满足正则表达式了,返回true,错误返回false
* lookingAt() : 字符串的开头是否符合正则表达式,满足true,错误false
* find() : 对字符串进行匹配,可以匹配到字符串的任何位置,每次调用,指针都会向后移动
* reset() : 重置find()指针位置
2.Pattern 类和 Matcher 类
Pattern 类
Pattern这个类,才是真正来操作正则表达式的类,它位于java.util.regex包下。在String类中的提供的 matches 、split 、replace等方法,其实都是对这个类中的某些方法的封装。
1).常用方法
Pattern类的构造方法是私有的,不可直接创建
可通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式
Pattern p = Pattern.compile("\\w+");
pattern() : 返回的是正则表达式的参数
p.pattern() 返回值是 \w+
Matcher 类
Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持。
String str = "12422222222222222222286";
String str1 = "564ajbn6132hjk998sdvsb9u98273vsh d8 3gv";
//必须要填上数量词来匹配,不然都表示为匹配错误,除非只有一个字符
System.out.println("2".matches("\\d"));//true
System.out.println(str.matches("\\d{18}"));//false
System.out.println(str.matches("[0-9]{19}"));//false
//要查中间重复的字符或数字出现了多少次,就需要完整写出该字符串的剩余的首位字符串
System.out.println(str.matches("1242{3,}86"));//true
//定义正则表达式的规则
Pattern pattern = Pattern.compile("(\\d){1,}");
//输出正则标的式的规则内容
System.out.println(pattern.pattern());// \d
//Matcher对象就是Pattern所定义的正则表达式的内容与字符串匹配的结果
Matcher matcher = pattern.matcher(str);
//直接返回的结果:java.util.regex.Matcher[pattern=\d region=0,23 lastmatch=]
System.out.println(matcher);
Matcher matcher1 = pattern.matcher(str1);
System.out.println(matcher1);
//调用matchers()方法进行匹配
System.out.println(matcher.matches());
//检查字符串的开头是否匹配正则表达式
boolean b = matcher.lookingAt();
System.out.println(b);
matcher1.reset();
matcher = pattern.matcher("56478");
System.out.println(matcher.find(0));
//检查是否匹配正则表达式,满足表达式的,当作是切割符,切割原字符串
String[] str2 = pattern.split(str1);
for(String i:str2){
System.out.println(i);
}
//重置指针位置
matcher.reset();
matcher1.reset();