Primero, un diagrama simplificado del marco de recopilación: ↓ ↓ ↓
(1), interfaz de colección
Collection es la interfaz principal de List , Set , Queue (primero en entrar , primero en salir) , Deque (lista de doble enlace) y otras interfaces.
[Nota: no hay relación entre la colección y el mapa. La colección contiene objetos uno por uno y el mapa contiene pares clave-valor.]
[Nota: Deque hereda la cola e indirectamente hereda la colección]
(2), clase Colecciones
Colecciones es una clase, una clase de herramienta para contenedores, al igual que Arrays es una clase de herramienta para arreglos, también puede realizar algunas operaciones en el contenedor.
| Palabras clave de nombre de método | Caracteristicas |
| contrarrestar | Contrarrestar |
| barajar | Confusión (desorden del orden) |
| ordenar | Ordenar |
| intercambiar | Intercambiar datos en la posición del subíndice especificada |
| girar | Desplaza los datos de la colección hacia la derecha por la longitud de la unidad especificada |
| SynchronizedList | Convierta colecciones no seguras para subprocesos en colecciones seguras para subprocesos |
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
// 初始化List
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add(i+1);
}
// 原List
System.out.println("原list:\t\t\t" + list);
System.out.println("******************************");
// 反转
Collections.reverse(list);
System.out.println("反转后的list:\t\t" + list);
System.out.println("******************************");
// 混淆
Collections.shuffle(list);
System.out.println("混淆后的list:\t\t" + list);
System.out.println("******************************");
// 排序
Collections.sort(list);
System.out.println("排序后的list:\t\t" + list);
System.out.println("******************************");
// 交换两个位置的数据
Collections.swap(list, 0, 1);
System.out.println("交换0和1下标的数据后的list:\t" + list);
System.out.println("******************************");
// 先恢复原list
Collections.swap(list, 0, 1);
System.out.println("恢复后的list:\t\t" + list);
// 滚动
Collections.rotate(list, 3);
System.out.println("向右滚动3个单位后的list:\t" + list);
System.out.println("******************************");
// 线程安全化
List<Integer> newList = Collections.synchronizedList(list);
// 把原来不是线程安全的list转换为了现在线程安全的newList
}
}
Resultado de salida:
(3) Interfaz de lista y clase ArrayList
Los objetos de la colección List están organizados en un orden determinado y el contenido del interior puede repetirse;
Las clases implementadas por la interfaz List son: ArrayList (para implementar matrices dinámicas) , Vector (para implementar matrices dinámicas) , LinkedList (para implementar listas enlazadas) , Stack (para implementar pilas) .
[1], las limitaciones de usar matrices
Si desea almacenar varios objetos, puede usar matrices, ¡pero las matrices tienen limitaciones! ! !
Por ejemplo: si declara una matriz con una longitud de 10, la matriz no utilizada se desperdiciará y el número de más de 10 no encajará. ! !
[2] 、 ArrayList
Para resolver las limitaciones de las matrices, se introduce el concepto de clases contenedoras. La clase de contenedor más común es: La capacidad "capacidad" del contenedor ArrayList aumentará automáticamente a medida que aumenta el objeto.
[3] Métodos comunes de ArrayList
| Palabras clave de nombre de método | Caracteristicas |
| contiene | Determina si existe |
| añadir | Agregar objeto |
| añadir todo | Agregar todos los objetos en otro contenedor |
| eliminar | Eliminar objeto |
| claro | Vacío |
| conjunto | Reemplazar el objeto en una posición determinada (reasignación) |
| obtener | Obtener el objeto en la ubicación especificada |
| índice de | Obtener la ubicación del objeto |
| toArray | Convertir a matriz |
| Talla | Obtener tamaño |
[4], recorrido de iterador
Utilice iterador Iterador para recorrer los elementos de la colección , el principio es el siguiente: ↓ ↓ ↓
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 5; i++) {
list.add("String " + i);
}
System.out.println("最初的list为：" + list);
// 获取List的迭代器
Iterator<String> iterator = list.iterator();
//从最开始的位置判断"下一个"位置是否有数据
//如果有就通过next取出来，并且把指针向下移动
//直到"下一个"位置没有数据
System.out.println("--------使用while的iterator-------");
// 利用while循环遍历
while(iterator.hasNext()) {
String str = iterator.next();
System.out.println(str);
}
System.out.println("--------使用for的iterator-------");
// 利用for循环遍历
for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
String str = it.next();
if(str.equals("String 2")) {
it.remove();
System.out.println(str + "（当字符串为“String 2”时从迭代器中删除它）");
}else {
System.out.println(str);
}
}
System.out.println("删除“String 2”后的list为：" + list);
}
}Resultado de salida:
Puede utilizar iteradores para eliminar elementos de la lista.
（4） 、 LinkedList
La secuencia se divide en: primero en entrar, primero en salir FIFO , primero en entrar-último en salir FILO
FIFO también se llama Cola
en Java, FILO también se llama Pila en Java
[1] Al igual que ArrayList, LinkedList también implementa la interfaz List;
[2] Pero al mismo tiempo, LinkedList no solo implementa la interfaz List, sino que LinkedList también implementa la estructura de lista doblemente vinculada Deque, que puede insertar y eliminar datos fácilmente al principio y al final;
import java.util.LinkedList;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
//LinkedList是一个双向链表结构的list
LinkedList<String> list =new LinkedList<>();
//所以可以很方便的在头部和尾部插入数据
//在最后插入新的字符串
list.addLast("String 1");
list.addLast("String 2");
list.addLast("String 3");
System.out.println("加入数据后的list:\t\t" + list);
//在最前面插入新的字符串
list.addFirst("String X");
System.out.println("最前面插入新的字符串后的list:\t" + list);
//查看最前面的字符串
System.out.println("最前面的字符串:\t\t " + list.getFirst());
//查看最后面的字符串
System.out.println("最后面的字符串:\t\t " + list.getLast());
//查看不会导致元素被删除
System.out.println("再次查看list:\t\t" + list);
//取出最前面的字符串
System.out.println("取出来的最前面的字符串：\t " + list.removeFirst());
//取出最后面的字符串
System.out.println("取出来的最后面的字符串：\t " + list.removeLast());
//取出会导致元素被删除
System.out.println("再次查看list:\t\t" + list);
}
}Resultado de salida:
[3] Además de implementar List y Deque , LinkedList también implementa la interfaz Queue (cola)
La cola es un FIFO de cola de primero en entrar, primero en salir, métodos comúnmente utilizados:
offer 在最后添加元素
poll 取出第一个元素
peek 查看第一个元素import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class CollectionsTest {
public static void main(String[] args) {
// 和ArrayList一样，LinkedList也实现了List接口
List<String> list = new LinkedList<>();
// 同时，LinkedList还实现了Deque接口
// Deque代表双向链表
Deque<String> deque = new LinkedList<>();
// 同时，LinkedList也实现了Queue这个接口
// Queue代表FIFO 先进先出的队列
Queue<String> queue = new LinkedList<>();
for (int i = 0; i < 2; i++) {
queue.offer("String " + i); // 在最后添加元素
}
for (int i = 0; i < 3; i++) {
queue.add("String " + (i + 2)); // 与offer()同样的效果，添加元素
} //
System.out.println("利用offer()方法或add()方法添加元素。");
System.out.println("添加元素后的queue为：\t" + queue);
System.out.println();
String first = queue.peek(); //
System.out.println("利用peek()方法查看第一个元素。");
System.out.println("查看第一个元素：\t\t " + first);
System.out.println();
queue.poll(); //
System.out.println("利用poll()方法取出第一个元素。");
System.out.println("取出第一个元素......");
System.out.println("第一个元素取出后的queue为：\t" + queue);
}
}Resultado de salida:
(5) Árbol binario
El árbol binario se compone de varios nodos Las características del
árbol binario:
cada nodo puede tener un nodo hijo izquierdo, un nodo hijo derecho y un valor.
public class Node {
// 左子节点
public Node leftNode;
// 右子节点
public Node rightNode;
// 值
public Object value;
}[1], Principio de datos de inserción de árbol binario:
Suponga que los siguientes 10 números aleatorios se ordenan a través de un árbol binario
67, 7, 30, 73, 10, 0, 78, 81, 10, 74.
El primer paso de la clasificación es insertar datos en el árbol binario. La
lógica básica para insertar es, pequeño , El mismo lugar a la izquierda, el más grande a la derecha
1. 67 en el nodo raíz
2. 7 es menor que 67, el nodo izquierdo en 67 es
3. 30 es menor que 67, se encuentra el nodo izquierdo de 67 y 30 es mayor que 7, entonces Ponga el nodo derecho de
7. 4. 73 es mayor que 67, ponga el nodo derecho de
67, 5. 10 es menor que 67, encuentre el nodo izquierdo de 67, 10 es mayor que 7 y encuentre el nodo derecho de 7, 30, 10 es menor que 30, Colóquelo en el nodo izquierdo del 30.
...
...
9.10 menos que 67 para encontrar el nodo izquierdo 67 7,10 más grande que 7, encuentre el nodo derecho 7 de 30, 10 de 30 horas para encontrar el nodo izquierdo 30 tan grande como 10, 10 y 10, Poner a la izquierda
public class Node {
/**
* 左子节点
*/
public Node leftNode;
/**
* 右子节点
*/
public Node rightNode;
/**
* 值
*/
public Object value;
/**
* 插入数据
* @param v
*/
public void add(Object v) {
// 如果当前节点没有值，就把数据放在当前节点上
if (value == null) {
value = v;
} else { // 如果当前节点有值，就进行判断，新增的值与当前的值的大小关系
// 新增的值，比当前值小或者相同
if ((Integer) value - (Integer) v >= 0) {
if (leftNode == null) {
leftNode = new Node();
}
leftNode.add(v);
}
// 新增的值，比当前值大
else {
if (rightNode == null) {
rightNode = new Node();
}
rightNode.add(v);
}
}
}
public static void main(String[] args) {
int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
Node roots = new Node();
for (int number : randoms) {
roots.add(number);
}
}
}[2], Cruce de árbol binario:
Mediante el comportamiento de inserción del paso anterior, los datos realmente se ordenan. Lo siguiente que debe hacer es ver, atravesar estos datos ordenados en nuestra forma de lista o matriz de uso común.
El recorrido del árbol binario se divide en primer orden, orden medio y segundo orden
[primer orden], es decir: el número medio después del recorrido Colóquelo a la izquierda
[Orden del medio]: el número del medio se atraviesa y se coloca en el medio
[Pedido posterior]: El número del medio se atraviesa y se coloca a la derecha
import java.util.ArrayList;
import java.util.List;
public class Node {
/**
* 左子节点
*/
public Node leftNode;
/**
* 右子节点
*/
public Node rightNode;
/**
* 值
*/
public Object value;
/**
* 插入数据
* @param v
*/
public void add(Object v) {
// 如果当前节点没有值，就把数据放在当前节点上
if (value == null) {
value = v;
} else { // 如果当前节点有值，就进行判断，新增的值与当前的值的大小关系
// 新增的值，比当前值小或者相同
if ((Integer) value - (Integer) v >= 0) {
if (leftNode == null) {
leftNode = new Node();
}
leftNode.add(v);
}
// 新增的值，比当前值大
else {
if (rightNode == null) {
rightNode = new Node();
}
rightNode.add(v);
}
}
}
// 先序遍历所有的节点
public List<Object> valuesOfLeft() {
List<Object> values = new ArrayList<>();
// 当前节点
values.add(value);
// 左节点的遍历结果
if (leftNode != null) {
values.addAll(leftNode.valuesOfLeft());
}
// 右节点的遍历结果
if (rightNode != null) {
values.addAll(rightNode.valuesOfLeft());
}
return values;
}
// 中序遍历所有的节点
public List<Object> valuesOfCenter() {
List<Object> values = new ArrayList<>();
// 左节点的遍历结果
if (leftNode != null) {
values.addAll(leftNode.valuesOfCenter());
}
// 当前节点
values.add(value);
// 右节点的遍历结果
if (rightNode != null) {
values.addAll(rightNode.valuesOfCenter());
}
return values;
}
// 后序遍历所有的节点
public List<Object> valuesOfRight() {
List<Object> values = new ArrayList<>();
// 左节点的遍历结果
if (leftNode != null) {
values.addAll(leftNode.valuesOfRight());
}
// 右节点的遍历结果
if (rightNode != null) {
values.addAll(rightNode.valuesOfRight());
}
// 当前节点
values.add(value);
return values;
}
public static void main(String[] args) {
int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
Node roots = new Node();
for (int number : randoms) {
roots.add(number);
}
System.out.println("先序遍历的二叉树：\t" + roots.valuesOfLeft());
System.out.println("中序遍历的二叉树：\t" + roots.valuesOfCenter());
System.out.println("后序遍历的二叉树：\t" + roots.valuesOfRight());
}
}
Resultado de salida:
（6） 、 HashMap
La forma en que HashMap almacena los datos es pares clave-valor
Para HashMap, la clave es única y no se puede repetir.
Por lo tanto, insertar diferentes valores en el Mapa con la misma clave hará que los elementos antiguos se sobrescriban, dejando solo el último elemento insertado.
Sin embargo, el mismo objeto se puede insertar en el mapa como un valor, siempre que la clave correspondiente sea diferente
（7） 、 HashSet
Los elementos del conjunto no se pueden repetir
[1], sin orden
Los elementos del conjunto no tienen ningún orden.
Estrictamente hablando,
el orden específico del HashSet no está organizado en el orden de inserción de los elementos , ni en el orden de inserción ni en el orden del código hash.
En otras palabras, lo mismo es insertar 0-9 en HashSet, el orden de visualización es diferente en diferentes versiones de JVM.
import java.util.HashSet;
public class HashSetTest {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("hello");
set.add("world");
set.add("!!!");
System.out.println(set);
}
}resultado de la operación:
[2], transversal
El conjunto no proporciona get () para obtener el elemento en la posición especificada,
por lo que se necesitan iteradores o bucles for mejorados para el recorrido.
[3] La relación entre HashSet y HashMap
Al observar el código fuente de HashSet, se
puede encontrar que HashSet en sí no tiene una implementación independiente, pero un Map está encapsulado en él.
HashSet existe como la clave del Map
y el valor es un objeto Object estático llamado PRESENT, porque es Un atributo de clase, por lo que solo habrá uno.
private static final Object PRESENT = new Object();package collection;
import java.util.AbstractSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable {
// HashSet里封装了一个HashMap
private HashMap<E, Object> map;
private static final Object PRESENT = new Object();
// HashSet的构造方法初始化这个HashMap
public HashSet() {
map = new HashMap<E, Object>();
}
// 向HashSet中增加元素，其实就是把该元素作为key，增加到Map中
// value是PRESENT，静态，final的对象，所有的HashSet都使用这么同一个对象
public boolean add(E e) {
return map.put(e, PRESENT) == null;
}
// HashSet的size就是map的size
public int size() {
return map.size();
}
// 清空Set就是清空Map
public void clear() {
map.clear();
}
// 迭代Set,就是把Map的键拿出来迭代
public Iterator<E> iterator() {
return map.keySet().iterator();
}
}（8） 、 Conjunto
HashSet Unordered
LinkedHashSet
Ordena según el orden de inserción TreeSet de pequeño a grande
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
public class HashSetTest {
public static void main(String[] args) {
HashSet<String> numberSet1 =new HashSet<>();
//HashSet中的数据不是按照插入顺序存放
numberSet1.add("bbbbb");
numberSet1.add("aaaaa");
numberSet1.add("ccccc");
System.out.println(numberSet1);
LinkedHashSet<String> numberSet2 =new LinkedHashSet<>();
//LinkedHashSet中的数据是按照插入顺序存放
numberSet2.add("bbbbb");
numberSet2.add("aaaaa");
numberSet2.add("ccccc");
System.out.println(numberSet2);
TreeSet<String> numberSet3 =new TreeSet<>();
//TreeSet 中的数据是进行了排序的
numberSet3.add("bbbbb");
numberSet3.add("aaaaa");
numberSet3.add("ccccc");
System.out.println(numberSet3);
}
}resultado de la operación:
(9) La diferencia entre ArrayList y LinkedList
ArrayList es la estructura de [Lista de secuencias], [Buscar datos rápidamente], [Insertar y eliminar datos es lento],
LinkedList es la estructura de [Lista vinculada], [Buscar datos es lento], [Insertar y eliminar datos rápidamente].
(10) La diferencia entre ArrayList y HashSet
ArrayList tiene orden y los datos se pueden repetir;
HashSet no tiene orden y los datos no se pueden repetir.
El criterio de juicio de repetición de HashSet es:
primero observe si el código hash es el mismo.
Si el código hash es diferente, se considera datos diferentes.
Si el código hash es el mismo, entonces compare iguales. Si iguales son iguales, son los mismos datos; de lo contrario, son datos diferentes.
(11) La diferencia entre HashMap y HashTable
Tanto HashMap como Hashtable implementan la interfaz Map, ambos son pares clave-valor para almacenar datos.
Diferencia 1:
HashMap puede almacenar valores nulos,
Hashtable no puede almacenar valores nulos.
Diferencia 2:
HashMap no es una clase segura para subprocesos
Hashtable es una clase segura para subprocesos
import java.util.HashMap;
import java.util.Hashtable;
public class MapTableTest {
public static void main(String[] args) {
// HashMap 可以存放 null 值
HashMap<String, Integer> map = new HashMap<>();
map.put("first", null);
System.out.println(map);
// Hashtable 不能存放null 值
Hashtable<String, Integer> table = new Hashtable<>();
table.put("first", null);
System.out.println(table);
}
}resultado de la operación:
(12) Principio de HashCode
[1], comparación de eficiencia
Las diferencias que trae HashCode son las siguientes:
[2], principio HashCode
Por ejemplo, si desea encontrar el significado chino correspondiente de una palabra en un diccionario inglés-chino, suponga que la palabra es Lengthdary, primero busque Lengthdary en el directorio de la página 555.
Luego, vaya a la página 555. No solo hay una palabra en esta página, sino que la cantidad es muy pequeña Compárelas una por una y localice rápidamente la longitud de la palabra objetivo.
555 es equivalente al código hash correspondiente a Lengendary
[3], analice las razones del excelente rendimiento de HashMap
----- Concepto de código hash -----
Todos los objetos tienen un código hash correspondiente (valor hash). Por
ejemplo, la cadena "gareen" corresponde a 1001 (en realidad no, aquí hay un valor conveniente para comprender, valor hipotético) ) Por
ejemplo, la cadena "temoo" corresponde a 1004. Por
ejemplo, la cadena "db" corresponde a 1008. Por
ejemplo, la cadena "annie" corresponde a 1008.
----- Guarde los datos -----
Prepare una matriz cuya longitud sea 2000 y establezca un algoritmo de código hash especial, de modo que el código hash correspondiente a todas las cadenas se sitúe entre
0 y 999. Para almacenar el héroe cuyo nombre es "gareen", el héroe y el nombre forman un par clave-valor y lo almacenan en
Para almacenar el héroe cuyo nombre es "temoo" en la posición 1001 de la matriz, almacene el héroe en la posición 1004 de la matriz.
Para almacenar el héroe cuyo nombre es "db", almacene el héroe en la posición 1008 de la matriz.
Para almacenar el héroe cuyo nombre es "annie", pero ya hay un héroe db en la ubicación correspondiente al código hash 1008 de "annie", luego cree una lista vinculada aquí y almacene a annie después del héroe db
----- busque datos-- --- Por
ejemplo, para encontrar gareen, primero calcule que el código hash de "gareen" sea 1001, y ubíquelo en la matriz de acuerdo con el subíndice de 1001. (La ubicación de acuerdo con el subíndice de la matriz es muy rápida). Se encuentra que solo hay una posición de 1001 Héroe, entonces el héroe es verde.
Por ejemplo, para encontrar a annie, primero calcule que el código hash de "annie" sea 1008. De acuerdo con el subíndice de 1008, ubíquelo en la matriz y encuentre que hay dos héroes en la posición 1008, luego compare los nombres de los dos héroes uno por uno (iguales) , Porque la cantidad a comparar en este momento es mucho menor, y el héroe objetivo se puede encontrar pronto
Este es el uso de hashmap para consultas, que es muy rápido.
Esta es una forma de pensar que usa el espacio para el tiempo.
[4], HashSet juzga si se repite
Los datos de HashSet no se pueden repetir. Los mismos datos no se pueden almacenar juntos. ¿Cómo juzgar si se repiten?
De acuerdo con la relación entre HashSet y HashMap, aprendimos que debido a que HashSet no tiene su propia implementación, sino que encapsula un HashMap, esencialmente determina si la clave del HashMap está duplicada.
A través del paso anterior de aprendizaje, si la clave se repite se juzga mediante dos pasos:
si el código hash es el mismo.
Si el código hash es diferente, está en un pozo diferente.
Si el código hash es el mismo, está en el mismo pozo. También es necesario comparar
iguales. Si igual es igual, son datos duplicados.
Si igual no es igual, son datos diferentes.
(13) Comparador
El método Collections.sort () puede ordenar los elementos de la colección
Sin embargo, si hay una colección, los elementos en ella son todos objetos de tipo Persona y sus atributos son nombre, edad, dirección, etc., ¿según qué atributo ordenar?
¡Esto requiere un comparador! ! !
[1], método uno
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
public class ComparatorTest {
public static void main(String[] args) {
Random r = new Random();
List<Person> persons = new ArrayList<>();
for (int i = 0; i < 10; i++) {
persons.add(new Person("张" + i, r.nextInt(20) + 20, "西安"));
}
System.out.println("初始化后的集合：");
System.out.println(persons);
// 直接调用sort会出现编译错误，因为Person有各种属性
// 到底按照哪种属性进行比较，Collections也不知道，不确定，所以没法排
// Collections.sort(persons);
// 引入Comparator，指定比较的算法
Comparator<Person> c = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
// 按照hage进行排序
if (p1.age >= p2.age)
return 1; // 正数表示p1比hp2要大
else
return -1;
}
};
Collections.sort(persons, c);
System.out.println("按照年龄排序后的集合：");
System.out.println(persons);
}
}
class Person {
public String name;
public int age;
public String address;
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "\n" + "Name : " + name + "\tAge : " + age + "\tAddress : " + address;
}
}Resultados de:
[2], método dos
Haga que la clase Person implemente la interfaz Comparable
. Proporcione el algoritmo de comparación
Collections.sort en la clase para tener suficiente información para ordenar, y no es necesario proporcionar un comparador adicional Comparator
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
public class ComparatorTest {
public static void main(String[] args) {
Random r = new Random();
List<Person> persons = new ArrayList<>();
for (int i = 0; i < 10; i++) {
persons.add(new Person("张" + i, r.nextInt(20) + 20, "西安"));
}
System.out.println("初始化后的集合：");
System.out.println(persons);
// 直接调用sort会出现编译错误，因为Person有各种属性
// 到底按照哪种属性进行比较，Collections也不知道，不确定，所以没法排
// Collections.sort(persons);
// 引入Comparator，指定比较的算法
Comparator<Person> c = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
// 按照hage进行排序
if (p1.age >= p2.age)
return 1; // 正数表示p1比hp2要大
else
return -1;
}
};
//Person类实现了接口Comparable，即自带比较信息。
//Collections直接进行排序，无需额外的Comparator
Collections.sort(persons);
System.out.println("按照年龄排序后的集合：");
System.out.println(persons);
}
}
class Person implements Comparable<Person> {
public String name;
public int age;
public String address;
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "\n" + "Name : " + name + "\tAge : " + age + "\tAddress : " + address;
}
@Override
public int compareTo(Person o) {
if (age > o.age) {
return 1;
}
return -1;
}
}resultado de la operación:
