Java基础17 集合（排序和迭代，Lambda表达式）

为热爱编程的你点赞！
学习SpringBoot实战课程 https://edu.csdn.net/course/detail/31433
学习SpringCloud入门课程 https://edu.csdn.net/course/detail/31451

---

前言

本文将介绍Collections工具类和迭代、排序的相关接口，还有Java8推出的强大工具：Lambda表达式，它们将大大提高我们使用集合的效率。

Collections工具类

集合操作的工具类
常用方法：

方法	作用
sort(List)	对List集合排序
shuffle(List）	对List集合打乱
reverse(List）	反转List集合
max(Collection）	返回最大值
min(Collection）	返回最小值
binarySearch(List,查找数)	二分查找

Comparable接口

Collections.sort(List集合)
集合中的对象必须实现Comparable接口

interface Comparable<T>{
	int compareTo(T t);
}

汽车按价格排序

class Car implements Comparable<Car>{
	//品牌
	private String brand;
	//价格
	private double price;
	//年限
	private int useYears;
	//排量
	private double gas;
	...省略getter/setter

	public Car() {
	}
	
	public Car(String brand, double price, int useYears, double gas) {
		this.brand = brand;
		this.price = price;
		this.useYears = useYears;
		this.gas = gas;
	}
	
	public void run(){
		System.out.printf("品牌%s价格%f年限%d排量%f的汽车在行驶\n",brand,price,useYears,gas);
	}

	@Override
	public int compareTo(Car o) {
		if(this.getPrice() > o.getPrice()){
			return 1;
		}else if(this.getPrice() < o.getPrice()){
			return -1;
		}else{
			return 0;
		}
	}
}

public class Test1 {

	public static void main(String[] args) {
		//Arrays.asList(Object...) 返回List集合
		List<Car> cars = Arrays.asList(
				new Car("宝马X6",1000000,5,2.0),
				new Car("奔驰S600",1500000,6,3.0),
				new Car("奥迪A6",400000,3,2.5),
				new Car("别克",150000,8,1.8),
				new Car("丰田",140000,2,1.0));
		//排序
		Collections.sort(cars);
		for(Car car : cars){
			car.run();
		}
	}

}

Comparator接口

Comparator接口提供比较的方式，可以在运行时指定排序方式
Collections.sort(List集合,Comparator比较器)

interface Comparator<T>{
	int compare(T o1, T o2);
}

按多种方式进行排序

public static void main(String[] args) {
	List<Car> cars = Arrays.asList(
			new Car("宝马X6",1000000,5,2.0),
			new Car("奔驰S600",1500000,6,3.0),
			new Car("奥迪A6",400000,3,2.5),
			new Car("别克",150000,8,1.8),
			new Car("丰田",140000,2,1.0));
	Scanner input = new Scanner(System.in);
	System.out.println("请输入排序方式：1、价格 2、年限 3、排量 ");
	int type = input.nextInt();
	switch(type){
	case 1:
		//用匿名内部类实现Comparator，按价格排序
		Collections.sort(cars,new Comparator<Car>(){
			@Override
			public int compare(Car o1, Car o2) {
				if(o1.getPrice() > o2.getPrice()){
					return 1;
				}else if(o1.getPrice() < o2.getPrice()){
					return -1;
				}else{
					return 0;
				}
			}
		});
		break;
	case 2:
		//按年限排序
		Collections.sort(cars,new Comparator<Car>(){
			@Override
			public int compare(Car o1, Car o2) {
				if(o1.getUseYears() > o2.getUseYears()){
					return 1;
				}else if(o1.getUseYears() < o2.getUseYears()){
					return -1;
				}else{
					return 0;
				}
			}
		});
		break;
	case 3:
		//按排量排序
		Collections.sort(cars,new Comparator<Car>(){
			@Override
			public int compare(Car o1, Car o2) {
				if(o1.getGas() > o2.getGas()){
					return 1;
				}else if(o1.getGas() < o2.getGas()){
					return -1;
				}else{
					return 0;
				}
			}
		});
		break;
	}
	for(Car car : cars){
		car.run();
	}
}

集合迭代

Iterator接口

作用是对数据进行遍历，不需要考虑数据的数据结构，提供通用的遍历方式。

方法：

• boolean hasNext() 判断数据是否还有下一个
• T next() 向后移动，返回当前数据
  

Iterable接口

实现该接口的对象，可以通过foreach循环遍历
方法：

• Iterator iterator() 返回迭代器

List接口继承Collection接口，Collection继承Iterable接口。
进行foreach循环时，会自动调用iterator()，返回迭代器对象，执行next和hasNext完成数据遍历

Lambda表达式

Lambda表达式是Java1.8的重要特性，能使用非常简洁的代码，完成对接口的实现。
应用场景是：实现函数式接口（FunctionalInterface）
函数式接口通常只有一个需要实现的方法，如：Comparator

@FunctionalInterface
public interface Comparator<T> {
	int compare(T o1, T o2);
}

语法特点：

() -> 表达式       			实现没有参数的方法
(参数名,参数名...) -> 表达式	实现有参数的方法，参数类型可以自动推断出来
(参数名,参数名...) -> {代码}		

用Lambda实现排序

Collections.sort(cars,(o1,o2)->{
	if(o1.getPrice() > o2.getPrice()){
		return 1;
	}else if(o1.getPrice() < o2.getPrice()){
		return -1;
	}else{
		return 0;
	}
});

遍历集合

List集合.forEach(Consumer接口)

Consumer<T> 接口
void accept(T t)

示例：

cars.forEach((car) -> System.out.println(car));
cars.forEach((car) -> System.out::println));

Stream接口

java1.8推出的Stream接口，提供对集合操作的一系列方法

集合的筛选

Stream filter(Predicate<T>接口)
Predicate<T>接口
boolean test(T t)

集合的收集

collect(Collector收集器)
Collectors类
Collector toList()	List类型收集器
Collector toSet()	Set类型收集器
Collector toMap()	Map类型收集器

集合的排序

sorted(Comparator<T>比较器）

限制返回值个数

limit(个数)

找最大值

max(Comparator<T>比较器)

Stream的使用

List<Car> cars = Arrays.asList(
	new Car("宝马X6",1000000,5,2.0),
	new Car("奔驰S600",1500000,6,3.0),
	new Car("奥迪A6",400000,3,2.5),
	new Car("别克",150000,8,1.8),
	new Car("丰田",140000,2,1.0));
//筛选出价格200000以上,排量2.0以上的车，按年限排序
List<Car> result = cars.stream()
	.filter((car)-> car.getPrice() > 200000)
	.filter((car)-> car.getGas() > 2.0)
	.sorted((c1,c2)-> c1.getUseYears() - c2.getUseYears())
	.collect(Collectors.toList());
result.forEach((c)->System.out.println(c));
//集合中最贵的三辆车
List<Car> result = cars.stream()
	.sorted((c2,c1)->{
		if(c1.getPrice() > c2.getPrice()){
			return 1;
		}else if(c1.getPrice() < c2.getPrice()){
			return -1;
		}else{
			return 0;
		}
	})
	.limit(3)
	.collect(Collectors.toList());
result.forEach((c)->c.run());
//最贵的车
Car max = cars.stream()
	.max((c1,c2)->{
		if(c1.getPrice() > c2.getPrice()){
			return 1;
		}else if(c1.getPrice() < c2.getPrice()){
			return -1;
		}else{
			return 0;
		}
	})
.get();
System.out.println("最贵的车：" + max);

结束

作业：

1. 定义食品类，属性有：名称、价格(double)、重量（double)、保质年数(int)，重写toString方法
   创建食品集合，添加一定数量的食品
   用户输入排序方式（1、价格 2、重量 3、保质期）
   按排序方式进行排序，并显示
   显示价格在100以下，重量超过10，保质期超过2年的所有商品。
   显示价格最高的1样商品

---

大家如果需要学习其他Java知识点，戳这里 超详细的Java知识点汇总