Escribir al frente
Hola a todos, hoy continuaré actualizando Java Intermediate Advanced. La razón por la que se actualiza cada dos días es porque me tomé un día para recopilar y organizar los puntos de conocimiento para compartir. Al recopilar, personalmente valoro si vale la pena clasificar los puntos de conocimiento en sí mismos y luego vincular estos puntos de conocimiento ordenados con una "línea". Primero, es conveniente para uno mismo recordar y usar; segundo, compartir con otros para que los demás parezcan más organizados. "Al final del artículo, hay un vínculo jerárquico y organizado de mis puntos de conocimiento originales, y la estructura de los puntos de conocimiento es más clara".
Marco de colección JAVA
1. ArrayList
1.1 La diferencia entre ArrayList y array
Limitaciones de las matrices:
① Si desea almacenar varios objetos, puede utilizar matrices, pero las matrices tienen limitaciones. Si excede la longitud de la matriz, no encajará y la matriz se desperdiciará si no está llena.
Código:
1//先声明一个学生类（Student.java）
2public class Student {
3 public String name;
4 public Student () {
5 }
6// 增加一个初始化name的构造方法
7public Student (String name) {
8 this.name = name;
9}
10// 重写toString方法
11public String toString() {
12 return name;
13 }
14}
15//数组的局限性,声明测试类（Test.java）
16//声明长度是5的数组
17Student Student [] = new Student [5];
18//不用的数组就浪费了
19Student [0] = new Student ("张三");
20//放不下要报错
21Student [20] = new Student ("李四");ArrayList almacena objetos:
① Para resolver las limitaciones de las matrices, se introduce el concepto de clases contenedoras. La clase de contenedor más común es ArrayList.
② La capacidad del contenedor ArrayList aumentará automáticamente con el aumento de objetos
③Simplemente siga agregando objetos de estudiantes al contenedor, no se preocupe por el problema de los límites de la matriz.
Código:
1//容器类 ArrayList，用于存放对象
2ArrayList student = new ArrayList();
3student .add( new Student ("张三"));
4System.out.println(student .size());
5//只需要不断往容器里增加学生即可，不用担心会出现数组的边界问题。
6student .add( new Student ("李四"));
7System.out.println(student .size());
1.2 Métodos comunes
① agregue "dos métodos"
☛Agregue el objeto directamente y agregue el objeto al final: student.add (new Student ("nombre"));
☛Añadir objetos en la ubicación especificada: student.add (3, "李四");
Código:
1ArrayList students= new ArrayList();
2// 把5个对象加入到ArrayList中
3for (int i = 0; i < 5; i++) {
4studenst.add(new Student("student" + i));
5}
6System.out.println(studenst);
7// 在指定位置增加对象
8Student stu = new Student("李四");
9studenst.add(3, stu );
10System.out.println(studenst.toString());
② contiene para determinar si existe
☛ Determinar si un objeto está en el contenedor mediante el método contiene.
☛ Criterios de juicio: si es el mismo objeto, no si el nombre es el mismo.
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6Student stu = new Student ("李四");
7students.add(stu );
8System.out.println(students);
9// 判断一个对象是否在容器中
10// 判断标准： 是否是同一个对象，而不是name是否相同
11System.out.print("虽然一个新的对象名字也叫 student1，但是contains的返回是:");
12System.out.println(students.contains(new Student("student1")));
13System.out.print("而对stu 的判断，contains的返回是:");
14System.out.println(students.contains(stu));
15}③ obtener Obtiene el objeto en la ubicación especificada
☛Obtener el objeto en la posición especificada a través de get. Si el subíndice de entrada está fuera de los límites, se informará un error.
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
Studentstu= new Student("李四");
7students.add(stu);
8//获取指定位置的对象
9System.out.println(students.get(5));
10//如果超出了范围，依然会报错
11System.out.println(students.get(6));
④ indexOf obtiene la posición del objeto
☛ indexOf se utiliza para determinar la posición de un objeto en ArrayList.
☛ Como contiene, el criterio de juicio es si los objetos son iguales, no si los valores de nombre de los objetos son iguales.
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6Student stu = new Student("李四");
7students.add(stu );
8System.out.println(students);
9System.out.println("stu所处的位置:"+students.indexOf(stu));
10System.out.println("新的学生，但是名字是\"student1\"所处的位置:"+students.indexOf(new Student("student1")));
⑤ eliminar eliminar
☛ eliminar se utiliza para eliminar objetos de ArrayList: estudiantes.remove (2);
☛ remove puede eliminar elementos de ArrayList de acuerdo con el subíndice (objeto): estudiantes.remove (stu);
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6Student stu= new Student("李四");
7students.add(stu);
8System.out.println(students);
9students.remove(2);
10System.out.println("删除下标是2的对象");
11System.out.println(students);
12System.out.println("删除李四");
students.remove(stu);
14System.out.println(students);⑥ conjunto de reemplazo
☛ set se usa para reemplazar el elemento en la posición especificada
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6Student stu= new Student ("李四");
7students.add(stu);
8System.out.println(students);
9System.out.println("把下标是5的元素，替换为\"student5\"");
10students.set(5, new Student("student5"));
11System.out.println(students);
12}⑦ tamaño Obtener tamaño
☛ size se usa para obtener el tamaño de ArrayList
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Students("student" + i));
5}
6Students stu= new Students("李四");
7students.add(stu);
8System.out.println(students);
9System.out.println("获取ArrayList的大小：");
10System.out.println(students.size());⑧ toArray se convierte en una matriz
☛ toArray puede convertir un objeto ArrayList en una matriz.
☛ Nota: Si desea convertir a una matriz Student, debe pasar un objeto del tipo de matriz Student a toArray (), para que el método toArray sepa a qué tipo de matriz desea convertir; de lo contrario, solo puede convertir a una matriz de objetos
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Students("student" + i));
5}
6Student stu= new Student ("李四");
7students.add(stu);
8System.out.println(students);
9Student st[] = (Student[])students.toArray(new Student []{});
10System.out.println("数组:" +st);⑨ addAll agrega todos los objetos en otro contenedor
☛ addAll agrega todos los objetos en otro contenedor
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6System.out.println("ArrayList heros:\t" + students);
7//把另一个容器里所有的元素，都加入到该容器里来
8ArrayList anotherstudents = new ArrayList( );
9anotherstudents .add(new Student("student a"));
10anotherstudents .add(new Student("student b"));
11anotherstudents .add(new Student("student c"));
12System.out.println("anotherstudents students:\t" + anotherstudents );
13students.addAll(anotherstudents );
14System.out.println("把另一个ArrayList的元素都加入到当前 ArrayList:");
15System.out.println("ArrayList students:\t" + students);
⑩ claro
☛ borrar Clear an ArrayList
Código:
1ArrayList students= new ArrayList();
2// 初始化5个对象
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student" + i));
5}
6System.out.println("ArrayList students:\t" + students);
7System.out.println("使用clear清空");
8students.clear();
9System.out.println("ArrayList students:\t" + students);
1.3 Interfaz de lista
ArrayList 和 List ：
① ArrayList implementa la interfaz List.
② La forma común de escribir declarará la referencia como el tipo de lista de interfaz.
③ Nota: es java.util.List, no java.awt.List.
Código:
1import java.util.ArrayList;
2import java.util.List;
3import charactor.Student;
4public class TestCollection {
5public static void main(String[] args) {
6//接口引用指向子类对象（多态）
7List students = new ArrayList();
8students .add( new Student("李四"));
9System.out.println(students .size());
10}
11}Métodos de la interfaz List:
① Debido a que ArrayList implementa la interfaz List, se implementan todos los métodos de la interfaz List ArrayList.
② Hay una explicación detallada en el capítulo de métodos comunes de ArrayList
1.4 Interfaz de lista
Genérico:
① No especifique un contenedor genérico, puede almacenar cualquier tipo de elemento
② Se especifica un contenedor genérico, que solo puede almacenar elementos del tipo especificado y sus subclases
Abreviatura de genérico:
① Para que el compilador no advierta, debe usar genéricos antes y después
1List <Student> gen = new ArrayList <Student> ();
② Sin embargo, JDK7 proporciona una abreviatura genérica que puede reducir ligeramente la cantidad de código
1List <Estudiante> gen = new ArrayList <> ();
1.5 transversal
Atravesar con un bucle for:
① A través del estudio anterior, sé que puede usar size () y get () para obtener el tamaño y el elemento en la posición especificada respectivamente, combinado con el bucle for, puede recorrer el contenido de ArrayList
Código:
1List<Student> students= new ArrayList<Student>();
2// 放5个Student进入容器
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student name " + i));
5}
6// 第一种遍历 for循环
7System.out.println("--------for 循环-------");
8for (int i = 0; i < students.size(); i++) {
9Student s = students.get(i);
10System.out.println(s);
Recorrido del iterador:
① Utilice Iterator para recorrer los elementos de la colección
Código:
1List<Student> students= new ArrayList<Student>();
2//放5个students进入容器
3for (int i = 0; i < 5; i++) {
4students.add(new students("student name " +i));
5}
6//第二种遍历，使用迭代器
7System.out.println("--------使用while的iterator-------");
8Iterator<Student> it= students.iterator();
9//从最开始的位置判断"下一个"位置是否有数据
10//如果有就通过next取出来，并且把指针向下移动
11//直达"下一个"位置没有数据
12while(it.hasNext()){
13Student s = it.next();
14System.out.println(s);
15}
16//迭代器的for写法
17System.out.println("--------使用for的iterator-------");
18for (Iterator<Student> iterator = students.iterator(); iterator.hasNext();) {
19Student student= (Student ) iterator.next();
20System.out.println(student);
21}Uso mejorado para bucle:
① Es muy conveniente utilizar el bucle for mejorado para atravesar los elementos en ArrayList, que es la primera opción de muchos desarrolladores.
② Sin embargo, el bucle for mejorado también tiene sus defectos: no se puede utilizar para inicializar ArrayList, y es imposible saber qué elemento es actualmente. Cuando solo se necesitan imprimir elementos singulares, no se puede hacer. La variable de subíndice debe personalizarse nuevamente.
Código:
1List<Student> students= new ArrayList<Student>();
2// 放5个Student进入容器
3for (int i = 0; i < 5; i++) {
4students.add(new Student("student name " + i));
5}
6// 第三种，增强型for循环
7System.out.println("--------增强型for循环-------");
8for (Student s : students) {
9System.out.println(s);
10}