StringBuilder builder = new StringBuilder();

System.out.println(builder.capacity());

System.out.println(builder.length());

System.out.println("---------------------------------");

StringBuilder builder1 = new StringBuilder(10);

System.out.println(builder1.capacity());

System.out.println(builder1.length());

System.out.println("---------------------------------");

StringBuilder builder2 = new StringBuilder("hello");

// 获取 StringBuilder 容量大小的长度 16+5 => 21

System.out.println(builder2.capacity());

// 获取字符串实际长度

System.out.println(builder2.length());

System.out.println("---------------builder-------------");

StringBuilder builder = new StringBuilder("hello");

StringBuilder sb = builder.insert(0,"abc");

System.out.println("sb ="+sb);//"abchello"

System.out.println("builder ="+builder);//"abchello" 因为它返回的就是本身所以调用自己也就同样的被操作过的值

StringBuilder sb1 = builder.append("java");

System.out.println("sb1 ="+sb1);

System.out.println("builder ="+builder);

System.out.println("---------------buffer------------------");

//StringBuffer 也是一样的它们调用方法修改时返回的是本身

StringBuffer buffer = new StringBuffer("hello");

StringBuffer f = buffer.insert(0,"abc");

System.out.println("f ="+f);

System.out.println("buffer ="+buffer);

StringBuffer f1 = buffer.append("java");

System.out.println("f1"+f1);

System.out.println("buffer ="+buffer);

StringBuilder ar = new StringBuilder("helloworld");

// 此时的循环已经不代表下标，可以根据要删除字符的个数来设定比如留下 h 从 1 开始删除到 ld 的 l 前就停止打印结果为:hld

for(int i = 0;i < 7;i ++){

    // 打印结果 elwrd, 这是为什么呢？因为每删掉一位之后字符就会往前补位

    // 因此下标会发生变化

    // ar.deleteCharAt(i);

    // 解决办法让它始终只删除一个位置

    ar.deleteCharAt(1);// 打印结果 hld

}

System.out.println(ar);// 打印结果 elwrd

StringBuilder ar = new StringBuilder("helloworld");

ar.delete(0,5);//java 中都有这一特定就是包含 0 但不包含 4

// 笔试考点

// 考点一：既然 StringBuilder 类的对象本身可以修改，那么为什么成员方法有返回值呢？

// 解析为了连续调用

ar.reverse().append("1").append("2").insert(0,"3").delete(0,1).reverse();

// 考点二：如何实现 StringBuilder 类型和 String 类型之间的转换呢？

String t = ar.toString();// 转换为 String

StringBuilder builder = new StringBuilder(t);// 转换为 StringBuilder

// 考点三：String,StringBuffer,StringBuilder 之间效率谁高？排列如何？

//String < StringBuffer < StringBuilder

Date date = new Date();// 获取当前系统时间戳

System.out.println(date);//2022 年 8 月 31 日星期三 10:02:56 CST

Date date1 = new Date(1000);//1970 年 1 月 1 日 0 时 0 分 0 秒，过去一秒的时间 1000 毫秒为 1 秒

System.out.println(date1);//1970 年 1 月 1 日星期四 08:00:01 CST

System.out.println("--------------------------------------------------------------");

long x = date1.getTime();// 获取 date1 对象构造器中的毫秒值

System.out.println(x);//1000

date1.setTime(2000);// 设置 date1 距离 1970 年 1 月 1 日 0 时 0 分 0 秒，过去二秒的时间 2000 毫秒为 2 秒

System.out.println(date1);//1970 年 1 月 1 日星期四 08:00:02 CST

// 自定义格式化对象                                  y 四个因为年就是四位的嘛

SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-ddEH:mm:ss");

String format = simple.format(date);//2022 年 8 月 31 日星期三 10:35:24 CST

// 格式化日期时间

System.out.println(format);//2022-08-31 周三 10:35:24

String ar = "2022-08-31周三10:34:59";

// 解析字符串日期时间

Date d = simple.parse(ar);

System.out.println(d);//2022 年 8 月 31 日星期三 10:34:59 CST

SimpleDateFormat simple = new SimpleDateFormat();

// 通过调用静态方法 instance 方法获取 Calendar 对象 定义：设置日历字段

Calendar calendar = Calendar.getInstance();

// 设置制定的日历字段的值

calendar.set(2018,12 - 1,19,0,0,0);

// 获取 Date 类型的日历字段的值

Date dr = calendar.getTime();

System.out.println("dr ="+dr);////2018 年 12 月 19 日星期三 00:00:00 CST

// 将 Date 日历字段对象格式化为字符串类型日期时间

String x = simple.format(dr);

System.out.println("String ="+x);//2018/12/19 上午 12:00

// 将字符串类型的日历字段的值解析为 Date 类型的日期时间

String z = "2018/12/19 上午12:00";

Date xx = simple.parse(z);

System.out.println("Date ="+xx);//2018 年 12 月 19 日星期三 00:00:00 CST

LocalDateTime of = LocalDateTime.of(2008,10,10,5,6,7);

//"-------- 设置 year:2012-------"

System.out.println("----------设置Year为:2012-----------");

LocalDateTime of1 = of.withYear(2012);

System.out.println("year: "+of1);

//"-------- 增加 month:2-------"

LocalDateTime of2 = of.plusMonths(2);

System.out.println("month: "+of2);

//"--------- 减少 day:9----------"

LocalDateTime of3 = of.minusDays(9);

System.out.println("day: "+of3);

//"--------- 增加 hour:6---------"

LocalDateTime of4 = of.plusHours(6);

System.out.println("hour: "+of4);

//"-------- 设置 minute:40--------"

LocalDateTime of5 = of.withMinute(40);

System.out.println("minute: "+of5);

//"-------- 减少 second:6---------"

LocalDateTime of6 = of.minusSeconds(6);

System.out.println("second: "+of6+"\n");

// 由此可见 LocalDateTime 返回的是一个新的对象它与 String 类似，并不是在原有的对象中进行修改

//----------LocalDateTime 对象的值 ----------

System.out.println("of: "+of);//2008-10-10T00:00

// 从默认时区的系统时间中获取当前日期时间

LocalDateTime datetime = LocalDateTime.now();

System.out.println("localdatetime: "+datetime);

// 从系统时钟上获取当前时间

Instant in = Instant.now();

System.out.println("获取当前的时间为: "+in);

// 从此瞬间与偏移量组成以创建偏移量日期时间

OffsetDateTime offsetDateTime = in.atOffset(ZoneOffset.ofHours(8));

System.out.println("获取修改后的时间为: "+offsetDateTime);

// 获取距离 1970-1-1-0-0-0 的毫秒值

long l = in.toEpochMilli();

System.out.println("toEpochMilli: "+l);

// 根据参数指定的毫秒值构造对象

Instant x = Instant.ofEpochMilli(l);

System.out.println("ofEpochMilli: "+x);

// 获取当前系统日期和时间

LocalDateTime ld = LocalDateTime.now();

// 通过 ofPattern 获取自定义模式的 DateTimeFormatter 格式化对象 构造器中定义日期时间格式

DateTimeFormatter tter = DateTimeFormatter.ofPattern("yyyy-MM-dd EH:mm:ss");

// 对象名调用 format 将日期时间格式化为日期时间字符串

String tter1 = tter.format(ld);

System.out.println(tter1);

// 通过 ofLocalizedDateTime 获取格式化对象 构造器中赋值通过 FormatStyle 调用的格式

//FULL 完整格式，LONG 长格式，SHORT 短格式，MEDIUM 普通格式

DateTimeFormatter tt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG,FormatStyle.SHORT);

String tt1 = tt.format(ld);

System.out.println(tt1);

// 通过对象名调用 parse 将日期时间字符串解析为 Date 日期时间

TemporalAccessor parse = tter.parse(tter1);

System.out.println(parse);

// 定义改对象的时间类型

String x1 = "2022-09-01 周四11:42:29";

// 通过 LocalDateTime 调用 parse 构造器中传入时间类型与该时间的对象将其解析为 Date 类型的日期时间

LocalDateTime x = LocalDateTime.parse(x1,tter);

System.out.println(x);

// 与上同理

String ar = "2022年9月1日 上午11:45";

LocalDateTime ar1 = LocalDateTime.parse(ar,tt);

System.out.println(ar1);