【JavaSE】Arrays类常见方法

举报
兮动人 发表于 2022/03/27 00:38:03 2022/03/27
【摘要】 【JavaSE】Arrays类常见方法

1. Arrays 类常见方法应用案例

  • 传统方法的遍历数组
	Integer[] integers = {1, 20, 90};
	//遍历数组
	for (int i = 0; i < integers.length; i++) {
	    System.out.println(integers[i]);
	}

在这里插入图片描述

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

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

	//直接使用 Arrays.toString 方法,显示数组
	Integer[] integers = {1, 20, 90};
	System.out.println(Arrays.toString(integers));

在这里插入图片描述

1.2 sort 排序(自然排序和定制排序),

Integer arr[] = {1,-1,7,0,89};

  • 自然排序
	Integer arr[] = {1, -1, 7, 0, 90};
	//解读:
	//1. 可以直接使用冒泡排序,也可以使用 Arrays 提供的 sort 方法排序
	//2. 因为数组是引用类型,所以通过 sort 排序后,会直接影响到 实参 arr
	Arrays.sort(arr); //默认排序方法
	System.out.println("===排序后===");
	System.out.println(Arrays.toString(arr));

在这里插入图片描述

  • 定制排序
3. sort的重载,也可以通过传入一个接口 Comparator 实现定制排序

4. 调用 定制排序 时,传入两个参数:
 (1) 排序的数组 arr
 (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
 
5. 这里体现了接口编程的方式 , 看源码
   源码分析:
(1) Arrays.sort(arr, new Comparator()
(2) 最终到 TimSort类的 
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
    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
    将来的底层框架和源码的使用方式,会非常常见的

在这里插入图片描述

  • 定制从大到小排列,return i2 - i1
	Integer arr[] = {1, -1, 7, 0, 90};
	//Arrays.sort(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));//

在这里插入图片描述

  • 如果 return i1 - i2,就是从小到大排序
    在这里插入图片描述

案例演示:定制版的冒泡排序

  • 冒泡排序
public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {1, -1, 8, 0, 20};
        bubble01(arr);

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

        int[] arr = {1, -1, 8, 0, 20};

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;//拆箱
                int i2 = (Integer) o2;
                return i1 - i2; // return i2 - i1;
            }
        });

        System.out.println("===定制排序后的情况===");
        System.out.println(Arrays.toString(arr));

    }

    //结合冒泡 + 定制
    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;
                }
            }
        }
    }
}

从大到小:return i2 - i1;
在这里插入图片描述

1.3 binarySearch 通过二分搜索法进行查找,要求必须排好序

	Integer[] arr = {1, 2, 90, 123, 567};
	1. 使用 binarySearch 二叉查找
	2. 要求该数组是有序的。 如果该数组是无序的,不能使用 binarySearch
	int index1 = Arrays.binarySearch(arr, 1);
	int index2 = Arrays.binarySearch(arr, 90);
	System.out.println("index1=" + index1);
	System.out.println("index2=" + index2);

在这里插入图片描述

  • 如下,900 如果存在在上面的数组中,排序下标应为 5,此时low = 5,通过如下公式所知,返回 -6
	3. 如果数组中不存在该元素,就返回 return -(low + 1);  // key not found.
	int index3 = Arrays.binarySearch(arr, 900);
	System.out.println("index3=" + index3);

在这里插入图片描述

1.4 copyof 数组元素的复制

Integer[] newArr = Arrays.copyOf(arr, arr.length);
	Integer[] arr = {1, 2, 90, 123, 567};
	// copyOf 数组元素的复制
	1. 从 arr 数组中拷贝 arr.length 个元素到 newArr 数组中
	Integer[] newArr = Arrays.copyOf(arr, arr.length);
	System.out.println("===拷贝执行完成后===");
	System.out.println(Arrays.toString(newArr));

在这里插入图片描述

	2. 如果拷贝的长度大于了 arr.length ,就在新数组后面 增加 null
	Integer[] newArr = Arrays.copyOf(arr, 6);
	System.out.println("===拷贝执行完成后===");
	System.out.println(Arrays.toString(newArr));

在这里插入图片描述

	3. 如果拷贝的长度 < 0 , 就抛出异常 NegativeArraySizeException
	4. 该方法的底层使用的是 System.arraycopy()
	Integer[] newArr = Arrays.copyOf(arr, -1);
	System.out.println("===拷贝执行完成后===");
	System.out.println(Arrays.toString(newArr));

在这里插入图片描述

1.5 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));

在这里插入图片描述

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

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

在这里插入图片描述

1.7 asList将一组值,转换成list

	//asList 将一组值,转换成 list
	//1. asList 方法,会将(2, 3, 4, 5, 6, 1)数据转成一个 list 集合
	//2. 返回 asList 编译类型 List(接口)
	//3. asList 运行类型,class 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());

在这里插入图片描述

2. 练习

  • 案例:自定义Book类,里面包含nameprice,,按price排序(从大到小)。要求使用两种方式排序,有一个Book[] books = 4本书对象。
  • 使用前面学习过的传递实现Comparator接口匿名内部类,也称为定制排序。
  • 可以按照price (1)从大到小 (2)从小到大 (3)按照书名长度从大到小
  1. price 从大到小 排列
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) o2;
                double priceVal = book2.getPrice() - book1.getPrice();
                //这里进行了一个转换
                //如果发现返回结果和我们输出的不一致,就修改一下返回的 1 和 -1
                if (priceVal > 0) {
                    return 1;
                } else if (priceVal < 0) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
    }
}

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 +
                '}';
    }
}

在这里插入图片描述

  1. price 从小到大 排列
    只需要调整 返回 1 和 -1 的位置即可
    在这里插入图片描述
    在这里插入图片描述

  2. 按照书名长度从大到小

	Arrays.sort(books, new Comparator() {
	    //这里是对Book数组排序,因此  o1 和 o2 就是Book对象
	    @Override
	    public int compare(Object o1, Object o2) {
	        Book book1 = (Book) o1;
	        Book book2 = (Book) o2;
	        //要求按照书名的长度来进行排序
	        return book2.getName().length() - book1.getName().length();
	    }
	});

在这里插入图片描述

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200