常用类
包装类
包装类的分类
1、针对八种基本定义相应的引用类型-包装类
2、有了类的特点，就可以调用类中的方法
基本数据类型 | 包装类 |
boolean | Boolean |
char | Character |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
包装类和基本数据的转换
演示包装类和基本数据类型的相互转换，这里以int和 Integer演示。
1、 jdk5 前的手动装箱和拆箱方式，装箱：基本类型->包装类型，反之，拆箱
2、 jdk5 以后(含jdk5)的自动装箱和拆箱方式
3、自动装箱底层调用的是valueOf方法，比如Integer.valueOf()
4、其他包装类的用法类似
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title Integer01
* @package com13.wrapper
* @time 2023/1/10 14:44
*/
public class Integer01 {
public static void main(String[] args) {
//演示int <--> Integer 的装箱和拆箱
//jdk5前 是 手动装箱 和 拆箱
//手动装箱
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer -> int
int i = integer.intValue();
//jdk5后 就可以自动装箱 和 自动拆箱
int n2 = 200;
//自动装箱 int -> Integer
Integer integer2 = n2;//底层使用的是 Integer.valueOf(n1)
//自动拆箱 Integer -> int
int n3 = integer2;//底层仍然是integer.intValue()方法
}
}
练习题
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title WrapperExercise01
* @package com13.wrapper
* @time 2023/1/10 15:15
*/
public class WrapperExercise01 {
public static void main(String[] args) {
//下面代码是否正确，为什么
Double d = 100d;//正确，自动装箱Double.valueOf(100d);
Float f = 1.5f;//正确，自动装箱Float.valueOf(1.5f);
//如下两个题目输出的结果相同吗？各为什么？
Object obj1 = true ? new Integer(1) : new Double(2.0);//三元运算符[是一个整体] 一真大师
System.out.println(obj1);//1.0
Object obj2;
if (true) {
obj2 = new Integer(1);
} else {
obj2 = new Double(2.0);
}
System.out.println(obj2);//1 分别计算
}
}
包装类型和String类型的相互转换
案例类型，以Integer和String转换为例，其他类似
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title WrapperVSString
* @package com13.wrapper
* @time 2023/1/10 16:06
*/
public class WrapperVSString {
public static void main(String[] args) {
//包装类(Integer)->String
Integer i = 100;//自动装箱
//方式1
String str1 = i + "";
//方式2
String str2 = i.toString();
//方式3
String str3 = String.valueOf(i);
//String->包装类(Integer)
String str4 = "12345";
Integer i2 = Integer.valueOf(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器
System.out.println("~~~");
}
}
Integer类和Character类的常用方法
Integer类和Character有些常用的方法，如下
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title WrapperMethod
* @package com13.wrapper
* @time 2023/1/10 16:17
*/
public class WrapperMethod {
public static void main(String[] args) {
System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写
System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写
}
}
Integer类面试题1
看下面的代码，输出结果是什么？为什么？
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title WrapperExercise02
* @package com13.wrapper
* @time 2023/1/10 16:21
*/
public class WrapperExercise02 {
public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//False
//所以，这里主要是看范围 -128~127 就是直接返回
//1.如果i 在IntegerCache.low(-128) ~ i <= IntegerCache.high(127)，就直接从数组返回
//2.如果不在-128~127，就直接new Integer(i)
// public static Integer valueOf(int i) {
// if (i >= IntegerCache.low && i <= IntegerCache.high)
// return IntegerCache.cache[i + (-IntegerCache.low)];
// return new Integer(i);
// }
Integer m = 1;//底层 Integer.valueOf(1); -> 阅读源码
Integer n = 1;//底层 Integer.valueOf(1);
System.out.println(m == n);//True
//所以，这里主要是看范围 -128~127 就是直接返回
//否则，就要new Integer(xx);
Integer x = 128;//底层 Integer.valueOf(1);
Integer y = 128;//底层 Integer.valueOf(1);
System.out.println(x == y);//False
}
}
Integer类面试题2
看下面的代码，输出结果是什么？为什么？
package com13.wrapper;
/**
* @author 甲柒
* @version 1.0
* @title WrapperExercise03
* @package com13.wrapper
* @time 2023/1/10 16:35
*/
public class WrapperExercise03 {
public static void main(String[] args) {
//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false
//示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
//示例三
Integer i5 = 127;//底层Integer.valueOf(127)
Integer i6 = 127;//-128~127
System.out.println(i5 == i6);//true
//示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//false
//示例五
Integer i9 = 127;//底层Integer.valueOf(127)
Integer i10 = new Integer(127);
System.out.println(i9 == i10);//false
//示例六
Integer i11 = 127;
int i12 = 127;
//只要有基本数据类型，判断是值是否相同
System.out.println(i11 == i12);//true
//示例七
Integer i13 = 128;
int i14 = 128;
System.out.println(i13 == i14);//true
}
}
String类
String类的理解和创建对象
1、String对象用于保存字符串，也就是一组字符序列
2、字符串常量对象是用双引号括起来的字符序列。例如"甲柒"、"3.1415926"、"dog"等
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);
说明:
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title String01
* @package com13.string_
* @time 2023/1/10 17:14
*/
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[];//用于存放字符串内容
//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;//错误
}
}
创建String对象的两种方式
1、方式一：直接赋值String s = "甲柒";
2、方式二：调用构造器String s = new String("甲柒");
方式一：先从常量池查看是否有"甲柒"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
方式二：先在堆中创建空间，里面维护了value属性，指向常量池的"甲柒"空间。如果常量池也没有"甲柒"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。
画出两种方式的内存分布图
练习题
1、
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise01
* @package com13.string_
* @time 2023/1/10 18:35
*/
public class StringExercise01 {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
System.out.println(a.equals(b));//true
System.out.println(a == b);//true
}
}
2、
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise02
* @package com13.string_
* @time 2023/1/10 18:38
*/
public class StringExercise02 {
public static void main(String[] args) {
String a = "甲柒";
String b = new String("甲柒");
System.out.println(a.equals(b));//true
System.out.println(a == b);//false
System.out.println(a == b.intern());//true
System.out.println(b == b.intern());//false
}
}
知识点:
当调用intern方法时，如果池已经包含一个等于此String对象的字符串(用equals(Object)方法确定)则返回池中的字符串。否则，将此 String对象添加到池中，并返回此 String对象的引用
解读：(1) b.intern()方法最终返回的是常量池的地址(对象)
3、
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise03
* @package com13.string_
* @time 2023/1/10 18:47
*/
public class StringExercise03 {
public static void main(String[] args) {
String s1 = "甲柒";
String s2 = "java";
String s4 = "java";
String s3 = new String("java");
System.out.println(s2 == s3);//false
System.out.println(s2 == s4);//true
System.out.println(s2.equals(s3));//true
System.out.println(s1 == s2);//false
}
}
4、
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise04
* @package com13.string_
* @time 2023/1/10 18:54
*/
public class StringExercise04 {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "甲柒";
Person p2 = new Person();
p2.name = "甲柒";
System.out.println(p1.name.equals(p2.name));//true
System.out.println(p1.name == p2.name);//true
System.out.println(p1.name == "甲柒");//true
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2);//false
}
}
class Person {
String name;
}字符串的特性
说明
1、String是一个final类，代表不可变的字符序列
2、字符串是不可变的。一个字符串对象一旦被分配，内容是不可变的
//以下语句创建了几个对象？画出内存布局图
String s1 = "hello";
s1 = "haha";//创建了两个对象面试题String
题1
String a = "hello" + "abc";//创建了几个对象
//解读：String a = "hello" +"abc"; => 优化等价 String a = "helloabc";
//分析
//1.编译器做优化，判断创建的常量池对象，是否有引用指向
//2.String a = "hello" + "abc"; =>String a = "helloabc";题2
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise05
* @package com13.string_
* @time 2023/1/10 21:19
*/
public class StringExercise05 {
public static void main(String[] args) {
String a = "hello";//创建对象a
String b = "abc";//创建对象b
//解读
//1.先创建一个StringBuilder sb = StringBuilder()
//2.执行sb.append("hello");
//3.sb.append("abc");
//4.String c= sb.toString()
//最后其实是c指向堆中的对象(String) value[] -> 池中"helLoabc"
String c = a + b;//创建了几个对象//3个
String d = "helloabc";
System.out.println(c == d);//false
String e = "hello" + "abc";//直接看池，e指向常量池
System.out.println(d == e);//true
}
}
题3
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise06
* @package com13.string_
* @time 2023/1/10 21:33
*/
public class StringExercise06 {
public static void main(String[] args) {
String s1 = "甲柒";//s1指向池中的"甲柒"
String s2 = "java";//s2指向池中的"java"
String s5 = "甲柒java";//s5指向池中的"甲柒java"
String s6 = (s1 + s2).intern();//s6指向池中的"甲柒java"
System.out.println(s5 == s6);//true
System.out.println(s5.equals(s6));//true
}
}
题4
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringExercise07
* @package com13.string_
* @time 2023/1/10 21:39
*/
public class StringExercise07 {
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.println(ex.ch);
}
}
class Test1 {
final char[] ch = {'j', 'a', 'v', 'a' };
String str = new String("甲柒");
public void change(String str, char ch[]) {
str = "java";
ch[0] = 'h';
}
}
String类
String类常见方法的说明
String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和 StringBuffer 来增强String的功能,并提高效率。
String类的常见方法一览
equals //区分大小，判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length //获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1
lastlndexOf //获取字符在字符串中最后1次出现的索引，索引从0开始，如果找不到，返回-1
substring //截取指定范围的字串
trim //去前后空格
charAt //获取某索引处的字符，注意不能使用Str[index]这种方式
toUpperCase
toLowerCase
concat
replace //替换字符串中的字符
split //分割字符串，对于某些分割字符，需要转义比如|\\等
compareTo //比较两个字符串的大小
toCharArray //转换成字符数组
format //格式化字符串，%s字符串 %c字符 %d整型 %.2f浮点型
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringMethod01
* @package com13.string_
* @time 2023/1/10 22:39
*/
public class StringMethod01 {
public static void main(String[] args) {
//1. equals 比较内容是否相同，区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//
// 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
String username = "johN";
if ("john".equalsIgnoreCase(username)) {
System.out.println("Success!");
} else {
System.out.println("Failure!");
}
// 3.length 获取字符的个数，字符串的长度
System.out.println("甲柒".length());
// 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
String s1 = "wer@terwe@g";
int index = s1.indexOf('@');
System.out.println(index);// 3
System.out.println("weIndex=" + s1.indexOf("we"));//0
// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
s1 = "wer@terwe@g@";
index = s1.lastIndexOf('@');
System.out.println(index);//11
System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4
// 6.substring 截取指定范围的子串
String name = "hello,张三";
//下面name.substring(6) 从索引6开始截取后面所有的内容
System.out.println(name.substring(6));//截取后面的字符
//name.substring(0,5)表示从索引0开始截取，截取到索引 5-1=4位置
System.out.println(name.substring(2,5));//llo
}
}
package com13.string_;
/**
* @author 甲柒
* @version 1.0
* @title StringMethod02
* @package com13.string_
* @time 2023/1/10 22:39
*/
public class StringMethod02 {
public static void main(String[] args) {
// 1.toUpperCase转换成大写
String s = "heLLo";
System.out.println(s.toUpperCase());//HELLO
// 2.toLowerCase
System.out.println(s.toLowerCase());//hello
// 3.concat拼接字符串
String s1 = "宝玉";
s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
System.out.println(s1);//宝玉林黛玉薛宝钗together
// 4.replace 替换字符串中的字符
s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
//在s1中，将 所有的 林黛玉 替换成薛宝钗
//解读: s1.replace() 方法执行后，返回的结果才是替换过的.
//注意对 s1没有任何影响
String s11 = s1.replace("宝玉", "jack");
System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
// 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
//解读：
// 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
// 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
String[] split = poem.split(",");
// poem = "E:\\aaa\\bbb";
// split = poem.split("\\\\");
System.out.println("=========================");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
// 6.toCharArray 转换成字符数组
s = "happy";
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
// 7.compareTo 比较两个字符串的大小，如果前者大，
// 则返回正数，后者大，则返回负数，如果相等，返回0
// 解读
// (1) 如果长度相同，并且每个字符也相同，就返回 0
// (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
// 就返回 if (c1 != c2) {
// return c1 - c2;
// }
// (3) 如果前面的部分都相同，就返回 str1.len - str2.len
String a = "jcck";// len = 3
String b = "jack";// len = 4
System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值
// 8.format 格式字符串
/* 占位符有:
* %s 字符串 %c 字符 %d 整型 %.2f 浮点型
*
*/
String name = "john";
int age = 10;
double score = 56.857;
char gender = '男';
//将所有的信息都拼接在一个字符串.
String info =
"我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！";
System.out.println(info);
//解读
//1. %s , %d , %.2f %c 称为占位符
//2. 这些占位符由后面变量来替换
//3. %s 表示后面由 字符串来替换
//4. %d 是整数来替换
//5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
//6. %c 使用char 类型来替换
String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
String info2 = String.format(formatStr, name, age, score, gender);
System.out.println("info2=" + info2);
}
}
StringBuffer类
基本介绍
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。很多方法与String相同，但StringBuffer是可变长度的。
StringBuffer是一个容器。
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringBuffer01
* @package com13.stringbuffer_
* @time 2023/1/10 22:56
*/
public class StringBuffer01 {
public static void main(String[] args) {
//解读
//1.StringBuffer的直接父类是AbstractStringBuilder
//2.StringBuffer实现了Serializable，即StringBuffer的对象可以串行化
//3.在父类中 AbstractStringBuilder有属性char[] value，不是final
//该value数组存放字符串内容，引出存放在堆中
//4.StringBuffer是一个final类，不能被继承
//5.因为StringBuffer字符内容是存在char[] value，所有在变化(增加/删除)
//不用每次都更换地址(即不是每次都创建新对象)，所以效率高于String
StringBuffer stringBuffer = new StringBuffer("hello");
}
}
String VS StringBuffer
1、String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
2、StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高//char[] value;//这个放在堆
StringBuffer的构造器
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringBuffer02
* @package com13.stringbuffer_
* @time 2023/1/11 16:56
*/
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相互转换
在开发中，经常需要将String和StringBuffer进行转换，看如何实现
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringAndStringBuffer
* @package com13.stringbuffer_
* @time 2023/1/11 17:06
*/
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 stringBuffer2 = new StringBuffer("甲柒");
//方式1 使用StringBuffer提供的toString方法
String s = stringBuffer2.toString();
//方式2 使用构造器来搞定
String s1 = new String(stringBuffer2);
}
}
StringBuffer类常见方法
1)增append
2)删delete(start, end)
3)改replace(start,end,string) //将start----end间的内容替换掉，不含end
4)查indexOf //查找子串在字符串第1次出现的索引，如果找不到返回-1
5)插insert
6)获取长度 length
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringBufferMethod
* @package com13.stringbuffer_
* @time 2023/1/11 17:20
*/
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)
*/
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, "赵敏");
System.out.println(s);//"hello,张三丰赵敏周芷若true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);
}
}
StringBuffer练习题
1、
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringBufferExercise01
* @package com13.stringbuffer_
* @time 2023/1/11 17:29
*/
public class StringBufferExercise01 {
public static void main(String[] args) {
String str = null;//ok
StringBuffer sb = new StringBuffer();//ok
sb.append(str);//看源码，底层调用的是AbstractStringBuilder的appendNull
System.out.println(sb.length());//4
System.out.println(sb);//null
StringBuffer sb1 = new StringBuffer(str);//空指针异常NullPointerException
System.out.println(sb1);
}
}
2、输入商品名称和商品价格，要求打印效果示例，使用前面学习的方法完成：商品名商品价格
手机 123,564.59 //比如价格3,456,789.88
要求：价格的小数点前面每三位用逗号隔开。
package com13.stringbuffer_;
/**
* @author 甲柒
* @version 1.0
* @title StringBufferExercise02
* @package com13.stringbuffer_
* @time 2023/1/11 17:37
*/
public class StringBufferExercise02 {
public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
String price = "4123456.59";
StringBuffer sb = new StringBuffer(price);
//先完成一个最简单的实现123,456.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);
}
}
StringBuilder类
基本介绍
1、一个可变的字符序列。此类提供一个与StringBuffer 兼容的API，但不保证同步(StringBuilder 不是线程安全)。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快[后面测]。
2、在 StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。
StringBuilder常用方法
StringBuilder和StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样
package com13.stringbuilder_;
/**
* @author 甲柒
* @version 1.0
* @title StringBuilder01
* @package com13.stringbuilder_
* @time 2023/1/11 17:50
*/
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
String、StringBuffer 和StringBuilder的效率测试
效率：StringBuilder > StringBuffer > String
package com13.stringbuilder_;
/**
* @author 甲柒
* @version 1.0
* @title StringVsStringBufferVsStringBuilder
* @package com13.stringbuilder_
* @time 2023/1/11 16:14
*/
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，比如配置信息等
