常用类--Arrays、System

6、Arrays类

6.1 Arrays的常用方法

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

toString 返回数组的字符串形式
```
System.out.println(Arrays.toString);
```

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

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

//1.可以直接使用冒泡排序，也可以直接使用Arrays提供的方法排序
//2.因为数组是引用类型，所以经过sort排序后，会直接影响到 实参 arr

Arrays.sort(arr);//默认排序方法


//3.sort重载的，也可以通过传入一个接口Comparator，实现定制排序
//4.调用 定制排序 时，传入两个参数：（1）排序的数组、（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，会影响整个排序的结果，这就充分体现 动态编程+动态绑定+匿名内部类 的综合使用

Arrays.sort(arr, new Comparator(){
    @Override
    public int compare(Object o1,Object o2){
        Integer i1 = (Integer o1);
        Integer i2 = (Integer o2);
        return i2-i1;
    }
})

![常用类 6.1.1](D:\桌面\博客\picture\常用类 6.1.1.png)

//若依然不理解

public void main(String[] args){
    int[] arr = {1,-1,9,0,11};
    bubble02(arr,new Comparator(){
       @Override
        Integer i1 = (Integer o1);
        Integer 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; 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;
            }
        }
    }
}

binarySearch 通过二分搜索法查找排序，要求必须排好序
- 使用 binarySearch 二叉查找，要求该数组时有序的
- 不存在该元素，返回 return -(low + 1)
- low : 如果参在的话，应该在的位置
```
int index = Arrays.binarySearch(arr,3);
```
copyOf 数组元素的复制
- 从 arr 拷贝 arr.length 个元素到 newArr 数组中
- 如果拷贝的长度 > arr.length，就在新数组后面加 null
- 如果拷贝的长度 < 0，就抛出异常 NegativeArraySizeException
- 该方法的底层使用的是 System.arraycopy
```
Integer[] newArr = Arrays.copyOf(arr,arr.length);
```
fill 数组元素的填充
- 可以理解为替换原数组的元素
```
Arrays.fill(arr,99);
```
equals 比较两个数组元素是否完全一致
- 若两数组完全一样，则返回true
```
boolean equals = Arrays.equals(arr1,arr2);
```
asList 将一组值，转换成list
- asList 方法，会将(2,3,4,5,6,1)数据转成一个List集合
- 返回的 asList 编译类型List（接口）
- asList 运行类型 java.util.Arrays#ArraysList，是 Arrays类的静态内部类
  
  private static class ArrayList extends AbstractList
  implements RandomAccess, java.io.Serializable
```
List<Integer> asList = Arrays.asList(2,3,4,5,6,1);
```

练习：
自定义Book类，里面包含name和price，按price排序(从大到小)。要求使用
两种方式排序，有一个 Book books=4本书对象

使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。

（1）按照price从大到小，（2）按照price从小到大，（3）按照书名长度从大到小

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）；

punlic class ArraysExercise{
    public 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();
                if(priceVal > 0){
                    return 1;
                }else if(priceVal < 0){
                    return -1;
                }else{
                    return 0;
                }
            }
        });
        
        
        //（2）按照price从小到大,同理
        
        
        //（3）按照书名长度从大到小
        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();
            }
        });
    }
}

class Book{
    private String name;
    private double price;
    //构造器，set/get省略
    ......
}

7、System类

7.1 System的常用方法

exit 退出当前程序
1. exit(0) 表示程序退出
2. 0 表示一个状态，正常的状态
```
System.exit(0);
```
arraycopy 复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组
1. 主要搞清楚五个参数的含义
2. 源数组
  
  @param* src the source array
  
  srcPos：从源数组的哪个索引开始拷贝
  
  @param* srcPos starting position in the source array
  
  dest：目标数组，即把源数组的数据拷贝到哪个数组
  
  @param* dest the destination array
  
  destPos：把源数组的数据拷贝到目标数组的哪个索引
  
  @param* destPos starting position in the destination data
  
  length：从源数组拷贝多少个数据到目标数组
  
  @param length the number of array elements to be copied
```
int[] src={1,2,3};
int[] dest= new int[3];
System.arraycopy(src, 0, dest, 0, 3);
```
currentTimeMillens 返回当前时间距离1970-1-1的毫秒数
gc 运行垃圾回收机制 System.gc();

posted @ 2025-08-22 17:49 lu璐阅读(13) 评论(0) 收藏举报

刷新页面返回顶部

lulu14

常用类--Arrays、System

6、Arrays类

6.1 Arrays的常用方法

7、System类

7.1 System的常用方法

公告