常用类（四）Math类和Arrays类

一、Math类 

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

我们查看math类的常用方法：

我们查看他的源码如下所示：

我们查看他的类图：

他的这些方法基本都是静态的：

 我们的代码设置如下所示：

package com.ypl.Math_;

public class MathMethod_ {
    public static void main(String[] args) {
        //Math常用的方法(静态方法）
        //1.abs  绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9
        //2.pow 求幂
        double pow = Math.pow(2, 4); //2的4次方
        System.out.println(pow); //16
        //3.ceil  向上取整，返回>=该参数的最小整数(转成double)
        double ceil = Math.ceil(-3.0001);
        System.out.println(ceil);//-3
        //4.floor 向下取整，返回<=该参数的最大整数(转成double)
        double floor = Math.floor(-4.999);
        System.out.println(floor);//-5.0
        //5.round  四舍五入 Math.floor(该参数+0.5）
        long round = Math.round(-5.001);
        System.out.println(round);
        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt); //3.0
        //7.random 求随机数
        //random 返回的是0<=x<1之间的一个随机小数。
        //思考：请写出获取a-b之间的一个随机整数，a,b均为整数,比如a=2,b=7.
        // 即返回一个数 x ,   2<=x<=7 .

        //Math.random()*(b-a)返回的就是0<= X <= b-a

        //(1)(int)(a)<=x<=(int)(a+ Math.random()*(b-a+1))
        //(2)使用具体的数进行解释如下：
        //a= 2  b=7
        //(int)(a+Math.random( )*(b-a  +1))=(int)(2+Math.random( )*(6)
        //Math.random( )*6 返回的是 0<=x<6  小数
        //2+Math.random( )*6 返回的就是  2<=x<8
        //(int)2+Math.random( )*6  =   2<=x<=7
        //(3)公式就是 (int)(a+ Math.random()*(b-a+1))
        //如果写成(int)(b)即为一个固定的值,而(int)(a + b-a)可以进行如上操作
        for (int i = 0; i< 3; i++) {
            System.out.println((int)(2+Math.random()*(7-2+1 )));
        }
       //获取一个a-b之间的一个随机整数
        //int num=(int)(Math.random()*(b-a +1)+a);

        //max,min返回最大值和最小值
        System.out.println("max="+Math.max(55,99));//99
        System.out.println("min="+Math.min(66,88));//66

    }
}

我们运行之后如下所示：

 我们了解到规律如下所示：
获取一个a-b之间的一个随机整数
int num=(int)(Math.random()*(b-a +1)+a);

二、Arrays类

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

（1）toString 返回数组的字符串形式

我们按以前的方式如下所示：

package com.ypl.Arrays_;

public class ArrayMethod01 {
    public static void main(String[] args) {
        Integer[]  integers={1,20,90};
        //遍历数组
        for (int i=0;i<integers.length;i++){
            System.out.println(integers);
        }
    }
}

我们运行之后如下所示：

 

我们 采用toString方法如下所示：

package com.ypl.Arrays_;

import java.util.Arrays;

public class ArrayMethod01 {
    public static void main(String[] args) {
        Integer[]  integers={1,20,90};
        //遍历数组
        //直接使用Arrays.toString方法，显示数组。
        System.out.println(Arrays.toString(integers));
    }
}

我们运行之后如下所示：

 

我们查看toString的源码如下所示：

public static String toString(Object[] a) {
        if (a == null)
            return "null";

        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(String.valueOf(a[i]));
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

 （2）sort 排序（自然排序和定制排序） Integer  arr[ ] ={1,-1,7,0,89};

我们可以通过这个方法Comparator这个比较器，可以指定排序的规则是什么，可以选择从大到小，也可以选择从小到大。可以根据自己的想法去设计。 

我们设计的代码如下所示：

package com.ypl.Arrays_;

import java.util.Arrays;
import java.util.Comparator;

public class ArrayMethod01 {
    public static void main(String[] args) {
        //演示sort方法的使用
        Integer arr[]={1,-1,7,0,89};
        //进行排序
        //1.可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序
        //2.因为数组是引用类型，所以通过sort排序后，会直接影响到实参 arr.
        //3.sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4.Arrays.sort(arr) 默认排序方法。
        //默认排序
        Arrays.sort(arr);
        System.out.println("=====排序后=====");
        System.out.println(Arrays.toString(arr));
        //5.调用定制排序时，传入两个参数（1）排序的数组 arr
         //(2)实现了Comparator接口的匿名内部类，要求实现 compare方法
        //6.这里体现了接口编程的方式
        //源码分析：
        //(1) Arrays.sort(arr, new Comparator() 
        //(2)最终到TimeSort的
       // private static <T> void binarySort(T[] a, int lo, int hi, int start,
        //Comparator<? super T> c)
        //(3）执行到binarySort方法的代码,会根据动态绑定机制c.compare( )执行我们传入的匿名内部类compare( )方法.
        //while (left < right) {
        //                int mid = (left + right) >>> 1;
        //                if (c.compare(pivot, a[mid]) < 0)
        //                    right = mid;
        //                else
        //                    left = mid + 1;
        //            }
        //(4) new Comparator() {
        //           @Override
        //           public int compare(Object o1, Object o2) {
        //               Integer i1 = (Integer) o1;
        //               Integer i2 = (Integer) o2;
        //
        //               return i2-i1;
        //           }
        //       });
        //(5) public int compare(Object o1, Object o2)方法返回的值>0的还是<0的会影响整个排序的结果
        //这就充分体现了接口编程+动态绑定+匿名内部类的综合使用
        //将来的底层框架和源码的使用方式，会非常常见。
        //定制排序
        Arrays.sort(arr, new Comparator() {
           @Override
           public int compare(Object o1, Object o2) {
               Integer i1 = (Integer) o1;
               Integer i2 = (Integer) o2;

               return i2-i1;
           }
       });
        System.out.println("=====排序后=====");
        System.out.println(Arrays.toString(arr));


    }
}

我们在运行的时候，我们会先调用sort方法，这个sort方法底层会调用Comparator接口。

我们运行之后如下所示：

我们通过debug来看待如何进行的自己定义的排序：

我们在如下地方打断点：

 我们追进去如下所示：

 我们传进去一个匿名类，所以不为null。

 

我们发现底层其实是二叉树排序：

我们继续进去如下所示：

 在binarySort方法底层，会通过实现的匿名内部类的compare方法来决定排序的顺序

在排序的底层，它调用了传入的接口实现的compare方法。

我们通过模拟排序来加深对排序的认识：

我们设计的代码如下所示：

package com.ypl.Arrays_;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysSourtCustom {
    public static void main(String[] args) {
        int [] arr={1,-1,8,0,20};
        bubble01(arr);
        System.out.println("默认排序为："+Arrays.toString(arr));
        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1=(Integer) o1;
                int i2=(Integer)o2;
                return i2-i1;  //return  i2-i1;
            }
        });
        System.out.println("===定制排序后的情况===");
        System.out.println(Arrays.toString(arr));
    }

    //使用冒泡完成排序
    public  static void  bubble01(int [] arr){
        int temp=0;
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j< arr.length-1-i;j++){
                //从小到大
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    //结合冒泡+定制
    public static  void  bubble02(int [] arr, Comparator c){
        int temp=0;
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j< arr.length-1-i;j++){
                //数组排序由c.compare(arr[j],arr[j+1])返回的值决定
                if(c.compare(arr[j],arr[j+1])>0) {
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

    }

}

我们运行之后如下所示：

 我们通过debug来进行更加清晰的认识：

我们继续进行追加进去如下所示：
 我们继续进行下一步，如下所示：

 其中c.compare就是我们传进去的匿名对象的Comparator,里面有动态绑定，我们进去step into，如下所示：会将arr[j]和arr[j+1]这两个元素传递给我们传入的匿名的类。

 

 (3)  binarySearch 通过二分搜索法进行查找，要求必须排好序       

   int  index =Arrays.binarySearch(arr,3);

我们设计代码如下所示：

package com.ypl.Arrays_;

import java.util.Arrays;

public class ArrayMethod02 {
    public static void main(String[] args) {
        // binarySearch 通过二分搜索法进行查找，要求必须排好序
        Integer[]  arr={1,2,90,123,567};
        //1.使用binarySearch 二叉查找
        //2.要求该数组是有序的，如果该数组是无序的，不能使用 binarySearch。
        int index = Arrays.binarySearch(arr, 1);
        System.out.println("index="+index);
        int i = Arrays.binarySearch(arr, 123);
        System.out.println("i="+i);
        //3.如果数组中不存在该元素，就返回-1.
        int i3 = Arrays.binarySearch(arr, -127);
        System.out.println("i3="+i3);
        int i1 = Arrays.binarySearch(arr, 556);
        System.out.println("i1="+i1);
        int i2 = Arrays.binarySearch(arr, 92);
        System.out.println("i2="+i2);


    }
}

我们运行之后如下所示：

我们发现我们搜索不存在的数组的时候，我们返回的是-5，不是-1.我们来查看源码：

我们根据源码我们了解到，low为值应该存放的地址，我们所求的556，如果存在的话应该位于第4个，即4为源码的low值，---（4+1）,为-5. 
我们设计的代码如下所示：

（4）copyOf 数组元素的复制： 

package com.ypl.Arrays_;

import java.util.Arrays;

public class ArrayMethod03 {
    public static void main(String[] args) {
        //copyOf  数组元素的复制
        //1.从arr数组中，拷贝arr.length个元素到 newArr数组中
        Integer [] arr={1,2,90,123,567};
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行哦完毕后===");
        System.out.println(Arrays.toString(newArr));
        //2.如果拷贝的长度>arr.length就在新数组的后面增加null。
        //3.如果拷贝的长度<0就抛出异常NegativeArraySizeException
        //4.该方法的底层使用的是System.arraycopy( )
        Integer[] integers1 = Arrays.copyOf(arr, arr.length + 1);
        System.out.println(Arrays.toString(integers1));
        Integer[] integers = Arrays.copyOf(arr, 3);
        System.out.println(Arrays.toString(integers));
     
    }
}

运行之后如下所示：

我们查看copy的底层源码：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

(5) fill数组元素的填充

Integer [] num=new Integer [ ]{9,3,2};

Arrays.fill(num,99)

我们设计的代码如下所示：

package com.ypl.Arrays_;

import java.sql.Array;
import java.util.Arrays;

public class ArrayMethod04 {
    public static void main(String[] args) {
        //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));
        
    }
}

我们运行之后如下所示：

 （6）equals  比较两个数组元素内容是否完全一致

boolean equals=Arrays.equals(arr,arr2);

我们设计的代码如下所示：

package com.ypl.Arrays_;

import java.util.Arrays;

public class ArrayMethod05 {
    public static void main(String[] args) {
        //equals 比较两个数组元素内容是否完全一致
        Integer [] arr ={1,2,90,123,567};
        Integer [] arr2={1,2,90,123,567};
        Integer[] num= new Integer[]{9,3,2};
        //1.如果arr 和 arr2 数组的元素一样，则返回true
        boolean equals = Arrays.equals(arr, arr2);
        //2.如果不是完全一样，就返回false.
        boolean equals1 = Arrays.equals(arr, num);
        System.out.println("equals="+equals);
        System.out.println("equals1="+equals1);
    }
}

我们运行之后如下所示：

(7)aList将一组值，转换成list

Liist<Integer> aList =Arrays.aList(2,3,4,5,6,1);

System.out.println("asList="+aList);

我们设计的代码如下所示：

package com.ypl.Arrays_;

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

public class ArrayMethod06 {
    public static void main(String[] args) {
        //1.asList方法，会将（2，3，4，5，6，1）数据转成一个List集合
        //2.返回的asList编译类型 List(接口）
        //3.asList 运行类型  java.util.Arrays$ArrayList,是Arrays类的静态内部类
        
        List<Integer> asList = Arrays.asList(2, 3, 4, 5, 6, 1);
        System.out.println("asList="+asList);
        System.out.println("asList的运行类型"+asList.getClass());
    }
}

我们运行之后如下所示：

我们查看Arrays的类图如下所示：Arrays的内部类如下：

 我们查看他的源码如下所示：

 private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
    
    

(八）课堂练习：

案例：自定义Book类，里面包含name和price,按price排序（从大到小）。要求使用两种方式排序，对对象的某个属性排序，有一个Book[ ] books=5本书对象。

使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。

可以按照价格price(1)从大到小  （2）从小到大   （3）按照书名长度从大到小

我们设计的代码如下：

package com.ypl.Arrays_;

import java.util.Arrays;
import java.util.Comparator;

public class ArrayExercise {
    public static void main(String[] args) {
        Book [] books=new Book[4];
        books[0]=new Book("红楼梦~",100);
        books[1]=new Book("金瓶梅新版",90);
        books[2]=new Book("青年文摘20年",5);
        books[3]=new Book("java从入门到放弃~",300);

        //(1)price从大到小
        Arrays.sort(books, new Comparator() {
            //这里是对Book数组排序，因此，o1和o2就是Book对象
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o1;
                return book2.getName().length() - book1.getName().length();
            }
        });
        System.out.println(Arrays.toString(books));
    }
}

class Book {
   private  String name;
   private  double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

我们运行之后如下所示：