• 【JAVA学习笔记】50 - Math类，Array类，System类，BigInteger和BigDecimal类

    项目代码

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/math_

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/array_

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/system_

    https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/bignum_

    目录

    项目代码

    Math类

    一、基本介绍

    二、常用方法

    Arrays类

    一、基本介绍

    2.Arrays方法（建议多看看排序方法）

    1）基本用法

    2）手写模拟Arrays定制排序的处理

    3.其他方法

    1.binarySearch 通过二分搜索法进行查找，要求必须排好

    2.copyOf 数组元素的复制拷贝

    3.fill 数组元素的填充

    4.asList 将一组值，转换成list

    二、练习（也可以多看看这个）

    System类

    一、常用方法

    BigInteger和BigDecimal类

    一、基本介绍

    1. BigInteger适合保存比较大的整型

    2. BigDecimal适合保存精度更高的浮点型(小数)

    Math类

    一、基本介绍

            Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

    二、常用方法

            

    1. public class MathMethod {
    2.     public static void main(String[] args) {
    3.         //看看Math常用的方法(静态方法)
    4.         //1.abs 绝对值
    5.         int abs = Math.abs(-9);
    6.         System.out.println(abs);//9
    7.         //2.pow 求幂
    8.         double pow = Math.pow(2, 4);//2的4次方
    9.         System.out.println(pow);//16
    10.         //3.ceil 向上取整,返回>=该参数的最大整数(转成double);
    11.         double ceil = Math.ceil(3.9);
    12.         System.out.println(ceil);//4.0
    13.         //4.floor 向下取整，返回<=该参数的最小整数(转成double)
    14.         double floor = Math.floor(4.001);
    15.         System.out.println(floor);//4.0
    16.         //5.round 四舍五入  Math.floor(该参数+0.5)
    17.         long round = Math.round(5.51);
    18.         System.out.println(round);//6
    19.         //6.sqrt 求开方
    20.         double sqrt = Math.sqrt(9.0);
    21.         System.out.println(sqrt);//3.0
    22.  
    23.         //7.random 求随机数
    24.         //  random 返回的是 0 <= x < 1 之间的一个随机小数
    25.         // 思考：请写出获取 a-b之间的一个随机整数,a,b均为整数 ，比如 a = 2, b=7
    26.         //  即返回一个数 x  2 <= x <= 7
    27.         // 老韩解读 Math.random() * (b-a) 返回的就是 0  <= 数 <= b-a
    28.         // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
    29.         // (2) 使用具体的数给小伙伴介绍 a = 2  b = 7
    30.         //  (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
    31.         //  Math.random()*6 返回的是 0 <= x < 6 小数
    32.         //  2 + Math.random()*6 返回的就是 2<= x < 8 小数
    33.         //  (int)(2 + Math.random()*6) = 2 <= x <= 7
    34.         // (3) 公式就是  (int)(a + Math.random() * (b-a +1) )
    35.         for(int i = 0; i < 100; i++) {
    36.             System.out.println((int)(2 +  Math.random() * (7 - 2 + 1)));
    37.         }
    38.  
    39.         //max , min 返回最大值和最小值
    40.         int min = Math.min(1, 9);
    41.         int max = Math.max(45, 90);
    42.         System.out.println("min=" + min);
    43.         System.out.println("max=" + max);
    44.  
    45.     }
    46. }

    Arrays类

    一、基本介绍

     Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

    1.toString返回数组的字符串形式Arrays.toString(arr)

    2.sort排序(自然排序和定制排序)Integer arr[ = {1,-1, 7. 0, 89};

    3. binarySearch通过二分搜索法进行查找，要求必须排好序int index = Arrays.binarySearch(arr, 3);

    2.Arrays方法（建议多看看排序方法）

    1）基本用法
    1. public class ArraysMethod01 {
    2.     public static void main(String[] args) {
    3.  
    4.         Integer[] integers = {1, 20, 90};
    5.         //遍历数组
    6.         for (int i = 0; i < integers.length; i++) {
    7.             System.out.println(integers[i]);
    8.         }
    9.         //直接使用Arrays.toString方法，显示数组
    10.         System.out.println(Arrays.toString(integers));
    11.  
    12.         //演示 sort方法的使用
    13.  
    14.         Integer arr[] = {1, -1, 7, 0, 89};
    15.         //进行排序
    16.         //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
    17.         //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
    18.         //Arrays.sort(arr); // 默认排序方法
    19.         System.out.println("===排序后===");
    20.         System.out.println(Arrays.toString(arr));
    21.  
    22.         //3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
    23.         //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
    24.         //   (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
    25.         Arrays.sort(arr, new Comparator() {
    26.             @Override
    27.             public int compare(Object o1, Object o2) {//5. 这里体现了接口编程的方式 , 看看源码，就明白
    28.                 Integer i1 = (Integer) o1;
    29.                 Integer i2 = (Integer) o2;
    30.                 return i2 - i1;
    31.             }
    32.         });
    33.  
    34.         //   源码分析
    35.         //(1) Arrays.sort(arr, new Comparator()
    36.         //(2) 最终到 TimSort类的
    37.         // private static  void binarySort(T[] a, int lo, int hi, int start,Comparator c)()
    38.         //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的匿名内部类的 compare ()
    39.         //     while (left < right) {
    40.         //                int mid = (left + right) >>> 1;
    41.         //                if (c.compare(pivot, a[mid]) < 0)
    42.         //                    right = mid;
    43.         //                else
    44.         //                    left = mid + 1;
    45.         //            }
    46.         //(4) new Comparator() {
    47.         //            @Override
    48.         //            public int compare(Object o1, Object o2) {
    49.         //                Integer i1 = (Integer) o1;
    50.         //                Integer i2 = (Integer) o2;
    51.         //                return i2 - i1;
    52.         //            }
    53.         //        }
    54.         //(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
    55.         //    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用将来的底层框架和源码的使用方式，会非常常见
    56.  
    57.  
    58.         System.out.println("===排序后===");
    59.         System.out.println(Arrays.toString(arr));//
    60.  
    61.  
    62.     }
    63. }
    2）手写模拟Arrays定制排序的处理
    1. public class ArraysSortCustom {
    2.     public static void main(String[] args) {
    3.  
    4.         int[] arr = {1, -1, 8, 0, 20};
    5.         // bubble01(arr);
    6.         // System.out.println("==排序后的情况==");
    7.         // System.out.println(Arrays.toString(arr));
    8.  
    9.         bubble02(arr, new Comparator() {
    10.             @Override
    11.             public int compare(Object o1, Object o2) {//arr[j] arr[j+1]传入这里
    12.                 int i1 = (Integer) o1;//拆箱
    13.                 int i2 = (Integer) o2;//拆箱
    14.                 return i2 - i1;// 判断我们的逻辑是小到大(i1 - i2 > 0)执行排序还是大到小(i2 - i1 > 0)执行排序;
    15.             }
    16.         });
    17.  
    18.         System.out.println("==定制排序后的情况==");
    19.         System.out.println(Arrays.toString(arr));
    20.  
    21.     }
    22.  
    23.     //1.使用冒泡完成排序
    24.     public static void bubble01(int[] arr) {
    25.         int temp = 0;
    26.         for (int i = 0; i < arr.length - 1; i++) {
    27.             for (int j = 0; j < arr.length - 1 - i; j++) {
    28.                 //从小到大
    29.                 if (arr[j] > arr[j + 1]) {
    30.                     temp = arr[j];
    31.                     arr[j] = arr[j + 1];
    32.                     arr[j + 1] = temp;
    33.                 }
    34.             }
    35.         }
    36.     }
    37.  
    38.     //结合冒泡 + 定制
    39.     public static void bubble02(int[] arr, Comparator c) {
    40.         int temp = 0;
    41.         for (int i = 0; i < arr.length - 1; i++) {
    42.             for (int j = 0; j < arr.length - 1 - i; j++) {
    43.                 //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
    44.                 if (c.compare(arr[j], arr[j + 1]) > 0) {
    45.                     temp = arr[j];
    46.                     arr[j] = arr[j + 1];
    47.                     arr[j + 1] = temp;
    48.                 }
    49.             }
    50.         }
    51.     }
    52. }

    3.其他方法

    1.binarySearch 通过二分搜索法进行查找，要求必须排好


            //1. 使用 binarySearch 二叉查找
            //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
            int index = Arrays.binarySearch(arr, 167);
            System.out.println("index=" + index);
            //3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
            //low指的是搜索的值应该在的值，比如167就是 -(5 + 1),如果是3就是-(2 + 1)

    2.copyOf 数组元素的复制拷贝


            //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
            //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
            Integer[] newArr = Arrays.copyOf(arr, arr.length);
            System.out.println("==拷贝执行完毕后==");
            System.out.println(Arrays.toString(newArr));
            //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
            //4. 该方法的底层使用的是 System.arraycopy()


    3.fill 数组元素的填充


            Integer[] num = new Integer[]{9,3,2};
            //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
            Arrays.fill(num, 99);
            System.out.println("==num数组填充后==");
            System.out.println(Arrays.toString(num));

            //equals 比较两个数组元素内容是否完全一致
            Integer[] arr2 = {1, 2, 90, 123};
            //1. 如果arr 和 arr2 数组的元素一样，则方法true;
            //2. 如果不是完全一样，就返回 false
            boolean equals = Arrays.equals(arr, arr2);
            System.out.println("equals=" + equals);

    4.asList 将一组值，转换成list


            //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
            List asList = Arrays.asList(2,3,4,5,6,1);
            System.out.println("asList=" + asList);
            System.out.println("asList的运行类型" + asList.getClass());
            //2. 返回的 asList 编译类型 List(接口)
            //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
            //   静态内部类 private static class ArrayList extends AbstractList
            //              implements RandomAccess, java.io.Serializable
        }

    1. public class ArraysMethod02 {
    2.     public static void main(String[] args) {
    3.         Integer[] arr = {1, 2, 90, 123, 160};
    4.         // binarySearch 通过二分搜索法进行查找，要求必须排好
    5.         //1. 使用 binarySearch 二叉查找
    6.         //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
    7.         int index = Arrays.binarySearch(arr, 167);
    8.         System.out.println("index=" + index);
    9.         //3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
    10.         //low指的是搜索的值应该在的值，比如167就是 -(5 + 1),如果是3就是-(2 + 1)
    11.  
    12.         //copyOf 数组元素的复制拷贝
    13.         //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
    14.         //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
    15.         Integer[] newArr = Arrays.copyOf(arr, arr.length);
    16.         System.out.println("==拷贝执行完毕后==");
    17.         System.out.println(Arrays.toString(newArr));
    18.         //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
    19.         //4. 该方法的底层使用的是 System.arraycopy()
    20.  
    21.  
    22.         //ill 数组元素的填充
    23.         Integer[] num = new Integer[]{9,3,2};
    24.         //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
    25.         Arrays.fill(num, 99);
    26.         System.out.println("==num数组填充后==");
    27.         System.out.println(Arrays.toString(num));
    28.  
    29.         //equals 比较两个数组元素内容是否完全一致
    30.         Integer[] arr2 = {1, 2, 90, 123};
    31.         //1. 如果arr 和 arr2 数组的元素一样，则方法true;
    32.         //2. 如果不是完全一样，就返回 false
    33.         boolean equals = Arrays.equals(arr, arr2);
    34.         System.out.println("equals=" + equals);
    35.  
    36.         //asList 将一组值，转换成list
    37.         //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
    38.         List asList = Arrays.asList(2,3,4,5,6,1);
    39.         System.out.println("asList=" + asList);
    40.         System.out.println("asList的运行类型" + asList.getClass());
    41.         //2. 返回的 asList 编译类型 List(接口)
    42.         //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
    43.         //   静态内部类 private static class ArrayList extends AbstractList
    44.         //              implements RandomAccess, java.io.Serializable
    45.     }
    46. }

    二、练习（也可以多看看这个）

    1. public class ArraysExercise {
    2.     public static void main(String[] args) {
    3.         /*
    4.         案例：自定义Book类，里面包含name和price，按price排序(从大到小)。
    5.         要求使用两种方式排序 , 有一个 Book[] books = 4本书对象.
    7.         使用前面学习过的传递 实现Comparator接口匿名内部类，也称为定制排序。
    8.         [同学们完成这个即可 10min  ],
    9.         可以按照 price (1)从大到小 (2)从小到大 (3) 按照书名长度从大到小
    11.          */
    12.  
    13.         Book[] books = new Book[4];
    14.         books[0] = new Book("红楼梦", 100);
    15.         books[1] = new Book("金瓶梅新", 90);
    16.         books[2] = new Book("青年文摘20年", 5);
    17.         books[3] = new Book("java从入门到放弃~", 300);
    18.         arrCustom(books, new Comparator() {
    19.             @Override
    20.             public int compare(Object o1, Object o2) {
    21.                Book book1 = (Book)o1;
    22.                Book book2 = (Book)o2;
    23.                int temp =(int)(book1.getPrice() - book2.getPrice());
    24.                 return temp;
    25.             }
    26.         });
    27.         System.out.println(Arrays.toString(books));
    28.         arrCustom(books, new Comparator() {
    29.             @Override
    30.             public int compare(Object o1, Object o2) {
    31.                 Book book1 = (Book)o1;
    32.                 Book book2 = (Book)o2;
    33.                 int temp =(int)(book1.getPrice() - book2.getPrice());
    34.                 return -temp;
    35.             }
    36.         });
    37.         System.out.println(Arrays.toString(books));
    38.         arrMintoMax(books);
    39.         System.out.println(Arrays.toString(books));
    40.         arrMaxtoMin(books);
    41.         System.out.println(Arrays.toString(books));
    42.         arrNameLength(books);
    43.         System.out.println(Arrays.toString(books));
    44.     }
    45.     public static void arrMaxtoMin(Book[] books){//记得是引用赋值，改变这个books main方法内的也会改变
    46.         //price从大到小
    47.         Book temp;
    48.         for (int i = 0; i < books.length - 1; i++) {
    49.             for (int j = 0; j 1; j++) {
    50.                 if(books[j].getPrice() < books[j + 1].getPrice()){
    51.                     temp = books[j];
    52.                     books[j] = books[j + 1];
    53.                     books[j + 1] = temp;
    54.                 }
    55.             }
    56.         }
    57.     }
    58.     public static void arrMintoMax(Book[] books){
    59.         //price从小到大
    60.         Book temp;
    61.         for (int i = 0; i < books.length - 1; i++) {
    62.             for (int j = 0; j < books.length - i - 1; j++) {
    63.                 if(books[j].getPrice() > books[j + 1].getPrice()){
    64.                     temp = books[j];
    65.                     books[j] = books[j + 1];
    66.                     books[j + 1] = temp;
    67.                 }
    68.             }
    69.         }
    70.     }
    71.     public static void arrCustom(Book[] books,Comparator c){
    72.         //定制
    73.         Book temp;
    74.         for (int i = 0; i < books.length - 1; i++) {
    75.             for (int j = 0; j < books.length - i - 1; j++) {
    76.                 if(c.compare(books[j],books[j + 1]) > 0){
    77.                     temp = books[j];
    78.                     books[j] = books[j + 1];
    79.                     books[j + 1] = temp;
    80.                 }
    81.             }
    82.         }
    83.     }
    84.     public static void arrNameLength(Book[] books){
    85.         //书名长度从大到小
    86.         Book temp;
    87.         for (int i = 0; i < books.length - 1; i++) {
    88.             for (int j = 0; j < books.length - i - 1; j++) {
    89.                 if(books[j].getName().length() < books[j + 1].getName().length()){
    90.                     temp = books[j];
    91.                     books[j] = books[j + 1];
    92.                     books[j + 1] = temp;
    93.                 }
    94.             }
    95.         }
    96.     }
    97. }
    98.  
    99. class Book {
    100.     private String name;
    101.     private double price;
    102.  
    103.     public Book(String name, double price) {
    104.         this.name = name;
    105.         this.price = price;
    106.     }
    107.  
    108.     public String getName() {
    109.         return name;
    110.     }
    111.  
    112.     public void setName(String name) {
    113.         this.name = name;
    114.     }
    115.  
    116.     public double getPrice() {
    117.         return price;
    118.     }
    119.  
    120.     public void setPrice(double price) {
    121.         this.price = price;
    122.     }
    123.  
    124.     @Override
    125.     public String toString() {
    126.         return "Book{" +
    127.                 "name='" + name + '\'' +
    128.                 ", price=" + price +
    129.                 '}';
    130.     }
    131. }

     

    System类

    一、常用方法

    1) exit退出当前程序

    2) arraycopy :复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组

            int[] src={1,2,3};

            int[] dest = new int[3];

            System.arraycopy(src, 0, dest, 0, 3);

    3) currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

    4) gc:运行垃圾回收机制System.gc;
     

    1. public class System_ {
    2.     public static void main(String[] args) {
    3.  
    4.         //exit 退出当前程序
    5.  
    6.        System.out.println("ok1");
    7.  
    8.         //1. exit(0) 表示程序退出
    9.         //2. 0 表示一个状态
    10.        // System.exit(0);
    11.        System.out.println("ok2");
    12.  
    13.         //arraycopy ：复制数组元素，比较适合底层调用，
    14.         // 一般使用Arrays.copyOf完成复制数组
    15.         int[] src={1,2,3};
    16.         int[] dest = new int[3];// dest 当前是 {0,0,0}
    17.         //1. 主要是搞清楚这五个参数的含义
    18.         //2.   * @param      src      the source array. src为源数组
    19.  
    20.         //     * @param      srcPos   starting position in the source array.
    21.         //     srcPos： 从源数组的哪个索引位置开始拷贝
    22.  
    23.         //     * @param      dest     the destination array.
    24.         //     dest : 目标数组，即把源数组的数据拷贝到哪个数组
    25.  
    26.         //     * @param      destPos  starting position in the destination data.
    27.         //     destPos: 把源数组的数据拷贝到 目标数组的哪个索引
    28.  
    29.         //     * @param      length   the number of array elements to be copied.
    30.         //     length: 从源数组拷贝多少个数据到目标数组
    31.         System.arraycopy(src, 0, dest, 0, src.length);
    32.         // int[] src={1,2,3};
    33.         System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]
    34.  
    35.         //currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数
    36.         System.out.println(System.currentTimeMillis());
    37.     }
    38. }

    BigInteger和BigDecimal类

    一、基本介绍

    1. BigInteger适合保存比较大的整型

    1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
    2. 可以创建一个 要操作的 BigInteger 然后进行相应操作

    1. public class BigInteger_ {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         //当我们编程中，需要处理很大的整数，long 不够用
    6.         // long l = 23788888899999999999999999999l;
    7.         // System.out.println("l=" + l);
    8.         //可以使用BigInteger的类来搞定
    9.         BigInteger bigInteger = new BigInteger("23788888899999999999999999999");//用字符串
    10.         BigInteger bigInteger2 = new BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
    11.         //本质上是对字符串进行操作
    12.         System.out.println(bigInteger);
    13.         System.out.println(bigInteger);
    14.         //1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
    15.         //System.out.println(bigInteger + 1);//报错
    16.         //2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
    17.         BigInteger add = bigInteger.add(bigInteger2);
    18.         System.out.println(add);//
    19.         BigInteger subtract = bigInteger.subtract(bigInteger2);
    20.         System.out.println(subtract);//减
    21.         BigInteger multiply = bigInteger.multiply(bigInteger2);
    22.         System.out.println(multiply);//乘
    23.         BigInteger divide = bigInteger.divide(bigInteger2);
    24.         System.out.println(divide);//除
    25.     }
    26. }

    2. BigDecimal适合保存精度更高的浮点型(小数)

    1. 如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
    2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
    3.System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常ArithmeticException无限循环小数，会抛出异常
    4.在调用divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
    5.如果有无限循环小数，就会保留 分子 的精度

    1. public class BigDecimal_ {
    2.     public static void main(String[] args) {
    3.         //当我们需要保存一个精度很高的数时，double 不够用
    4.         //可以是 BigDecimal
    5.         //double d = 1999.11111111111999999999999977788d;
    6.         //System.out.println(d);
    7.         BigDecimal bigDecimal = new BigDecimal("1999.11");
    8.         BigDecimal bigDecimal2 = new BigDecimal("3");
    9.         System.out.println(bigDecimal);
    10.  
    11.         //1. 如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
    12.         //2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
    13.         System.out.println(bigDecimal.add(bigDecimal2));//加
    14.         System.out.println(bigDecimal.subtract(bigDecimal2));//减
    15.         System.out.println(bigDecimal.multiply(bigDecimal2));//乘
    16.         //System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常ArithmeticException
    17.         //可能是无限循环小数，会抛出异常
    18.         //在调用divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
    19.         System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
    20.         //如果有无限循环小数，就会保留 分子 的精度
    21.     }
    22. }

  • 相关阅读:
    解读MySQL 8.0数据字典的初始化与启动
    Julia编程基础
    Java精进-手写持久层框架
    Android源码笔记--恢复出厂设置
    相机专业模型详解，各个参数作用，专业模式英文全称和缩写
    如何保障数仓数据质量？
    HTTP报文首部
    Objects.equals有坑
    程序员的编程格言
    LabVIEW远程开发与调试
  • 原文地址：https://blog.csdn.net/qq_41891655/article/details/134095293