Array类

Array类

Array类包含了一系列的静态方法，用于管理和操作数组（比如排序和搜索）
Array类提供了动态创建和访问Java数组的静态方法

Array类的常用方法

1. toString方法：返回数组的字符串形式
2. sort方法：排序（自然排序和定制排序）
3. binarySearch方法：通过二分搜索法进行查找，要求必须排好序
4. copyOf方法：数组复制
5. fill方法:数组元素的填充
6. equals方法：比较两个数组元素内容是否一致
7. asList方法：将一组值，转换成list

演示使用：
binarySearch

public class test2 {
    public static void main(String[] args) {
        int arr [] ={1,2,3,4,5};
        System.out.println(Arrays.binarySearch(arr,1));
    }
}

可传一个数组，和要查找的元素
使用binarySearch要求传入的数组是排好序的
如果传入查找的元素在数组中没有，则会返回 -（low+1），low代表传入元素应该在的位置。比如传入一个6.那么就会返回-5

copyOf

public class test2 {
    public static void main(String[] args) {
        int arr [] ={1,2,3,4,5};
        int[] arr2 = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(arr2));;
    }
}

可传入两个参数，一个数组，一个数组长度。
会复制传入的数组，返回一个新数组，复制的长度是由传入参数来定
如果传入的长度比原数组长，会在后面添加默认值，int是0 Intger是null
如果传入的长度比原数组小，会缩减最后一位。如果小于0会报异常
底层使用的是System.arraycopy()

fill

public class test2 {
    public static void main(String[] args) {
        int arr [] ={1,2,3,4,5};
       Arrays.fill(arr,99);
        System.out.println(Arrays.toString(arr));;
    }
}

传入一个数组一个元素，把元素填充到数组，替换原元素

sort排序自然排序和定制排序

在数组排序中之前学习了冒泡排序：

public class test1 {
    public static void main(String[] args) {
       int arr [] = {-1,2,42,4};
       bubble01(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubble01(int [] arr){//冒泡排序方法
        //普通冒泡排序
        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]){
                    int num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                }
            }
        }
    }
}

这里面控制排序条件的是if (arr[j]>arr[j+1])，如果前面的比后面的大，那么就进行交换。
这里就觉得了排序后是从小到大排序的，而如果是if (arr[j]<arr[j+1]),前面的比后面的小
那么就会变成从大到小的排序。
而所谓的定制排序我们借用拆析sort的一个重载方法 sort（T[] a,Comparator）

public class test1 {
    public static void main(String[] args) {
       int arr [] = {-1,2,42,4};
       bubble02(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(Arrays.toString(arr));
    }

    public static void bubble02(int [] arr, Comparator c){
        //定制冒泡排序
        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){
                    int num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                }
            }
        }
    }
}

这里一共做了以下几件事情：

1. 先用Comparator 接口的compara方法替代了原本的arr[j]>arr[j+1]，条件判断
2. 接着在调用bubble02方法的时候，传入了实现了Comparator 接口的匿名内部类
3. 在这个匿名内部类中重写方法中，将arr[j]和arr[j+1]传入，也就是数组中的元素一前一后
4. 接着向下转型变成Intger类型，然后拆箱赋值给int i1和i2.
5. 最后关键的一步，return i1-i2。这里就觉得了排序条件
6. 如果前面的比后面的大就会返回一个正数，而正数是大于0的，所以会进行下面的元素换位。
7. 而如果前面的比后面的小就会返回一个负数，负数小于0，就不会进行换位
8. 以此达到排序的效果，而怎么排序取决于，匿名内部类重写的方法，i1和i2 是谁-谁
9. 与普通的冒泡原理是一样的

Array类练习

1.编程题
自定义Book类，里面包含name和pice，按pice排序（从大到小和从小到大）两种排序
使用实现Comparator接口匿名内部类完成，也就是定制排序
有以下4本书：
红楼梦 100
读者 50
青年 30
java入门到放弃 300

思路：
创建排序方法，在普通的冒泡排序的排序条件使用Comparator接口匿名内部类实现的方法完成

public class test2 {
   public static void main(String[] args) {
       Book books[] = new Book[4];
       books[0] = new Book("红楼梦",100);
       books[1] = new Book("读者",50 );
       books[2] = new Book("青年",30);
       books[3] = new Book("java入门到放弃",300);
       bosort(books, new Comparator() {
           @Override
           public int compare(Object o1, Object o2) {
               Integer i1 = (Integer) o1;
               Integer i2 = (Integer) o2;
               return i1-i2;
           }
       });
       for (int i = 0; i < books.length; i++) {
           System.out.println(books[i].name+books[i].price);
       }

   }
   public static void bosort(Book[]books, Comparator c){
       for (int i = 0; i < books.length-1; i++) {
           for (int j = 0; j < books.length-1-i; j++) {
               if (c.compare(books[j].price,books[j+1].price)<0){//如果前面的价格减后面的价格小于0 就交换，这就是从大到小，从小到大改小于号为大于号即可
                   Book inBook  = new Book("null",0);
                   inBook = books[j];
                   books[j] = books[j+1];
                   books[j+1] = inBook;
                }
           }
       }
   }
}
class Book{
   public Book(String name, int price) {
       this.name = name;
       this.price = price;
   }

   String name;
   int price;
}

如果要按照name长度排序，把条件属性从price换成name.length即可