[Colección Java] Métodos comunes en la interfaz de la colección

Interfaz de colección

La interfaz Collection es la interfaz principal de las interfaces List, Set y Queue. Los métodos definidos en esta interfaz se pueden usar para operar tanto la colección Set como las colecciones List y Queue.

JDK no proporciona ninguna implementación directa de esta interfaz, pero proporciona una implementación de subinterfaces más específicas (como: Set y List).

Antes de Java5, las colecciones de Java perderían los tipos de datos de todos los objetos en el contenedor y tratarían todos los objetos como tipos de objetos; dado que JDK 5.0 agregó genéricos, las colecciones de Java pueden recordar los tipos de datos de los objetos en el contenedor.

Métodos de la interfaz de colección:

1. Agregar

 añadir (Objeto objeto)

 addAll(Colección coll)

2. Obtener el número de elementos válidos

 tamaño int()

3. Colección vacía

 vacío claro ()

4. ¿Es una colección vacía?

 booleano estáVacío()

5. ¿Contiene un elemento

 boolean contains(Object obj): Es juzgar si es el mismo objeto a través del método equals del elemento

 boolean containsAll(Colección c): También se compara llamando al método equals del elemento. Compara los elementos de dos colecciones uno por uno.

6. Eliminar

 boolean remove(Object obj): determina si es el elemento a eliminar a través del método equals del elemento. Solo se eliminará el primer elemento encontrado

 boolean removeAll(Collection coll): Toma la diferencia de la colección actual

7. Toma la intersección de dos conjuntos.

 booleano retenerTodo (Colección c): almacena el resultado de la intersección en la colección actual sin afectar a c

8. ¿Son iguales los conjuntos?

 booleano es igual a (Objeto obj)

9. Convertir a matriz de objetos

 Objeto[] aArray()

10. Obtenga el valor hash del objeto de colección

 código hash()

11. Travesía

 iterador (): devuelve un objeto iterador para el recorrido de la colección

  ================================================== =======================

 ejemplo;

public class CollectionTest {

    @Test
    public void test1(){
        Collection collection = new ArrayList();

        //add(Object e):将元素e添加到集合collection中
        collection.add("AA");
        collection.add("AA");
        collection.add("BB");
        collection.add(123);//自动装箱
        collection.add(new Date());

        //size()：获取添加的元素的个数
        System.out.println(collection.size());

        //addAll(Collection collection1):将collection集合中的元素添加到当前的集合中
        Collection collection1 = new ArrayList();
        collection1.add(111);
        collection1.add("CC");
        collection.addAll(collection1);
        System.out.println(collection.size());
        System.out.println(collection);

        //clear():清空集合元素
        collection.clear();
        
        //isEmpty():判断当前集合是否为空
        System.out.println(collection.isEmpty());


    }
}

El resultado de la operación es el siguiente

Anotamos collection.clear(); El resultado de la operación es el siguiente

 Ejemplo 2

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

/**
 *  Collection接口中声明的方法的测试
 */
public class CollectionTest {

    @Test
    public void test1(){
        Collection collection = new ArrayList();

        collection.add(123);
        collection.add(456);
        collection.add(new String("Tom"));
        collection.add(false);
        Person p = new Person("Jerry", 20);
        collection.add(p);
        

        //contains(Object obj):判断当前集合中是否包含obj
        boolean contains = collection.contains(123);
        System.out.println(contains);//true

        System.out.println(collection.contains(new String("Tom")));//true
        System.out.println(collection.contains(p));//true
        

    }
}

clase de persona

import java.util.Objects;

public class Person {
    private String Name;
    private int age;

    public Person() {
        super();
    }

    public Person(String name, int age) {
        Name = name;
        this.age = age;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "Name='" + Name + '\'' +
                ", age=" + age +
                '}';
    }

correr:

El resultado de la ejecución es verdadero, lo que indica que se llama a equals() para juzgar

Agregamos collection.add(new Person("Tom", 20)); y luego ejecutamos System.out.println(collection.contains(new Person("Tom", 20))); el resultado se vuelve falso

Necesitamos anular los iguales () de la clase Persona

import java.util.Objects;

public class Person {
    private String Name;
    private int age;

    public Person() {
        super();
    }

    public Person(String name, int age) {
        Name = name;
        this.age = age;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "Name='" + Name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Name.equals(person.Name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(Name, age);
    }
}

 correr:

Estamos viendo algunos métodos

el código se muestra a continuación:

package com.dai.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTest {

    @Test
    public void test1(){
        Collection collection = new ArrayList();

        collection.add(123);
        collection.add(456);
        collection.add(new String("Tom"));
        collection.add(false);
        Person p = new Person("Jerry", 20);
        collection.add(p);
        collection.add(new Person("Tom",20));

        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们再判断时辉调用obj对象的equals()
        boolean contains = collection.contains(123);
        System.out.println(contains);//true

        System.out.println(collection.contains(new String("Tom")));//true
        System.out.println(collection.contains(p));//true
        System.out.println(collection.contains(new Person("Tom", 20)));//false
        //变成true，重写equals()

        //2.containsAll(Collection collection):判断形参collection中所有元素是否都存在与当前集合中
        Collection collection1 = Arrays.asList(123,456);
        collection.containsAll(collection1);
    }
}

resultado de la operación:

mirar de nuevo borrar

boolean remove(Object obj): determina si es el elemento a eliminar a través del método equals del elemento. Solo se eliminará el primer elemento encontrado

    @Test
    public void test2(){
        //3.remove(Object obj):从当前集合中移除obj元素
        Collection collection = new ArrayList();
        collection.add(123);
        collection.add(456);
        collection.add(new Person("Jerry", 20));
        collection.add(new String("Tom"));
        collection.add(false);

        collection.remove(123);
        System.out.println(collection);

        collection.remove(new Person("Jerry",20));
        System.out.println(collection);
    }

El resultado de la operación es el siguiente:

boolean removeAll(Collection coll): Toma la diferencia de la colección actual

 

    @Test
    public void test2(){
        //3.remove(Object obj):从当前集合中移除obj元素
        Collection collection = new ArrayList();
        collection.add(123);
        collection.add(456);
        collection.add(new Person("Jerry", 20));
        collection.add(new String("Tom"));
        collection.add(false);

//        collection.remove(123);
//        System.out.println(collection);

        collection.remove(new Person("Jerry",20));
        System.out.println(collection);

        //removeAll(Collection coll1):从当前集合中移除coll1中所有的元素
        Collection coll1 = Arrays.asList(123,4567);
        collection.removeAll(coll1);
        System.out.println(collection);
    }
}

El resultado de la operación es el siguiente:

retenerTodo(Colección coll1): Intersección: Obtener la intersección de la colección actual coll1 y devolverla a la colección actual

    @Test
    public void test3(){
        Collection collection = new ArrayList();
        collection.add(123);
        collection.add(456);
        collection.add(new Person("Jerry", 20));
        collection.add(new String("Tom"));
        collection.add(false);

        //5.retainAll(Collection coll1):交集：获取当前集合coll1集合的交集，并返回给当前集合
        Collection coll1 = Arrays.asList(123,456,789);
        collection.retainAll(coll1);
        System.out.println(collection);
   }

 resultado de la operación:

Si los conjuntos son iguales: boolean equals(Object obj): para devolver verdadero, los elementos del conjunto actual y el conjunto de parámetros deben ser iguales

    @Test
    public void test3(){
        Collection collection = new ArrayList();
        collection.add(123);
        collection.add(456);
        collection.add(new Person("Jerry", 20));
        collection.add(new String("Tom"));
        collection.add(false);

        //5.retainAll(Collection coll1):交集：获取当前集合coll1集合的交集，并返回给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        collection.retainAll(coll1);
//        System.out.println(collection);

        //6.equals(Object obj):
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry", 20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        System.out.println(collection.equals(coll1));
    }

 resultado de la operación:

 Si intercambiamos 123 y 456:

 Obtenga el valor hash  hashCode() del objeto de colección

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(456);
        coll.add(123);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());
    }

 resultado de la operación:

Convertir a matriz de objetos Object[] toArray()

 

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(456);
        coll.add(123);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //8.集合 ---> 数组：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

 El resultado de la operación es el siguiente:

Expansion: Array ---> Collection: Llame al método estático asList() de la clase Arrays

 

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(456);
        coll.add(123);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //8.集合 ---> 数组：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //拓展：数组  ---> 集合:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);
    }

 resultado de la operación:

 ================================================== =======================

  Conclusión: al agregar datos obj al objeto de la clase de implementación de la interfaz Collection, se requiere que la clase de obj reescriba equals()

¡gracias por ver! ! !