Java基础学习第20天——Arrays类常见方法及应用案例

Arrays类

• Arrays类常见方法及应用案例

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

  1. toString 返回数组的字符串形式

     Arrays.toString(arr)

  2. sort 排序（自然排序和定制排序）Integer arr[] = {1, -1, 7, 0, 89}；

     • 定制+冒泡排序

     package Arrays;
     
     import java.util.Arrays;
     import java.util.Comparator;
     
     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;
                 }
             });
         }
         //结合冒泡+定制排序
         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++) {
                     if (c.compare(arr[j],arr[j+1])>0) {
                         temp = arr[j];
                         arr[j] = arr[j + 1];
                         arr[j + 1] = temp;
                     }
                 }
             }
             System.out.println(Arrays.toString(arr));
         }
     }
     
     

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

     package Arrays;
     
     import java.util.Arrays;
     
     public class ArraysMethod02 {
         public static void main(String[] args) {
             Integer[] arr = {1,2,9,10,123,567};
             //binarySearch 通过二分法进行查找，要求必须排好
             //1.使用 binarySearch 二叉查找
             //2.要求该数组是有序的，如果该数组是无序的，不能使用binarySearch
             //3.不存在返回 return -(low + 1);  
             int index = Arrays.binarySearch(arr,1);
             System.out.println("index=" + index );
             //   index=0
         }
     }
     
     

  4. copyOf 数组元素的赋值

     //从 arr 数组中拷贝 arr.length个元素到 newArr数组中
     Integer[] newArr =  Arrays.copyOf(arr, arr.length);
     

  5. fill 数组元素的填充

     //使用 99 去填充 num 数组，可以理解成是替换原理的元素
     Integer[] num = {9,3,2};
     Arrays.fill(num,99);
     System.out.println(Arrays.toString(arr))
     // [99,99,99]
     

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

     //前者与后者完全一致返回true,否则返回false
     boolean equals = Arrays.equals(arr,arr2);
     

  7. asList 将一组值，转换成list

     //1、aslist方法，会将(2,3,4,5,6,1) 中数据转成一个List集合
     List<Integer> asList = Arrays.asList(2,3,4,5,6,1);
     System.out.println("asList=" + asList);
     

• 案例分析

  package Arrays;
  
  import java.util.Arrays;
  import java.util.Comparator;
  
  public class ArrayExercise {
      public static void main(String[] args) {
          // 自定义Book类，里面包含name和price,按price排序(从大到小)。
          // 要求使用两种方式排序，有一个Book[] books= 4本书对象
          Book[] books = new Book[4];
          books[0] = new Book("书1", 100);
          books[1] = new Book("书书2", 90);
          books[2] = new Book("书书书3", 5);
          books[3] = new Book("书书书书4", 300);
          bubble(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));
      }
  
      public static void bubble(Book[] books, Comparator c) {
          Book temp;
          for (int i = 0; i < 3; i++) {
              for (int j = 0; j < 3 - i; j++) {
                  if (c.compare(books[j], books[j + 1]) > 0) {
                      temp = books[j];
                      books[j] = books[j + 1];
                      books[j + 1] = temp;
                  }
              }
          }
      }
  }