Java高级-常用类的使用-优快云博客

String类的使用

String 字符串，使用一对""引起来表示

String类被声明为final的，不可被继承

String实现了Serializable接口，表示字符串是支持序列化的

也实现了Comparable接口，表示String字符串可以比较大小

String内部定义了final char[] value用于存储字符串数据。

注意value属性是final的，证明String一旦被定义则是不可变的。

String类不可变性的体现

1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
2.当对现有的字符串进行拼接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

补充

通过字面量的方式给一个字符串赋值，此时的字符串声明在字符串常量池中，字符串常量池中是不会存储相同内容的字符串的，可以共享内容

写法

字面量的定义方式
   String s1 = "abc"; //此时的数据abc声明在方法区中的字符串常量池中
创建对象的定义方式
   Strin s2 = new String("abc");//此时s2保存的是地址值，是数据在堆空间中开辟空间以后对应的地址值

String s = new String("abc")的方式创建对象，在内存中创建了几个对象？
答案是两个，一个是堆空间中new结构，另一个是char[]对应的常量池中的数据 "abc"

String intern()方法

String s1 = "鸣雏之恋";
String s2 = "鸣雏";
String s3 = s2 + "之恋";

System.out.println(s1 == s3); //false 现在是不想等的

final String s4 = "鸣雏";
String s5 = s4+"之恋";
System.out.println(s5 == s1);//true 此时是相等的。

String s6 = s3.intern(); //s6从常量池中得到已经存在的内容。

System.out.println(s6==s1);//true

/*
* 1.常量与常量的拼接结果在常量池，且常量池中不会出现相同内容的常量
* 2.只要其中有一个是变量，结果就在堆中
* 3.调用intern()方法，如果常量池中有这个内容就从常量池中返回，如果常量池中没有，就把字符串对象先放到常量池中，然后再从常量池中返回值。
*
* */

String类和其他结构之间的转换

和基本数据类型转换
   String --> 基本数据类型 : 包装类.parseXxx(字符串)
   基本数据类型-->字符串: String.valueOf(基本数据类型)
和char[]之间的转换
   String -->char[] : str.toCharArray()
   char[] -->String : String str = new String(char[])
和byte[]之间的转换
   编码: String --> byte[]: 调用String的getBytes("字符集") (就是从看的懂的文本内容，转换成二进制数据)
解码: byte[]-->String : 调用String的构造器 new String(byte[],"字符集") (把看不懂的二进制数据，转换成看得懂的文本内容)
解码时，要求字符集必须与编码的使用的字符集一致，否则会出现乱码
String --> byte[] :Byte[] by = str.getBytes("字符集")
byte[] --> String : String str = new String(byte[],“字符集”)

String常用方法

int length

String内部是char[]数组，所以有索引
int length() 返回字符串的长度
char charAt(index) 返回某索引处的字符

boolean isEmpty()

boolean isEmpty() 判断是否是空字符串

对字符串内容的操作

String toLowerCase() 将String的所有字符转换为小写
String toUpperCase() 将String的所有字符转换为大写
String trim() 忽略两头空

字符串比较

boolean equals(Object obj) 判断字符串内容是否相同
boolean equalsIgnoreCase(String) 忽略大小写，判断字符串内容是否相同

int compareTo(String)比较两个字符串的大小

字符串拼接

String concat(String) 连接字符串，等同于+

字符串截取

String subString(int beginIndex) 返回一个新的字符串，它是此字符串从beginIndex开始截取到最后一个字符串
String subString(int beginIndex,int endIndex) 返回一个新的字符串，是此字符串从beginIndex开始截取到endIndex(不包含)的字符串

字符串是否含有xx元素

boolean endsWith(String) 字符串是否是以指定的后缀结束
boolean startsWith(String) 字符串是否以指定的前缀开始
boolean startsWith(String ,int) 字符串从指定索引开始的字符串是否已指定前缀开始
boolean contains(CharSequence) 当此字符串包含指定的 char 值序列时，返回 true

boolean matches(regex) 判断字符串是否匹配指定正则

返回xx元素的位置

int indexOf(String) 返回指定元素在该字符串中第一次出现的索引
int indexOf(String ,int) 返回指定元素在该字符串指定索引后面出现的第一个索引
int lastIndexOf(String) 返回指定元素在此字符串中最后出现的索引
int lastIndexOf(String,int)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
indexOf和lastIndexOf如果未找到都是返回-1

替换字符串中的内容

String replace(oldChar,newChar) //将oldChar替换成newChar
String replace(oldCharSequence,newCharSequence) 将oldCharSequence序列替换成newCharSequence
String replaceAll(regex,replacment) 把满足正则的字符串替换成replacment
String replaceFirst(regex,replacement) 把第一个满足正则的字符串替换成replacement

拆分字符串

String[] split(regex) 根据正则拆分字符串
String[] split(regex,limit) 根据正则拆分字符串，数组元素最多不超过limit，如果超过，剩下的全部放到最后一个元素中

StringBuffer和StringBuilder

创建StringBuffer对象

/*
* 构造器有三个
* 空参构造器: 初始容量为16的字符串缓冲区
* int构造器 : 构造指定容量的字符串缓冲区
* String构造器 : 将内容初始化为指定字符串内容
*
* */
StringBuffer stringBuffer = new StringBuffer();
StringBuffer stringBuffer1 = new StringBuffer(20);
StringBuffer stringBuffer2 = new StringBuffer("java好");

创建StringBuilder对象(jdk5.0新增)

StringBuilder stringBuilder = new StringBuilder();

/*
* StringBuffer代表可变的字符序列
* StringBuilder也代表可变的字符序列，而且方法和StringBuffer的方法一样
*
* */

String VS StringBuffer VS StringBuilder

String :不可变的字符序列，
StringBuffer:可变的字符序列，线程安全但效率低
StringBuilder:可变的字符序列，线程不安全但效率高
相同点:底层都是用char[]数组存储

常用方法

拼接append(xx)
删除delete(start,end) 不包含end下标
替换replace(start,end,str) 把 [start,end)的位置替换成str
逆转reverse()
indexOf(String str)str第一次出现的位置
substring(start,end)截取字符串，[start,end)
length():获取长度
char charAt(index):获取下标的元素
setCharAt(int index,char ch)把index位置的元素替换成指定的ch

扩容问题

扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。
如果扩容还不够，就直接把str当作数组的长度

时间API

JDK8.0之前的API

Date类

1:空参构造器就是创建一个对应当前时间的Date对象
2:创建指定毫秒数的Date对象 Date(123123)
有很多重载的构造器已经过时了，可以使用，但Java不建议使用
两个方法的使用
* 1.toString() 显示当前的年、月、日、时、分、秒
* 2.getTime() 获取当前Date对象对应的毫秒数(时间戳)
java.sql.Date对应着数据库中的日期类型的变量
如何实例化？
       java.sql.Date d = new java.sql.Date(毫秒)

java.util.Date对象转换为java.sql.Date对象
    //方式1：
       Date d3 = new java.sql.Date(1620033120000L);
            java.sql.Date d4 = (java.sql.Date)d3;
       System.out.println(d4.toString());
//方式2:
Date d5 = new Date();
java.sql.Date d6 = new java.sql.Date(d5.getTime());
System.out.println(d6.toString());

SimpleDateFormat的使用

SimpleDateFormat对日期Date类的格式化和解析
/*
* 格式化: 日期-->字符串
* 解析格式化的逆过程字符串 -->日期
*
*/

写法

//SimpleDateFormat的实例化
SimpleDateFormat sk = new SimpleDateFormat();
//日期-->字符串
Date date = new Date();
System.out.println(date);
String format = sk.format(date);
System.out.println(format);

//格式化的逆过程 ,字符串-->日期
String str = "12-2-5 上午11:45";
Date date1 = sk.parse(str);
System.out.println(date1);

按照指定的方式进行格式化和解析

SimpleDateFormat sk1 = new SimpleDateFormat("yyyy.MMMM.dd GGG hh:mm ss");
SimpleDateFormat sk2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
String format1 = sk1.format(date);
System.out.println(format1);

//解析必须按照构造器指定的格式解析，否则报异常
Date parse = sk2.parse("2020-2-18 11:48:27");
System.out.println(parse);

Calendar日历类的使用

//1.实例化Calendar
//方法1 ：创建其子类 GregorianCalendar的对象
GregorianCalendar gregorianCalendar = new GregorianCalendar();
//方法2：调用其静态方法getInstance
Calendar instance = Calendar.getInstance();
System.out.println(instance.getClass());//class java.util.GregorianCalendar

常用方法

//日历类--> Date


//final Date getTime()
Date time = instance.getTime();
System.out.println(time);
System.out.println("--------------------------");

//Datel
//final void setTime(Date date)
instance.setTime(time);
System.out.println(time);
System.out.println("--------------------------");

//void set(int field,int value)
//设置指定时间
time = new Date(23233553455435L);
instance.set(Calendar.DAY_OF_MONTH,8); //日期设置为8号
System.out.println(instance.getTime());
System.out.println("--------------------------");
//void get()
        //获取指定时间
        instance.get(静态常量)//获取指定的日期
//void add(int field,int amount)
        //添加
instance.add(Calendar.HOUR,2);//时间添加2个小时
System.out.println(instance.getTime());
System.out.println("--------------------------");

/*
        * 静态常量:
        * YEAR
        * MONTH
        * DAY_OF_WEEK
        * DAY_OF_MONTH
        * DAY_OF_YEAR
        * HOUR_OF_DAY
        * MINUTE
        * SECOND
*...
* 注意 1月是0、周日是1，以此类推
*
* */

JDK8.0新时间日期API

日期和时间这样的类是不可变的，而Date\Calendar具有可变性
* 偏移性： Date中的年份是从1900开始的，而月份都从0开始
* 格式化 : 格式化只对Date有用，Calendar则不行
*线程也不安全

LocalDate\LocalTime\LocalDateTime的使用

LocalDateTime比其他两个使用频率较高，类似于Calendar

//now() 获取当前的日期、时间、日期+时间
LocalDate now = LocalDate.now();//代表IOS格式的日期

LocalTime now1 = LocalTime.now();//表示一个时间，而不是日期

LocalDateTime now2 = LocalDateTime.now();//用来表示日期和时间的

System.out.println(now);
System.out.println(now1);
System.out.println(now2);

//of() : 设置指定的年、月、日、时、分、秒没有偏移量

LocalDateTime of = LocalDateTime.of(2020, 1, 1, 1, 1, 1);
System.out.println(of);

//getXxx() : 获取相关的属性

System.out.println(now2.getDayOfMonth());
System.out.println(now1.getHour());
System.out.println(now.getDayOfYear());

//不可变性
//withXxx() 设置相关的属性

LocalDate localDate = now.withDayOfMonth(22);
System.out.println(now);
System.out.println(localDate);

//不可变性
//plusXxx(int y) 向当前对象添加几天、几周....
LocalDateTime localDateTime = now2.plusMonths(3);
System.out.println(now2);
System.out.println(localDateTime);
//minusXxx() 从当前对象减去几月、几周....
LocalDateTime localDateTime1 = now2.minusDays(6);
System.out.println(now2);
System.out.println(localDateTime1);

Instant的使用

Instant的使用 : 时间线上的一个瞬时点，这可能被用来记录应用程序中的事件时间戳
//类似java.util.Date类
//now() : 获取本初子午线对应的标准时间
Instant instant = Instant.now();
System.out.println(instant);

//添加时间的偏移量
//ofEpochMilli(long epochMilli) : 静态方法返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象
//atOffset(ZoneOffset offser) ：结合即时的偏移来创建一个OffsetDateTime
//toEpochMilli() : 返回1970-01-01 00:00:00到当前时间的毫秒数，也就是时间戳
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset .ofHours(8)) ;
System.out.println(offsetDateTime);

格式化与解析日期或时间

String format(Date) --> 日期-->字符串(格式化)
TemporalAccessor parse(String) ---> 字符串->日期(解析)

方式1:预定义的标准格式

DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//格式化：日期-->字符串
LocalDateTime time = LocalDateTime.now();
String str1 = formatter.format(time);
System.out.println(time);
System.out.println(str1);

//解析字符串-->日期

TemporalAccessor parse = formatter.parse("2025-07-09T17:13:04.854");
System.out.println(parse);

方式2：本地化相关的格式

DateTimeFormatter formatter1 =DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
String str2 = formatter1.format(time);
System.out.println(str2);
ofLocalizedDateTime():适用于LocalDateTime
/*
FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT
*/
//本地化相关的格式。如：ofLocalizedDate()
// FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
//格式化
String str3 = formatter2.format(LocalDate.now());
System.out.println(str3);//2025-7-10

方式3：

//重点：方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//格式化
String str4 = formatter3.format(LocalDateTime.now());
System.out.println(str4);//2025-07-10 03:52:09

//解析
TemporalAccessor accessor = formatter3.parse("2025-07-10 03:52:09");
System.out.println(accessor);

其他API

ZoneId

//ZoneId:类中包含了所有的时区信息
// ZoneId的getAvailableZoneIds():获取所有的ZoneId
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
for (String s : zoneIds) {
System.out.println(s);
}
// ZoneId的of():获取指定时区的时间
LocalDateTime localDateTime = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
System.out.println(localDateTime);

ZonedDateTime

ZonedDateTime : 获取一个在 ISO-8601日历系统的日期时间
//每个时区都对应着ID 地区ID都为{区域|城市}的格式

// ZonedDateTime的now():获取本时区的ZonedDateTime对象
ZonedDateTime zonedDateTime = ZonedDateTime.now();
System.out.println(zonedDateTime);
// ZonedDateTime的now(ZoneId id):获取指定时区的ZonedDateTime对象
ZonedDateTime zonedDateTime1 = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
System.out.println(zonedDateTime1);

Clock

Clock ：使用时区提供对当前即时，日期和时间的访问的时钟
//Duration : 用于计算两个时间的间隔
//Duration:用于计算两个“时间”间隔，以秒和纳秒为基准
LocalTime localTime = LocalTime.now();
LocalTime localTime1 = LocalTime.of(15, 23, 32);
//between():静态方法，返回Duration对象，表示两个时间的间隔
Duration duration = Duration.between(localTime1, localTime);
System.out.println(duration);
System.out.println(duration.getSeconds());
System.out.println(duration.getNano());
LocalDateTime localDateTime2 = LocalDateTime.of(2016, 6, 12, 15, 23, 32);
LocalDateTime localDateTime1 = LocalDateTime.of(2017, 6, 12, 15, 23, 32);
Duration duration1 = Duration.between(localDateTime1, localDateTime2);
System.out.println(duration1.toDays());

Period

Period:用于计算两个“日期”间隔，以年、月、日衡量
LocalDate localDate = LocalDate.now();
LocalDate localDate1 = LocalDate.of(2028, 3, 18);
Period period = Period.between(localDate, localDate1);
System.out.println(period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
Period period1 = period.withYears(2);
System.out.println(period1);

Java比较器

java比较运算符，大部分只能比较基本数据类型，对于引用数据类型则不能使用，比如两个对象不能用> < 来比较，这就需要比较器

Java比较器的两个接口

Compareable || Comparator

Compareable（自然排序）

String，包装类等实现了Comparable接口，重写了compareTo(obj)方法，实现了比较两个对象的大小。从而实现从小到大排序
   对于自定义类来说，如果需要排序，可以让自定义类实现Comparable接口，重写compareTo(obj)方法，在方法中指明该如何排序
   重写compareTo(obj)应该遵循的规则
   如果this 大于形参对象obj，则返回正数
   如果this 小于形参对象obj，则返回负数
   如果this 等于形参对象obj，则返回0
以京东页面举例，需要筛选商品，可以通过价格，评价等筛选，每个商品就是一个对象，价格，评论等都是属性，实现compareablle，重写compareTo后，方法内部就可以以属性比较大小，并进行排序

Comparator接口（定制排序）

Comparator接口(定制排序)
   当自定义类没有实现Comparable接口，且不方便修改代码，或实现了Comparable接口，但重写的compareTo(obj)方法不适合排序
   可以使用Comparator接口的匿名对象,实现compare(Object o1,Object o2)
   方法的规则
       返回正数表示o1 大于 o2
       返回负数表示o1 小于 o2
       返回0表示o1 等于 o2

两者的区别

两者的区别
Comparable接口的方式一旦确定，保证Compareable接口实现类的对象在任何位置都可以比较大小
Comparator接口属于临时性的比较

其他类的使用

System的使用

//返回当前的计算机时间的时间戳
long l = System.currentTimeMillis();
System.out.println(l);

//System.exit(0);//退出程序，0代表正常退出，非零代表异常退出

//gc() 请求系统进行垃圾回收,至于系统是否立即回收，取决于系统中垃圾回收算法的实现以及系统执行时的情况
System.gc();
//getProperty(String key) : 获取系统中属性名为key的属性对应的值
/*
* 属性名属性说明
* java.version java运行时环境版本
* java.home java安装目录
* os.name 操作系统的名称
* os.version 操作系统的版本
* user.name 用户的账户名称
* user.home 用户的主目录
* user.dir 用户的当前工作目录
* */

String property1 = System.getProperty("os.name");
System.out.println(property1);
String property2 = System.getProperty("os.version");
System.out.println(property2);
String property3 = System.getProperty("user.name");
System.out.println(property3);

Math类的使用

//常用方法
* abs 绝对值
* acos,asin,atan,cos,sin,tan 三角函数
* sqrt 平方根
* pow(a,b) a的b次幂
* log 对数
* exp 指数
* max(a,b) 最大值
* min(a,b) 最小值
* random() 返回0.0-1.0的随机数
* round(a) 四舍五入
* toDegrees(d) 弧度转角度
* toRadians(d) 角度转弧度

BigInteger和BigDecimal的使用

* BigInteger可以表示不可变的任意精度的整数
* BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、
* 位操作以及一些其他操作
* BigInteger(String val)：根据字符串构建BigInteger对象

常用方法
       * abs() 绝对值
* add(val) 返回this+val
* subtract(val) 返回 this-val
* multiply(val) 返回 this *val
* divide(val) 返回this/val
* remainder(val) 返回this%val
* divideAndRemainder(val) 返回包含this/val后跟this%val的两个数组
* pow(i) 返回 this的i次方
//BigDecimal
    *商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类
* 构造器:
* public BigDecimal(double val)
* public BigDecimal(String val)
常用方法
        * add()+
* subtract()-
* multiply()乘
* divide(divisor,scale,roundingMode)除
       divsor:被除数
       scale:保留几位小数
       roundingMode : BigDecimal的常量