Colecciones de Java Basics 17 (clasificación e iteración, expresiones Lambda)

¡Como tú que amas la programación!
Aprenda los cursos prácticos de SpringBoot https://edu.csdn.net/course/detail/31433
Aprenda los cursos de introducción a SpringCloud https://edu.csdn.net/course/detail/31451

---

Prefacio

Este artículo presentará la clase de herramienta Colecciones y las interfaces relacionadas de iteración y clasificación, así como la poderosa herramienta introducida por Java 8: Expresiones Lambda, que mejorará enormemente la eficiencia de nuestro uso de colecciones.

Herramientas de colecciones

Herramientas para operaciones de cobranza
Métodos comunes:

método	efecto
Lista Ordenada)	Ordenar la colección List
barajar (Lista）	Interrumpir la colección List
reverso (Lista）	Colección de lista inversa
max (Colección）	Retorno máximo
min (Colección）	Retorno mínimo
binarySearch (Lista, número de búsqueda)	Búsqueda binaria

Interfaz comparable

Los
objetos Collections.sort (colección de listas) de la colección deben implementar la interfaz Comparable

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

Coches ordenados por precio

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();
		}
	}

}

Interfaz comparador

La interfaz del comparador proporciona un método de comparación, que se puede especificar en tiempo de ejecución
Collections.sort (colección de listas, comparador de comparador)

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

Ordenar de múltiples formas

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();
	}
}

Iteración de la colección

Interfaz de iterador

La función es recorrer los datos sin considerar la estructura de datos de los datos y proporcionar un método de recorrido general.

método:

• boolean hasNext () Determina si los datos tienen el siguiente
• T next () se mueve hacia atrás y devuelve los datos actuales
  

Interfaz iterable

Los objetos que implementan esta interfaz se pueden atravesar mediante el
método de bucle foreach :

• Iterador iterador () devuelve iterador

La interfaz Lista hereda la interfaz Colección y la Colección hereda la interfaz Iterable.
Al realizar un bucle foreach, llamará automáticamente a iterator (), devolverá el objeto iterador, ejecutará next y hasNext para completar el recorrido de datos

Expresión lambda

La expresión Lambda es una característica importante de Java 1.8, que puede usar código muy conciso para completar la implementación de la interfaz.
El escenario de la aplicación es: para implementar una interfaz funcional (FunctionalInterface)
, la interfaz funcional generalmente solo tiene un método que debe implementarse, como por ejemplo: Comparador

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

Características gramaticales:

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

Clasificación con Lambda

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

Iterar sobre la colección

List collection.forEach (interfaz de consumidor)

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

Ejemplo:

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

Interfaz de transmisión

La interfaz Stream introducida por java1.8 proporciona una serie de métodos para las operaciones de recolección

Selección de colección

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

Colección de colecciones

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

Clasificación de colecciones

sorted(Comparator<T>比较器）

Limitar el número de valores devueltos

limit(个数)

Encuentra el máximo

max(Comparator<T>比较器)

Uso de 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);

Fin

operación:

1. Defina la categoría de alimentos, con atributos: nombre, precio (doble), peso (doble), vida útil (int), reescriba el método toString para
   crear una colección de alimentos, agregue un cierto número de
   usuarios de alimentos para ingresar el método de clasificación (1 , precio 2, peso 3, vida útil)
   clasifique por método de clasificación, y muestre
   todos los productos cuyo precio sea inferior a 100, peso superior a 10 y vida útil superior a 2 años.
   Muestra el 1 producto con el precio más alto

---

Si necesita aprender otros conocimientos de Java, haga clic aquí Conocimiento ultra detallado de Java Resumen