目录
1.String字符串类型：
java.lang.String类使用final修饰，不能被继承
String的底层封装的是一个字符数组
String在内存中采用Unicode编码格式，每个字符占用2个字节的空间
字符串对象一旦创建，对象内容永远无法改变，单字符串引用可以重新赋值(指向新的对象)
将String称为不变对象
2.字符串常量池：
java对String字符串有一个优化措施：字符串常量池
java推荐我们使用字面量/直接量(直接"")的方式创建字符串对象，并且会将所有以字面量方式创建的对象缓存到常量池中，当使用相同字面量再创建字符串对象时将会复用常量池中的对象，以减少内存开销。
public class StringDemo {
public static void main(String[] args) {
/*
使用字面量(直接"")来创建字符串对象时，JVM会检查常量池中是否有该对象:
1)若没有，则会创建字符串对象，并将其引用存入到常量池中
2)若有，则直接将常量池中的对象(引用)返回，并不会创建新的字符串对象
*/
/*
String s1 = "123abc"; //常量池还没有，因此创建该字符串对象，并存入常量池中
String s2 = "123abc"; //常量池中已经有了，直接复用对象
String s3 = "123abc"; //常量池中已经有了，直接复用对象
//引用类型==，比较的是地址是否相同
System.out.println(s1==s2); //true
System.out.println(s1==s3); //true
System.out.println(s2==s3); //true
s1 = s1+"!"; //创建新的字符串对象("123abc!")并将地址赋值给s1
System.out.println(s1==s2); //false
*/
String s1 = "123abc"; //堆中创建123abc字面量对象，并缓存到常量池中
//编译器在编译时，若发现是两个字面量相连，则会直接连接好并将结果保存起来
//如下语句会被编译为: String s2 = "123abc";
String s2 = "123"+"abc";
System.out.println(s1==s2); //true
String s3 = "123";
//因为s3是一个变量，所以在编译期并不会直接编译好
String s4 = s3+"abc"; //创建一个新的对象存储123abc
System.out.println(s1==s4); //false
}
}3.String类的常用方法
length():获取字符串的长度(字符个数)
String str = "娃哈哈真好喝oo!";
int len = str.length(); //获取str的长度
System.out.println(len); //9注：数组是length属性.length，String字符串是length方法.length()
trim():去除当前字符从两边的空白字符
String str = " good day ";
str = str.trim(); //去除str两边的空白字符(一个新的字符串对象)，并存入str中
System.out.println(str); //good daycharAt():返回当前字符串指定位置上的字符--根据位子找字符
// 111111----和下面的连成10/11/12/13/14/15
// 0123456789012345
String str = "thinking in java";
char c = str.charAt(5); //获取str中下标5所对应的字符
System.out.println(c); //isubstring():截取当前字符串中指定范围的字符串(含头不含尾)
// 111--与下面数字的连成10/11/12
// 0123456789012
String str = "www.baidu.con";
int start = str.indexOf(".")+1; //4
int end = str.lastIndexOf("."); //9
String name = str.substring(start,end); //截取下标4到8的字符串
System.out.println(name); //baidutoUpperCase()/toLowerCase():将当前字符串中的英文部分给转换为全大写/全小写
String str = "快乐Java!";
String upper = str.toUpperCase(); //将str中的英文部分转换为全大写，并赋值给upper
System.out.println(upper); //快乐JAVA!
String lower = str.toLowerCase(); //将str中的英文部分转换为全小写，并赋值给lower
System.out.println(lower); //快乐java!startsWith()/endsWith():判断当前字符串是否是以给定的字符串开始的/结束的
String str = "thinking in java";
boolean starts = str.startsWith("think"); //判断str是否是以think开始的
System.out.println(starts); //true
boolean ends = str.endsWith(".png"); //判断str是否是以.png结尾的
System.out.println(ends); //falseindexOf()/lastIndexOf():检索给定字符串在当前字符串中第一次/最后一次出现的位置--根据字符串找位置
// 111111----与下面的连成10/11/12/13/14/15
// 0123456789012345
String str = "thinking in java";
int index = str.indexOf("in"); //检索in在str中第1次出现的位置
System.out.println(index); //2
index = str.indexOf("in",3); //从下标为3的位置开始找in第1次出现的位置
System.out.println(index); //5
index = str.indexOf("abc"); //若字符串在str中不存在，则返回-1
System.out.println(index); //-1
index = str.lastIndexOf("in"); //检索in在str中最后一次出现的位置
System.out.println(index); //9静态方法valueOf():将其他数据类型转换为String
int a = 123;
String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
System.out.println(s1); //123---字符串类型
double b = 123.456;
String s2 = String.valueOf(b); //将double型变量b转换为String类型并赋值给s2
System.out.println(s2); //123.456---字符串类型
String s3 = b+""; //任何类型与字符串相连，结果都会变为字符串类型，效率低
System.out.println(s3); //123.456---字符串类型public class StringDemo { public static void main(String[] args) { /* 常见面试题: String s = new String("hello"); 问:如上语句创建了几个对象? 答:2个 第一个:字面量"hello" ----java会创建一个String对象表示字面量"hello"，并将其存入常量池中 第二个:new String() ----new String()时会再创建一个字符串对象，并引用hello字符串内容 */ String s = new String("hello"); //创建了2个对象 String s1 = "hello"; //复用常量池中的字面量对象 System.out.println("s:"+s); System.out.println("s1:"+s1); System.out.println(s==s1); //false，==比较的是地址是否相同 //在实际应用中，String比较相等一般都是比较字符串内容是否相同 //因此我们需要使用equals()方法来比较两个字符串内容是否相同 System.out.println(s.equals(s1)); //true，equals()比较的是内容是否相同 } }
4.StringBuilder类的常用方法
由于String是不变对象，每次修改内容都会创建新的对象，因此String不适合频繁修改操作，为了解决这个问题，java提供了StringBuilder类
StringBuilder类是专门用于修改字符串的一个类，内部维护一个可变的char数组，所做操作都是在这个数组之上进行的，修改速度、性能优秀，并且提供修改字符串的常见方法：增、删、改、插。
append():追加内容-----------增
delete():删除部分内容-------删
replace():替换内容部分-----改
insert():插入内容-------------插
//StringBuilder的创建方式:
StringBuilder builder1 = new StringBuilder(); //空字符
StringBuilder builder2 = new StringBuilder("abc"); //abc串
//String和StringBuilder互转
String str = "abc";
StringBuilder builder3 = new StringBuilder(str); //abc串
String str2 = builder3.toString(); //将builder3转换为String类型
-------------------------------
String str = "好好学习Java";
//复制str的内容到builder中-----好好学习Java
StringBuilder builder = new StringBuilder(str);
//append():追加内容----在末尾追加
builder.append("，天天向上");
System.out.println(builder); //好好学习Java，天天向上
//replace():替换部分内容(含头不含尾)
//将下标为9到13的内容替换为---就是为了改变自己
builder.replace(9,13,"就是为了改变自己");
System.out.println(builder); //好好学习Java，就是为了改变自己
//delete():删除部分内容(含头不含尾)
builder.delete(0,8); //删除下标为0到7的
System.out.println(builder); //，就是为了改变自己
//insert():插入内容
builder.insert(0,"活着");
System.out.println(builder); //活着，就是为了改变自己5.正则表达式：
用来描述字符串的内容格式，使用它通常用于匹配一个字符串是否符合格式要求。
正则表达式的语法:
1.[]:表示一个字符,该字符可以是[]中指定的内容
例如:
[abc]:这个字符可以是a或b或c
[a-z]:表示任意一个小写字母
[a-zA-Z]:表示任意一个字母
[a-zA-Z0-9]:表示任意一个字母数字
[a-zA-Z0-9_]:表示任意一个数字字母下划线
[^abc]:该字符只要不是a或b或c
2.预定义字符:
.:表示任意一个字符,没有范围限制
\d:表示任意一个数字,等同于[0-9]
\w:表示任意一个单词字符,等同于[a-zA-Z0-9_]----单词字符指字母、数字和_
\s:表示任意一个空白字符
\D:不是数字
\W:不是单词字符
\S:不是空白字符
3.量词:
?:表示前面的内容出现0-1次
例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
但是不能匹配：m或aaa
+:表示前面的内容最少出现1次
例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba....
但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
*:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写
但是不能匹配:abcfdfsbbaqbb34bbwer...
{n}:表示前面的内容出现n次
例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
但是不能匹配: aaaa 或 aad
{n,m}:表示前面的内容出现最少n次最多m次
例如: [abc]{3,5} 可以匹配:aaa 或 abcab 或者 abcc
但是不能匹配:aaaaaa 或 aabbd
{n,}:表示前面的内容出现n次以上(含n次)
例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba....
但是不能匹配:aa 或 abbdaw...
4.()用于分组,是将小括号里面的内容看做是一个整体
例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
但是不能匹配aaa 或abc 或abcabccba
(abc|def){3}表示abc或def整体出现3次.
可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
但是不能匹配abcdef 或abcdfbdefString支持正则表达式的方法：
matches():使用给定的正则表达式验证当前字符串的格式是否符合要求，若符合则返回true，不符合则返回false
public class MatchesDemo {
public static void main(String[] args) {
/*
邮箱正则表达式:
[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
注意: \.中的\是正则表达式中的转义符
\\.中的第1个\，是在转义正则表达式中的\
*/
String email = "wangkj@tedu.cn";
String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
//使用regex匹配email是否符合格式要求
boolean match = email.matches(regex);
if(match){
System.out.println("是正确的邮箱格式");
}else{
System.out.println("不是正确的邮箱格式");
}
}
}replaceAll():将当前字符串中满足正则表达式的部分给替换为指定字符串
public class ReplaceAllDemo {
public static void main(String[] args) {
String line = "abc123def456ghi78";
//将数字部分给替换为#NUMBER#
line = line.replaceAll("[0-9]+","#NUMBER#");
System.out.println(line);
}
}split():将当前字符串按照满足则正表达式(regex)的部分进行拆分，将拆分出的以String[]形式返回
public class SplitDemo {
public static void main(String[] args) {
String line = "abc123def456ghi";
String[] data = line.split("[0-9]+"); //按数字拆分(数字就拆没了)
System.out.println(Arrays.toString(data)); //将data数组转换为字符串并输出
line = "123.456.78";
data = line.split("\\."); //按.拆(.就拆没了)
System.out.println(Arrays.toString(data));
//最开始就是可拆分项，那么数组第1个元素为空字符串---------------""
//如果连续两个(两个以上)可拆分项，那么中间也会拆出一个空字符串----""
//如果末尾连续多个可拆分项，那么拆出的空字符串被忽略
line = ".123.456..78.........";
data = line.split("\\."); //按.拆(.就折没了)
System.out.println(Arrays.toString(data));
System.out.println(data.length); //5
}
}6.Object:
是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
Object中有两个经常被派生类重写方法：toString()和equals()
调用Object类的toSring()时默认返回:类的全称@hashcode值，没有参考意义，所以常常重写toString()来返回具体的属性值
注：String、StringBuilder都重写了toString()来返回字符串内容了
调用Object类的equals()时默认比较的还是==(即计较地址),没有参考意义，所以常常重写equals()来比较具体的属性值
注：String类重写equals()来比较字符串内容了,但是StringBuilder并没有
包装类也重写了equals()来比较具体的值
重写equals()的基本原则：
原则上要比较两个对象的属性值是否相同
两个对象必须是同一类型的，若类型不同则返回false
7.包装类:
java定义了8个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使基本类型可以通过包装类的形式存在
包含：Integer、Character、Byte、Short、Long、Float、Double、Boolean，其中Character和Boolean是直接继承自OBject的，其余6个包装类继承自Number类。
JKD1.5时推出了一个特性：自动拆装箱。当编译器编译时若发现是基本类型与包装类型之间的互相赋值，则自动补齐代码完成转换工作，这个过程叫做自动拆装箱。
public class IntegerDemo {
public static void main(String[] args) {
//演示包装类的常用操作:
//1)可以通过包装类来获取基本类型的取值范围:
int max = Integer.MAX_VALUE; //获取int的最大值
int min = Integer.MIN_VALUE; //获取int的最小值
System.out.println("int的最大值为:"+max+"，最小值为:"+min);
long max1 = Long.MAX_VALUE; //获取long的最大值
long min1 = Long.MIN_VALUE; //获取long的最小值
System.out.println("long的最大值为:"+max1+"，最小值为:"+min1);
//2)包装类可以将字符串转换为对应的基本类型-----必须熟练掌握
String s1 = "38";
int age = Integer.parseInt(s1); //将字符串s1转换为int类型并赋值给age
System.out.println(age); //38---int类型
String s2 = "123.456";
double price = Double.parseDouble(s2); //将字符串s2转换为double类型并赋值给price
System.out.println(price); //123.456---double类型
/*
//触发了自动装箱特性，会被编译为：Integer i = Integer.valueOf(5);
Integer i = 5; //基本类型到包装类----装箱
//触发了自动拆箱特性，会被编译为：int j = i.intValue();
int j = i; //包装类型到基本类型----拆箱
*/
/*
//演示包装类的定义:
Integer i1 = new Integer(5);
Integer i2 = new Integer(5);
System.out.println(i1==i2); //false，==比较的是地址
System.out.println(i1.equals(i2)); //true，Integer重写equals()比较值了
//valueOf()方式会复用1个字节范围内(-128到127)的数据，建议使用valueOf()
Integer i3 = Integer.valueOf(5);
Integer i4 = Integer.valueOf(5); //复用
System.out.println(i3==i4); //true
System.out.println(i3.equals(i4)); //true，Integer重写equals()比较值了
*/
}
}
扫一扫
6802
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
