当前位置： 首页 > article >正文

Java 基础进阶篇（十一）—— Arrays 与 Collections 工具类

article 2024/11/15 21:30:05

文章目录

  • 一、Arrays工具类
    • 1.1 Arrays 类常用方法
    • 1.2 对于 Comparator 比较器的支持
    • 1.3 Arrays 的综合应用
      • 1.3.1 应用一：数组的降序排序
      • 1.3.2 应用二：根据学生年龄进行排序
  • 二、Collections工具类
    • 2.1 Collections 类常用方法
    • 2.2 Collections 排序相关 API
    • 2.3 Collections 的综合应用
      • 2.3.1 应用一：类自定义比较规则
      • 2.3.2 应用二：匿名内部类方式

一、Arrays工具类

Arrays工具类是数组操作工具类，专门用于操作数组元素的。

1.1 Arrays 类常用方法

在这里插入图片描述

举例：

public static void main(String[] args) {
	int[] arr = {10, 2, 55, 23, 24, 100};
	System.out.println(arr); // [I@4eec7777
	
	// 1、返回数组内容的 toString(数组)
	//String rs = Arrays.toString(arr);
	//System.out.println(rs);
	System.out.println(Arrays.toString(arr)); // [10, 2, 55, 23, 24, 100]
	
	// 2、排序的API(默认自动对数组元素进行升序排序)
	Arrays.sort(arr);
	System.out.println(Arrays.toString(arr)); // [2, 10, 23, 24, 55, 100]
	
	// 3、二分搜索技术（前提数组必须排好序才支持，否则出bug）
	int index = Arrays.binarySearch(arr, 55);
	System.out.println(index); // 4
	
	// 返回不存在元素的规律：“-（应该插入的位置索引 + 1）” 
	int index2 = Arrays.binarySearch(arr, 22);
	System.out.println(index2); // -3
	
	// 注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug!!
	int[] arr2 = {12, 36, 34, 25 , 13,  24,  234, 100};
	System.out.println(Arrays.binarySearch(arr2 , 36));
}

注：sort() 方法默认对数组进行升序排序

1.2 对于 Comparator 比较器的支持

自定义排序规则：通过设置 Comparator 接口对应的比较器对象，来定制比较规则。

在这里插入图片描述
注：参数比较器对象是一个函数式接口，因此有两种方案：一种是匿名内部类的形式，另一种是比较类实现该接口的方法。

如果认为左边数据 大于 右边数据，返回正整数。
如果认为左边数据 小于 右边数据，返回负整数。
如果认为左边数据 等于 右边数据 返回0。

1.3 Arrays 的综合应用

1.3.1 应用一：数组的降序排序

方式一：匿名内部类

public class Test2 {
    public static void main(String[] args) {
        // 定义数组
        Integer[] ages = {34, 12, 42, 23};

        // 匿名内部类
        Arrays.sort(ages, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
            	// 指定比较规则：
                //if(o1 > o2){
                //    return 1;
                //}else if(o1 < o2){
                //    return -1;
                //}
                //return o1 - o2; // 默认升序
                return o2 - o1; //  降序
            }
        });
        // 简化形式 1
        Arrays.sort(ages, (Integer o1, Integer o2) ->{
            return o2 - o1;
        });
        // 简化形式 2
        Arrays.sort(ages, (o1, o2) ->{
            return o2 - o1;
        });

        // 简化形式 3
        Arrays.sort(ages, (o1, o2) -> o2 - o1 );
    }
}

方式二：子类实现

public class Test2 {
    public static void main(String[] args) {
        Integer[] ages = {34, 12, 42, 23};
        Arrays.sort(ages, new Comp());
        System.out.println(Arrays.toString(ages)); // [42, 34, 23, 12]
    }
}
class Comp implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}

1.3.2 应用二：根据学生年龄进行排序

public class Student {
    private String name;
    private int age;
    private double height;

   	// set 和 get 方法省略
}

方式一：匿名内部类

public class ArraysDemo2 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("吴磊",23 , 175.5);
        students[1] = new Student("谢鑫",18 , 185.5);
        students[2] = new Student("王亮",20 , 195.5);

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序！
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序！

                // return (int)o2.getAge() - o1.getAge(); // 不要这样写，因为 (int)(170.5-170.9) = 0
                
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students)); // 王亮...、谢鑫...、吴磊...
        
		// Lambda 化简
		Arrays.sort(students, ( o1,  o2) -> Double.compare(o2.getHeight(), o1.getHeight()) );
    }
}

方式二：子类实现

public class ArraysDemo2 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("吴磊",23 , 175.5);
        students[1] = new Student("谢鑫",18 , 185.5);
        students[2] = new Student("王亮",20 , 195.5);

        Arrays.sort(students, new ComImp());
        System.out.println(Arrays.toString(students));
    }
}

class ComImp implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return Double.compare(o2.getHeight(), o1.getHeight()); // 王亮...、谢鑫...、吴磊...
    }
}

二、Collections工具类

Collections 工具类并不属于集合，其是集合操作工具类，是专门用于操作 Collection 系列集合元素的。

2.1 Collections 类常用方法

在这里插入图片描述

2.2 Collections 排序相关 API

排序方式 1：
在这里插入图片描述
注：本方式不可以直接对自定义类型的 List 集合排序，除非自定义类型实现了比较规则 Comparable 接口。

排序方式 2：
在这里插入图片描述

注：Collections 自定义排序功能指针对 list 集合，相同元素会保留。(set集合、map集合自带自定义排序)

举例：

public static void main(String[] args) {
	List<String> names = new ArrayList<>();
	// 1. 批量添加
	Collections.addAll(names, "楚留香", "橙留香", "陆小凤");
	System.out.println(names); //[楚留香, 橙留香, 陆小凤]
	
	// 2. 打乱顺序
	Collections.shuffle(names);
	System.out.println(names);
	
	// 3. public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
	List<Integer> list = new ArrayList<>();
	Collections.addAll(list, 1,21,13,24);
	Collections.sort(list);
	System.out.println(list); // [1, 13, 21, 24]
}

2.3 Collections 的综合应用

2.3.1 应用一：类自定义比较规则

Apple 类：省略 set 和 get 方法。

public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private double price;
    private int weight;

    /**
      方式一：类自定义比较规则
      o1.compareTo(o2)
     */
    @Override
    public int compareTo(Apple o) {
        // 按照重量进行比较的
        return this.weight - o.weight ; // 升序，List 集存储相同大小的元素会保留！
    }
}

2.3.2 应用二：匿名内部类方式

public class CollectionsDemo02 {
	public static void main(String[] args) {
		List<Apple> apples = new ArrayList<>(); // 可以重复！
		apples.add(new Apple("红富士", "红色", 9.9, 500));
		apples.add(new Apple("青苹果", "绿色", 15.9, 300));
		apples.add(new Apple("绿苹果", "青色", 29.9, 400));
		apples.add(new Apple("黄苹果", "黄色", 9.8, 500));
		
		
		// 方式二：sort方法自带比较器对象
		Collections.sort(apples, new Comparator<Apple>() {
			@Override
			public int compare(Apple o1, Apple o2) {
				return Double.compare(o1.getPrice() , o2.getPrice()); // 按照价格排序，价格相同会保留！！
			}
		});
		System.out.println(apples);
		
		// Lambda 方式化简
		Collections.sort(apples, ( o1,  o2) ->  Double.compare(o1.getPrice() , o2.getPrice()) );	
	}
}

文章参考：Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）


http://www.kler.cn/a/17584.html

相关文章：

  • 微信小程序——01开发前的准备和开发工具
  • 探索MoviePy：Python视频编辑的瑞士军刀
  • 深度学习--正则化
  • python制作一个简单的端口扫描器，用于检测目标主机上指定端口的开放状态
  • OceanStor Pacific系列 8.1.0 功能架构
  • 【数据结构与算法】第12课—数据结构之归并排序
  • 在前端开发中，何时应该使用 jQuery，何时应该使用 Vue.js
  • 定积分比较大小的常用手段。
  • 基于SpringBoot+Vue实现的酒店管理系统
  • 【关于Linux中----生产消费模型】
  • 如何使用HTML和CSS创建有方向感知的按钮
  • Mybatis入门
  • nodejs+vue+java农村信息化服务平台
  • 【郭东白架构课 模块二：创造价值】23｜节点四：架构规划之统一语义
  • java多线程下
  • 数据结构（六）—— 二叉树（6）二叉搜索树
  • 【redis】spring-cache使用指南
  • 给孩子描述非对称加密算法
  • 代码随想录算法训练营第三十天 | 航班问题、二维回溯
  • HashMap底层结构和源码分析
  • 爬取景区源码
  • 【Maven笔记1】Maven介绍
  • ConcurrentHashMap底层实现原理
  • Java时间类（四）-- DateTimeFormatter类
  • PostgreSQL 基础知识：psql 入门
  • ChatGPT诞生的新岗位：提示工程师（Prompt Engineer）