Clase de herramienta de colecciones: una clase de herramienta sobre colecciones en Java, que contiene varios métodos polimórficos estáticos relacionados con las operaciones de colección y no se puede instanciar (privatizar el constructor).
La diferencia con Collection: Collection es una interfaz, que proporciona métodos de interfaz generales para operaciones básicas en objetos de colección y varias clases de implementación específicas, como List y Set. Collections es una clase de herramienta que se especializa en manipular los elementos en la clase de implementación de la interfaz Collection.
Métodos de uso común: sort sort (List list) es visible
en orden ascendente de clasificación natural , y la salida está en orden alfabético ascendente después de la clasificación de forma predeterminada.
package Demo_1;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortTest {
public static void main(String[] args) {
sortTest();
}
public static void sortTest() {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("yyy");
list.add("mmm");
list.add("ddd");
System.out.println("排序前:" + " " + list);
Collections.sort(list);
System.out.println("排序后:" + " " + list);
Cuando la matriz contiene caracteres en mayúsculas y minúsculas, el resultado de salida de la ordenación es primero en mayúsculas y luego en minúsculas.
package Demo_1;
public class SortTest {
public static void main(String[] args) {
sortTest();
}
public static void sortTest() {
List<String> list = new ArrayList<>();
list.add("AAA");
list.add("yyy");
list.add("MMM");
list.add("ddd");
System.out.println("排序前:" + " " + list);
Collections.sort(list);
System.out.println("排序后:" + " " + list);
El valor predeterminado es ascendente, igual a Collections.sort(lista), Collections.sort(lista, Comparator.naturalOrder())
descendente: Collections.sort(lista, Comparator.reverseOrder());
//默认升序
Collections.sort(list, Comparator.naturalOrder());
System.out.println("默认升序:" + " " + list);
//降序
Collections.sort(list, Comparator.reverseOrder());
System.out.println("降序:" + " " + list);
Orden aleatorio aleatorio (lista de lista): se puede ver que el orden de clasificación de salida es aleatorio.
//随机排序
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
list.add("8");
list.add("9");
list.add("10");
list.add("M");
list.add("P");
list.add("A");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Obtenga el elemento máximo max (Colección coll, Comparator comparador) donde Comparator es un objeto pasado. A continuación se utiliza un ejemplo de un pedido diario para explicar su uso.
Cree una clase de Cliente y cree sus métodos get/set
public class CollectionsTest {
public static void main(String [] args){
}
}
class Customer{
private String name;
private int order;
public Customer(String name,int order){
this.name = name;
this.order = order;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getOrder() {
return order;
}
public void setOrder(int order) {
this.order = order;
}
}
Crear un objeto de lista
public static void main(String [] args){
List<Customer> list = new ArrayList<>();
list.add(new Customer("陈小姐",25));
list.add(new Customer("王先生",30));
list.add(new Customer("黄小姐",33));
list.add(new Customer("伍小姐",18));
list.add(new Customer("李先生",42));
System.out.println(list);
}
Imprima esta lista, el resultado es solo un montón de direcciones de memoria.
Podemos obtener información detallada del pedido agregando un método de depuración.
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", order=" + order +
'}';
}
La información del pedido de cada cliente se puede generar llamando al método toString().
Obtenga el valor máximo: cree un nuevo comparador (). El comparador es en realidad una interfaz. De acuerdo con el código subyacente, o1 - o2 está en orden ascendente. Cuando o1 - o2> 0, demuestra que o1> o2. , por lo que el resultado es 42 del maximo
Por el contrario, para obtener el valor mínimo, o2 - o1 es en orden decreciente, cuando o2 - o1 < 0, se demuestra que o2 < o1, y se jerarquizará hasta el final, el que sea más delgado se jerarquizará el abajo. El valor mínimo es 18
Otro método de escritura personalizado, como crear otra clase CustomerComparator para implementar la interfaz Comparator.
package Demo_2;
import java.util.Comparator;
public class CustomerComparator implements Comparator<CollectionsTest.Customer> {
@Override
public int compare(CollectionsTest.Customer o1, CollectionsTest.Customer o2) {
return o1.getOrder()-o2.getOrder();
}
}
También llame a Collections.max, pasando el objeto StudentComparator recién creado.
Cree una colección inmutable unmodifiablleXXX() , donde XXX es una colección de objetos.
Al agregar un nuevo producto, aparecerá un error.
Del mismo modo, también puede crear Set, Map
Después de agregar contenido, también hay un error.
Finalmente, presente Comparable, que es una interfaz para personalizar las reglas de clasificación. Ordene los objetos de cada clase que lo implementa como un todo. El método compareTo es un método específico para lograr la ordenación, como TreeSet, SortedSet y Collections.sort() llamadas al método para ordenar. Las clases como String e Integer implementan esta interfaz de forma predeterminada, por lo que se pueden ordenar.
public interface Comparable<T> {
public int compareTo(T o);
}
El método compareTo se usa para comparar el orden del objeto secundario y el objeto especificado, o es el objeto que se comparará y devuelve un tipo int.
Si es mayor que 0, significa que este es mayor que el objeto o pasado, y luego pasa a la fila de atrás, es decir, el orden ascendente es igual a 0, lo que significa que este es igual al objeto
pasado in. o
es menor que 0, lo que significa que es más pequeño que el objeto o pasado en
Cree un objeto contenedor TreeSet y agregue la misma información de pedido del cliente que se indicó anteriormente.
Del mismo modo, cree una clase de Cliente e implemente la interfaz Comparable
Anule el método compareTo(), fuerce el Cliente y devuelva this.order - customer.order, que se expresa como orden ascendente, donde este es el elemento actual, por ejemplo, si es el primero en el conjunto, entonces este es el primero, y así sucesivamente.
@Override
public int compareTo(Object o) {
Customer customer = (Customer)o;
return this.order - customer.order;
}
Otro método de sobrescritura relativamente estándar es juzgado por la instancia de condición. La función es juzgar si una clase implementa una determinada interfaz, o juzgar si un objeto de instancia pertenece a una clase. Pero aparece un error como "Falta declaración de devolución".
El método compareTo() en realidad devuelve 0 de forma predeterminada, lo que significa que cuando el número devuelto es 0, los dos objetos comparados son iguales.
@Override
public int compareTo(Object o) {
// Customer customer = (Customer) o;
// return this.order - customer.order;
if (o instanceof Customer) {
Customer customer = (Customer) o;
return this.order - customer.order;
}
return 0;
}
Del mismo modo, si desea lograr un orden descendente, solo necesita cambiarlo a pedido.cliente - este.pedido.
@Override
public int compareTo(Object o) {
// Customer customer = (Customer) o;
// return this.order - customer.order;
if (o instanceof Customer) {
Customer customer = (Customer) o;
// return this.order - customer.order;
return customer.order - this.order;
}
return 0;
}
Combinando la clasificación de Python y Javascript presentada en este número y el número anterior, puede encontrar que aunque el método de escritura de Java parece ser relativamente complicado, de hecho, algunos de los principios son básicamente los mismos. Cada uno tiene sus propias ventajas de aplicación en diferentes escenarios. El próximo número continuará explicando la aplicación de Colecciones en detalle a través de otro proyecto diario.