【JavaSE】Arrays类常见方法-天翼云

【JavaSE】Arrays类常见方法

2023-07-28 08:29:03 阅读次数：616

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

传统方法的遍历数组

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

【JavaSE】Arrays类常见方法

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

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

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

定制排序

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
    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
    将来的底层框架和源码的使用方式，会非常常见的

【JavaSE】Arrays类常见方法

定制从大到小排列，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));//

【JavaSE】Arrays类常见方法

如果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;
                }
            }
        }
    }
}

【JavaSE】Arrays类常见方法

定制版的冒泡排序

从小到大排序：

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;

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

如下，900 如果存在在上面的数组中，排序下标应为5，此时low = 5，通过如下公式所知，返回-6

3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
  int index3 = Arrays.binarySearch(arr, 900);
  System.out.println("index3=" + index3);

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

2. 练习

案例:自定义Book类，里面包含name和price,，按price排序(从大到小)。要求使用两种方式排序，有一个Book[] books = 4本书对象。
使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。
可以按照price (1)从大到小 (2)从小到大 (3)按照书名长度从大到小

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

【JavaSE】Arrays类常见方法

price 从小到大排列
只需要调整返回 1 和 -1 的位置即可
按照书名长度从大到小

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();
      }
  });

【JavaSE】Arrays类常见方法

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

【JavaSE】Arrays类常见方法

【JavaSE】Arrays类常见方法

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

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

1.2​​sort​​ 排序(自然排序和定制排序)，

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

1.4​​copyof​​ 数组元素的复制

1.5​​fill​​ 数组元素的填充

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

1.7​​asList​​​将一组值，转换成​​list​​

2. 练习

相关文章

Java基础（Arrays工具类）(asList()方法)（详细）

初学Java,List和ListIterator(二十八)

idea 2017.3 版本激活

深入浅出 Java 数组：从基础到进阶

【JavaSE】接口基本使用

浅学hello world

HTML之媒体元素

java，捕获和抛出异常

字符串比较方法

方法的调用和加强

作者介绍

最新文章

Java基础（Arrays工具类）(asList()方法)（详细）

初学Java,List和ListIterator(二十八)

idea 2017.3 版本激活

深入浅出 Java 数组：从基础到进阶

【JavaSE】接口基本使用

浅学hello world

热门文章

第十一章《Java实战常用类》第8节：Arrays类

Arrays类的使用

注解，学习

【JavaSE】final关键字基本使用

封装详解

java 反射 Reflection

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

JAVAWeb --JSP基础语法

【JavaSE】finalize方法基本使用

javaweb

DOS命令

java.super详解

【JavaSE】可变参数的基本使用

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

1.2`sort` 排序(自然排序和定制排序)，

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

1.4`copyof` 数组元素的复制

1.5`fill` 数组元素的填充

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

1.7`asList`将一组值，转换成`list`