Java基础17 集合（排序和迭代，Lambda表达式，4年小Java的心路历程

Java基础17 集合（排序和迭代，Lambda表达式，4年小Java的心路历程

Collections.sort(cars);

for(Car car : cars){

car.run();

}

}

}

Comparator接口

==========================================================================

Comparator接口提供比较的方式，可以在运行时指定排序方式

Collections.sort(List集合,Comparator比较器)

interface Comparator{

int compare(T o1, T o2);

}

按多种方式进行排序

public static void main(String[] args) {

List 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(){

@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(){

@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(){

@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接口

---

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

---

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

方法：

• Iterator iterator() 返回迭代器

List接口继承Collection接口，Collection继承Iterable接口。

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

Lambda表达式

=======================================================================

Lambda表达式是Java1.8的重要特性，能使用非常简洁的代码，完成对接口的实现。

应用场景是：实现函数式接口（FunctionalInterface）

函数式接口通常只有一个需要实现的方法，如：Comparator

@FunctionalInterface

public interface Comparator {

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 接口

void accept(T t)

示例：

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

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

Stream接口

---

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

集合的筛选

Stream filter(Predicate接口)

Predicate接口

boolean test(T t)

集合的收集

collect(Collector收集器)

Collectors类

Collector toList() List类型收集器

Collector toSet() Set类型收集器

Collector toMap() Map类型收集器

集合的排序

sorted(Comparator比较器）

限制返回值个数

limit(个数)

找最大值

max(Comparator比较器)

Stream的使用

List 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 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(©->System.out.println©);

//集合中最贵的三辆车

List 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.run());

//最贵的车

Car max = cars.stream()

.max((c1,c2)->{

if(c1.getPrice() > c2.getPrice()){

return 1;

}else if(c1.getPrice() < c2.getPrice()){