480-484Math和Arrays类

一、Math类

package com.day5_21;

/**
 * @author alice_huijing
 * @version 1.0
 */
/*
    在Math类中包含用于执行基本数学运算的方法，比如初等指数，对数，平方根和三角函数
    这些方法都是静态的方法，可以直接拿过来使用。
    首先还是看下Math类的类图
    看看Math常用的方法
    1、abs绝对值
    2、pow求幂
    3、ceil向上取整
    4、floor向下取整
    5、round四舍五入
    6、sqrt求开方
    7、random求随机数
    8、max最大值
    9、min最小值
 */
public class MathClass07 {
    public static void main(String[] args) {
        // 1、abs求绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9
        // 2、pow求幂
        double pow = Math.pow(2,4);
        System.out.println(pow);  // 16.0，因为返回的是double所以是16.0
        // 3、ceil向上取整
        double ceil = Math.ceil(-3.0001);
        System.out.println(ceil); // -3.0
        // 4、floor向下取整
        double floor = Math.floor(-4.999);
        System.out.println(floor);  // -5.0
        // 5、round四舍五入
        long round = Math.round(-5.001);
        System.out.println(round);
        // 6、求开方
        double sqrt = Math.sqrt(-9.0);  // 如果不是大于等于0的就NaN得不到结果
        System.out.println(sqrt);
        // 7、random求随机数
        // random返回的是0<=x<1之间的一个随机小数
        /*
            思考：请写出获取a-b之间的一个随机整数，ab都是整数，比如a = 2，b = 7
            即返回一个数：
            2 <= x <= 7
            Math.random()*(b-a+1)返回的是0 <= x <= b-a
            再加上一个a
            a <= x <= b
            (int)(a) <= x <= (int)(a+Math.random()*(b-a+1))
         */
        // max，和min
        int min = Math.min(1,9);
        int max = Math.max(45,90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

二、Arrays类

package com.day5_21;

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

/**
 * @author alice_huijing
 * @version 1.0
 */
public class ArraysClass08 {
    public static void main(String[] args) {
        Integer[] integers = {1,20,90};
//        以前遍历的方式是for循环
        for (int i = 0; i < integers.length; i++) {
            System.out.println(integers[i]);
        }
        // 1、提供一个toString方法，显示数组信息
        System.out.println(Arrays.toString(integers));

        Integer arr[] = {1, -1, 7, 0, 89};
        // 1、可以直接使用冒泡排序，也可以使用Arrays提供的sort方法排序，默认是升序，传入一个数组进去即可，也可以定制排序的规则
        // 2、数组是引用类型，所以通过sort排序之后，会直接影响到实参arr
        // 3、sort重载的，也可以通过传入一个接口Comparator实现定制排序
        // 4、调用定制排序时，传入两个参数1）排序数组arr2）实现了Comparator接口的匿名内部类，要求实现compare方法
        // 这里体现了接口编程的方式，看源码就明白了
        // c.compare(pivot, a[mid]) < 0)，在方法binarySort方法底层，会通过匿名内部类的compare方法
        // 来决定排序的顺序
        System.out.println(Arrays.toString(arr));
        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));
    }
}

package com.day5_21;

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

/**
 * @author alice_huijing
 * @version 1.0
 */
public class ArraysClass09 {
    public static void main(String[] args) {
        int[] arr = {1, -1, 8, 0, 20};
        bubble(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println("==排序后的情况==");
        System.out.println(Arrays.toString(arr));
    }

    public static void bubble(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++) {
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

package com.day5_21;

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

/**
 * @author alice_huijing
 * @version 1.0
 */
public class ArraysClass10 {
    public static void main(String[] args) {
        // 二分查找
        Integer[] arr = {1,2,90,123,567};
        // binarySearch通过二分查找进行搜索，要求必须要有序，如果不存在返回-1，对吗
        // 568的时候返回的居然是-6看源码return -(low + 1);  // key not found.
        int index = Arrays.binarySearch(arr, 568);
        // 如果568如果存在，因为数组是有序的，所以必须在567之后，也就是index为5的位置，
        // 这里的low就是5，然后返回-(low+1)得到-6
        System.out.println("index="+index);
        // 其他的方法
        // copyOf数据元素的复制，从指定数组中拷贝指定长度的元素到新的数组
        // 如果拷贝的长度 > arr.length就在新数组后面插入一个null
        // 如果拷贝的长度 是0就是一个空的数组[]
        // 如果拷贝的长度 < arr.length就抛出异常
        // 底层使用的是System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length+1);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));
        // fill数组元素的填充,使用指定的元素去替换原来数组中的元素
        Integer[] num = new Integer[]{9,3,2};
        Arrays.fill(num, 99);;
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));

        // equals比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1, 2, 90, 123, 567};
        // 如果arr和arr2数组的元素是一样的，则方法true
        // 如果不是完全一样，就返回false
        boolean equals = Arrays.equals(arr,arr2);
        System.out.println("equals=" + equals);
        // asList将一组值，转换成list
        // 1、asList方法，会将(2,3,4,5,6,1)数据转换成一个List集合
        // 2、返回的asList编译类型List（接口）
        // 3、asList运行类型java.util.Arrays$ArrayList，是Arrays类的
        // 静态内部类
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        System.out.println("asList的运行类型" + asList.getClass());
    }
}

package com.day5_21;


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

/**
 * @author alice_huijing
 * @version 1.0
 */
public class ArraysClass11 {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("jpm新", 90);
        books[2] = new Book("青年文摘20年", 5);
        books[3] = new Book("java从入门到放弃~", 300);

//        Arrays.sort(books, new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal = book2.getPrice() - book1.getPrice();
//                // 两个是double类型，运算结果是double，但是要返回int
//                if(priceVal > 0) return 1;  // 如果要从小到大可以-1 1 0
//                else if (priceVal < 0) return -1;
//                else return 0;
//            }
//        });
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                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 +
                '}';
    }
}
/*
    练习一：
    自定义Book类，里面包含name和price，按price排序（从大到小）。要求使用两种方式排序，对对象的某个属性排序，有一个
    Book[] books = 4本书对象。
    使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。
    Book[] books = new Book[4];
    books[0] = new Book("红楼梦~",100);
    books[1] = new Book("jpm~",90);
    books[2] = new Book("青年文摘~",5);
    books[3] = new Book("java从入门到放弃~",300);
 */