# 9.Java-常用类

最新推荐文章于 2025-04-07 15:52:16 发布

码农碎碎念

最新推荐文章于 2025-04-07 15:52:16 发布

阅读量151

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_29294165/article/details/120653292

版权

java 专栏收录该内容

29 篇文章

订阅专栏

一、包装类

1. 包装类说明

将基本类型进行封装成一个新的类，叫包装类
基本数据类型->基本类型
包装类->引用类型
基本类型和包装类的对象关系

基本类型          对应的包装类       继承关系
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

已经有了基本数据类型，为什么还要封装包装类？
（1）java语言面向对象的语言，最擅长操作各种各样的类。
（2）以前虚的装数据的–>数组，int[] String[] double[]
以后学习的装数据的–>集合，特点：只能装引用数据类型
是不是有个包装类就不用基本类型了
不是。基本类型操作方便，定义数据类型方便。

2. Integer 类学习

1. 属性

package com.fj.common.packing;

public class Demo01 {
    public static void main(String[] args) {
        //属性
        System.out.println("最大值：" + Integer.MAX_VALUE);
        System.out.println("最小值：" + Integer.MIN_VALUE);
        //物极必反
        System.out.println(Integer.MAX_VALUE + 1);// 最大+1成最小值 -2147483648
        System.out.println(Integer.MIN_VALUE - 1);//最小-1成最大值2147483647
    }
}

结果：

最大值：2147483647
最小值：-2147483648
-2147483648
2147483647

2. 构造器

没有空的构造器

package com.fj.common.packing;

public class Demo02 {
    public static void main(String[] args) {
        //构造器
        Integer i1 = new Integer(12);
        System.out.println(i1.toString());//12
        Integer i2 = new Integer("12");
        System.out.println(i2);//12 把string转为int进行处理
    }
}

3. 包装类特有的机制：自动装箱自动拆箱

说明：就是将基本类型和包装类进行快速的转换

package com.fj.common.packing;

public class Demo03 {
    public static void main(String[] args) {
        // 自动装箱  int 转为了Integer
        Integer i = 12;
        System.out.println(i);
        // 自动拆箱
        Integer i2 = new Integer(12);
        int num = i2;
        System.out.println(num);
    }
}

4. 方法

package com.fj.common.packing;

public class Demo04 {
    public static void main(String[] args) {
        //比对方法compareTo i1>i2 = 1   i1 < i2 = -1   i1 == i2 = 0,比较数值
        Integer i1 = new Integer(23);
        Integer i2 = new Integer(23);
        System.out.println(i1.compareTo(i2));
        //equals: Inteeger对Object 中的equals方法进行了重写，比较的是底层封装的那个value的值
        //Integer 对象是通过new关键字创建的对象
        Integer i3 = new Integer(23);
        Integer i4 = new Integer(23);
        System.out.println(i3 == i4);//false 因为== 比较的是两个对象的地址
        System.out.println(i3.equals(i4));//true 重写，比较的是值
        // Integer 对象通过自动装箱来完成：
        Integer i5 = 130;
        Integer i6 = 130;
        System.out.println(i5.equals(i6));//true
        System.out.println(i5 == i6);//12 true  130 false
        /*
         如果自动装箱的值在-128~127之间，那么比较的就是具体的数值
         否则，比较的就是对象的地址
         */
        //intValue() 将Integer转换为int
        Integer i7 = 130;
        int i8 = i7.intValue();
        System.out.println(i8);
        //parseInt 吧字符串转为int
        int i9=Integer.parseInt("12");
        System.out.println(i9);
        //toString():将int转为string
        Integer i10=120;
        System.out.println(i10.toString());
    }
}

二、日期相关类

1. java.util.Date

package com.fj.common.date;

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);//Fri Oct 08 17:19:28 CST 2021
        System.out.println(d.toString());//Fri Oct 08 17:19:28 CST 2021
        System.out.println(d.toGMTString());//8 Oct 2021 09:19:28 GMT 过期方法，过时方法，废弃方法
        System.out.println(d.toLocaleString());//2021年10月8日 下午5:20:43
        System.out.println(d.getYear());//121 121+1900=2021
        System.out.println(d.getMonth());//9  返回的值在0-11之间，0表示一月
        System.out.println(d.getTime());//毫秒数 1633685052070
        System.out.println(System.currentTimeMillis());//1633685171738
        /*疑问：以后获取时间差用getTime()还是currentTimeMillis()
         答案 是currentTimeMillis 因为这个方法是静态的，可以类名.方法名直接调用，本地方法，没有方法体，这个方法不是通过java
         作用：计算时间差
         以下实例
        */

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }
}

2. java.sql.Date

（1）java.sql.Date 和java.util.Date区别
java.util.Date：年月日时分秒
java.sql.Date：年月日
（2）java.sql.Date 和java.util.Date联系
java.sql.Date(子类) extends java.util.Date(父类)
（3）java.sql.Date 和java.util.Date转换

package com.fj.common.date;

import java.sql.Date;

/**
 * java.sql.Date;
 */
public class Demo02 {
    public static void main(String[] args) {
        java.util.Date ud = new java.util.Date();
        System.out.println(ud.getTime());//毫秒数 1633685052070
        System.out.println("==================================");
        //java.sql.Date 没有空构造器，必须传入long date数据,用以上代码获取
        Date d = new Date(1633685052070L);
        System.out.println(d);
        /**
         *  （1）java.sql.Date 和java.util.Date区别
         *           java.util.Date：年月日  时分秒
         *           java.sql.Date： 年月日
         *  （2）java.sql.Date 和java.util.Date联系
         *           java.sql.Date(子类) extends  java.util.Date(父类)
         * （3）java.sql.Date 和java.util.Date转换
         */
        //【1】util-->sql util转为sql类型
        java.util.Date date = new java.util.Date();//创建util.Date的对象
        //方式1：向下转型  sql-->util  Date date1是sql  (Date) date是util ,util转为sql类型
        Date date1 = (Date) date;
        //方式2：利用构造器   Date date2是sql  date.getTime()是util,util转为sql类型
        Date date2 = new Date(date.getTime());
        //【2】sql -->util  sql 转为util 小向大转，直接赋值
         java.util.Date date3 = d;
    }
}

3. string 最终转为java.util.Date

前端输入的日期字符串转为java.sql.Date ，java.util.Date
弊端：有局限性，字符串格式必须是年-月-日，用-拼接，换成其他类型，会异常

package com.fj.common.date;

public class Demo03 {
    public static void main(String[] args) {
        // string -->java.sql.Date ,有局限性，字符串格式必须是年-月-日，用-拼接，换成其他类型，会异常
        java.sql.Date date = java.sql.Date.valueOf("2015-9-24");
        // java.sql.Date --->java.util.Date
        java.util.Date date1 =date;
        System.out.println(date1.toString());
    }
}

4. SimpleDateFormat

SimpleDateFormat(子类) extends DateFormat(父类是一个抽象类)

在这里插入图片描述

package com.fj.common.date;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo04 {
    public static void main(String[] args) throws ParseException {
        //日期转换
        //SimpleDateFormat(子类) extends  DateFormat(父类是一个抽象类)
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //string ->date
        try {
            Date d =df.parse("2019-12-24 12:23:12");
            System.out.println(d);
        }catch (ParseException e){
            e.printStackTrace();
        }
        // date->string
        String format = df.format(new Date());
        System.out.println(format);

    }
}

5.日历Calendar类

学习

package com.fj.common.date;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Demo05 {
    public static void main(String[] args) {
        //Calendar 是一个抽象类，不可以直接创建对象，可以用他的子类
        //GregorianCalendar(子类) extends Calendar(父类，抽象类)
        Calendar cal = new GregorianCalendar();
        //通过调用getInstance可以看创建Calendar
        Calendar cal2 = Calendar.getInstance();
        //java.util.GregorianCalendar[time=1633747163194,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=9,WEEK_OF_YEAR=41,WEEK_OF_MONTH=2,DAY_OF_MONTH=9,DAY_OF_YEAR=282,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=2,AM_PM=0,HOUR=10,HOUR_OF_DAY=10,MINUTE=39,SECOND=23,MILLISECOND=194,ZONE_OFFSET=28800000,DST_OFFSET=0]
        System.out.println(cal);
        System.out.println(cal2);
        //常用的方法；
        System.out.println(cal.get(Calendar.YEAR));//2021
        System.out.println(cal.get(Calendar.MONTH));//从0开始 9
        System.out.println(cal.get(Calendar.DATE));//9
        System.out.println(cal.get(Calendar.DAY_OF_WEEK));//从周日开始算
        //获取当月日期最大天数
        System.out.println(cal.getActualMaximum(Calendar.DATE));
        //获取当月日期最小天数
        System.out.println(cal.getActualMinimum(Calendar.DATE));
        //set方法
        cal.set(Calendar.YEAR,1999);
        cal.set(Calendar.DATE,3);
        cal.set(Calendar.MONTH,5);
        System.out.println(cal);

        //string-->calendar
        //string -->data
        java.sql.Date date3 = java.sql.Date.valueOf("2021-10-09");
        cal.setTime(date3);
        System.out.println(cal);

    }
}

练习题

package com.fj.common.date;

import java.util.Calendar;
import java.util.Scanner;

//打印日历
public class Demo06 {
    public static void main(String[] args) {
        //录入日期的String
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要查看的日期：（提示：请按照例如2020-12-6的格式书写）");
        //获取录入的数据
        String strDate = sc.next();
        //System.out.println(strDate);
        //将字符串转为data
        java.sql.Date date = java.sql.Date.valueOf(strDate);
        //将data转为Calendar;[1]:创建一个Calendar对象
        Calendar cal = Calendar.getInstance();
        //将data转为Calendar;[2]:设置当前输入的时间
        cal.setTime(date);
        //后续操作：
        //星期提示
        System.out.println("日\t一\t二\t三\t四\t五\t六\t");
        //获取本月的最大天数：
        int maxDay = cal.getActualMaximum(Calendar.DATE);
        //获取当前日期中的日
        int nowDay = cal.get(Calendar.DATE);
        //将日期调整为本月的1号
        cal.set(Calendar.DATE, 1);
        //获取这个一号是本周的第几天,
        int num = cal.get(Calendar.DAY_OF_WEEK);
        //从周日开始，相当于前面空出来的天数-1
        int day = num - 1;
        //遍历空出来的空格数
        for (int i = 1; i <= day; i++) {
            System.out.print("\t");
        }
        int count = 0;//计数器
        count = count + day;
        //遍历从1到最大天数
        for (int i = 1; i <= maxDay; i++) {

            //遍历的i==当前输入的日期，拼入*
            if (i == nowDay) {
                System.out.print(i + "*" + "\t");
            } else {
                System.out.print(i + "\t");
            }
            count++;
            if (count % 7 == 0) {
                System.out.println();
            }

        }


    }
}

6. LocalDate LocalTime LocalDateTime(常用)

package com.fj.common.date;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo07 {
    public static void main(String[] args) {
        //1.完成实例化：
        //方法1：now() LocalDateTime常用
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);//2021-10-09 日期
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);//11:39:07.403526600 时间
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);//2021-10-09T11:39:07.403526600 日期+时间
        //方法2 ：of() 设置日期
        LocalDate.of(2020,5,6);
        LocalTime.of(10,20,12);
        LocalDateTime.of(2020,12,3,20,12,3);
        /****************************localDateTime常用方法************************************/
        //一系列常用get **
        System.out.println(localDateTime.getYear());//2021 当前年份
        System.out.println(localDateTime.getMonth());//OCTOBER 十月
        System.out.println(localDateTime.getMonthValue());//10 当前月份
        System.out.println(localDateTime.getDayOfMonth());//9  当期日期
        System.out.println(localDateTime.getDayOfWeek());//  SATURDAY 周六
        System.out.println(localDateTime.getHour());//11  小时
        System.out.println(localDateTime.getMinute());//47  分
        System.out.println(localDateTime.getSecond());//58  秒
        //一系列常用with
        LocalDateTime localDateTime1 =  localDateTime.withMonth(8);
        //产生了新的时间，但是原先的数据没有变，不可变性
        System.out.println(localDateTime);//2021-10-09T11:51:31.621866100
        System.out.println(localDateTime1);//2021-10-09T11:51:31.621866100
        //提供加减操作
        //加
        LocalDateTime localDateTime2 = localDateTime.plusMonths(4);//加4个月 当前2021-10-9
        System.out.println(localDateTime);//2021-10-09T11:54:56.037275700
        System.out.println(localDateTime2);//2022-02-09T11:54:56.037275700

        //减
        LocalDateTime localDateTime3 = localDateTime.minusMonths(5);//加4个月 当前2021-10-9
        System.out.println(localDateTime);//2021-10-09T13:03:56.955070900
        System.out.println(localDateTime3);//2021-05-09T13:03:56.955070900
    }
}

7. DateTimeFormatter中String和LocalDateTime时间转换

package com.fj.common.date;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

public class Demo08 {
    public static void main(String[] args) {
        //DateTimeFormatter
        // 方式一： 预定义标准格式。如：ISO_LOCAL_DATA_TIME;ISO_LOCAL_DATA;ISO+LOCAL_TIME
        DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //df1:就可以帮我们完成localDateTime和String之间的转换
        // LocalDateTime-->String
        LocalDateTime now = LocalDateTime.now();
        String str = df1.format(now);
        System.out.println(str);
        //string -> LocalDateTime
        TemporalAccessor parse = df1.parse("2021-10-09T13:13:05.8112927");
        System.out.println(parse);
        System.out.println("==============================方式一： 预定义标准格式结束===========================================");
        // 方式二：本地化相关的格式。如 ofLocalizedDateTime()
        // 参数： FormatStyle.LONG  / FormatStyle.MEDIUM/ FormatSTYLE.SHORT
        DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
        // LocalDateTime-->String
        LocalDateTime now1 = LocalDateTime.now();
        System.out.println(now1);
        String str2 = df2.format(now1);
        System.out.println(str2);
        //string -> LocalDateTime
        TemporalAccessor parse1 = df2.parse("2021年10月9日 下午1:21:44");
        System.out.println(parse1);
        System.out.println("==============================方式一： 本地化相关的格式结束===========================================");
        // 方式三：自定义格式。如：ofPattern("yyyy-MM-dd  HH:mm:ss")->常用，重点
        DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        // LocalDateTime-->String
        LocalDateTime now3 = LocalDateTime.now();
        String str3 = df3.format(now3);
        System.out.println(str3);
        //string -> LocalDateTime
        TemporalAccessor parse2 = df3.parse(str3);
        System.out.println(parse2);

    }
}

三、 Math类

静态类，无需new,可直接调用

package com.fj.common.math;
//静态导入不建议用，可以直接使用random()；不用Math.random()

import static java.lang.Math.*;

/**
 * math
 */
public class Demo01 {
    public static void main(String[] args) {
        // 常用属性
        System.out.println(Math.PI);
        //常用发方法
        System.out.println("随机数：" + Math.random());
        System.out.println("绝对值：" + Math.abs(-50));
        System.out.println("向上取值：" + Math.ceil(9.1));
        System.out.println("向下取值：" + Math.floor(9.9));
        System.out.println("四舍五入：" + Math.round(3.4));
        System.out.println("最大值：" + Math.max(3, 6));
        System.out.println("最小值：" + Math.min(3, 6));

    }
}

四、 Random类

有参：传入的值如果是固定值，返回的值也是固定值，不随机。传入的值每次都不一样，返回的才是随机数
无参：看是调用无参，底层调用的还是有参
Math.random()底层也是调用的Random类

package com.fj.common.math;

import java.util.Random;

/**
 * Random
 */
public class Demo02 {
    public static void main(String[] args) {
        //返回带正好的double值，该值大于等于0.0,且小于1.0
        System.out.println("随机数：" + Math.random());
        //学习Random类
        //(1)利用带参数的构造器创建对象
        Random r1 = new Random(System.currentTimeMillis());//传入固定值，获取的随机数都是一样的
        //System.out.println(r1);
        int i = r1.nextInt();
        System.out.println(i);
        //(2)利用空构造器创建对象
        Random r2 = new Random();
        System.out.println(r2.nextInt(10));
        System.out.println(r2.nextDouble());
    }
}

五、 String类（不可变）

1. String说明

  *   1.直接使用，无需导包：package java.lang
  *   2.字符串由一堆字符组成
  *   3.String str ="abc" "abc"就是String类下的一个具体的对象
  *   4.字符串是不可变得：？？？
  *   5.这个String类不可以被继承，不能有子类
  *   6.String是一个Char类型的数组

2. String常用方法

package com.fj.common.string;

import java.util.Arrays;
import java.util.Locale;

public class Demo01 {

    public static void main(String[] args) {
        /*******************************************************************************
         *   1.直接使用，无需导包：package java.lang
         *   2.字符串由一堆字符组成
         *   3.String str ="abc" "abc"就是String类下的一个具体的对象
         *   4.字符串是不可变得：？？？
         *   5.这个String类不可以被继承，不能有子类
         *   6.String是一个Char类型的数组
         * *******************************************************************************
         */
        //声明变量，类型为String
        String str = "str";
        System.out.println(str);//str
        //通过构造器来创建对象
        String s1 = new String();
        System.out.println(s1);//空
        //通过构造器来创建对象
        String s2 = new String("s2");
        System.out.println(s2);//s2
        //通过new char[]来创建对象
        String s3 = new String(new char[]{'s','3','c'});
        System.out.println(s3);//s3c 字符串底层是char 数组
        //字符串长度length()
        String s4 = "s4";
        System.out.println("字符串的长度为："+s4.length());//字符串的长度为：2
        //字符串判断是否为空isEmpty()
        String s5 = new String();
        System.out.println("字符串是否为空："+s5.isEmpty());//字符串是否为空：true
        //字符串通过下标获取某个字符 charAt()   str.charAt(1)
        System.out.println(s4.charAt(1));//4  s4 = "s4"; 获取s4下标为4的字符
        //equals:当两个对象的地址指向相同的时候，直接返回true.当自己跟自己比较的时候，直接返回true.
        //       当你传入的字符串不是String实例的具体实例的时候，那么直接返回false.
        //       如果两个字符串长度不一样直接false，否则对数组进行遍历，安慰比较，不一样直接返回false
        String s6 = new String("ABC");
        String s7 = new String("abc");
        System.out.println(s6.equals(s7));//false
        //compareTo :String对CompareTO进行了重写
        //           相同：等于0 例如：String s8 = new String("abc");String s9 = new String("abc");0
        //            s8.compareTo(s9) s8>s9:返回s8大于s9的整数ASCII
        //            s8.compareTo(s9) s8<s9:返回s8小于s9的负数
        String s8 = new String("adbc");
        String s9 = new String("abcf");
        System.out.println(s8.compareTo(s9));//1
        //substring;字符串截取
        String s10 = "abcdefjhijklmn";
        System.out.println(s10.substring(3));//defjhijklmn 从三开始截取，取到最后一位
        System.out.println(s10.substring(3,6));//def 截取3-6位的数据 左边包含，右边不包含
        //concat 字符串拼接
        System.out.println(s10.concat("pppp"));//abcdefjhijklmnpppp
        //replace 字符串中的字符替换
        String s11 = "abcdeafjja";
        System.out.println(s11.replace('a','u'));//ubcdeufjju
        //split 字符串分割为数组
        String s12 = "a-b-c-d-e";
        String[] strs = s12.split("-");
        System.out.println(Arrays.toString(strs));//[a, b, c, d, e]
        //转大小写toUpperCase 大写  toLowerCase小写
        String s13 = "abc";
        System.out.println(s13.toUpperCase(Locale.ROOT));
        System.out.println(s13.toUpperCase(Locale.ROOT).toLowerCase(Locale.ROOT));
        //去除首付空格trim()
        String s14 = " a b c ";
        System.out.println(s14.trim());//a b c
        //toString 返回当前自己
        String s15 = "abc";
        System.out.println(s15.toString());//abc
        //转为string类型
        System.out.println(String.valueOf(false));//false




    }
}

3. string内存分析

1. 字符串拼接

package com.fj.common.string;

public class Demo02 {
    public static void main(String[] args) {
        /**
         * 下面的字符串，会进行编译器优化，直接合并为完整的字符串，我们可以反编译验证：
         * 在常量池中，常量池的特点是第一次如果没有这个字符串，就放进去，如果有这个字符串，就直接从常量池中取
         */
        String s1 = "a" + "b" + "c" + "d";
        String s2 = "ab" + "c";
        String s3 = "a" + "bc";
        String s4 = "abc";
        String s5 = "abc" + "";
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s5);//true
    }
}

画图演示，字符串拼接。内存：开辟1个空间（1.常量池中的字符串）
在这里插入图片描述

2. new关键字创建对象

package com.fj.common.string;

public class Demo02 {
    public static void main(String[] args) {
       
        /**
         * 2. new关键字创建对象
         * 内存：开辟两个空间（1.字符串常量池中的字符串 2. 堆中开辟的空间）
         * s6 在堆里面有一个value对象，value对象指向方法中的常量池
         *
         */
        String s6 = new String("abc");

    }
}

画图演示，new关键字创建对象。内存：开辟两个空间（1.字符串常量池中的字符串 2. 堆中开辟的空间）

在这里插入图片描述

3.有变量参与的字符串拼接

代码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.fj.common.string;

public class Demo03 {
    public Demo03() {
    }

    public static void main(String[] args) {
        String a = "abc";
        String b = a + "def";
        System.out.println(b);
    }
}

利用idea进行反编译，命令：javap 文件名

PS E:\Java\3_ProcessControl\out\production\3_ProcessControl\com\fj\common\string> javap .\Demo03.class
Compiled from "Demo03.java"
public class com.fj.common.string.Demo03 {
  public com.fj.common.string.Demo03();
  public static void main(java.lang.String[]);
}
PS E:\Java\3_ProcessControl\out\production\3_ProcessControl\com\fj\common\string>

在这里插入图片描述

六、StringBuilder(可变)

底层：两个非常重要的属性
value: StringBuilder底层的存储方式
count:count指的是value数组中被使用的长度

1. 内存解析

package com.fj.common.string_Builder;

/**
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建StringBuilder对象：
        //final 修饰不能被继承
        // 表面上调用StringBuilder的空构造器，实际底层是对value数组进行初始化，长度为16
        StringBuilder sb3 = new StringBuilder();
        // 表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层是对value数组进行初始化，长度为你传入的数据
        StringBuilder sb2 = new StringBuilder(3);
        // 表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层是对value数组进行初始化，长度为你传入的数据
        // 底层长度默认传入的数据长度+16=19 ,6个长度被占用了，底层不够用就扩容
        //19*2+2=40,底层不能超过21亿
        StringBuilder sb = new StringBuilder("abc");
        //长度40,24个长度被占用了
        sb.append("def").append("aaaaaaaa").append("bbb").append("0000000");//链式调用方式，return this
        System.out.println(sb);


    }
}

String 不可变：在地址不变的情况下，想把一个字符串变成另一个字符串是不可能的。
StringBuilder可变：在对象地址不变的情况下，想把一个字符串变成另一个字符串是可能的，直接追加就可以

2.StringBuilder 常用方法

package com.fj.common.string_Builder;

public class Demo02 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abcdefg");
        //增
        sb.append("是是是");//
        System.out.println(sb);//abcdefg是是是
        //删
        sb.delete(3,6);//删除位置在3，6上得字符
        System.out.println(sb);//abcg是是是

        sb.deleteCharAt(1);//删除位置在16上得字符
        System.out.println(sb);//acg是是是
        //改--->插入
        StringBuilder sb1 = new StringBuilder("$235648794");
        sb1.insert(3,",");//在下标为3的位置,插入,插入到下标为3的前面
        System.out.println(sb1);//$23,5648794
        //改-->替换
        StringBuilder sb2 = new StringBuilder("$2你好吗噜啦噜啦嘞绿绿绿");
        sb2.replace(3,5,"我好累");//在下标3，5位置插入字符串
        System.out.println(sb2);//$2你我好累噜啦噜啦嘞绿绿绿
        sb2.setCharAt(3,'*');//在下标为3的地方插入*
        System.out.println(sb2);//$2你*好累噜啦噜啦嘞绿绿绿
        //查
        StringBuilder sb3 = new StringBuilder("asdfg");
        for (int i = 0;i<sb3.length();i++){
            System.out.print(sb3.charAt(i)+"\t");
        }
        System.out.println();
        //截取
        String str = sb3.substring(2, 4);//截取2，4返回的是一个新的string,对StringBuilder没有影响
        System.out.println(str);//df
        System.out.println(sb3);//asdfg


    }
}

七、StringBuffer(可变)

1. 常用方法

package com.fj.common.string_Builder;

public class Demo02 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("abcdefg");
        //增
        sb.append("是是是");//
        System.out.println(sb);//abcdefg是是是
        //删
        sb.delete(3,6);//删除位置在3，6上得字符
        System.out.println(sb);//abcg是是是

        sb.deleteCharAt(1);//删除位置在16上得字符
        System.out.println(sb);//acg是是是
        //改--->插入
        StringBuilder sb1 = new StringBuilder("$235648794");
        sb1.insert(3,",");//在下标为3的位置,插入,插入到下标为3的前面
        System.out.println(sb1);//$23,5648794
        //改-->替换
        StringBuilder sb2 = new StringBuilder("$2你好吗噜啦噜啦嘞绿绿绿");
        sb2.replace(3,5,"我好累");//在下标3，5位置插入字符串
        System.out.println(sb2);//$2你我好累噜啦噜啦嘞绿绿绿
        sb2.setCharAt(3,'*');//在下标为3的地方插入*
        System.out.println(sb2);//$2你*好累噜啦噜啦嘞绿绿绿
        //查
        StringBuilder sb3 = new StringBuilder("asdfg");
        for (int i = 0;i<sb3.length();i++){
            System.out.print(sb3.charAt(i)+"\t");
        }
        System.out.println();
        //截取
        String str = sb3.substring(2, 4);//截取2，4返回的是一个新的string,对StringBuilder没有影响
        System.out.println(str);//df
        System.out.println(sb3);//asdfg


    }
}