day12
一、StringBuilder
是一个可变的字符串。
在
StringBuilder
上的主要操作是append
和insert
方法,可重载这些方法,以接受任意类型的数据。
1.1 为什么使用StringBuilder
public class Demo {
public static void main(String[] args) {
/*
因为字符串String,都是常量,并且它们的值在创建之后不能更改。
那么下方的代码就创建了3个常量,分别为"Hello"、"World"、"HelloWorld"
以上这种操作,既浪费了空间,也浪费了时间。很不好,所以Java提供了一个新的类StringBuilder来改善
StringBuilder是一个可变的字符串
*/
String s = "Hello";
s += "World";
System.out.println(s);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5S5rnY0q-1620344684859)(img/image-20210421104549338.png)]
1.2 StringBuilder和String的区别
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qAH8kgL9-1620344684862)(img/image-20210421105418071.png)]
1.3 构造方法
StringBuilder()
StringBuilder(String str)
注意:
length() 获取StringBuilder中字符的个数
capacity() 获取StringBuilder的容量
public class Demo2 {
public static void main(String[] args) {
//StringBuilder() 创建一个StringBuilder对象,并且默认有16的容量
// StringBuilder sb = new StringBuilder();
//
// System.out.println(sb); //
// System.out.println(sb.length()); //0
// System.out.println(sb.capacity()); //16
//StringBuilder(String str) 创建一个StringBuilder对象,初始容量为16+str的长度
StringBuilder sb = new StringBuilder("abcd");
System.out.println(sb); //abcd
System.out.println(sb.length()); //4
System.out.println(sb.capacity()); //20
}
}
1.3 常见方法
添加和插入方法
append 添加
insert 插入
注意:
1. 因为append方法的返回值是StringBuilder类型,实际上返回的是该类的对象,所以我们可以在append方法后面继续使用append方法,这种方式叫做”链式编程“。
2. StringBuiler的默认容量为16,如果超过了这个容量,那么会自动扩容。扩容后的大小为 原来的容量*2 + 2
3. append和insert方法,有很多重载,可以接收任意数据类型(包括所有基本数据类型和引用数据类型)
public class Demo3 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
StringBuilder sb1 = sb.append("abcd");
StringBuilder sb2 = sb1.append("666");
/*
此处证明,StringBuilder使用append添加之后返回的对象和原来的StringBuilder对象是同一个(而不是一个新的对象)
所以,我们以后可以全部通过同一个对象添加即可。
如:
sb.append("abcd");
sb.append("6666");
甚至可以写为:
sb.append("abcd").append("6666");
这种方式也被称为链式编程
*/
System.out.println(sb == sb1); //true
System.out.println(sb1 == sb2); //true
/*
因为sb和sb1和sb2实际上是同一个对象(也就是地址相同),所以都可以访问到容器中的内容abcd666
*/
System.out.println(sb); //abcd666
System.out.println(sb1); //abcd666
System.out.println(sb2); //abcd666
}
}
public class Demo4 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("HelloWorld");
/*
通过以下实验,我们发现了insert可插入的位置 从0到 索引+1
*/
// sb.insert(0, "Java"); //JavaHelloWorld
// sb.insert(1, "Java"); //HJavaelloWorld
// sb.insert(9, "Java"); //HelloWorlJavad
// sb.insert(10, "Java"); //HelloWorldJava
// sb.insert(11, "Java"); //运行报错。 StringIndexOutOfBoundsException
sb.insert(0, "Java").insert(0, "China").append("666"); //ChinaJavaHelloWorld666
System.out.println(sb);
}
}
删除功能
StringBuilder deleteCharAt(int index)
StringBuilder delete(int start, int end)
public class Demo5 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("HelloWorld");
//StringBuilder deleteCharAt(int index) 删除指定索引index处的字符
// sb.deleteCharAt(0);
// System.out.println(sb); //elloWorld
//StringBuilder delete(int start, int end) 删除从索引start开始到索引end结束中间的字符(包括start,但是不包括end)
sb.delete(2, 5);
System.out.println(sb); //HeWorld
}
}
替换和反转功能
StringBuilder replace(int start, int end, String str)
StringBuilder reverse()
public class Demo6 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("HelloWorld");
//StringBuilder replace(int start, int end, String str)
// sb.replace(2, 5, "China");
// System.out.println(sb); //HeChinaWorld
//StringBuilder reverse()
sb.reverse();
System.out.println(sb); //dlroWolleH
}
}
练习:
1. 用StringBuilder改进 将数组int[] arr = {11, 22, 33}; 遍历的结果封装成[11, 22, 33]并打印
2. 用StringBuilder改进,定义一个方法,实现字符串反转功能
public class Test {
public static void main(String[] args) {
int[] arr = {11, 22, 33};
//1. 先定义一个StringBuilder,用来存储结果
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i == arr.length-1){
sb.append(arr[i] + "]");
}else{
sb.append(arr[i] + ", ");
}
}
// 输出结果
System.out.println(sb);
}
}
public class Test2 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("abc");
System.out.println(reverseString(sb));
}
public static StringBuilder reverseString(StringBuilder sb){
return sb.reverse();
}
}
1.4 StringBuilder和StringBuffer之间的区别
StringBuilder和StringBuffer几乎是一样的。都有append及insert方法
区别:
StringBuiler是线程不安全的(不同步),效率高
StringBuffer是线程安全的 (同步),效率低
1.5 String和StringBuilder之间的区别
关于存储字符串的方式:
String:固定的常量
StringBuilder:可变的字符序列
出现的版本:
String:JDK1.0
StringBuilder:JDK1.5
1.6 String和StringBuilder之间的互相转换
String转为StringBuilder
1. 通过StringBuilder的构造方法 StringBuilder(String str)
String s = "abc";
// 方式一:通过StringBuilder的构造方法 StringBuilder(String str)
StringBuilder sb = new StringBuilder(s);
System.out.println(sb); //abc
将StringBuilder转为String
1. 通过String类型的构造方法 String(StringBuilder sb)
2. 通过StringBuilder的toString方法
public class Demo3 {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("abc");
// 方式一:通过String类型的构造方法 String(StringBuilder sb)
// String s = new String(sb);
// System.out.println(s);
// 方式二:通过StringBuilder的toString方法
String s = sb.toString();
System.out.println(s);
}
}
练习:
写一个方法,判断一个字符串是否是对称的。
如:字符串"abc" 不对称 字符串"abcba" 对称 字符串"1001" 对称
public class Test {
public static void main(String[] args) {
String s = "abc";
//1. 将String类型转为StringBuilder
StringBuilder sb = new StringBuilder(s);
//2. 使用StringBuilder类型的reverse方法反转
String ss = sb.reverse().toString();
//3. 用反转之后的字符串和反转之前的字符串比较
if(ss.equals(s)){
//如果相同,那么证明是对称的
System.out.println(s + "是对称的");
}else{
//如果不相同,那么证明是不对称的
System.out.println(s + "是不对称的");
}
}
}
1.7 String和StringBuilder当做参数传递
public class Test2 {
public static void main(String[] args) {
String s = "abc";
change(s);
System.out.println(s); //abc
System.out.println("------------");
StringBuilder sb = new StringBuilder();
sb.append("abc");
change(sb);
System.out.println(sb); //abcxyz
}
public static void change(String s){
s += "xyz";
System.out.println(s); //abcxyz
}
public static void change(StringBuilder sb){
sb.append("xyz");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6HLU16k3-1620344684864)(img/image-20210421154906803.png)]
二、包装类
2.1 为什么使用包装类
1. 如求int类型的最大值、求整数66的2进制、16进制等操作
2. 以后开发过程中,前台传数据给后端可能全是以字符串的形式,比如:"1949-10-1"、年龄 "30"。后台拿到这些字符串之后,有可能会需要将这些字符串转为整数类型。
以上场景都需要用到包装类。
2.2 概述
包装类就是对基本数据类型进行包装,给每一个基本数据类型都提供了一个对应的引用数据类型。既然是引用数据类型了,那么肯定会有构造方法,及其它方法。这些方法就可以解决很多问题。比如上面说的两大类常见问题。
基本数据类型 | 包装类类型(实际上就是引用数据类型) |
---|---|
byte | Byte |
short | Short |
int | Integer 【重要】 |
long | Long |
float | Float |
double | Double |
char | Character 【重要】 |
boolean | Boolean |
三、Integer类
Integer
类在对象中包装了一个基本类型int
的值。Integer类提供了多个方法,能在
int
类型和String
类型之间互相转换,还提供了处理int
类型时非常有用的其他一些常量和方法。
3.1 构造方法
Integer(int value)
Integer(String s)
public class Demo {
public static void main(String[] args) {
//Integer(int value)
// Integer i = new Integer(666);
// System.out.println(i);
//Integer(String s)
// Integer i = new Integer("666");
// System.out.println(i);
/*
Integer类的构造方法虽然可以接收字符串类型,但是只能接收整数的字符串类型
*/
Integer i = new Integer("1949-10-1"); //运行报错。
System.out.println(i);
}
}
3.2 常见方法
重要的方法:
int intValue()
static Integer valueOf(int i)
static int parseInt(String s)
不大重要的方法:
static String toBinaryString(int i)
static String toOctalString(int i)
static String toHexString(int i)
static String toString(int i, int radix)
String toString()
public class Demo2 {
public static void main(String[] args) {
Integer i = new Integer(666);
//int intValue() 将Integer类型的数字转为基本数据类型int
// int ii = i.intValue();
// System.out.println(ii); //666
//static Integer valueOf(int i) 将整数从基本数据类型int转为引用数据类型Integer
// Integer ii = Integer.valueOf(666);
// System.out.println(ii); //666
//static int parseInt(String s) 将字符串类型的数字转为int类型
int ii = Integer.parseInt("666");
System.out.println(ii); //666
}
}
public class Demo3 {
public static void main(String[] args) {
//static String toBinaryString(int i) 将整数转为二进制
// System.out.println(Integer.toBinaryString(66)); //1000010
//static String toOctalString(int i) 将整数转为八进制
// System.out.println(Integer.toOctalString(66)); //102
//static String toHexString(int i) 将整数转为十六进制
// System.out.println(Integer.toHexString(66)); //42
//static String toString(int i, int radix)
/*
通过探究,发现目前的进制范围为:2-36进制
*/
System.out.println(Integer.toString(66, 36)); //1u
//String toString() 将Integer类型转为String类型
Integer i = new Integer(66);
System.out.println(i.toString());
}
}
3.3 常见常量
static int MAX_VALUE 它表示 int 类型能够表示的最大值
static int MIN_VALUE 它表示 int 类型能够表示的最小值
public class Demo4 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE); //2147483647
System.out.println(Integer.MIN_VALUE); //-2147483648
}
}
n(Integer.toString(66, 36)); //1u
//String toString() 将Integer类型转为String类型
Integer i = new Integer(66);
System.out.println(i.toString());
}
}
3.3 常见常量
static int MAX_VALUE 它表示 int 类型能够表示的最大值
static int MIN_VALUE 它表示 int 类型能够表示的最小值
public class Demo4 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE); //2147483647
System.out.println(Integer.MIN_VALUE); //-2147483648
}
}