java进阶五(重要API)

JavaSE进阶第五天

课程大纲：

• Math类
• System类
• Object类
• Objects类
• BigDecimal类
• 包装类
• 数组高级操作
• 递归
• Arrays

一. API文档的使用

1.什么是API

application programming interface:应用程序编程接口
简单理解：API就是一些别人提供好的类，所以学习API也可以认为是学习一些类

2.API文档

文档类似一部字典，其中对JDK提供的类的用法进行了说明

3.API文档的使用

3.1 打开文档

3.2 索引

     找到索引选项卡，输入要查找的类名，回车后右边主区域就会显示类的所有信息索引中搜索的最小范围是类，不要去搜索方法

3.3 查看类的信息

（1）看包

    如果使用的是java.lang包下的类、或者使用的是本包下的类就不要导包， 否则都需要导包

（2）看类的描述

类的作用、类的注意事项...

（3）看构造方法

  用于创建对象
   // 类名 对象名= new 构造方法;
  Random r = new Random();

（4）看成员方法

方法的作用：干什么的，是否能满足你的需求
    方法名称：方便调用
    方法的参数：有参数就要传递实参，无参数则不需要传递实参
    有几个参数传几个实参，类型也要对应
    方法的返回值类型：有返回值则还可以赋值和输出调用，无返回值只能单独调用
    赋值调用的时候，返回值是什么类型就用什么类型接收

目前要求能查看我们学过的类和方法即可。

二.Math类

和算术相关的一个工具类，其中所有的方法都是静态的，调用的时候通过类名.进行调用，
	 构造方法是私有的，不能创建对象，但是它是有构造方法。
     位于java.lang包下，使用的时候不需要导包
     是final修饰的类，不能去继承该类，该类也没有其他子类

2.1成员方法

public static int abs(int a) 返回参数的绝对值

 //返回参数的绝对值
int abs = Math.abs(-10);
System.out.println("绝对值:"+abs);
System.out.println("----------------");

public static double ceil(double a) 向上取整

//向上取整
double ceil = Math.ceil(10.1);
System.out.println("向上取值"+ceil);
System.out.println("----------------");

public static double floor(double a) 向下取整

//向下取证
double floor = Math.floor(10.4);
System.out.println("向下取整"+floor);
System.out.println("----------------");

public static int round(float a) 四舍五入

 //四舍五入
long round = Math.round(10.5);
System.out.println("四舍五入"+round);
System.out.println("----------------");

public static int max(int a,int b) 返回两个int值中的较大值

//返回两个int较大的一个
int max = Math.max(10, 20);
System.out.println("Max:"+max);
System.out.println("----------------");

public static int min(int a,int b) 返回两个int值中的较小值

//返回两个int较小的一个
int min = Math.min(10, 29);
System.out.println("Min:"+min);
System.out.println("----------------");

public static double pow(double a,double b)返回a的b次幂的值

//返回a的b次幂
double pow = Math.pow(2, 3);
System.out.println("2的3次幂为"+pow);
System.out.println("----------------");

public static double random() 返回值为double的正值，[0.0,1.0)

double random = Math.random();
System.out.println("返回正太分布的随机数:"+random);

三.System类

和系统相关的工具类
位于java.lang包下的类，使用的时候不需要导包
final修饰的类，该类不能有子类

3.1成员方法

static void exit(int status):退出JVM

 public static void TestExit() {
        System.out.println(1111);
        System.exit(0);  //0表示正常情况下停止JVM
        System.out.println(222);  //没有运行
    }

static long currentTimeMillis()：获取当前系统时间的毫秒值

public static void TestCurrentTimeMillis() {
	long l = System.currentTimeMillis();  //返回当前时间(以毫秒为单位)
    System.out.println(l);
}

当前系统时间：你的电脑的时间
    毫秒值：时间单位
    1秒 = 1000毫秒
通过该方法获取的毫秒值，其实是一个相对值（基准时间1970-1-1）
    
    
系统时间 ： 1970-1-1 9:0:0   1970-1-1 9:0:0-1970-1-1 8:0:0  1*60*60*1000
系统时间 ： 2021-8-15 15:35:0   2021-8-15 15:35:0-1970-1-1 8:0:0

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：复制数组

public static void TestArraycopy() {
    int[] arr1 = {1, 2, 3, 4, 5};
    int[] arr2 = new int[10];
    //        arraycopy(数据源数组,起始索引,目的地数组,起始索引,拷贝个数)  数组copy
    System.arraycopy(arr1, 0, arr2, 0, 5);
    System.arraycopy(arr1, 3, arr2, 8, 2);
    System.out.println(Arrays.toString(arr2));
}

* src：目标数组
    * srcPos：目标数据复制的起始索引
    * det：目的地数组
    * destPos：目的地数组存放的起始索引
    * length：复制的元素的个数

    将src数组复制到dest数组中，从src数组的srcPos索引处开始复制，复制length个元素，从destPos索引开始放到dest数组中

四.Object类

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。所有的类都直接或者间接继承自Object类。

4.1 成员方法

String toString()：将对象转换为字符串形式返回

默认继承自Object类中的toString方法，转换的字符串格式为：全类名@十六进制地址值，
对于这样的格式来说，没有很大的意思，所以一般我们的子类中都会去重写toString方法，
重写的原则是可以查看到对象中的内容，如何进行重写？通过idea快捷键：alt+insert 选择toString()

boolean equals(Object obj)：比较两个对象是否相等

	默认继承自Object类中的equals方法，比较的是两个对象的地址否则相等
    对应我们平常的比较来说，一般都不会使用比较地址的功能，即使有这个需求则使用==运算符即可
    所以一般我们的子类都会去重写equals方法
    重写的原则是比较对象中的内容是否相等，如果都相等则返回true
    如何进行重写？通过idea快捷键：alt+insert 选择equals()
        
        

定义在Object类中的方法，一般我们不会直接创建Object的对象，调用这些方法
这些的作用一般是给子类继承，或者重写的，我们使用的时候都是创建子类对象进行调用

4.2 equals和==的区别（面试题）

==既可以比较基本类型也可以比较引用类型的值， 比较基本类型比较的是值是否相等，比较引用类型比较的是地址值是否相等

equals方法只能比较引用类型的值，不能比较基本类型的值，比较的引用类型的时候，如果没有去重写Object类中继承下来的equals方法，则比较的是地址值，如果重写了equals方法，则比较的是内容是否相等
，比如字符串String中就重写了equals方法，那么比较的就是两个字符串的内容是否相等。

五.Objects类

5.1成员方法

public static String toString(对象)—和s.toString是一样的结果

public static void ObjectsTest01() {
    //        Student stu = new Student("小花同学", 23);
    Student s = new Student("小罗同学",50);
    String result = Objects.toString(s);
    System.out.println(result);
}

public static String toString(对象,默认字符)

（如果对象为null,返回默认字符）

public static void ObjectsNullTest() {
    Student stu =null;
    String result = Objects.toString(stu, "这是什么?");
    System.out.println(result);
}

public static Boolean isNull(对象)

public static void ObjectNullTest02() {
    Student stu =null;
    boolean result = Objects.isNull(stu);
    System.out.println(result);  //判断对象是否为null
}

public static Boolean nonNull(对象)

public static void ObjectsNonNull() {
    Student student = new Student();
    boolean b = Objects.nonNull(student);
    System.out.println(b);  //判断对象是否不为空
}

六.BigDecimal类(精确运算)

用于处理小数的，可以保留小数点后几位，并且可以对小数做精确计算

6.1构造方法

BigDecimal(double val)
BigDecimal(String val)   ----推荐

BigDecimal bigDecimal = new BigDecimal(10.1);
BigDecimal bigDecimal1 = new BigDecimal("3.3");
System.out.println(bigDecimal);
System.out.println(bigDecimal1);

6.2常用方法

BigDecimal add(BigDecimal augend)

BigDecimal subtract(BigDecimal subtrahend)
BigDecimal multiply(BigDecimal multiplicand)
BigDecimal divide(BigDecimal divisor)
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

BigDecimal num1 = new BigDecimal("1.0");
BigDecimal num2 = new BigDecimal("3.0");
BigDecimal add = num1.add(num2);
System.out.println("相加的结果为:"+add);
System.out.println(1.12+3.1);

System.out.println("----------------------------");
BigDecimal subtract = num1.subtract(num2);
System.out.println("相减为"+subtract);

System.out.println("----------------------------");
BigDecimal multiply = num1.multiply(num2);
System.out.println("积为:"+multiply);

System.out.println("----------------------------");

6.3BigDecimal的舍入模式

参数一:表示参与运算的另一个对象
参数二:表示小数点后精确到多少位
参数三:摄入模式
    ROUND_FLOOR:向下取整（去尾法）
    ROUND_UP:向上取整（进一法）
    ROUND_HALF_UP:四舍五入

BigDecimal divide = num1.divide(num2,2,BigDecimal.ROUND_FLOOR);
System.out.println("商为(向下取整):"+divide);
BigDecimal divide1 = num1.divide(num2,2,BigDecimal.ROUND_UP);
System.out.println("商为(向上取整):"+divide1);
BigDecimal divide3 = num1.divide(num2,2,BigDecimal.ROUND_HALF_UP);
System.out.println("商为(四舍五入取整):"+divide3);

七.包装类

7.1定义

什么是包装类
    基本类型的包装类，将基本类型的数据包装到一个类中
    也就是说包装类就是基本类型对应引用类型数据。

7.2作用

包装类的作用：让基本类型的一些数据操作更加方便，操作更加丰富

7.3包装类的范围

	 byte                Byte
     short               Short
     int                 Integer(特殊)
     long                Long
     float               Float
     double              Double
     char                Character（特殊）
     boolean             Boolean

八.Integer类

8.1得到Integer对象

8.1.1创建

创建对象的格式：
    类名 对象名 = new 构造方法名(参数);
构造方法名和类名一致

Integer(int value)
Integer(String s)
    
  //一，通过创建对象
Integer i1 = new Integer(100);
Integer i2 = new Integer("100");
System.out.println(i1);
System.out.println(i1.toString());
System.out.println(i2);
System.out.println(i2.toString());

8.1.2获取(替代创建Integ对象)

直接通过类名.的方式进行调用

static Integer valueOf(int i)
static Integer valueOf(String s)
    
Integer integer = Integer.valueOf(300);
System.out.println(integer);
Integer integer1 = Integer.valueOf("400");
System.out.println(integer1);

8.2拆装箱

拆箱：将Integer类型转为int类型，将包装类型转为基本类型
装箱：将int类型转为Integer类型，将基本类型转为包装类型

8.2.1手动拆装箱

这个拆装箱操作并不会自动完成，需要手动去调用一些方法进行拆装箱操作

装箱操作
    Integer i1 = new Integer(100);
	Integer i3 = Integer.valueOf(300);// 自动装箱底层

拆箱操作
    int i = i1.intValue();  // 自动拆箱底层
    int intValue()

8.2.2 自动拆装箱

这个拆装箱操作会自动完成
JDK5.0之后的新特性

自动装箱
    // 100(int) -> i1(Integer)
    Integer i1 = 100;   // Integer i1 = 				Integer.valueOf(100);

自动拆箱
    Integer i2 = Integer.valueOf(200);
							// i2(Integer) -> i(int)
		int i = i2;         // int i = i2.intValue();

8.3 int和String互转的操作

int ->String
    1、+""                           【推荐】
    2、Integer类中的方法
    static String toString(int i)
    3、int->Integer->String
    4、String类中的方法
    static String valueOf(int i)

    String ->int
    1、Integer类中的方法              【推荐】
    static int parseInt(String s)

    2、String->Integer->int

8.4面试题

public static void main(String[] args) {
    Integer i = 200;
    Integer j = 200;
    System.out.println(i == j);     //false
    System.out.println(i.equals(j));    //true
    //自动装箱的内存查找范围为-128---127，超出了就会重新创建对象
    Integer i1 = 100;
    Integer j1 = 100;
    System.out.println(i1 == j1);       //true
    System.out.println(i1.equals(j1));  //true
}

九.递归

 什么是递归？
        方法内部调用自身的情况
        要编写递归的代码，一定要自定义一个方法，不能把递归的代码放在main方法中

    递归的情况
        直接递归
            show() {
                show();
            }

        间接递归
            method1() {
                method2();
            }

            method2() {
                method1();
            }

    递归的注意事项
        1、递归一定要有出口，否则会报内存溢出错误
        2、出口也不要太深，否则没有到达出口就溢出
        3、构造方法不能递归

    递归程序两个明确：
        1、找到递归执行的规律
        2、找到递归的出口

十.排序

10.1二分排序

public class MyBinarySearchDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int number = 5;
        int index = binarySearchForIndex(arr, number);
        System.out.println(index);
    }

    private static int binarySearchForIndex(int[] arr, int number) {
        int min = 0;
        int max = arr.length - 1;
        while (arr[min] <= arr[max]) {
            int mid = (max + min) >> 1;
            if (arr[mid] > number) {
                max = mid - 1;
            } else
                if (arr[mid] < number) {
                    min = mid + 1;
                } else
                    if (arr[mid] == number) {
                        return mid;
                    }

        }
        return -1;
    }

}

10.2冒泡排序

public class MyBubbleSortDemo {
    public static void main(String[] args) {
        int[] arr ={3,5,2,1,4};
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = 0; i < arr.length-1-j; i++) {
                if (arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }


        System.out.println(Arrays.toString(arr));
    }
}  

10.3快速排序

public class MyQuiteSortDemo {
    public static void main(String[] args) {
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};

        quiteSort(arr, 0, arr.length - 1); //数组，范围开始，范围结束

        System.out.println(Arrays.toString(arr));
    }

    private static void quiteSort(int[] arr, int left, int right) {
        if (right<left){
            return;
        }
        int left0 = left;
        int right0 = right;
        //计算基准数
        int baseNumber = arr[left0];
        while (left != right) {
            //1，从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            //2.从左开始找比基准数大的
            while (arr[left] <= baseNumber && left < right) {
                left++;
            }
            //交换2个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;

        quiteSort(arr,left0,left-1);
        quiteSort(arr,left+1,arr.length-1);
    }
}

十一.Arrays类

 public static void main(String[] args) {
        int[] arr = {3,2,4,6,7};
//        排序（从小到大）---原理是快排
        Arrays.sort(arr);
        //打印数组
        System.out.println(Arrays.toString(arr));

        int[] brr={1,2,3,4,5,7,6,8,9,10};
//      根据键查索引-----返回一个数组的索引
        int i = Arrays.binarySearch(brr, 7);
        System.out.println(i);
    }

    //交换2个值的位置
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }
    //基准数归位
    int temp = arr[left];
    arr[left] = arr[left0];
    arr[left0] = temp;

    quiteSort(arr,left0,left-1);
    quiteSort(arr,left+1,arr.length-1);
}

}

## 十一.Arrays类

````java
 public static void main(String[] args) {
        int[] arr = {3,2,4,6,7};
//        排序（从小到大）---原理是快排
        Arrays.sort(arr);
        //打印数组
        System.out.println(Arrays.toString(arr));

        int[] brr={1,2,3,4,5,7,6,8,9,10};
//      根据键查索引-----返回一个数组的索引
        int i = Arrays.binarySearch(brr, 7);
        System.out.println(i);
    }