1、昨日复习

  1. 画出如下几行代码的内容结构：
    String s1 = “hello”;
    String s2 = “hello”;
    String s3 = new String(“hello”);
    s1 += “world”;

  2. 如何理解String类的不可变性

  3. String类是否可以被继承？为什么？
    String s = new String(“hello”);在内存中创建了几个对象？请说明

  4. String，StringBuffer，StringBuilder三者的对比

  5. String的常用方法有哪些？（至少7个）
    length() / charAt() / equals() / compareTo() / startsWith() / endsWith()
    containts() / indexOf() / lastIndexOf() / getBytes() / toCharArray() / valueOf() / ….

    2、常见算法题目

    ```java package com.atguigu.java;

import java.util.ArrayList; import java.util.Arrays; import java.util.List;

import org.junit.Test;

/*

  • 1.模拟一个trim方法，去除字符串两端的空格。
  • 2.将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
  • 3.获取一个字符串在另一个字符串中出现的次数。 比如：获取“ab”在 “cdabkkcadkabkebfkabkskab”
    中出现的次数

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

5.对字符串中字符进行自然顺序排序。”abcwerthelloyuiodef” 提示： 1）字符串变成字符数组。 2）对数组排序，选择，冒泡，Arrays.sort(str.toCharArray()); 3）将排序后的数组变成字符串。

*/ public class StringExer {

  1. // 第1题
  2. public String myTrim(String str) {
  3.     if (str != null) {
  4.         int start = 0;// 用于记录从前往后首次索引位置不是空格的位置的索引
  5.         int end = str.length() - 1;// 用于记录从后往前首次索引位置不是空格的位置的索引
  7.         while (start < end && str.charAt(start) == ' ') {
  8.             start++;
  9.         }
  11.         while (start < end && str.charAt(end) == ' ') {
  12.             end--;
  13.         }
  14.         if (str.charAt(start) == ' ') {
  15.             return "";
  16.         }
  18.         return str.substring(start, end + 1);
  19.     }
  20.     return null;
  21. }
  23. // 第2题
  24. // 方式一：
  25. public String reverse1(String str, int start, int end) {// start:2,end:5
  26.     if (str != null) {
  27.         // 1.
  28.         char[] charArray = str.toCharArray();
  29.         // 2.
  30.         for (int i = start, j = end; i < j; i++, j--) {
  31.             char temp = charArray[i];
  32.             charArray[i] = charArray[j];
  33.             charArray[j] = temp;
  34.         }
  35.         // 3.
  36.         return new String(charArray);
  38.     }
  39.     return null;
  41. }
  43. // 方式二：
  44. public String reverse2(String str, int start, int end) {
  45.     // 1.
  46.     String newStr = str.substring(0, start);// ab
  47.     // 2.
  48.     for (int i = end; i >= start; i--) {
  49.         newStr += str.charAt(i);
  50.     } // abfedc
  51.         // 3.
  52.     newStr += str.substring(end + 1);
  53.     return newStr;
  54. }
  56. // 方式三：推荐 （相较于方式二做的改进）
  57. public String reverse3(String str, int start, int end) {// ArrayList list = new ArrayList(80);
  58.     // 1.
  59.     StringBuffer s = new StringBuffer(str.length());
  60.     // 2.
  61.     s.append(str.substring(0, start));// ab
  62.     // 3.
  63.     for (int i = end; i >= start; i--) {
  64.         s.append(str.charAt(i));
  65.     }
  67.     // 4.
  68.     s.append(str.substring(end + 1));
  70.     // 5.
  71.     return s.toString();
  73. }
  75. @Test
  76. public void testReverse() {
  77.     String str = "abcdefg";
  78.     String str1 = reverse3(str, 2, 5);
  79.     System.out.println(str1);// abfedcg
  81. }
  83. // 第3题
  84. // 判断str2在str1中出现的次数
  85. public int getCount(String mainStr, String subStr) {
  86.     if (mainStr.length() >= subStr.length()) {
  87.         int count = 0;
  88.         int index = 0;
  89.         // while((index = mainStr.indexOf(subStr)) != -1){
  90.         // count++;
  91.         // mainStr = mainStr.substring(index + subStr.length());
  92.         // }
  93.         // 改进：
  94.         while ((index = mainStr.indexOf(subStr, index)) != -1) {
  95.             index += subStr.length();
  96.             count++;
  97.         }
  99.         return count;
  100.     } else {
  101.         return 0;
  102.     }
  104. }
  106. @Test
  107. public void testGetCount() {
  108.     String str1 = "cdabkkcadkabkebfkabkskab";
  109.     String str2 = "ab";
  110.     int count = getCount(str1, str2);
  111.     System.out.println(count);
  112. }
  114. @Test
  115. public void testMyTrim() {
  116.     String str = "   a   ";
  117.     // str = " ";
  118.     String newStr = myTrim(str);
  119.     System.out.println("---" + newStr + "---");
  120. }
  122. // 第4题
  123. // 如果只存在一个最大长度的相同子串
  124. public String getMaxSameSubString(String str1, String str2) {
  125.     if (str1 != null && str2 != null) {
  126.         String maxStr = (str1.length() > str2.length()) ? str1 : str2;
  127.         String minStr = (str1.length() > str2.length()) ? str2 : str1;
  129.         int len = minStr.length();
  131.         for (int i = 0; i < len; i++) {// 0 1 2 3 4 此层循环决定要去几个字符
  133.             for (int x = 0, y = len - i; y <= len; x++, y++) {
  135.                 if (maxStr.contains(minStr.substring(x, y))) {
  137.                     return minStr.substring(x, y);
  138.                 }
  140.             }
  142.         }
  143.     }
  144.     return null;
  145. }
  147. // 如果存在多个长度相同的最大相同子串
  148. // 此时先返回String[]，后面可以用集合中的ArrayList替换，较方便
  149. public String[] getMaxSameSubString1(String str1, String str2) {
  150.     if (str1 != null && str2 != null) {
  151.         StringBuffer sBuffer = new StringBuffer();
  152.         String maxString = (str1.length() > str2.length()) ? str1 : str2;
  153.         String minString = (str1.length() > str2.length()) ? str2 : str1;
  155.         int len = minString.length();
  156.         for (int i = 0; i < len; i++) {
  157.             for (int x = 0, y = len - i; y <= len; x++, y++) {
  158.                 String subString = minString.substring(x, y);
  159.                 if (maxString.contains(subString)) {
  160.                     sBuffer.append(subString + ",");
  161.                 }
  162.             }
  163.             System.out.println(sBuffer);
  164.             if (sBuffer.length() != 0) {
  165.                 break;
  166.             }
  167.         }
  168.         String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
  169.         return split;
  170.     }
  172.     return null;
  173. }
  174. // 如果存在多个长度相同的最大相同子串：使用ArrayList

// public List getMaxSameSubString1(String str1, String str2) { // if (str1 != null && str2 != null) { // List list = new ArrayList(); // String maxString = (str1.length() > str2.length()) ? str1 : str2; // String minString = (str1.length() > str2.length()) ? str2 : str1; // // int len = minString.length(); // for (int i = 0; i < len; i++) { // for (int x = 0, y = len - i; y <= len; x++, y++) { // String subString = minString.substring(x, y); // if (maxString.contains(subString)) { // list.add(subString); // } // } // if (list.size() != 0) { // break; // } // } // return list; // } // // return null; // }

  1. @Test
  2. public void testGetMaxSameSubString() {
  3.     String str1 = "abcwerthelloyuiodef";
  4.     String str2 = "cvhellobnmiodef";
  5.     String[] strs = getMaxSameSubString1(str1, str2);
  6.     System.out.println(Arrays.toString(strs));
  7. }
  9. // 第5题
  10. @Test
  11. public void testSort() {
  12.     String str = "abcwerthelloyuiodef";
  13.     char[] arr = str.toCharArray();
  14.     Arrays.sort(arr);
  16.     String newStr = new String(arr);
  17.     System.out.println(newStr);
  18. }

}

  1. <a name="ltRH1"></a>
  2. # 3、**java.text.SimpleDateFormat类**
  3. Date类的API不易于国际化，大部分被废弃了，**java.text.SimpleDateFormat**类是一个不与语言环境有关的方式来格式化和解析日期的具体类。 <br />它允许进行**格式化：日期》文本**、**解析：文本》日期 **<br />**格式化： **<br />**SimpleDateFormat() **：默认的模式和语言环境创建对象 <br />**public SimpleDateFormat(String pattern)：**该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用： **public String format(Date date)：**方法格式化时间对象date <br />**解析： **<br />**public Date parse(String source)：**从给定字符串的开始解析文本，以生成一个日期。
  5. ---
  7. SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析<br />1、两个操作：<br />1.1 格式化：日期--->字符串<br />1.2 解析：格式化的逆过程，字符串--->日期<br />2、SimpleDateFormat的实例化
  8. ```java
  9. @Test
  10.     public void test1() throws ParseException {
  11.         SimpleDateFormat sdf = new SimpleDateFormat();
  12.         //格式化
  13.         Date date = new Date();
  14.         System.out.println(date);
  15.         String format = sdf.format(date);
  16.         System.out.println(format);
  17.         //解析
  18.         String str = "2022-1-16 下午3:25";
  19.         Date date1 = sdf.parse(str);
  20.         System.out.println(date1);
  22.         System.out.println("********************************");
  23.         //指定方式格式化，调用带参的构造器
  24.         SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  25.         //格式化
  26.         String s = sdf1.format(date);
  27.         System.out.println(s);
  28.         //解析：要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器参数体现），否则抛异常
  29.         Date date2 = sdf1.parse("2019-11-28 16:44:25");
  30.         System.out.println(date2);
  31.     }
  1.     /*
  2.     练习一：字符串“2020-09-08”转换为java.sql.Date
  3.      */
  4.     @Test
  5.     public void test2() throws ParseException {
  6.         String birth = "2020-09-08";
  7.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  8.         Date date = sdf.parse(birth);
  9. //        System.out.println(date);
  10.         java.sql.Date birthDate  = new java.sql.Date(date.getTime());
  11.         System.out.println(birthDate);
  12.     }

4、java.util.Calendar(日历)类

Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
获取Calendar实例的方法
使用Calendar.getInstance()方法
调用它的子类GregorianCalendar的构造器。
一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
public void set(int field,int value)
public void add(int field,int amount)
public final Date getTime()
public final void setTime(Date date)
注意:
获取月份时：一月是0，二月是1，以此类推，12月是11
获取星期时：周日是1，周二是2 ， 。。。。周六是7

  1.     @Test
  2.     public void test1(){
  3. //        Calendar的使用
  4. //        1、实例化
  5. //        方式一：创建其子类（GregorianCalendar）的对象
  6. //        方式二：调用其静态方法getInstance();
  7.         Calendar calendar = Calendar.getInstance();
  8.         System.out.println(calendar.getClass());//class java.util.GregorianCalendar
  9.         Calendar calendar1 = new GregorianCalendar();
  10. //        2、常用方法
  11. //        get()
  12.         int days = calendar.get(Calendar.DAY_OF_MONTH);
  13.         System.out.println(days);//16
  14.         System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//16
  15. //
  16. //        set()
  17.         calendar.set(Calendar.DAY_OF_MONTH,5);
  18.         days = calendar.get(Calendar.DAY_OF_MONTH);
  19.         System.out.println(days);//5
  20. //
  21. //        add()
  23.         calendar.add(Calendar.DAY_OF_MONTH,-3);
  24.         days = calendar.get(Calendar.DAY_OF_MONTH);
  25.         System.out.println(days);//2
  26. //
  27. //        getTime()：日历类———>Date
  28.         Date date = calendar.getTime();
  29.         System.out.println(date.getTime());//1641111904994
  30.         System.out.println(date);//Sun Jan 02 16:25:04 CST 2022
  31.         //setTime()：Date———>日历类
  32.         Date date1 = new Date();
  33.         calendar.setTime(date1);
  34.         days = calendar.get(Calendar.DAY_OF_MONTH);
  35.         System.out.println(days);//16
  36.     }
  37. }

5、JDK8中新日期时间API

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。
新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime） 和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法， 用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简 化了日期时间和本地化的管理。

5.1 LocalDate、LocalTime、LocalDateTime

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.time.LocalDate;
  6. import java.time.LocalDateTime;
  7. import java.time.LocalTime;
  9. public class JDK8DateTimeTest {
  10.     /*
  11.     说明：
  12.         1、LocalDateTime相较于LocalDate、LocalTime，使用频率要更高
  13.         2、类似于Calendar
  14.      */
  15.     @Test
  16.     public void test1(){
  17.         //now()：获取当前的日期、时间、日期+时间
  18.         LocalDate localDate = LocalDate.now();
  19.         LocalTime localTime = LocalTime.now();
  20.         LocalDateTime localDateTime = LocalDateTime.now();
  22.         System.out.println(localDate);
  23.         System.out.println(localTime);
  24.         System.out.println(localDateTime);
  26.         //of()：设置指定的年月日，时分秒，没有偏移量。
  27.         LocalDateTime localDateTime1 = LocalDateTime.of(2022, 1, 16, 17, 31, 54);
  28.         System.out.println(localDateTime1);
  30.         //getXxx()：获取相关的属性
  31.         System.out.println(localDateTime.getDayOfWeek());
  32.         System.out.println(localDateTime.getDayOfMonth());
  33.         System.out.println(localDateTime.getMonth());
  34.         System.out.println(localDateTime.getMonthValue());
  35.         System.out.println(localDateTime.getMinute());
  37.         //体现不可变性
  38.         //withXxx()：设置相关的属性
  39.         LocalDate localDate1 = localDate.withDayOfMonth(22);
  40.         System.out.println(localDate);
  41.         System.out.println(localDate1);
  43.         LocalDateTime localDateTime2 = localDateTime.withHour(4);
  44.         System.out.println(localDateTime);
  45.         System.out.println(localDateTime2);
  47.         //plusXxx()：
  48.         LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
  49.         System.out.println(localDateTime);
  50.         System.out.println(localDateTime3);
  51.         //minusXxx()：
  52.         LocalDateTime localDateTime4 = localDateTime.minusDays(6);
  53.         System.out.println(localDateTime);
  54.         System.out.println(localDateTime4);
  55.     }
  56. }

QQ截图20220116175617.png

5.2 瞬时：Instant

Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。
QQ截图20220116180053.png
QQ截图20220116180126.png

  1.  /*
  2.     Instant的使用
  3.     类似于java.util.Date类
  4.      */
  5.     @Test
  6.     public void test2(){
  7.         //now():获取本初子午线对应的标准时间
  8.         Instant instant = Instant.now();
  9.         System.out.println(instant);
  11.         //添加时间的偏移量
  12.         OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
  13.         System.out.println(offsetDateTime);
  15.         //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数-->Date类的getTime()
  16.         long milli = instant.toEpochMilli();
  17.         System.out.println(milli);
  19.         //ofEpochMilli():通过给定的毫秒数，获取Instant实例-->Date(long millis)
  20.         Instant instant1 = Instant.ofEpochMilli(1642330764482L);
  21.         System.out.println(instant1);
  22.     }

5.3 格式化与解析日期或时间

QQ截图20220116190618.png

  1.     /*
  2.     DateTimeFormatter:格式化与解析日期或时间
  3.     类似于SimpleDateFormat
  4.      */
  5.     @Test
  6.     public void test3(){
  7. //         预定义的标准格式。ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
  8.         DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
  9.         //格式化：日期-->字符串
  10.         LocalDateTime localDateTime = LocalDateTime.now();
  11.         String str1 = formatter.format(localDateTime);
  12.         System.out.println(localDateTime);
  13.         System.out.println(str1);
  14.         //解析：字符串-->日期
  15.         TemporalAccessor parse = formatter.parse("2022-01-16T19:15:43.29");
  16.         System.out.println(parse);
  17. //         本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
  18.         DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
  19.         //格式化
  20.         String str2 = formatter1.format(localDateTime);
  21.         System.out.println(str2);
  23.         DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
  24.         //格式化
  25.         String str3 = formatter2.format(LocalDate.now());
  26.         System.out.println(str3);
  28. //        重点 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
  29.         DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  30.         //格式化
  31.         String str4 = formatter3.format(LocalDateTime.now());
  32.         System.out.println(str4);
  34.         //解析
  35.         TemporalAccessor accessor = formatter3.parse("2022-01-16 19:32:46");
  36.         System.out.println(accessor);
  37.     }

5.4 其它API

QQ截图20220116193620.png
QQ截图20220116193830.png

6、 Java比较器

Java实现对象排序的方式有两种：
自然排序：java.lang.Comparable
定制排序：java.util.Comparator

  1. package com.atguigu.java2;
  3. public class Goods implements Comparable {
  4.     private String name;
  5.     private double price;
  7.     public Goods() {
  8.     }
  10.     public Goods(String name, double price) {
  11.         this.name = name;
  12.         this.price = price;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public double getPrice() {
  24.         return price;
  25.     }
  27.     public void setPrice(double price) {
  28.         this.price = price;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Goods{" +
  34.                 "name='" + name + '\'' +
  35.                 ", price=" + price +
  36.                 '}';
  37.     }
  39.     @Override
  40.     public int compareTo(Object o) {
  41.         if (o instanceof Goods) {
  42.             Goods goods = (Goods) o;
  43.             //方式一
  44.             if (this.price > goods.price) {
  45.                 return 1;
  46.             } else if (this.price < goods.price) {
  47.                 return -1;
  48.             } else {
  49.                 return 0;
  50.             }
  51.             //方式二
  52. //            return Double.compare(this.price, goods.price);
  53.         }
  54.         throw new RuntimeException("传入的数据类型不一致！");
  55.     }
  56. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.util.Arrays;
  6. import java.util.Comparator;
  8. /**
  9.  * 一、说明：java中的对象，正常情况下，只能进行比较：==或！=。不能使用</或>的
  10.  * 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
  11.  * 如何实现？使用两个接口中的任何一个：Comparable或Comparator
  12.  * 二、Comparable接口与Comparator的使用对比：
  13.  *      Comparable接口的方式一旦指定，保证Comparable接口实现类的对象在任何位置都可以比较大小
  14.  *      Comparator接口属于临时性的比较。
  15.  *
  16.  *
  17.  */
  18. public class ComparaTest {
  19.     /*
  20.     Comparable接口的使用举例：自然排序
  21.     1、像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式
  22.     2、像String、包装类等重写compareTo(obj)方法以后，进行了从小到大的排序
  23.     3、重写compareTo(obj)方法的规则：
  24.         如果当前对象this大于形参对象obj，则返回正整数，
  25.         如果当前对象this小于形参对象obj，则返回负数
  26.         如果当前对象this等于形参对象obj，则返回零。
  27.     4、对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。
  28.         在compareTo(obj)方法中指明如何排序
  29.      */
  30.     @Test
  31.     public void test1() {
  32.         String[] arr = new String[]{"AA", "CC", "MM", "GG", "JJ", "DD", "KK"};
  34.         Arrays.sort(arr);
  36.         System.out.println(Arrays.toString(arr));
  37.     }
  39.     @Test
  40.     public void test2() {
  41.         Goods[] arr = new Goods[5];
  42.         arr[0] = new Goods("lianxiangMouse", 34);
  43.         arr[1] = new Goods("dellMouse", 43);
  44.         arr[2] = new Goods("xiaomiMouse", 12);
  45.         arr[3] = new Goods("huaweiMouse", 65);
  46.         arr[4] = new Goods("microsoftMouse", 43);
  47.         Arrays.sort(arr);
  48.         System.out.println(Arrays.toString(arr));
  49.     }
  51.     /*
  52.     Comparator接口的使用举例：定制排序
  53.     1、背景：
  54.     当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
  55.     或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，
  56.     那么可以考虑使用 Comparator 的对象来排序。
  57.     2、重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
  58.     如果方法返回正整数，则表示o1大于o2；
  59.     如果返回0，表示相等；
  60.     返回负整数，表示o1小于o2。
  61.      */
  62.     @Test
  63.     public void test3() {
  64.         String[] arr = new String[]{"AA", "CC", "MM", "GG", "JJ", "DD", "KK"};
  65.         Arrays.sort(arr, new Comparator<String>() {
  66.             //按照字符串从大到小的顺序排列
  67.             @Override
  68.             public int compare(String o1, String o2) {
  69.                 if (o1 instanceof String && o2 instanceof String) {
  70.                     String s1 = (String) o1;
  71.                     String s2 = (String) o2;
  72.                     return -s1.compareTo(s2);
  73.                 }
  74.                 throw new RuntimeException("输入的数据类型不一致");
  75.             }
  76.         });
  77.     }
  78.     @Test
  79.     public void test4(){
  80.         Goods[] arr = new Goods[6];
  81.         arr[0] = new Goods("lianxiangMouse", 34);
  82.         arr[1] = new Goods("dellMouse", 43);
  83.         arr[2] = new Goods("xiaomiMouse", 12);
  84.         arr[3] = new Goods("huaweiMouse", 65);
  85.         arr[4] = new Goods("huaweiMouse", 224);
  86.         arr[5] = new Goods("microsoftMouse", 43);
  87.         Arrays.sort(arr, new Comparator<Goods>() {
  88.             //指明商品比较大小的方式：按照产品名称从低到高排序，再按照价格从高到低排序
  89.             @Override
  90.             public int compare(Goods o1, Goods o2) {
  91.                 if (o1 instanceof Goods && o2 instanceof Goods) {
  92.                     Goods g1 = (Goods) o1;
  93.                     Goods g2 = (Goods) o2;
  94.                     if (g1.getName().equals(g2.getName())){
  95.                         return -Double.compare(g1.getPrice(), g2.getPrice());
  96.                     }else{
  97.                         return g1.getName().compareTo(g2.getName());
  98.                     }
  100.                 }
  101.                 throw new RuntimeException("输入的数据类型不一致");
  102.             }
  103.         });
  104.         System.out.println(Arrays.toString(arr));
  105.     }
  106. }

7、System类

QQ截图20220116210058.png
QQ截图20220116210118.png

  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. /*
  6. 其他常用类的使用
  7. 1、System
  8. 2、Math
  9. 3、BigInteger 和BigDecimal
  10.  */
  11. public class OtherClassTest {
  13.     @Test
  14.     public void test1() {
  15.         String javaVersion = System.getProperty("java.version");
  16.         System.out.println("java的version:" + javaVersion);
  17.         String javaHome = System.getProperty("java.home");
  18.         System.out.println("java的home:" + javaHome);
  19.         String osName = System.getProperty("os.name");
  20.         System.out.println("os的name:" + osName);
  21.         String osVersion = System.getProperty("os.version");
  22.         System.out.println("os的version:" + osVersion);
  23.         String userName = System.getProperty("user.name");
  24.         System.out.println("user的name:" + userName);
  25.         String userHome = System.getProperty("user.home");
  26.         System.out.println("user的home:" + userHome);
  27.         String userDir = System.getProperty("user.dir");
  28.         System.out.println("user的dir:" + userDir);
  29.     }
  30. }

8、Math类

QQ截图20220116210604.png

9、BigInteger类和BigDecimal类

QQ截图20220116210723.png
QQ截图20220116210848.png

QQ截图20220116210935.png

  1.     @Test
  2.     public void test2() {
  4.         BigInteger bi = new BigInteger("12433241123");
  5.         BigDecimal bd = new BigDecimal("12435.351");
  6.         BigDecimal bd2 = new BigDecimal("11");
  7.         System.out.println(bi);
  8.         // System.out.println(bd.divide(bd2));
  9.         System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
  10.         System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
  12.     }
  13. }