Java的一些常用类

会移动的树~

已于 2023-12-12 18:32:19 修改

阅读量789

点赞数 18

分类专栏： java 文章标签： java 开发语言 java-ee

于 2023-12-12 18:32:11 首次发布

本文链接：https://blog.csdn.net/m0_59740242/article/details/134956086

版权

java 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1.1、字符串相关的类

String类:代表字符串。Java程序中的所有字符串字面值（如 "abc" )都作为此类的实例实现。
String是一个final类，代表不可变的字符序列 不可变性
字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改
string内部定义了final char[] value用于存储字符串数据
通过字面量的方式(区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
字符串常量池中是不会存储相同内容的字符串的。

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

实现了Comparable接口:表示String可以比较大小

理解不可变性

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

String不同实例化方式对比

方式一:通过字面量定义的方式
方式二:通过new +构造器的方式

 public void test2(){
         //通过字面量定义的方式  此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
         String s1 = "JAVAEE";
         String s2 = "JAVAEE";
         //通过new +构造器的方式  此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
         String s3 = new String("JAVAEE");
         String s4 = new String("JAVAEE");
 
         System.out.println(s1==s2);  //true
         System.out.println(s1==s3);  //false
         System.out.println(s1==s4);  //false
         System.out.println(s3==s4); //false
      
      Person person = new Person(12,"TOM");
         Person person2 = new Person(12,"TOM");
     }

结论：

常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
只要其中有一个是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中

 @Test
     public void test3(){
         String s1 = "hello";
         String s2 = "world";
         String s3 = "hello" + "world";
         String s4 = s1 + "world";
         String s5 = s1 + s2;
         String s6 = (s1 + s2).intern();
 
         System.out.println(s1 == s3);  //false
         System.out.println(s3 == s4);  //false
         System.out.println(s1 == s3);  //false
         System.out.println(s1 == s5);  //false
         System.out.println(s3 == s6);  //false
     }

常用方法

int length() :返回字符串的长度 return value.length
char charAt(int index) : 返回某索引处的字符 return value[index]
boolean isEmpty() : 判断是否为空字符串 return value.length ==0
String toLowerCase() : 使用默认语言环境，将String中的所有字符转换为小写
String toUpperCase() : 使用默认语言环境，将String中的所有字符转换为大写
String trim() 返回字符串的副本，忽略前导空白和尾部空白(去除字符串的首尾空格)
boolean equals(Object object) :比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString) :与equals方法类似，忽略大小写
String concat(String str) : 将指定字符连接到此字符串的结尾。等价于用“ + ”
int compareTo(String anotherString) : 比较两个字符串的大小涉及到字符串排序
String subString(int beginIndex) : 返回一个新的字符串，它是此字符串从beginIndex开始截取到最后一个子字符串
String subString(int beginIndex,intendIndex) : 返回一个新的字符串，它是此字符串从beginIndex开始截取到endIndex(不包含) 左闭右开
boolean endsWith(String suffix) : 测试此字符串是否以指定的后缀结束
boolean stratsWith(String prefix) : 测试此字符串是否以指定的前缀结束
blloean startsWith(String prefix,int toffset) : 测试此字符串从指定索引开始的子字符串是否以指定前缀开始 (从2开始是不是以ll开头)
boolean contains(CharSequence s) : 当且仅当此字符串包含指定的 char 值序列时，返回true

从前往后

int indexOf(String str) : 返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str,int formIndex) : 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 eg：从5开始找lo

从后往前

int lastIndex0f(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(string str, int fromIndex):返回指定子字符串在此字符串中最后一次出现从指定的索引开始反向搜索
注: indexof和LastIndex0f方法如果未找到都是返回-1

‘什么情况下， indexof (str)和LastIndexof(str)返回值相同?

情况一:存在唯一的一个str。情况二:不存在str

String与其他结构转换问题

复习：String与基本数据类型、包装类之间的转换。

......

string char[]之间的转换

string --> char[]:调用String的toCharArray()

char[-->String:调用string的构造器

 /*
     String 与 char[]之间的转换
 
     String --> char[]:调用String的toCharArray()
     char[] --> String:调用String的构造器
      */
     @Test
     public void test2(){
         String str1 = "abc123";  //题目： a21cb3
 
         char[] charArray = str1.toCharArray();
         for (int i = 0; i < charArray.length; i++) {
             System.out.println(charArray[i]);
         }
 
         char[] arr = new char[]{'h','e','l','l','o'};
         String str2 = new String(arr);
         System.out.println(str2);
     }

String 与 byte[] 之间的转换

编码：string --> byte[]:调用String的getBytes()

解码: byte[] --> String:调用String的构造器

 /*
     String 与 byte[]之间的转换
     编码：String --> byte[]:调用String的getBytes()
     解码：byte[] --> String:调用String的构造器
 
     编码：字符串 -->字节  (看得懂 --->看不懂的二进制数据)
     解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）
 
     说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
      */
     @Test
     public void test3() throws UnsupportedEncodingException {
         String str1 = "abc123中国";
         byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
         System.out.println(Arrays.toString(bytes));
 
         byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
         System.out.println(Arrays.toString(gbks));
 
         System.out.println("******************");
 
         String str2 = new String(bytes);//使用默认的字符集，进行解码。
         System.out.println(str2);
 
         String str3 = new String(gbks); 
         System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！
 
 
         String str4 = new String(gbks, "gbk");
         System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！
 
 
     }

编码:字符串-->字节(看得懂--->看不懂的二进制数据)

解码:编码的逆过程，字节--〉字符串(看不懂的二进制数据--->看得懂）

出现乱码。原因:编码集和解码集不一致!

说明:解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

String常见算法题目

1.模拟一个trim方法，去除字符串两端的空格。

2.将一个字符串进行反转。将字符串中指定部分进行反转。比如"abcdefg”反转为"abfedcg"

3.获取一个字符串在另一个字符串中出现的次数。比如:获取“ab”在“abkkcadkabkebfkabkskab”中出现的次数

4.获取两个字符串中最大相同子串。比如:str1 = "abcwerthelloyuiodef;str2 = "cvhellobnm"提示:将短的那个串进行长度依次递减的子串与较长的串比较。

5.对字符串中字符进行自然顺序排序。

提示: 1）字符串变成字符数组。 2）对数组排序，选择，冒泡，Arrays.sort();

3）将排序后的数组变成字符串。

StringBuffer类(可变)

java.lang.StringBuffer代表可变的字符序列

常用方法

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接 StringBuffer delete(int start,int end)：删除指定位置的内容 StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str StringBuffer insert(int offset, xxx)：在指定位置插入xxx StringBuffer reverse() ：把当前字符序列逆转 public int indexOf(String str) public String substring(int start,int end): 返回一个从start开始到end索引结束的左闭右开区间的子字符串

public int length() public char charAt(int n ) public void setCharAt(int n ,char ch)

总结：增：append(xxx) 删：delete(int start,int end) 改：setCharAt(int n ,char ch) / replace(int start, int end, String str) 查：charAt(int n ) 插：insert(int offset, xxx) 长度：length(); 遍历：for() + charAt() / toString(

三者比较：

同: 底层使用char[]存储

String:不可变的字符序列;

StringBuffer:可变的字符序列;线程安全的，效率低;

stringBuilder:可变的字符序列; jdk5.0新增的，线程不安全的，效率高;

源码分析： String str = new String(); //char[] value = new char[0]; String str1 = new String("abc"); //char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer(); //char[] value = new char[16];底层创建了一个长度是16的数组。 System.out.println(sb1.length());// sb1.append('a');//value[0] = 'a'; sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc"); //char[] value = new char["abc".length() + 16];

//问题1. System.out.println(sb2.length()); //3 //问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

对比三者效率

从高到低排列: StringBuilder > StringBuffer > String

 @Test
     public void test3(){
         //初始设置
         long startTime = 0L;
         long endTime = 0L;
         String text = "";
         StringBuffer buffer = new StringBuffer("");
         StringBuilder builder = new StringBuilder("");
         //开始对比
         startTime = System.currentTimeMillis();
         for (int i = 0; i < 20000; i++) {
             buffer.append(String.valueOf(i));
         }
         endTime = System.currentTimeMillis();
         System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
 
         startTime = System.currentTimeMillis();
         for (int i = 0; i < 20000; i++) {
             builder.append(String.valueOf(i));
         }
         endTime = System.currentTimeMillis();
         System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
 
         startTime = System.currentTimeMillis();
         for (int i = 0; i < 20000; i++) {
             text = text + i;
         }
         endTime = System.currentTimeMillis();
         System.out.println("String的执行时间：" + (endTime - startTime));
 
     }

1.2、JDK8之前的日期时间API

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日O时0分0秒之间以毫秒为单位的时间差。

称为时间戳

此方法适于计算时间差。

Java中两个Date类的使用

java.util.Date类父类

两个构造器的使用

构造器一: Date() 创建一个对应当前时间的Date对象

构造器二创建指定毫秒数的Date对象

 @Test
     public void test2(){
         //构造器一: Date() 创建一个对应当前时间的Date对象
         Date date1 = new Date();
         System.out.println(date1.toString());//Sun Oct 16 17:38:00 CST 2022
         System.out.println(date1.getTime()); //时间戳
         //构造器二  创建指定毫秒数的Date对象
         Date date2 =new Date(1665913180184L);
         System.out.println(date2.toString());
     }

两个方法的使用

toString() 显示当前的年、月、日、时、分、秒
getTime() 获取当前Date对象对应的时间戳

java.sql.Date类子类

对应着数据库中的日期类型的变量

如何实例化

 //创建java.sql.Date对象
         java.sql.Date date3 = new java.sql.Date(123456346513L);
         System.out.println(date3.toString());  //1973-11-30

如何将java.util.Date对象转换为java.sql.Date对象

//将java.util.Date对象转换为java.sql.Date对象
         //情况一
 //        Date date4 = new java.sql.Date(2343243242323L);
 //        java.sql.Date date5 = (java.sql.Date) date4;
         //情况二
         Date date4 = new Date();
         java.sql.Date date5 = new java.sql.Date(date4.getTime());
 //        Date date6 = new Date();
 //        java.sql.Date date7 = (java.sql.Date)date6;   运行报错  不同的对象不能强制转换 new的是父类，不能转为子类

java.text.SimpleDateFormat类

简单日期格式化对日期Date类的格式化和解析

它允许进行格式化:日期→文本(字符串)、解析:(字符串)文本→日期

格式化

SimpleDateFormat() : 默认的模式和语言环境创建对象

public SimpleDateFormat(String pattern):该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用:public String format(Date date):方法格式化时间对象date

解析

public Date parse(String source):从给定字符串的开始解析文本，以生成一个日期。

解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现)，否则，报异常

 @Test
     public void testSimpleDateFormat() throws ParseException {
         //实例化 SimpleDateFormat
         SimpleDateFormat sdf = new SimpleDateFormat();
 
         //格式化 日期----> 字符串
         Date date = new Date();
        System.out.println(date); //Sun Oct 16 19:57:33 CST 2022
         String format = sdf.format(date);
         System.out.println(format);     //2022/10/16 下午7:57   字符串
 
         //解析 字符串---->日期
         String str = "2022/10/16 下午7:57";
         Date date1 = sdf.parse(str);
         System.out.println(date1);  //Sun Oct 16 19:57:00 CST 2022
         //********************************
         System.out.println("**********************************");
         // *********按照指定的方式格式化和解析:调用带参的构造器********
         SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
         //格式化
         String format1 = sdf1.format(date);
         System.out.println(format1);  //2022-10-16 08:07:46
         //解析
         Date date2 = sdf1.parse("2022-10-16 08:07:46");
         System.out.println(date2);  //Sun Oct 16 08:07:46 CST 2022
 
     }

练习二:"三天打渔两天晒网”1990-01-01xXXX-XX-xx打渔﹖晒网?举例: 2020-09-e8 ?总天数

 * 练习一：字符串"2002-10-29"转换为java.sql.Date
     * */
     @Test
     public void test1() throws ParseException {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         String str = "2002-10-29";
         Date parse = sdf.parse(str);
         System.out.println(parse);  //Tue Oct 29 00:00:00 CST 2002
 
         java.sql.Date birthDate = new java.sql.Date(parse.getTime());
         System.out.println(birthDate); //2002-10-29
     }

java.util.Calendar(日历)类

实例化

方式一:创建其子类(Gregoriancalendar）的对象
方式二:调用其静态方法getInstance()

常用方法

get()
set()
add()
getTime()
setTime()

 @Test
     public void testCalender(){
         //实例化
         Calendar calendar = Calendar.getInstance();
 
         //常用方法
         //get()
         int i = calendar.get(Calendar.DAY_OF_MONTH);
         System.out.println(i);  //16
 
         //set() 没有返回值
         calendar.set(Calendar.DAY_OF_MONTH,22);
         i = calendar.get(Calendar.DAY_OF_MONTH);
         System.out.println(i);
 
         //add() 没有返回值
         calendar.add(Calendar.DAY_OF_MONTH,3); //想减变为-3
         i = calendar.get(Calendar.DAY_OF_MONTH);
         System.out.println(i);
 
         //getTime()  日历类---------->Date
         Date date = calendar.getTime();
         System.out.println(date); //Tue Oct 25 20:41:43 CST 2022
 
         //setTime() Date------->日历类
         Date date1 = new Date();
         calendar.setTime(date1);
         i = calendar.get(Calendar.DAY_OF_MONTH);
         System.out.println(i);  //16
     }

注意：

获取月份时:一月是0，二月是1，以此类推，12月是11
获取星期时:周日是1，周二是2，。。。。周六是7

1.3、JDK8中新日期时间API

引出

可变性:像日期和时间这样的类应该是不可变的。
偏移性:Date中的年份是从1900开始的，而月份都从0开始。
格式化:格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的;不能处理闰秒等。

LocalDateTime类

ISO-8601为公历

它们的实例都是不可变的对象

类似于Calender

LocalDate

代表IOS格式（yyyy-MM-dd）的日期,可以存储生日、纪念日等日期

LocalTime

表示一个时间，而不是日期。

LocalDateTime

是用来表示日期和时间的，这是一个最常用的类之一

实例化：

now():根据当前时间创建对象/指定时区的对象
of():根据指定日期/时间创建对象

  @Test
     public void test(){
         //now()  获取当前的日期、时间、日期和时间  根据当前时间创建对象/指定时区的对象
         LocalDate now = LocalDate.now();
         LocalTime now1 = LocalTime.now();
         LocalDateTime now2 = LocalDateTime.now();
 
         System.out.println(now);  //2022-10-17
         System.out.println(now1); //09:50:16.696746700
         System.out.println(now2); //2022-10-17T09:50:16.696746700
 
         //of()根据指定日期/时间创建对象  无偏移量
         LocalDateTime of = LocalDateTime.of(2002, 10, 29, 12, 23, 23);
         System.out.println(of);
     }

方法：

getXxx() 获取
withXxx() 修改
plusMonths(2); 增加
minusDays(8); 减

 //getXxx()
         System.out.println(now2.getDayOfMonth()); //17
         System.out.println(now2.getDayOfWeek());  //MONDAY
         System.out.println(now2.getMonth());      //OCTOBER
         System.out.println(now2.getMonthValue()); //10
         System.out.println(now2.getMinute());     //2
 
         //withXxx() 修改  不可变性
         LocalDate localDate = now.withDayOfMonth(22);
         System.out.println(localDate);  //2022-10-22
         System.out.println(now);        //2022-10-17
 
         LocalDateTime localDateTime = now2.withHour(9);
         System.out.println(now2);  //2022-10-17T10:07:54.590084600
         System.out.println(localDateTime); //2022-10-17T09:07:54.590084600
 
         //增加  不可变性
         LocalDateTime localDateTime1 = now2.plusMonths(2);
         System.out.println(now2);            //2022-10-17T10:08:54.873055700
         System.out.println(localDateTime1);  //2022-12-17T10:08:54.873055700
 
         //减
         LocalDateTime localDateTime2 = now2.minusDays(8);
         System.out.println(now2);  //2022-10-17T10:09:57.188871700
         System.out.println(localDateTime2);  //2022-10-09T10:09:57.188871700
     }

瞬时：Instant类

时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳

类似于java.utiL.Date类

  @Test
     public void test1(){
         Instant instant = Instant.now();
         //本初子午线的时间 需要我们时间-8h
         System.out.println(instant);  //2022-10-17T02:15:22.825877Z
         //加偏移量
         OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
         System.out.println(offsetDateTime);  //2022-10-17T10:19:36.732001900+08:00  我们的时间
 
         //获取对应毫秒数
         long l = instant.toEpochMilli();
         System.out.println(l); //1665973253763      =getTime()
         //通过给定的毫秒数，获取Instant实例
         Instant instant1 = Instant.ofEpochMilli(1665973253763L);
         System.out.println(instant1);
 
     }

DateTimeFormatter类

格式化解析日期或时间

  @Test
     public void test2(){
         //        方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
         DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
         //格式化:日期-->字符串
         LocalDateTime localDateTime = LocalDateTime.now();
         String str1 = formatter.format(localDateTime);
         System.out.println(localDateTime);
         System.out.println(str1);//2019-02-18T15:42:18.797
 
         //解析：字符串 -->日期
         TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
         System.out.println(parse);
 
 //        方式二：
 //        本地化相关的格式。如：ofLocalizedDateTime()
 //        FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
         DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
         //格式化
         String str2 = formatter1.format(localDateTime);
         System.out.println(str2);//2019年2月18日 下午03时47分16秒
 
 //      本地化相关的格式。如：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);//2019-2-18
 
 
 //       重点： 方式三：自定义的格式。如：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);//2019-02-18 03:52:09
 
         //解析
         TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
         System.out.println(accessor);
 
     }

1.4、Java比较器

比较对象大小的接口

Java实现对象排序的方式有两种

java.util

Comparable接口

自然定序

像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
像String、包装类重写compareTo()方法以后，进行了从小到大的排列
重写compareTo(obj)方法的规则：
- 如果当前对象this大于形参对象obj，则返早正整数
- 如果当前对象this小于形参对象obj，则返四负整数
- 如果当前对象this等于形参对象obj，则返回零。
对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法在compareTo(obj)方法中指明如何排序(否则会报ClassCastException 类型转换异常)

//指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
     @Override
     public int compareTo(Object o) {
 //        System.out.println("**************");
         if(o instanceof Goods){
             Goods goods = (Goods)o;
             //方式一：
             if(this.price > goods.price){
                 return 1;
             }else if(this.price < goods.price){
                 return -1;
             }else{
 //                return 0;
                return -this.name.compareTo(goods.name);
             }
             //方式二：
 //           return Double.compare(this.price,goods.price);
         }
 //        return 0;
         throw new RuntimeException("传入的数据类型不一致！");
     }
 
  @Test
     public void test2(){
         Goods[] arr = new Goods[5];
         arr[0] = new Goods("lenovoMouse",34);
         arr[1] = new Goods("dellMouse",43);
         arr[2] = new Goods("xiaomiMouse",12);
         arr[3] = new Goods("huaweiMouse",65);
         arr[4] = new Goods("microsoftMouse",43);
 
         Arrays.sort(arr);
 
         System.out.println(Arrays.toString(arr));
     }

Comparator接口

定制排序

背景

当元素的类型没有实现java.Lang.Comparable接口而又不方便修改代码
或者实现了java.Lang.Comparable接口的排序规则不适合当前的操作
重写compare (object o1,object o2)方法，比较o1和o2的大小:

 @Test
     public void test2() {
         Goods[] arr = new Goods[6];
         arr[0] = new Goods("lenovoMouse", 34);
         arr[1] = new Goods("dellMouse", 43);
         arr[2] = new Goods("xiaomiMouse", 12);
         arr[3] = new Goods("huaweiMouse", 65);
         arr[4] = new Goods("huaweiMouse", 224);
         arr[5] = new Goods("microsoftMouse", 43);
 
         Arrays.sort(arr, new Comparator() {
             //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
             @Override
             public int compare(Object o1, Object o2) {
                 if (o1 instanceof Goods && o2 instanceof Goods) {
                     Goods g1 = (Goods) o1;
                     Goods g2 = (Goods) o2;
 
                     if (g1.getName().equals(g2.getName())) {
                         return -Double.compare(g1.getPrice(), g2.getPrice());
                     } else {
                         return g1.getName().compareTo(g2.getName());
                     }
                 }
                 throw new RuntimeException("输入的数据类型不一致");
             }
         });
 
         System.out.println(Arrays.toString(arr));
     }

Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小

Comparator接口属于临时性的比较

1.5、System类

类的构造器是private的，无法实例化，成员变量和成员方法都是static的，很方便调用

成员变量：

System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

成员方法

native long currentTimeMillis():
void exit(int status):该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出使用该方法可以在图形界面编程中实现程序的退出功能等。
void gc():该方法的作用是请求系统进行垃圾回收，不一定立马回收
String getProperty(String key):该方法的作用是获得系统中属性名为key的属性对应的值。

 @Test
     public void test1() {
         String javaVersion = System.getProperty("java.version");
         System.out.println("java的version:" + javaVersion);
 
         String javaHome = System.getProperty("java.home");
         System.out.println("java的home:" + javaHome);
 
         String osName = System.getProperty("os.name");
         System.out.println("os的name:" + osName);
 
         String osVersion = System.getProperty("os.version");
         System.out.println("os的version:" + osVersion);
 
         String userName = System.getProperty("user.name");
         System.out.println("user的name:" + userName);
 
         String userHome = System.getProperty("user.home");
         System.out.println("user的home:" + userHome);
 
         String userDir = System.getProperty("user.dir");
         System.out.println("user的dir:" + userDir);
 
     }
 java的version:16.0.2
 java的home:E:\Environment\JDK安装\jdk安装
 os的name:Windows 10
 os的version:10.0
 user的name:cx
 user的home:C:\Users\cx
 user的dir:E:\onestudy\JavaSenior\Day04

1.6Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

1.7、BigInteger 与 BigDecimal

BigInteger 整型

BigDecimal 浮点型

 @Test
     public void test2() {
         BigInteger bi = new BigInteger("1243324112234324324325235245346567657653");
         BigDecimal bd = new BigDecimal("12435.351");
         BigDecimal bd2 = new BigDecimal("11");
         System.out.println(bi);
         //System.out.println(bd.divide(bd2));  //ArithmeticException  算数异常
         System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
         System.out.println(bd.divide(bd2, 25, BigDecimal.ROUND_HALF_UP));
 
     }