第九章_Java常用类-Day20-《Java学习知识库》

admin
admin
admin
0
文章
0
评论
2025-11-02 01:02:35 编程 来源：ZONE.CI 全球网 0 阅读模式
  • 1、昨日复习
  • 2、常见算法题目
  • 4、java.util.Calendar(日历)类
  • 5、JDK8中新日期时间API
    • 5.1 LocalDate、LocalTime、LocalDateTime
    • 5.2 瞬时：Instant
    • 5.3 格式化与解析日期或时间
    • 5.4 其它API
  • 6、 Java比较器
  • 7、System类
  • 8、Math类
  • 9、BigInteger类和BigDecimal类

    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.pngQQ截图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.pngQQ截图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.pngQQ截图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.pngQQ截图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. }

    版权声明

    本站仅做备份收录，仅供研究与教学参考之用。
    读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。

    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    安全领域涉猎者-乌云独行地带
    以太坊cppgolang区别 编程

    以太坊cppgolang区别

    以太坊是一种去中心化的开源平台，它采用智能合约技术，旨在构建和运行不受干扰的分布式应用程序。作为目前最受欢迎的区块链平台之一，以太坊提供了多种编程语言的支持，其
    12-282 评论
    progolang 编程

    progolang

    Go语言（Golang）是由Google开发的一门静态类型编程语言。作为一名专业的Golang开发者，我深知这门语言的优势和特点。在本文中，我将介绍Golang
    12-281 评论
    golangn个发送者 编程

    golangn个发送者

    Golang是一种开源的编程语言，由Google团队开发，旨在提高程序的并发性和简化软件开发过程。在Go语言中，有时需要向多个接收者发送信息。本文将介绍如何在G
    12-280 评论
    golang技能图谱 编程

    golang技能图谱

    从互联网行业的快速发展到人工智能技术的日益成熟，各种编程语言也应运而生。而在这众多的编程语言中，Golang（即Go）作为一门强大且高效的开发语言备受关注。Go
    12-281 评论
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    评论：0   参与：  8