String类
一、String入门
1) String对象用于保存字符串,也就是一组字符序列
2)字符串常量对象是用双引号括起的字符序列。例如: "你好"、 "12.97"、 "boy"等
3)字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
4)String类较常用构造器
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a):
String s4 = new String(char[] a,int startindex,int count)
5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]
接口 Comparable [String 对象可以比较大小]
6. String 是final 类,不能被其他的类继承
7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组
8. 一定要注意:value 是一个final类型, 不可以修改(地址不可以修改):即value不能指向新的地址,但是单个字符内容是可以变化
public class String01 {
public static void main(String[] args) {
//1.String 对象用于保存字符串,也就是一组字符序列
//2. "jack" 字符串常量, 双引号括起的字符序列
//3. 字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节
//4. String 类有很多构造器,构造器的重载
// 常用的有 String s1 = new String(); //
//String s2 = new String(String original);
//String s3 = new String(char[] a);
//String s4 = new String(char[] a,int startIndex,int count)
//String s5 = new String(byte[] b)
//5. String 类实现了接口 Serializable[String 可以串行化:可以在网络传输]
// 接口 Comparable [String 对象可以比较大小]
//6. String 是final 类,不能被其他的类继承
//7. String 有属性 private final char value[]; 用于存放字符串内容 //字符串本质还是char类型数组
//8. 一定要注意:value 是一个final类型, 不可以修改(地址不可以修改):即value不能指向新的地址,但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';
//value = v2; 不可以修改 value地址
}
}
二、创建String对象的两种方式
方式一:直接赋值Strings = "hsp";
方式二:调用构造器String s2 = new String("hsp");
方式一,先从常量池查看是否有"hsp"数据空间,如果有,直接指向;如果没有则重新创建,然后指向。s最终指向的是常量池的空间地址
方式二:先在堆中创建空间,里面维护了value属性,指向常量池的hsp空间。如果常量池没有"hsp",重新创建,如果有,直接通过value指向。最终指向的是堆中的空间地址。value指向常量池的空间
3.画出两种方式的内存分布图
练习
1.
true ,String重写了equals方法,先比较地址,然后比较字符串内容,if(a == b),为假后循环遍历比较内容
true,==比较的是地址
2.
String a = "hsp";
String b =new String("hsp");
System.out.println(a.equals(b));
System.out.println(a==b);
System.out.println(a==b.intern0);
System.out.println(b==b.intern();
3.intern方法
public class StringExercise03 {
public static void main(String[] args) {
String a = "hsp";//指向常量池的hsp
String b = new String("hsp");//b指向堆,String内的,对象内的value指向常量池
System.out.println(a.equals(b));//T
System.out.println(a == b);//F a->常量池"hsp" b->堆里的String空间的value
System.out.println(a == b.intern());//T
System.out.println(b == b.intern());//F
//intern:返回当调用intern方法时,如果池已经包含一个等于此,String对象的字符串(用equals(Obiect方法确定)
//则返回池中的字符串。否则,将此String对象添加到池中,并返回此String对象的引用
//b.intern()方法最终返回的是常量池的地址(对象)
}
}
4.
public class StringExercise04 {
public static void main(String[] args) {
String s1 = "hspedu";//指向常量池
String s2 = "java";//指向常量池
String s4 = "java";//指向常量池
String s3 = new String("java");//指向堆中对象
System.out.println(s2 == s3);//F
System.out.println(s2 == s4);//T
System.out.println(s2.equals(s3));//T
System.out.println(s1 == s2);//F
}
}
5.
p1.name == p2.name 比较的是两者的地址,两者都指向hspedu,所以当然相等
6.字符串的特性常量池
创建了两个对象
7. 字符串特性常量相加
编译器会优化,等价于String a = "helloabc",因为创建的hello和abc没人用,所以优化了
8.字符串特性变量相加
.
public class StringExercise08 {
public static void main(String[] args) {
String a = "hello";
String b = "abc";
//1.创建了一个StringBuilder
//2.执行sb.append("hello") 3.再append("abc")
//再调用String sb.toString()
//最后其实是c->堆中的对象的value[] ->池中的"helloabc"
String c = a + b;
//如果有了就直接用
String d = "hello" + "abc";//直接指向堆里的helloabc
System.out.println(c == d);//false
}
}
底层是StringBuilder sb = new StringBuilder(); sb.append(a);sb.append(b); sb是在堆中,并且append是在原来字符串的基础上追加的.
重要规则,Stringc1 = "ab" + "cd";常量相加,看的是池。
Stringc1 = a+b ;变量相加,看的是堆。
9.
10.数组传递,字符串引用,多看!
三、String类的常用方法
String类是保存宇符事常量的。每次更新都需要重新开辟空间,效率较低,因此java设计者提供了StringBuilder和StringBuffer来增强String的功能,并提高效率。[后面我们还会详细介绍StringBuilder和StringBuffer]
equals //区分大小写,判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length /获取字符的个数,字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt:获取某索引处的字符,注意不能使用Str[index]这种方式.
String str = “hello”
str[0] //错误
str.chatAt(0) => h
//1.toUpperCase转换成大写
// Strings = "heLLo";
// System.out.println(s.toUpperCase();
// 2.toLowerCase
//System.out.println(s.toLowerCase();
// 3.concat拼接字符串
// Strings1 =“宝玉";
// s1 = s1.concat("林黛玉).concat("薛宝钗").concat(" together");
// System.out.println(s1);
// 4.replace替换字符串中的字符
”Strings1 =“宝玉and薛宝钗薛宝钗薛宝钗";
”s1 = s1.replace("林黛玉","薛宝钗");
// System.out.println(s1);
// 5.split分割字符串,对于某些分割字符,我们需要转义比如| |\等
// String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
// StringD] split = poem.split(",");
// String poem = "E:\laaa\bbb";
// String[ split = poem.split("\\|");
// String[] split = poem.splt("1lI");
// String[] split = poem.split(1"\1I");
”for(int i=0;i< split.length;i+ +){
System.out.println(split[);
}// 6.toCharArray转换成字符数组
// String s = "happy";
// char[ chs = s.toCharArray();
StringBuffer类
一、基本介绍
java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删。很多方法与String相同,但StringBuffer是可变长度的。StringBuffer是一个容器
类结构图
public class StringBuffer01 {
public static void main(String[] args) {
//老韩解读
//1. StringBuffer 的直接父类 是 AbstractStringBuilder
//2. StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化
StringBuffer stringBuffer = new StringBuffer("hello");
//3. 在父类中AbstractStringBuilder有属性 char[] value,不是final类型
// 该 value 数组存放 字符串内容,引出存放在堆中的
//4. StringBuffer 是一个 final类,不能被继承
//5. 因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)
// 不用每次都更换地址(即不是每次创建新对象), 所以效率高于 String
}
}
二、String和StringBuffer的对比
1) String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址, 效率较低//private final char valuel[];
2) StringBuffer保存的是字符串变量,里面的值可以更改,每次StringBuffer的更新实际上可以更新内容,不用更新地址,效率较高//char[] value; // 这个放在堆.
三、StringBuffer的构造器
public class StringBuffer02 {
public static void main(String[] args) {
//构造器的使用
//1. 创建一个 大小为 16的 char[] ,用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();
//2 通过构造器指定 char[] 大小
StringBuffer stringBuffer1 = new StringBuffer(100);
//3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16
StringBuffer hello = new StringBuffer("hello");
}
}
四、String和StringBuffer的互相转化
public class StringAndStringBuffer {
public static void main(String[] args) {
//看 String——>StringBuffer
String str = "hello tom";
//方式1 使用构造器
//注意: 返回的才是StringBuffer对象,对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//看看 StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();
//方式2: 使用构造器来搞定
String s1 = new String(stringBuffer3);
}
}
五、StringBuffer常用方法
public class StringBufferMethod {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//添加方法
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5"
System.out.println(s);//"hello,张三丰赵敏100true10.5"
//删除方法
/*
* 删除索引为>=start && <end 处的字符
* 解读: 删除 11~14的字符 [11, 14) 到14-1下标的索引都同理
*/
s.delete(11, 14);
System.out.println(s);//"hello,张三丰赵敏true10.5"
//修改方法
//使用 周芷若 替换 索引9-11的字符 [9,11)
s.replace(9, 11, "周芷若");
System.out.println(s);//"hello,张三丰周芷若true10.5"
//查找指定的子串在字符串第一次出现的索引,如果找不到返回-1
int indexOf = s.indexOf("张三丰");
System.out.println(indexOf);//6
//插入方法
//在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移
s.insert(9, "赵敏");//包含9
System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);
}
}
练习
1.
public class StringBufferExercise01 {
public static void main(String[] args) {
String str = null;// ok
StringBuffer sb = new StringBuffer(); //ok
sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull () 增加了null字符
System.out.println(sb.length());//4
System.out.println(sb);//null
//下面的构造器,会抛出NullpointerException
StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
System.out.println(sb1);
}
}
2.
public class StringBufferExercise02 {
public static void main(String[] args) {
/*
输入商品名称和商品价格,要求打印效果示例, 使用前面学习的方法完成:
商品名 商品价格
手机 123,564.59 //比如 价格 3,456,789.88
要求:价格的小数点前面每三位用逗号隔开, 在输出。
思路分析
1. 定义一个Scanner 对象,接收用户输入的 价格(String)
2. 希望使用到 StringBuffer的 insert ,需要将 String 转成 StringBuffer
3. 然后使用相关方法进行字符串的处理
代码实现
*/
//new Scanner(System.in)
String price = "8123564.59";
StringBuffer sb = new StringBuffer(price);
//先完成一个最简单的实现123,564.59
//找到小数点的索引,然后在该位置的前3位,插入,即可
//int i = sb.lastIndexOf(".");
//sb = sb.insert(i - 3, ",");
//上面的两步需要做一个循环处理,才是正确的
for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
sb = sb.insert(i, ",");
}
System.out.println(sb);//8,123,564.59
}
}
StringBuilder类
一、基本介绍
1.一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快。
2.在StringBuilder上的主要操作是 append和insert 方法,可重载这些方法,以接受任意类型的数据。
类结构图
public class StringBuilder01 {
public static void main(String[] args) {
//1. StringBuilder 继承 AbstractStringBuilder 类
//2. 实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
//3. StringBuilder 是final类, 不能被继承
//4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value 因此,字符序列是堆中
//5. StringBuilder 的方法,没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用StringBuilder
StringBuilder stringBuilder = new StringBuilder();
}
}
三个String、StringBuffer 和StringBuilder的比较
1) StringBuilder和StringBuffer非常类似,均代表可变的字符序列,而且方法也一样
2) String:不可变字符序列,效率低,但是复用率高。(如果相同都指向常量池的)
3) StringBuffer:可变字符序列、效率较高(增删)、线程安全
4) StringBuilder:可变字符序列、效率最高、线程不安全
5) String使用注意说明:
string s="a"; //创建了-一个字符串
s += "b"; //实际上原来的" a"字符串对象已经丢弃了,现在又产生了一个字符串s+ "b" (也就是"ab")。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能
结论:如果我们对String做大量修改,不要使用String
效率测试
public class StringVsStringBufferVsStringBuilder {
public static void main(String[] args) {
long startTime = 0L;
long endTime = 0L;
StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000次
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer的执行时间:" + (endTime - startTime));
StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000次
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder的执行时间:" + (endTime - startTime));
String text = "";
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//String 拼接 20000
text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String的执行时间:" + (endTime - startTime));
}
}
三个String、StringBuffer 和StringBuilder的使用原则
使用的原则,结论:
1.如果字符串存在大量的修改操作,一般使用StringBuffer或StringBuilder
2.如果字符串存在大量的修改操作,并在单线程的情况,使用StringBuilder
3.如果字符串存在大量的修改操作,并在多线程的情况,使用StringBuffer
4.如果我们字符串很少修改,被多个对象引用,使用String, 比如配置信息等