【JavaSE】Arrays类常见方法
  TEZNKK3IfmPf 2023年11月12日 28 0

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​​​，就是从小到大排序
    【JavaSE】Arrays类常见方法

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

  • 冒泡排序
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)按照书名长度从大到小
  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 +
                '}';
    }
}

【JavaSE】Arrays类常见方法

  1. ​​price​​ 从小到大 排列
    只需要调整 返回 1 和 -1 的位置即可
    【JavaSE】Arrays类常见方法
    【JavaSE】Arrays类常见方法

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

【JavaSE】Arrays类常见方法

【版权声明】本文内容来自摩杜云社区用户原创、第三方投稿、转载，内容版权归原作者所有。本网站的目的在于传递更多信息，不拥有版权，亦不承担相应法律责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@moduyun.com
  1. 分享：
最后一次编辑于 2023年11月12日 0

暂无评论

推荐阅读
  TEZNKK3IfmPf   2023年11月12日   31   0   0 反射JavaSE
  TEZNKK3IfmPf   2023年11月12日   63   0   0 javaJavaSE
  TEZNKK3IfmPf   2023年11月12日   54   0   0 javaJavaSEWeb
  TEZNKK3IfmPf   2023年11月12日   56   0   0 javaJavaSEWeb
  TEZNKK3IfmPf   2023年11月12日   57   0   0 接口CollectionJavaSE
  TEZNKK3IfmPf   2023年11月12日   44   0   0 IDEAJavaSE
  TEZNKK3IfmPf   24天前   24   0   0 JavaSE
  TEZNKK3IfmPf   2023年11月12日   22   0   0 javaJavaSEWeb
  TEZNKK3IfmPf   2023年11月12日   79   0   0 JavaSE
  TEZNKK3IfmPf   2023年11月15日   33   0   0 Arraysjava
  TEZNKK3IfmPf   2023年11月12日   53   0   0 注解JavaSE
  TEZNKK3IfmPf   2023年11月12日   41   0   0 javaJavaSEWeb
  TEZNKK3IfmPf   2023年11月13日   36   0   0 Arraysjava数组
  TEZNKK3IfmPf   2023年11月12日   64   0   0 封装JavaSE
  TEZNKK3IfmPf   2023年11月12日   38   0   0 javaJavaSEWeb
  TEZNKK3IfmPf   2023年11月12日   41   0   0 类JavaSE
  TEZNKK3IfmPf   2023年11月15日   18   0   0 Arraysjava
  TEZNKK3IfmPf   2023年11月13日   21   0   0 MathArrays
  TEZNKK3IfmPf   2023年11月12日   48   0   0 JavaSE
  TEZNKK3IfmPf   2023年11月12日   32   0   0 子类JavaSE继承
TEZNKK3IfmPf
TEZNKK3IfmPf
作者其他文章 更多
使用代码获得所有适用于创建的transaction type

2024-06-14

C/C++ realloc()函数解析

2024-06-14

生成一个文件 保存在指定的文件夹中 思路 python

2024-06-14

Windows 10封装中出现“无法验证你的Windows安装”错误解决方法

2024-06-14

109-修改返回体的内容RestControllerAdvice

2024-06-14

C/C++ 判断进程是否存在

2024-06-14

使用面向对象重构之-使用接口完成行为抽象

2024-06-14

使用面向对象重构之-把抽象控制在一处：提高内聚性

2024-06-14

重操旧业障碍多

2024-06-14

关于关闭自动装配

2024-06-14

常用标签
数据数据数据数据javalinuxlinuxpythonCentOSredisJavapython区块链技术区块链信息系统字符串MySQL资讯项目管理mysql教程MySQL