可变字符串类和日期相关类
一、可变字符串类（重点）
1.基本概念
- 由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。
- 为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如："ab"。
- StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。
- StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。
2、StringBuilder类常用的构造方法
方法声明 功能介绍
StringBuider() 使用无参方式构造对象，容量为16
StringBuilder(int capacity) 根据参数指定的容量大小来构造对象，容量大小为指定参数
StringBuilder(String str) 根据参数指定的字符串来构造对象。容量为：16+字符串长度
3、StringBuilder类常用的成员方法
方法声明 功能介绍
int capacity() 用于返回调用对象的容量
int length() 用于返回字符串的长度，也就是字符的个数
StringBuilder insert(int offset, String str) 插入字符串并返回调用对象的引用，就是自己
StringBuilder append(String str) 追加字符串
StringBuilder deleteCharAt(int index) 将当前字符串下标为index位置的单个字符删除
StringBuilder delete(int start, int end) 删除字符串
StringBuilder replace(int start,int end,String str) 替换字符串
StringBuilder reverse() 字符串反转
-
注意：
作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值
4、返回值的设计
- StringBuilder的很多方法的返回值均为StringBuilder类型，这些方法的返回语句均为return this。
- 由此可见，这些方法在对StringBuilder所封装的字符序列改变后有返回该对象的引用。基于这样设计的目的在于可以连续调用。
package com.FirstStage.ThridModule.Three;
public class StringBuilderTest {
public static void main(String[] args) {
//使用无参的方式构造StringBuilder类型的对象并打印容量和长度
StringBuilder sb1 = new StringBuilder();
System.out.println("sb1 = " + sb1);// 自动调用toString方法 啥也没有
System.out.println("容量是：" + sb1.capacity());// 16
System.out.println("长度是：" + sb1.length());// 0
System.out.println("---------------------------");
//使用参数指定的容量来构造对象并打印容量和长度
StringBuilder sb2 = new StringBuilder(20);
System.out.println("sb2 = " + sb2); // 自定调用toString方法
System.out.println("容量是：" + sb2.capacity());// 20
System.out.println("长度是：" + sb2.length()); // 0
System.out.println("------------------------------");
//根据参数指定的内容来构造对象并打印容量和长度
StringBuilder sb3 = new StringBuilder("hello");
System.out.println("sb3 = " + sb3);// 自动调用toString方法 打印hello
System.out.println("容量是：" + sb3.capacity());// 21
System.out.println("长度是：" + sb3.length());// 5
System.out.println("------------------------------");
String str1 = new String("hello");
String str2 = str1.toUpperCase();
System.out.println("str2 = " + str2); // HELLO
System.out.println("str1 = " + str1); // hello 字符串本身不会改变
//实现想字符串中追加和插入字符串
StringBuilder sb4 = sb3.append("world");
System.out.println("sb4 = " + sb4); // 返回调用对象自己的引用，也就是返回值和调用对象是同一个字符串
//向下表为3的位置插入字符串内容"mn"
StringBuilder sb5 = sb3.insert(3, "mn");
System.out.println("sb5 = " + sb5);
sb3.append("jiangsukejidaxue");
System.out.println("sb3 = " + sb3);
// 当字符串的长度超过字符串对象的初始容量时，该字符的对象会自动扩容，默认扩容算法是：原始容量*2 + 2
System.out.println("容量是：" + sb3.capacity());// 44
System.out.println("长度是：" + sb3.length());// 29
System.out.println("------------------------------");
//实现字符串中字符和字符串的删除
sb3.deleteCharAt(8);// 表示删除下标为8的单个字符
System.out.println("sb3 = " + sb3);
//使用for循环删除多个字符，重复四次
for (int i = 0; i < 4; i++) {
//由结果可知删除一个字符之后就跳过一个字符继续删除，因为删除一个字符后后面的字符会向前补位因此下标会发生变化
// sb3.deleteCharAt(i);
//始终删除下标为3的位置
sb3.deleteCharAt(3);
System.out.println("sb3 = " + sb3);
}
//删除字符串jiang
sb3.delete(7, 12);
System.out.println("sb3 = " + sb3);
System.out.println("-----------------------------------");
//实现字符串的查找修改和反转
//表示将下标从3到7的位置的字符串修改为lo
sb3.replace(3, 7, "lo");
System.out.println("sb3 = " + sb3);
//将下标为6的字符修改为z
sb3.setCharAt(6, 'z');
System.out.println("sb3 = " + sb3);
//将字符串进行反转
sb3.reverse();
System.out.println("sb3 = " + sb3);
//实现查找功能
int pos = sb3.indexOf("e");
System.out.println("从前往后找：" + pos);
pos = sb3.lastIndexOf("e");
System.out.println("从后往前找：" + pos);
System.out.println("------------------------------");
//笔试考点
//考点一：StringBuilder类的对象本身可以修改，那么为什么成员方法还要有返回值呢？
//解析：为了连续调用，如果没有返回值则无法连续调用
sb3.reverse().append("1").append("2").insert(0, "3").delete(0, 1).reverse();
System.out.println("sb3 = " + sb3);
//考点二：如何实现StringBuilder类型和String类型之间的转换
String str3 = sb3.toString();//将StringBuilder类型转换为String类型
StringBuilder sb6 = new StringBuilder(str3);//将String类型转换为StringB类型
//考点三：String StringBuilder StringBuffer之间效率谁高？排列如何
//String < StringBuffer < StringBuilder
}
}
输出：
sb1 =
容量是：16
长度是：0
---------------------------
sb2 =
容量是：20
长度是：0
------------------------------
sb3 = hello
容量是：21
长度是：5
------------------------------
str2 = HELLO
str1 = hello
sb4 = helloworld
sb5 = helmnloworld
sb3 = helmnloworldjiangsukejidaxue
容量是：44
长度是：28
------------------------------
sb3 = helmnlowrldjiangsukejidaxue
sb3 = helnlowrldjiangsukejidaxue
sb3 = hellowrldjiangsukejidaxue
sb3 = helowrldjiangsukejidaxue
sb3 = helwrldjiangsukejidaxue
sb3 = helwrldsukejidaxue
-----------------------------------
sb3 = hellosukejidaxue
sb3 = helloszkejidaxue
sb3 = euxadijekzsolleh
从前往后找：0
从后往前找：14
------------------------------
sb3 = 21euxadijekzsolleh
Process finished with exit code 0
二、Java8之前日期相关的类（熟悉）
1、System类的概述
（1）基本概念
- Java.lang.System类中提供了一些有用的类字段和方法。
（2）常用的方法
方法声明 功能介绍
static long currenTimeMillis() 返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
package com.FirstStage.ThridModule.Three;
public class SystemTest {
public static void main(String[] args) {
// 获取当前系统时间距离1970年1月1日0时0分0秒的毫秒数
long is = System.currentTimeMillis();
System.out.println("当前系统时间距离1970年1月1日0时0分0秒已经过去" + is + "毫秒了");
// 通常用于测试某一段代码的执行效率
}
}
2、Date类的概述
（1）基本概念
- java.uitl.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒
（2）常用的方法
方法声明 功能介绍
Date() 使用无参的方式构造对象
Date(long date) 根据参数指定毫秒数构造对象，参数为距离1970年1月1日0时0分0秒的毫秒数
long getTime() 获取调用对象距离1970年1月1日0时0分0秒的毫秒数
void setTime(long time) 设置调用对象为距离基准时间time毫秒的时间点
package com.FirstStage.ThridModule.Three;
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
//使用无参方式构造对象并打印
Date d1 = new Date();
System.out.println("d1 = " + d1);// 获取当前系统时间 Sun Jul 04 17:16:12 CST 2021
System.out.println("---------------------------");
//使用参数指定的毫秒数来构造Date对象并打印 1秒 = 1000毫秒
Date d2 = new Date(1000);
//获取距离1970年1月1日0时0分0秒的时间 1970年1月1日0时0分1秒，输出：Thu Jan 01 08:00:01 CST 1970，8小时当前时区东八区
System.out.println("d2 = " + d2);
System.out.println("---------------------------------");
//获取调用对象距离1970年1月1日0时0分0秒的毫秒数
long msec = d2.getTime();
System.out.println("获取到的毫秒数是：" + msec); // 1000
//设置调用对象所表示的时间点为指定参数指定的毫秒数
d2.setTime(2000);
System.out.println("修改后的时间是：" + d2);//输出：修改后的时间是：Thu Jan 01 08:00:02 CST 1970
}
}
3、SimpleDateFormat类的概述
（1）基本概念
- java.text.SimplDateFormat类主要用于实现日期和文本之间的转换。
（2）常用方法
方法声明 功能介绍
SimpleDateFormat() 使用无参方式构造对象
SimpleDateFormat(String pattern) 根据参数指定的模式来构造对象，模式主要有：y-年 M-月 d-日 H-时 m-秒 s-秒
final String format(Date date) 用于将日期类型转换为文本类型
Date parse(String source) 用于将文本类型转换日期类型
package com.FirstStage.ThridModule.Three;
import com.sun.jdi.event.MonitorContendedEnteredEvent;
import javafx.scene.control.Alert;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatTest {
public static void main(String[] args) throws ParseException {
//获取当前系统时间并打印
Date d1 = new Date();
System.out.println("d1 = " + d1);
//构造SimpleDateFormat类型的对象并指定格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//实现日期类型到文本类型的转换
//Alt+Enter
String format = sdf.format(d1);
System.out.println("转换后的文本类型为：" + format);
//实现文本类型到日期类型的转换
Date parse = sdf.parse(format);
System.out.println("转回后的日期为:" + parse);
}
}
4、Calendar类的概述
（1）基本概念
- java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化
- 该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。
（2）常用的方法
方法声明 功能介绍
static Calendar getInstance() 用于获取Calendar类型的引用
void set(int year, int month, int date, int hourOfDay, int minute, int second) 用于设置年月日时分秒信息
Date getTime() 用于将Calender类型转换为date类型
void set(int field, int value) 设置指定字段的数值
void add(int field, int amount) 向指定字段增加数值
（3）多态的使用场合
-
通过方法的参数传递形成多态；
Public static void draw(Shape s) { s.show(); } draw(new Rect(1, 2, 3, 4)); -
在方法体中直接使用多态的语法格式：Account acc = new FixedAccount();
-
通过方法的返回值类型形成多态
Calender getInstance() { return new GregorianCalendar(zone, aLocle); }package com.FirstStage.ThridModule.Three; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class CalenderTest { public static void main(String[] args) { //使用过时的方式按照指定的年月日时分秒来构造对象 Date d1 = new Date(2008-1900, 8-1, 8, 8, 8, 8); //设置日期对象的格式并打印 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String format = sdf.format(d1); System.out.println("获取到的时间是：" + format); System.out.println("-------------------------------"); // 使用取代的方式按照指定的年月日时分秒来构造对象 // 获取Calender类型的引用 // 考点：既然Calender是个抽象类不能创建对象，那么下面方法为啥可以获取Calender类型的引用呢？ // 解析：有源码可知，返回的并不是Calender类型的对象，而是Calender类的子类GregorianCalender等对象，形参多态 // 多态的使用场合之三 Calendar instance = Calendar.getInstance(); // 设置指定的年月日时分秒信息 instance.set(2008, 8-1, 8, 8, 8, 8); // 转换为Date类型的对象 Date d2 = instance.getTime(); String format1 = sdf.format(d2); System.out.println("获取到的时间是：" + format1); System.out.println("-----------------------------"); // 向指定的字段设置以及增加指定的数值 instance.set(Calendar.YEAR, 2018); // 转换为Date类型并按照指定的格式打印 Date d3 = instance.getTime(); System.out.println("设置年份后的结果是" + sdf.format(d3)); instance.add(Calendar.MONTH, 2); Date d4 = instance.getTime(); System.out.println("增加后的结果是:" + sdf.format(d4)); } } 输出： 获取到的时间是：2008-08-08 08:08:08 ------------------------------- 获取到的时间是：2008-08-08 08:08:08 ----------------------------- 设置年份后的结果是2018-08-08 08:08:08 增加后的结果是:2018-10-08 08:08:08 Process finished with exit code 0
三、Java8中的日期相关类（熟悉）
1、Java8日期类的由来
- JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
- Date类中的年份是从1900开始的，而月份都从0开始
- 格式化只对Date类有用，对Calendar类则不能使用。
- 非线程安全等。
2、Java8日期类的概述
-
Java 8通过发布新的Date-Time API来进一步加强对 日期与时间的处理。
-
java.time包：该包日期/时间API的基础包
-
java.time.chrono包：该包提供对不同日历系统的访问。
-
java.time.format包：该包能够格式化和解析日期时间对象。
-
java.time.temporal包：该包包含底层框架和扩展特性。
-
java.time.zone包：该包支持不同时区以及相关规则的类。
3、LocalDate类的概述
（1）基本概念
- java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。
（2）常用的方法
方法声明 功能介绍
static LocalDate now() 在默认时区中从系统时钟获取当前日期
4、LocalTime类的概述
（1）基本概述
- java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。
（2）常用的方法
方法声明 功能介绍
static LocalTime now() 从默认时区的系统时间中获取当前的时间
static LocalTime now(Zoneld zone) 获取指定时区的当前时间
5、LocalDateTime类的概述
（1）基本概念
- java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-03T10:15:30。
（2）常用的方法
方法声明 功能介绍
static LocalDateTime now() 从默认时区的系统时间中获取当前日期时间
static LocalDateTime of(int year, int month, int
dayOfMonth, int hour, int minute, int second) 根据参数指定的年月日时分秒信息来设置日期时间
int getYear() 获取年份字段的数值
int getMonthValue() 获取1到12之间的月份字段
int getDayOfMonth() 获取日期字段
int getHour() 获取小时数
int getMinute() 获取分钟数
int getSecond() 获取秒数
LocalDateTime withYear(int year) 设置为参数指定的年
LocalDateTime withMonth(int month) 设置为参数指定的月
LocalDateTime withDayOfMonth(int dayOfMonth) 设置为参数指定的日
LocalDateTime withHour(int hour) 设置为参数指定的时
LocalDateTime withMinute(int minute) 设置为参数指定的分
LocalDateTime withSecond(int second) 设置为参数指定的秒
LocalDateTime plusYears(long years) 加上参数指定的年
LocalDateTime plusMonths(long months) 加上参数指定的月
LocalDateTime plusDays(long days) 加上参数指定的日
LocalDateTime plusHours(long hours) 加上参数指定的时
LocalDateTime plusMinutes(long minutes) 加上参数指定的分
LocalDateTime plusSeconds(long seconds) 加上参数指定的秒
LocalDateTime minusYears(long years) 减去参数指定的年
LocalDateTime minusMonths(long months) 减去参数指定的月
LocalDateTime minusDays(long days) 减去参数指定的日
LocalDateTime minusHours(long hours) 减去参数指定的时
LocalDateTime minusMinutes(long minutes) 减去参数指定的分
LocalDateTime minusSeconds(long seconds) 减去参数指定的秒
package com.FirstStage.ThridModule.Three;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class LocalDateTimeTest {
public static void main(String[] args) {
// 获取当前日期信息并打印
LocalDate now = LocalDate.now();
System.out.println("获取到的当前日期是：" + now);
// 获取当前时间信息并打印
LocalTime localTime = LocalTime.now();
System.out.println("获取到的当前时间是：" + localTime);
// 获取当前日期时间信息并打印 使用最多
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("获取到的当前日期时间信息是：" + localDateTime);
//使用参数指定的年月日时分秒信息来获取对象
//使用Ctrl+F12来查找指定方法
LocalDateTime of = LocalDateTime.of(2008, 8, 8, 8, 8, 8);
System.out.println("指定的日期时间是：" + of); // 自动调用toString 2008-08-08T08:08:08
System.out.println("获取到的年是：" + of.getYear()); // 2008
System.out.println("获取到的月是：" + of.getMonth()); // 8
System.out.println("获取到的日是：" + of.getDayOfMonth()); // 8
System.out.println("获取到的小时是：" + of.getHour()); // 8
System.out.println("获取到的分钟是：" + of.getMinute()); // 8
System.out.println("获取到的秒是：" + of.getSecond()); // 8
}
}
输出：
获取到的当前日期是：2021-07-04
获取到的当前时间是：18:52:15.295300700
获取到的当前日期时间信息是：2021-07-04T18:52:15.295300700
指定的日期时间是：2008-08-08T08:08:08
获取到的年是：2008
获取到的月是：AUGUST
获取到的日是：8
获取到的小时是：8
获取到的分钟是：8
获取到的秒是：8
Process finished with exit code 0
6、Instant类的概述
（1）基本概念
- java.time.Instant类主要用于描述瞬间的时间点信息。
（2）常用方法
方法声明 功能介绍
static Instant now() 从系统时钟上获取当前时间
OffsetDateTime atOffset(ZoneOffset offset) 将此瞬间与偏移量组合以创建偏移日期时间
static Instant ofEpochMilli(longepochMilli) 根据参数指定的毫秒数来构造对象，参数为距离1970年1月1日0时0分0秒 的毫秒数
long toEpochMilli() 获取距离1970年1月1日0时0分0秒的毫秒数
package com.FirstStage.ThridModule.Three;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
public class InstantTest {
public static void main(String[] args) {
// 使用Instant来获取当前系统时间 并不是当前系统的默认时区时间
Instant instant = Instant.now();
System.out.println("获取的当前时间是：" + instant); // 获取的当前时间是：2021-07-04T11:09:26.008850500Z
// 加上时区所差的8个小时
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println("偏移后的日期时间为：" + offsetDateTime);
System.out.println("------------------------");
// 获取当前调用对象距离标准基准时间的毫秒数
long g1 = instant.toEpochMilli();
System.out.println("获取到的毫秒差为：" + g1);
//根据参数指定的毫秒数来构造对象
Instant instant1 = Instant.ofEpochMilli(g1);
System.out.println("根据参数指定的毫秒数构造出来的对象为：" + instant1);
}
}
输出：
获取的当前时间是：2021-07-04T11:28:02.208063300Z
偏移后的日期时间为：2021-07-04T19:28:02.208063300+08:00
------------------------
获取到的毫秒差为：1625398082208
根据参数指定的毫秒数构造出来的对象为：2021-07-04T11:28:02.208Z
Process finished with exit code 0
7、DateTimeFormatter类的概述
（1）基本概念
- java.time.format.DateTimeFormatter类主要用于格式化和解析日期。
（2）常用的方法
方法声明 功能介绍
static DateTimeFormatter ofPattern(String pattern) 根据参数指定的模式来获取对象
String format(TemporalAccessor temporal) 将参数指定日期时间转换为字符串
TemporalAccessor parse(CharSequence text) 将参数指定字符串转换为日期时间
package com.FirstStage.ThridModule.Three;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
public class DateTimeFormatterTest {
public static void main(String[] args) {
// 获取当前系统的日期时间并打印
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println("localDateTime = " + localDateTime);
// 按照指定的格式准备一个DateTimeFormatter类型的对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 实现日期时间向字符串类型的转换并打印
String str = dateTimeFormatter.format(localDateTime);
System.out.println("调整格式后的结果是：" + str);
// 实现字符串类型向日期类型的转换并打印
TemporalAccessor parse = dateTimeFormatter.parse(str);
System.out.println("转换回来的格式是：" + parse);
}
}
输出：
localDateTime = 2021-07-04T19:28:21.590239
调整格式后的结果是：2021-07-04 19:28:21
转换回来的格式是：{},ISO resolved to 2021-07-04T19:28:21
Process finished with exit code 0
本文来自博客园，作者：寒露凝珠，转载请注明原文链接：https://www.cnblogs.com/china-soldier/p/14969699.html
