Resumen del uso básico de la colección
1. Cómo utilizar la colección ArrayList
Hablar sobre la clasificación de la matriz de objetos.
Aquí usaré principalmente la clasificación de registros. Personalmente, recomiendo usar el comparador de Comparetor para hacer la clasificación. El código de muestra es el siguiente:
import java.util.*;
/**
* @author jiangzl
*/
public class MyArrayList {
public static void main(String[] args){
ArrayList myListOfTask = new ArrayList<Arraytask>();
Scanner sc = new Scanner(System.in);
for(int i = 0;i < 5;++i){
String name = sc.next();
int prio = sc.nextInt();
myListOfTask.add(new Arraytask(name, prio));
}
sc.close();
System.out.println("---------排序前---------");
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
System.out.println("---------排序后---------");
Collections.sort(myListOfTask, new Comparator<Arraytask>() {
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
});
for(int i = 0;i < 5;++i){
System.out.println(myListOfTask.get(i));
}
}
}
/**
* @author jiangzl
*/
class Arraytask{
private String taskName;
private int taskPriority;
public Arraytask(String name, int prio){
this.taskName = name;
this.taskPriority = prio;
}
public String getTaskName(){
return taskName;
}
public int getTaskPriority(){
return taskPriority;
}
@Override
public String toString(){
return new String("任务名：" + taskName + " , 任务优先级：" + taskPriority);
}
}
Cómo utilizar el comparador Comparetor:
Después de escribir una clase, necesitamos ordenar la matriz de objetos de esta clase. Podemos usar el método de colección:
Collection.sort(对象数组名（ArrayList 的对象名）, new Comparetor<类名（泛型）>(){
@Override
public int compare(类名 obj1, 类名 obj2) {
/……/
}
})
Puntos a tener en cuenta:
① El valor de retorno de la función de comparación aquí es de tipo int. Si devuelve un número positivo, significa que el objeto anterior obj1 es mayor que obj2 y un número negativo es menor que. Por supuesto, 0 es igual.
② Si desea mostrar una cierta prioridad, aquí está todo lo contrario de C ++ es que obj2 (el último) tiene una prioridad más alta que obj1 (el primero) por defecto. Por ejemplo, en mi código de muestra:
@Override
public int compare(Arraytask tk1, Arraytask tk2) {
if(tk1.getTaskPriority() != tk2.getTaskPriority()){
return tk2.getTaskPriority() - tk1.getTaskPriority();
}
else{
return tk1.getTaskName().compareTo(tk2.getTaskName());
}
}
El significado del representante es:
(1) Si la prioridad de las dos tareas no es la misma, deje que la que tenga la prioridad más alta ocupe el primer lugar. Debido a que el valor predeterminado es que este último ocupa el primer lugar, devolvemos: Cuando cumple con la prioridad de nuestro diseño, devuelve un número mayor que 0. Entonces, si es la prioridad más alta en el frente, entonces el mecanismo de comparación de Comparetor es el último en el frente, por lo que diseñamos el último valor para que sea mayor que el frente, es decir, se llama cuando la resta es mayor que 1. ( Observaciones : puede que no sea fácil de entender aquí ... es porque mi escritura no es lo suficientemente buena para escribir con claridad)
(2) En términos generales, se reduce a un punto: si desea ordenar en orden ascendente de acuerdo con un determinado valor de referencia, haga que el objeto frontal obj1 sea más grande que el último, es decir, obj1.val-obj2.val. Por ejemplo, cuando queremos la misma prioridad, los nombres se ordenan en orden lexicográfico ascendente, así que deje que el nombre del primer objeto menos el nombre del segundo objeto se ordene por mayor que 0 (es decir, en orden ascendente). De lo contrario, deje la parte de atrás menos el frente.
Hable brevemente sobre la adición, eliminación y modificación de la matriz de objetos (ArrayList)
(1) Atravesar y leer elementos
Esto sigue siendo muy simple. Si es solo una operación de "lectura", el mejor método (el más eficiente) es:
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 obj = arrayObj.get(i);
/……/
}
La eficiencia bajo esta operación de "lectura" es la más alta, que es más alta que foreach (el resultado de pruebas experimentales).
(2) Modificar elementos
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 update = new 类名(……) // 你的新改的对象
类名 obj = arrayObj.set(i, update);
/……/
}
(3) Eliminar elementos
int len = (ArrayList对象) arrayObj.size();
for(int i = 0;i < len;++i){
/……/
类名 remv = arrayObj.remove(i); // remv 就是你要删除的对象
/……/
}
Algunas explicaciones y resumen de adiciones, eliminaciones y cambios:
Use get (index) para leer, set (index, newObj) para modificar y remove (index) para borrar, ¡
pero los valores de retorno de los tres son objetos! ! ! ¡Esto necesita atención!
¡Y ArrayList es una estructura de datos basada en vectores a la que se puede acceder aleatoriamente! Entonces, desde esta capa inferior, debe ser una alta eficiencia de lectura y escritura, y una baja eficiencia para eliminar y agregar. Entonces existe la siguiente colección LinkedList
2. Cómo utilizar la colección LinkedList
Hablar sobre la interfaz Iterator y el recorrido LinkedList
Primero veamos un programa de muestra:
import java.util.*;
/**
* @author jiangzl
*/
public class MyLinkedList {
public static void main(String[] args){
LinkedList myList = new LinkedList<Student>();
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0;i < n;++i){
String name = sc.next();
int age = sc.nextInt();
myList.add(new Student(name, age));
}
String delName = sc.next();
Iterator<Student> it = myList.iterator();
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
}
}
/**
* @author jiangzl
*/
class Student{
private String name;
private int age;
public Student(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString(){
return new String("姓名：" + name + " , 年龄：" + age);
}
public String getName(){
return name;
}
}
Aquí primero hablamos sobre el recorrido de LinkedList
Usamos la clase Iterator para atravesar, usamos el método hasNext () para determinar si hay un valor siguiente, y luego usamos next () para obtener el objeto actualmente atravesado. ¡Entonces haz lo que tengas que hacer!
Iterator<类名> it = myList.iterator();
while(it.hasNext()){
类名 obj = it.next();
/……/
}
Permítanme decir interfaces ListIterator, donde la mayor diferencia es, ListIterator admite la ejecución concurrente, pero Iterator no es compatible. Eche un vistazo a un pequeño ejemplo:
import java.util.*;
import java.util.ListIterator;
public class MyListIterator {
public static void main(String[] args){
List myList = new ArrayList();
myList.add("stu1");
myList.add("stu2");
myList.add("stu3");
myList.add("stu4");
myList.add("stu5");
ListIterator it = myList.listIterator();
while(it.hasNext()){
if("stu2".equals(it.next())){
it.remove();
it.add("hello");
break;
}
}
it = myList.listIterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
Mira la salida de la consola:
Obviamente podemos ver:
① La interfaz ListIterator puede usar el método add () para insertar operaciones en la posición actual del iterador.
② La interfaz ListIterator, por ejemplo, después de que se completa cierto recorrido, si necesita atravesar la matriz de objetos nuevamente, debe volver a:
it = myList.listIterator();
③ La interfaz de Iterator es de solo lectura y es un atributo. Si desea modificarla, aún debe usar ListIterator para modificar "stu2" y convertirlo en "hello".
Luego hable sobre agregar, eliminar, modificar y verificar
En realidad, esto es muy simple: si usa ListIterator, no solo puede implementar it.remove () de Iterator; para eliminar el objeto apuntado por el iterador actual. También puede usar el método add (obj); para insertar el objeto obj después de la posición señalada por el iterador actual.
Al igual que este código en el ejemplo:
while(it.hasNext()){
if(it.next().getName().equals(delName)){
it.remove();
break;
}
}
while (it.hasNext()){
System.out.println(it.next());
}
Todas las operaciones se basan en: it.next (); para obtener el objeto actualmente atravesado, ¡y luego operarlo!
Finalmente, resuma los métodos extendidos después de que la interfaz List hereda de Collection:
No hablaré de otros métodos, la mayoría de ellos son muy simples.