java-常用类

公告

View Post

第十章 java常用类

包装类

引入

【1】什么是包装类：

以前定义变量，经常使用基本数据类型，

对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，

将基本数据类型对应进行了一个封装，产生了一个新的类，---》包装类。

int,byte.....--->基本数据类型

包装类--->引用数据类型

【2】对应关系：

基本数据类型对应的包装类继承关系

byte Byte ---》Number---》Object

short Short ---》Number---》Object

int Integer ---》Number---》Object

long Long ---》Number---》Object

float Float ---》Number---》Object

double Double ---》Number---》Object

char Character Object

boolean Boolean Object

【3】已经有基本数据类型了，为什么要封装为包装类？

（1）java语言面向对象的语言，最擅长的操作各种各样的类。

（2）以前学习装数据的---》数组，int[] String[] double[] Student[]

以后学习的装数据的---》集合，有一个特点，只能装引用数据类型的数据

【4】是不是有了包装类以后就不用基本数据类型了？

不是。

Integer

【1】直接使用，无需导包：

【2】类的继承关系：

【3】实现接口：

【4】这个类被final修饰，那么这个类不能有子类，不能被继承：

【5】包装类是对基本数据类型的封装：对int类型封装产生了Integer

【6】类的历史：

【7】属性：

1         //属性：
2         System.out.println(Integer.MAX_VALUE);
3         System.out.println(Integer.MIN_VALUE);
4         //“物极必反”原理：
5         System.out.println(Integer.MAX_VALUE+1);
6         System.out.println(Integer.MIN_VALUE-1);

【8】构造器（发现没有空参构造器）

（1）int类型作为构造器的参数：

Integer i1 = new Integer(12);

（2）String类型作为构造器的参数：

Integer i2 = new Integer("12");

Integer i3 = new Integer("abcdef");

【9】包装类特有的机制：自动装箱自动拆箱：

1         //自动装箱：int--->Integer
2         Integer i = 12;
3         System.out.println(i);
4         //自动拆箱：Integer--->int
5         Integer i2 = new Integer(12);
6         int num = i2;
7         System.out.println(num);

（1）自动装箱自动拆箱是从JDK1.5以后新出的特性

（2）自动装箱自动拆箱：将基本数据类型和包装类进行快速的类型转换。

验证：

可以自定打断点测试是否走入valueOf方法中：

【10】常用方法：

valueOf方法的底层：

 1 public class Test04 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         //compareTo：只返回三个值：要么是0,-1,1
 5         Integer i1 = new Integer(6);
 6         Integer i2 = new Integer(12);
 7         System.out.println(i1.compareTo(i2));// return (x < y) ? -1 : ((x == y) ? 0 : 1);
 8         //equals:Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。
 9         //Integer对象是通过new关键字创建的对象：
10         Integer i3 = new Integer(12);
11         Integer i4 = new Integer(12);
12         System.out.println(i3 == i4);//false 因为==比较的是两个对象的地址
13         boolean flag = i3.equals(i4);
14         System.out.println(flag);
15         //Integer对象通过自动装箱来完成：
16         Integer i5 = 130;
17         Integer i6 = 130;
18         System.out.println(i5.equals(i6));//true
19         System.out.println(i5 == i6);
20         /*
21         如果自动装箱值在-128~127之间，那么比较的就是具体的数值
22         否在，比较的就是对象的地址
23          */
24         //intValue() :作用将Integer--->int
25         Integer i7 = 130;
26         int i = i7.intValue();
27         System.out.println(i);
28         //parseInt(String s) :String--->int:
29         int i8 = Integer.parseInt("12");
30         System.out.println(i8);
31         //toString:Integer--->String
32         Integer i10 = 130;
33         System.out.println(i10.toString());
34     }
35 }

日期相关的类

java.util.Date

 1 package com.llh;
 2 
 3 import java.util.Date;
 4 
 5 
 6 public class Test {
 7     //这是一个main方法，是程序的入口：
 8     public static void main(String[] args) {
 9         //java.util.Date:
10         Date d = new Date();
11         System.out.println(d);
12         System.out.println(d.toString());
13         System.out.println(d.toGMTString());//过期方法，过时方法，废弃方法。
14         System.out.println(d.toLocaleString());
15         System.out.println(d.getYear());//120+1900=2020
16         System.out.println(d.getMonth());//5 :返回的值在 0 和 11 之间，值 0 表示 1 月。
17         //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
18         System.out.println(d.getTime());//1592055964263
19         System.out.println(System.currentTimeMillis());
20         /*
21         （1）疑问：以后获取时间差用：getTime()还是currentTimeMillis()
22         答案：currentTimeMillis()--》因为这个方法是静态的，可以类名.方法名直接调用
23         （2）public static native long currentTimeMillis();
24         本地方法
25         为什么没有方法体？因为这个方法的具体实现不是通过java写的。
26         （3）这个方法的作用：
27         一般会去衡量一些算法所用的时间
28          */
29         long startTime = System.currentTimeMillis();
30         for (int i = 0; i < 100000; i++) {
31             System.out.println(i);
32         }
33         long endTime = System.currentTimeMillis();
34         System.out.println(endTime-startTime);
35     }
36 }

java.sql.Date

 1 package com.llh;
 2 
 3 import java.util.Date;
 4 
 5 
 6 public class Test02 {
 7     //这是一个main方法，是程序的入口：
 8     public static void main(String[] args) {
 9         //java.sql.Date:
10         Date d = new Date(1592055964263L);
11         System.out.println(d);
12         /*
13         (1)java.sql.Date和java.util.Date的区别：
14         java.util.Date：年月日  时分秒
15         java.sql.Date：年月日
16         (2)java.sql.Date和java.util.Date的联系：
17         java.sql.Date(子类) extends java.util.Date （父类）
18          */
19         //java.sql.Date和java.util.Date相互转换：
20         //【1】util--->sql:
21         java.util.Date date = new Date(1592055964263L);//创建util.Date的对象
22         //方式1：向下转型
23         Date date1 = (Date) date;
24         /*
25         父类：Animal 子类：Dog
26         Animal an = new Dog();
27         Dog d = (Dog)an;
28          */
29         //方式2：利用构造器
30         Date date2 = new Date(date.getTime());
31         //【2】sql-->util:
32         java.util.Date date3 = d;
33         //[3]String--->sql.Date:
34         Date date4 =  Date.valueOf("2019-3-8");
35     }
36 }

SimpleDateFormat

【1】String---》java.util.Date 类型转换：

分解：

（1）String--->java.sql.Date

（2）java.sql.Date--->java.util.Date

 1 public class Test04 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         //（1）String--->java.sql.Date
 5         java.sql.Date date = java.sql.Date.valueOf("2015-9-24");
 6         //（2）java.sql.Date--->java.util.Date
 7         java.util.Date date2 = date;
 8         System.out.println(date2.toString());
 9     }
10 }

上面的代码有局限性，字符串的格式只能是年-月-日拼接的形式，换成其它类型，就会出现异常：

【2】引入新的类：SimpleDateFormat

 1 package com.llh;
 2 
 3 import java.text.DateFormat;
 4 import java.text.ParseException;
 5 import java.text.SimpleDateFormat;
 6 import java.util.Date;
 7 
 8 public class Test05 {
 9     //这是一个main方法，是程序的入口：
10     public static void main(String[] args) {
11         //日期转换：
12         //SimpleDateFormat(子类) extends DateFormat（父类是一个抽象类）
13         //格式化的标准已经定义好了：
14         DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
15         //String--->Date
16         try {
17             Date d = df.parse("2019-4-6 12:23:54");
18             System.out.println(d);
19         } catch (ParseException e) {
20             e.printStackTrace();
21         }
22         //Date--->String
23         String format = df.format(new Date());
24         System.out.println(format);
25         Date date = new Date();
26         System.out.println(date.toString());
27         System.out.println(date.toGMTString());
28         System.out.println(date.toLocaleString());
29     }
30 }

【3】日期格式：

Calendar

 1 package com.llh;
 2 
 3 import java.text.DateFormat;
 4 import java.text.ParseException;
 5 import java.text.SimpleDateFormat;
 6 import java.util.Date;
 7 
 8 import java.util.Calendar;
 9 import java.util.GregorianCalendar;
10 
11 public class Test06 {
12     //这是一个main方法，是程序的入口：
13     public static void main(String[] args) {
14         //Calendar是一个抽象类，不可以直接创建对象
15         //GregorianCalendar()子类 extends Calendar（父类是一个抽象类）
16         Calendar cal = new GregorianCalendar();
17         Calendar cal2 = Calendar.getInstance();
18         System.out.println(cal);
19         //常用的方法：
20         // get方法，传入参数：Calendar中定义的常量
21         System.out.println(cal.get(Calendar.YEAR));
22         System.out.println(cal.get(Calendar.MONTH));
23         System.out.println(cal.get(Calendar.DATE));
24         System.out.println(cal.get(Calendar.DAY_OF_WEEK));
25         System.out.println(cal.getActualMaximum(Calendar.DATE));//获取当月日期的最大天数
26         System.out.println(cal.getActualMinimum(Calendar.DATE));//获取当月日期的最小天数
27         // set方法：可以改变Calendar中的内容
28         cal.set(Calendar.YEAR,1990);
29         cal.set(Calendar.MONTH,3);
30         cal.set(Calendar.DATE,16);
31         System.out.println(cal);
32         //String--->Calendar:
33         //分解：
34         //String--->java.sql.Date:
35         java.sql.Date date = java.sql.Date.valueOf("2020-4-5");
36         //java.sql.Date-->Calendar:
37         cal.setTime(date);
38         System.out.println(cal);
39     }
40 }

练习

需求：

 1 package com.llh;
 2 
 3 import java.util.Calendar;
 4 import java.util.Scanner;
 5 
 6 public class Test08 {
 7     //这是一个main方法，是程序的入口：
 8     public static void main(String[] args) {
 9         //录入日期的String：
10         Scanner sc = new Scanner(System.in);
11         System.out.print("请输入你想要查看的日期：（提示：请按照例如2012-5-6的格式书写）");
12         String strDate = sc.next();
13         /*System.out.println(strDate);*/
14         //String--->Calendar:
15         //String-->Date:
16         java.sql.Date date = java.sql.Date.valueOf(strDate);
17         //Date--->Calendar:
18         Calendar cal = Calendar.getInstance();
19         cal.setTime(date);
20         //后续操作：
21         //星期提示：
22         System.out.println("日\t一\t二\t三\t四\t五\t六\t");
23         //获取本月的最大天数：
24         int maxDay = cal.getActualMaximum(Calendar.DATE);
25         //获取当前日期中的日：
26         int nowDay = cal.get(Calendar.DATE);
27         //将日期调为本月的1号：
28         cal.set(Calendar.DATE,1);
29         //获取这个一号是本周的第几天：
30         int num = cal.get(Calendar.DAY_OF_WEEK);
31         /*System.out.println(num);*/
32         //前面空出来的天数为：
33         int day = num - 1;
34         //引入一个计数器：
35         int count = 0;//计数器最开始值为0
36         //在日期前将空格打印出来：
37         for (int i = 1; i <= day; i++) {
38             System.out.print("\t");
39         }
40         //空出来的日子也要放入计数器：
41         count = count + day;
42         //遍历：从1号开始到maxDay号进行遍历：
43         for (int i = 1; i <= maxDay ; i++) {
44             if(i == nowDay){//如果遍历的i和当前日子一样的话，后面多拼一个*
45                 System.out.print(i+"*"+"\t");
46             }else{
47                 System.out.print(i+"\t");
48             }
49             count++;//每在控制台输出一个数字，计数器做加1操作
50             if(count%7 == 0){//当计数器的个数是7的倍数的时候，就换行操作
51                 System.out.println();
52             }
53         }
54     }
55 }

JDK1.8新增日期时间API

引入

JDK1.0中使用java.util.Date类 --》第一批日期时间API

JDK1.1引入Calendar类 --》第二批日期时间API

缺陷：

可变性 : 像日期和时间这样的类应该是不可变的。

偏移性 : Date中的年份是从1900开始的，而月份都从0开始。

格式化 : 格式化只对Date有用，Calendar则不行。

JDK1.8新增日期时间API --》第三批日期时间API

LocalDate/LocalTime/LocalDateTime

 1 package com.llh;
 2 
 3 import java.time.LocalDate;
 4 import java.time.LocalDateTime;
 5 import java.time.LocalTime;
 6 /**
 7  * @Auther: msb-zhaoss
 8  */
 9 public class Test09 {
10     //这是一个main方法，是程序的入口：
11     public static void main(String[] args) {
12         //1.完成实例化：
13         //方法1：now()--获取当前的日期，时间，日期+时间
14         LocalDate localDate = LocalDate.now();
15         System.out.println(localDate);
16         LocalTime localTime = LocalTime.now();
17         System.out.println(localTime);
18         LocalDateTime localDateTime = LocalDateTime.now();
19         System.out.println(localDateTime);
20         //方法2：of()--设置指定的日期，时间，日期+时间
21         LocalDate of = LocalDate.of(2010, 5, 6);
22         System.out.println(of);
23         LocalTime of1 = LocalTime.of(12, 35, 56);
24         System.out.println(of1);
25         LocalDateTime of2 = LocalDateTime.of(1890, 12, 23, 13, 24, 15);
26         System.out.println(of2);
27         //LocalDate,LocalTime用的不如LocalDateTime多
28         //下面讲解用LocalDateTime：
29         //一些列常用的get***
30         System.out.println(localDateTime.getYear());//2020
31         System.out.println(localDateTime.getMonth());//JUNE
32         System.out.println(localDateTime.getMonthValue());//6
33         System.out.println(localDateTime.getDayOfMonth());//14
34         System.out.println(localDateTime.getDayOfWeek());//SUNDAY
35         System.out.println(localDateTime.getHour());//22
36         System.out.println(localDateTime.getMinute());//22
37         System.out.println(localDateTime.getSecond());//6
38         //不是set方法，叫with
39         //体会：不可变性
40         LocalDateTime localDateTime2 = localDateTime.withMonth(8);
41         System.out.println(localDateTime);
42         System.out.println(localDateTime2);
43         //提供了加减的操作：
44         //加：
45         LocalDateTime localDateTime1 = localDateTime.plusMonths(4);
46         System.out.println(localDateTime);
47         System.out.println(localDateTime1);
48         //减：
49         LocalDateTime localDateTime3 = localDateTime.minusMonths(5);
50         System.out.println(localDateTime);
51         System.out.println(localDateTime3);
52     }
53 }

DateTimeFormatter

 1 package com.llh;
 2 
 3 import java.time.LocalDateTime;
 4 import java.time.format.DateTimeFormatter;
 5 import java.time.format.FormatStyle;
 6 import java.time.temporal.TemporalAccessor;
 7 /**
 8  * @Auther: msb-zhaoss
 9  */
10 public class Test10 {
11     //这是一个main方法，是程序的入口：
12     public static void main(String[] args) {
13         //格式化类：DateTimeFormatter
14         //方式一:预定义的标准格式。如: ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;IS0_LOCAL_TIME
15         DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
16         //df1就可以帮我们完成LocalDateTime和String之间的相互转换：
17         //LocalDateTime-->String:
18         LocalDateTime now = LocalDateTime.now();
19         String str = df1.format(now);
20         System.out.println(str);//2020-06-15T15:02:51.29
21         //String--->LocalDateTime
22         TemporalAccessor parse = df1.parse("2020-06-15T15:02:51.29");
23         System.out.println(parse);
24         //方式二:本地化相关的格式。如: oflocalizedDateTime()
25         //参数：FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT
26         //FormatStyle.LONG :2020年6月15日 下午03时17分13秒
27         //FormatStyle.MEDIUM: 2020-6-15 15:17:42
28         //FormatStyle.SHORT:20-6-15 下午3:18
29         DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
30         //LocalDateTime-->String:
31         LocalDateTime now1 = LocalDateTime.now();
32         String str2 = df2.format(now1);
33         System.out.println(str2);
34         //String--->LocalDateTime
35         TemporalAccessor parse1 = df2.parse("20-6-15 下午3:18");
36         System.out.println(parse1);
37         //方式三: 自定义的格式。如: ofPattern( "yyyy-MM-dd hh:mm:ss") ---》重点，以后常用
38         DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
39         //LocalDateTime-->String:
40         LocalDateTime now2 = LocalDateTime.now();
41         String format = df3.format(now2);
42         System.out.println(format);//2020-06-15 03:22:03
43         //String--->LocalDateTime
44         TemporalAccessor parse2 = df3.parse("2020-06-15 03:22:03");
45         System.out.println(parse2);
46     }
47 }

Math类

【1】直接使用，无需导包：

【2】final修饰类，这个类不能被继承：

【3】构造器私有化，不能创建Math类的对象：

不能：

【4】Math内部的所有的属性，方法都被static修饰：类名.直接调用，无需创建对象：

【5】常用方法：

 1 public class Test01 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         //常用属性：
 5         System.out.println(Math.PI);
 6         //常用方法：
 7         System.out.println("随机数："+Math.random());//[0.0,1.0)
 8         System.out.println("绝对值："+Math.abs(-80));
 9         System.out.println("向上取值："+Math.ceil(9.1));
10         System.out.println("向下取值："+Math.floor(9.9));
11         System.out.println("四舍五入："+Math.round(3.5));
12         System.out.println("取大的那个值："+Math.max(3, 6));
13         System.out.println("取小的那个值："+Math.min(3, 6));
14     }
15 }

【6】静态导入：

 1 package com.llh;
 2 
 3 //静态导入：
 4 import static java.lang.Math.*;
 5 
 6 public class Test01 {
 7     //这是一个main方法，是程序的入口：
 8     public static void main(String[] args) {
 9         //常用属性：
10         System.out.println(PI);
11         //常用方法：
12         System.out.println("随机数："+random());//[0.0,1.0)
13         System.out.println("绝对值："+abs(-80));
14         System.out.println("向上取值："+ceil(9.1));
15         System.out.println("向下取值："+floor(9.9));
16         System.out.println("四舍五入："+round(3.5));
17         System.out.println("取大的那个值："+max(3, 6));
18         System.out.println("取小的那个值："+min(3, 6));
19     }
20     //如果跟Math中方法重复了，那么会优先走本类中的方法（就近原则）
21     public static int random(){
22         return 100;
23     }
24 }

Random类

 1 package com.llh;
 2 
 3 import java.util.Random;
 4 
 5 public class Test02 {
 6     //这是一个main方法，是程序的入口：
 7     public static void main(String[] args) {
 8         //返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
 9         System.out.println("随机数："+Math.random());
10         //学习Random类
11         //（1）利用带参数的构造器创建对象：
12         Random r1 = new Random(System.currentTimeMillis());
13         int i = r1.nextInt();
14         System.out.println(i);
15         //（2）利用空参构造器创建对象：
16         Random r2 = new Random();//表面是在调用无参数构造器，实际底层还是调用了带参构造器
17         System.out.println(r2.nextInt(10));//在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
18         System.out.println(r2.nextDouble());//在 0.0 和 1.0 之间均匀分布的 double 值。
19     }
20 }

String类

【1】直接使用，无需导包：

【2】形象说一下字符串：

【3】

String str = “abc”;

"abc"就是String类下的一个具体的对象

【4】字符串是不可变的：

【5】这个String类不可以被继承，不能有子类：

【6】String底层是一个char类型的数组

验证：

常用方法

【1】构造器：底层就是给对象底层的value数组进行赋值操作。

1          //通过构造器来创建对象：
2         String s1 = new String();
3         String s2 = new String("abc");
4         String s3 = new String(new char[]{'a','b','c'});

【3】常用方法：

1         String s4 = "abc";
2         System.out.println("字符串的长度为："+s4.length());
3         String s5 = new SZtring("abc");
4         System.out.println("字符串是否为空："+s5.isEmpty());
5         System.out.println("获取字符串的下标对应的字符为："+s5.charAt(1));

【4】equals:

1         String s6 = new String("abc");
2         String s7 = new String("abc");
3         System.out.println(s6.equals(s7));

【5】String类实现了Comparable，里面有一个抽象方法叫compareTo，所以String中一定要对这个方法进行重写：4

1         String s8 = new String("abc");
2         String s9 = new String("abc");
3         System.out.println(s8.compareTo(s9));

【6】常用方法：

 1         //字符串的截取：
 2         String s10 = "abcdefhijk";
 3         System.out.println(s10.substring(3));
 4         System.out.println(s10.substring(3, 6));//[3,6)
 5         //字符串的合并/拼接操作：
 6         System.out.println(s10.concat("pppp"));
 7         //字符串中的字符的替换：
 8         String s11 = "abcdeahija";
 9         System.out.println(s11.replace('a', 'u'));
10         //按照指定的字符串进行分裂为数组的形式：
11         String s12 = "a-b-c-d-e-f";
12         String[] strs = s12.split("-");
13         System.out.println(Arrays.toString(strs));
14         //转大小写的方法：
15         String s13 = "abc";
16         System.out.println(s13.toUpperCase());
17         System.out.println(s13.toUpperCase().toLowerCase());
18         //去除收尾空格：
19         String s14 = "    a  b  c    ";
20         System.out.println(s14.trim());
21         //toString()
22         String s15 = "abc";
23         System.out.println(s15.toString());
24         //转换为String类型：
25         System.out.println(String.valueOf(false));

String的内存分析

【1】字符串拼接：

 1 public class Test02 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         String s1 = "a"+"b"+"c";
 5         String s2 = "ab"+"c";
 6         String s3 = "a"+"bc";
 7         String s4 = "abc";
 8         String s5 = "abc"+"";
 9     }
10 }

上面的字符串，会进行编译器优化，直接合并成为完整的字符串，我们可以反编译验证：

然后在常量池中，常量池的特点是第一次如果没有这个字符串，就放进去，如果有这个字符串，就直接从常量池中取：

内存：

【2】new关键字创建对象：

String s6 = new String("abc");

内存：开辟两个空间（1.字符串常量池中的字符串 2.堆中的开辟的空间）

【3】有变量参与的字符串拼接：

1 public class Test03 {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         String a = "abc";
5         String b = a + "def";
6         System.out.println(b);
7     }
8 }

a变量在编译的时候不知道a是“abc”字符串，所以不会进行编译期优化，不会直接合并为“abcdef”

反汇编过程：为了更好的帮我分析字节码文件是如何进行解析的：

利用IDEA中的控制台：

StringBuilder类

【1】字符串的分类：

（1）不可变字符串：String

（2）可变字符串：StringBuilder，StringBuffer

疑问：

（1）可变不可变？？

（2）本节课重点：StringBuilder -----》√

（3）StringBuilder和StringBuffer区别？？

【2】StringBuilder底层：非常重要的两个属性：

【3】对应内存分析：

 1 public class Test01 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         //创建StringBuilder的对象：
 5         StringBuilder sb3 = new StringBuilder();
 6         //表面上调用StringBuilder的空构造器，实际底层是对value数组进行初始化，长度为16
 7         StringBuilder sb2 = new StringBuilder(3);
 8         //表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层就是对value数组进行初始化，长度为你传入的数字
 9         StringBuilder sb = new StringBuilder("abc");
10         System.out.println(sb.append("def").append("aaaaaaaa").append("bbb").append("ooooooo").toString());;//链式调用方式：return this
11     }
12 }

解释可变和不可变字符串

【1】String---》不可变

【2】StringBuilder---》可变

可变，在StringBuilder这个对象的地址不变的情况下，想把“abc”变成“abcdef”是可能的，直接追加即可

1 public class Test02 {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         StringBuilder sb = new StringBuilder();
5         System.out.println(sb.append("abc")==sb.append("def"));//true
6     }
7 }

常用方法

【1】StringBuilder常用方法：

 1 public class Test03 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         StringBuilder sb=new StringBuilder("nihaojavawodeshijie");
 5         //增
 6         sb.append("这是梦想");
 7         System.out.println(sb);//nihaojavawodeshijie这是梦想
 8         //删
 9         sb.delete(3, 6);//删除位置在[3,6)上的字符
10         System.out.println(sb);//nihavawodeshijie这是梦想
11         sb.deleteCharAt(16);//删除位置在16上的字符
12         System.out.println(sb);//nihavawodeshijie是梦想
13         //改-->插入
14         StringBuilder sb1=new StringBuilder("$23445980947");
15         sb1.insert(3, ",");//在下标为3的位置上插入 ,
16         System.out.println(sb1);
17         StringBuilder sb2=new StringBuilder("$2你好吗5980947");
18         //改-->替换
19         sb2.replace(3, 5, "我好累");//在下标[3,5)位置上插入字符串
20         System.out.println(sb2);
21         sb.setCharAt(3, '!');
22         System.out.println(sb);
23         //查
24         StringBuilder sb3=new StringBuilder("asdfa");
25         for (int i = 0; i < sb3.length(); i++) {
26             System.out.print(sb3.charAt(i)+"\t");
27         }
28         System.out.println();
29         //截取
30         String str=sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
31         System.out.println(str);
32         System.out.println(sb3);
33     }
34 }

【2】StringBuffer常用方法：

 1 public class Test03 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         StringBuffer sb=new StringBuffer("nihaojavawodeshijie");
 5         //增
 6         sb.append("这是梦想");
 7         System.out.println(sb);//nihaojavawodeshijie这是梦想
 8         //删
 9         sb.delete(3, 6);//删除位置在[3,6)上的字符
10         System.out.println(sb);//nihavawodeshijie这是梦想
11         sb.deleteCharAt(16);//删除位置在16上的字符
12         System.out.println(sb);//nihavawodeshijie是梦想
13         //改-->插入
14         StringBuilder sb1=new StringBuilder("$23445980947");
15         sb1.insert(3, ",");//在下标为3的位置上插入 ,
16         System.out.println(sb1);
17         StringBuilder sb2=new StringBuilder("$2你好吗5980947");
18         //改-->替换
19         sb2.replace(3, 5, "我好累");//在下标[3,5)位置上插入字符串
20         System.out.println(sb2);
21         sb.setCharAt(3, '!');
22         System.out.println(sb);
23         //查
24         StringBuilder sb3=new StringBuilder("asdfa");
25         for (int i = 0; i < sb3.length(); i++) {
26             System.out.print(sb3.charAt(i)+"\t");
27         }
28         System.out.println();
29         //截取
30         String str=sb3.substring(2,4);//截取[2,4)返回的是一个新的String，对StringBuilder没有影响
31         System.out.println(str);
32         System.out.println(sb3);
33     }
34 }

面试题：String，StringBuilder，StringBuffer区别和联系

String、StringBuffer、StringBuilder区别与联系

1. String类是不可变类，即一旦一个String对象被创建后，包含在这个对象中的字符序列是不可改变的，直至这个对象销毁。

2. StringBuffer类则代表一个字符序列可变的字符串，可以通过append、insert、reverse、setChartAt、setLength等方法改变其内容。一旦生成了最终的字符串，调用toString方法将其转变为String

3. JDK1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和方法基本相同。不同是StringBuffer是线程安全的，而StringBuilder是线程不安全的，所以性能略高。通常情况下，创建一个内容可变的字符串，应该优先考虑使用StringBuilder

StringBuilder:JDK1.5开始效率高线程不安全

StringBuffer:JDK1.0开始效率低线程安全

posted on 2023-11-12 21:54 索静丨LLH 阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部