Interfaz Java Foundation-Collection Collection (lista y conjunto)

1. Métodos comunes de interfaz de recopilación

1. ¿Qué elementos
  se pueden almacenar en la colección? Antes de usar genéricos, todos los subtipos de objeto que se pueden almacenar
  en la colección. Después de usar genéricos, la colección solo puede almacenar un tipo específico. La
  colección no puede almacenar tipos de datos básicos, ni tampoco El objeto java solo puede almacenar la dirección de memoria del objeto java.

2. Métodos de uso común en la
colección : Nota: Los métodos incluidos en la colección también se incluyen en su clase de implementación, también se pueden usar y son públicos.
suma booleana (Objeto e)

// Colección c = new Collection (); // La interfaz es abstracta y no se puede instanciar
boolean add (Object e) Agrega elementos a la colección
int size (); Obtiene el número de elementos en la colección
void clear (); Clear la colección Todos los elementos en
booleano contiene (Objeto o): determina si la colección actual contiene el elemento o, incluido return true, sin incluir return false
boolean remove (Object o) elimina un elemento en
la colección boolean isEmpty () Determina si la colección es in Si el número de elementos es 0
Obect [] toArray () Convierte la colección en una matriz

public static void main(String[] args) {
    
    
    //Collection c=new Collection();      //接口是抽象的，无法实例化
    Collection c=new ArrayList();
    //测试collection接口中的常用方法
    c.add(1200);      //自动装箱，实际上是放进去了一个对象的内存地址。Integer i=new Integer(1200)
    c.add(3.14);      //自动装箱
    c.add(new Object());
    c.add(true);
    //获取集合中元素的个数
    System.out.println("集合中元素的个数"+c.size());
    //清空集合
    c.clear();
    System.out.println("集合中元素的个数"+c.size());
    //再向集合中添加元素
    c.add("hello");
    c.add("world");
    c.add("好客");
    c.add("绿巨人");
    //判断集合中是否包含绿巨人
    boolean flag=c.contains("绿巨人");
    System.out.println(flag);     //true
    boolean flag2=c.contains("绿巨人2");
    System.out.println(flag2);    //false

    System.out.println("集合中元素的个数"+c.size());

    //删除集合中某个元素
    c.remove("绿巨人");
    System.out.println("集合中元素的个数"+c.size());

    //判断集合是否为空
    System.out.println(c.isEmpty());      //false
    c.clear();
    System.out.println(c.isEmpty());      //true
}

Salida
El número de elementos en el
conjunto 4 El número de elementos en el conjunto 0
verdadero
falso
El número
de elementos en el conjunto 4 El número de elementos en el conjunto 3
falso
verdadero

2 iteración de colección de colección

public static void main(String[] args) {
    
    
          //注意：以下的遍历方式/迭代方式，是所有collection通用的一种方式
          //在Map集合中不能用，在所有的collection以及子类中使用
          //创建集合对象
          Collection c=new ArrayList();//后面的集合无所谓，主要是看前面的collection接口，怎么遍历/迭代
          //添加元素
          c.add("abc");
          c.add("def");
          c.add(100);
          c.add(new Object());
          //对集合Collection进行遍历/迭代
          //第一步:获取集合对象的迭代器对象Iterator
          //collection为什么能调用这个方法，因为继承了Iterable接口，可使用其父类的方法
          Iterator it=c.iterator();
          //第二步：通过以上获取的迭代器对象，开始迭代遍历集合
/*
 以下两个方法是迭代器Iterator中的方法
 boolean hasNext()如果仍有元素可以迭代，则返回true
 Object next() 返回迭代的下一个元素
 
 void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）
 * */
          while(it.hasNext()){
    
    
              //不管你当初存进去的是什么，取出来统一都是object
              Object obj=it.next();
              System.out.println(obj);
          }
  }

Salida
abc
def
100
java.lang.Object@15db9742

Un iterador es un objeto con dos métodos hasnext () y next ().
Los iteradores son universales.

public static void main(String[] args) {
    
    
    //HashSet集合。无序不可重复
    //无序：存进去和取出的顺序不一定相同
    //不可重复:存进去100，不能再存100
    Collection c=new HashSet();
    c.add(100);
    c.add(200);
    c.add(90);
    c.add(300);
    c.add(600);
    c.add(30);
    c.add(100);
    Iterator it=c.iterator();
    while(it.hasNext()){
    
    
        System.out.println(it.next());
    }
}

Salida
100
200
600
90
300
30

3.Contiene análisis de método

La colección en profundidad contiene el método
boolean contains (Objeto o) para
determinar si la colección contiene un objeto o, si contiene, devuelve verdadero, si no contiene falso
contiene, la capa inferior llama al método equals.

Collection c=new ArrayList();
String s1=new String("abc");      //内存地址假设s1=0x1111
c.add(s1);
String s2=new String("def");      //内存地址假设s2=0x2222
c.add(s2);

String x=new String("abc");          //内存地址假设s3=0x3333
//c集合中是否包含x
//contains里面调用了equals方法
System.out.println(c.contains(x));

Resultado: El
método true contiene se utiliza para juzgar si un determinado elemento está contenido en la colección.
Entonces, en la capa inferior, ¿cómo juzga si un determinado elemento está contenido en la colección?
Se llama al método equals para comparar y el
método equals devuelve verdadero, lo que significa que este elemento está incluido.
Para algunos tipos de objetos, es necesario volver a escribir su método de igual.

4. Eliminación de elementos de la colección

public static void main(String[] args) {
    
    
    //创建集合
    Collection c=new ArrayList();
    //注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器 
    //一定要注意：集合结构只要发生改变，迭代器必须重新获取
    Iterator it=c.iterator();
    //添加元素
    c.add(1);
    c.add(2);
    c.add(3);
    while(it.hasNext()){
    
    
        Object obj=it.next();
        System.out.println(obj);
    }
}

Cuando la estructura de la colección ha cambiado, el iterador no vuelve a adquirir, la llamada al método next (), se produce una excepción.

Clave:
cuando un conjunto de cambios estructurales, el iterador debe volver a adquirir, si todavía usa el iterador anterior, habrá una
eliminación anormal Después del elemento, la estructura de la colección cambia, el iterador debe volver a adquirirse, pero la próxima vez que el bucle, el iterador no se vuelve a adquirir, por lo que se producirá una excepción.

public static void main(String[] args) {
    
    
    //创建集合
    Collection c=new ArrayList();

    //添加元素
    c.add("abc");
    c.add("def");
    c.add("ghi");
    Iterator it=c.iterator();
    while(it.hasNext()){
    
    
        Object obj=it.next();
        //删除元素之后，集合的结构发生变化，应该重新获取迭代器，但是循环下一次的时候，并没有重新获取迭代器，所以会出现异常
        c.remove(obj);
        System.out.println(obj);
    }
}

En el proceso de iteración de los elementos de la colección, no puede llamar al método remove del objeto de la colección, de lo contrario se producirá una excepción.
Puede utilizar el método de eliminación del iterador

//创建集合
Collection c=new ArrayList();

//添加元素
c.add("abc");
c.add("def");
c.add("ghi");
Iterator it=c.iterator();
while(it.hasNext()){
    
    
    Object obj=it.next();
    it.remove();
    //c.remove(obj);
    System.out.println(obj);
}
System.out.println(c.size());

Salida 0;

5. Métodos únicos de la interfaz List

Métodos comunes para probar la interfaz de lista 1.
Características de los elementos de almacenamiento de la colección de listas : ordenados y repetidos.
Ordenado: los elementos de la colección de listas tienen subíndices, comenzando desde 0 y aumentando en 1.
Repetible: Almacene un 1 y podrá continuar almacenando 1.
2. Dado que la lista es una subinterfaz de la interfaz de colección, debe tener sus propios métodos "destacados"
en la interfaz de lista. Estos son solo métodos comunes específicos del list interface
void add (int index, E element);
E get (int index);
E remove (int index);
E set (int index, E element);
void add (int index, E element); Inserta el elemento especificado en la posición especificada de la lista (los primeros parámetros son subíndices)

public static void main(String[] args) {
    
    
    //创建list类型的集合
    List myList=new ArrayList();
    //添加元素
    myList.add("A");      //默认是向集合末尾添加元素
    myList.add("B");
    myList.add("C");
    myList.add("D");
    //在列表的指定位置插入指定元素(第一个参数是下标)
    //效率有点低。
    myList.add(1,"king");
    //迭代
    Iterator it=myList.iterator();
    while(it.hasNext()){
    
    
        Object et1=it.next();
        System.out.println(et1);
    }
}

E get (int index); Obtiene elementos según el subíndice

//根据下标获取元素
Object firstObj = myList.get(0);
System.out.println(firstObj);
//因为有下标，所以List集合有自己比较特殊的遍历方式
//通过下标遍历,list集合特有的方式，set没有
for(int i=0;i<myList.size();i++){
    
    
    Object obj = myList.get(i);
    System.out.println(obj);
}

E remove (int index);
elimina el elemento en la posición de índice especificada

//删除指定下标位置的元素
//删除下标为0的元素
System.out.println(myList.size());
myList.remove(0);
System.out.println(myList.size());

//修改指定位置的元素
myList.set(2, "soft");

Los métodos anteriores no necesitan memorizarse, comprender y encontrar archivos de ayuda.

6.Configurar interfaz

Las características de HashSet: desorden y no repetible

//演示HashSset的特点
Set<String> strs=new HashSet<>();
//添加元素
strs.add("hello3");
strs.add("hello4");
strs.add("hello1");
strs.add("hello2");
strs.add("hello3");
strs.add("hello3");
//遍历
for(String s:strs){
    
    
    System.out.println(s);
}

Salida
hello1
hello4
hello2
hello3
1. El orden de almacenamiento es diferente del orden sacado
2. No repetible
3. Los elementos colocados en la colección hashSet se colocan en la parte clave de la colección HashMap.
Las características de los elementos de almacenamiento de la colección TreeSet
no están ordenadas y no son repetibles, pero los elementos almacenados se pueden clasificar automáticamente en orden de tamaño, lo que se denomina colección ordenable.

//创建集合对象
Set<String> strs=new TreeSet<>();
//添加元素
strs.add("A");
strs.add("B");
strs.add("Z");
strs.add("Y");
strs.add("Z");
strs.add("K");
strs.add("M");
//遍历set集合
//从小到大自动排序
for(String s:strs){
    
    
    System.out.println(s);
}

Salida
A
B
K
M
Y
Z

El trastorno se refiere a la diferencia entre el orden en que se almacenan y el orden en que se extraen. Los elementos no tienen subíndices. La
clasificación se ordena en orden ascendente