[Aprendizaje] Java Collection Set, colecciones Herramientas

interfaz Set extiende Interfaz Collection
Set características de interfaz:
1. no permite elementos de almacenamiento duplicados
2 no indexados, indexados ningún método no se puede utilizar para el bucle normal a través de
HashSet establece Implementar Set interfaz
HashSet características:
almacenamiento 1. permitido elementos repetidos
2. no indexación, ningún método con un índice no se utiliza para bucle a través de una ordinaria
3 es una colección desordenada, el almacenamiento y el orden de los elementos pueden ser elementos de extracción inconsistentes
4. la estructura del fondo es una tabla hash ( velocidad de las consultas es muy rápido)

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo01Set {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        // 使用add方法往集合中添加元素
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {
            Integer n = it.next();
            System.out.println(n);
        }

        for (Integer n : set) {
            System.out.println(n);
        }
    }
}

valores Hash: es un entero decimal, se da (es decir, el valor de la dirección del objeto por el sistema al azar, es una dirección lógica, la dirección se simula para obtener datos de dirección física no es realmente almacenados en
un método de la clase Object, puede obtenerse el valor hash del objeto
hasCode int () devuelve el valor de código hash para este objeto
método fuente hasCode:

public native int hashCode();
native:代表该方法调用的是本地操作系统的方法

HashSet almacenar los elementos de tipo personalizada
conjunto de recopilación contiene los elementos singulares:
elementos de almacenamiento (cadena, entero, ... Student.Person), deben ser reescritos método hasCode y el método es igual
Requisitos:
con el mismo nombre con su edad, tratada como la misma persona, sólo se puede almacenar una vez

import java.util.Objects;

class Person {
    private String name;
    private int 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 &&
                Objects.equals(name, person.name);
    }

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

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

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Demo04HashSetSavePerson {
    public static void main(String[] args) {
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("小仙女",19);
        Person p2 = new Person("小美女",18);
        Person p3 = new Person("小美女",18);

        System.out.println(p1.hashCode()); // 722193131
        System.out.println(p2.hashCode()); // 734175839
        System.out.println(p3.hashCode()); // 734175839

        System.out.println(p2==p3); // false
        System.out.println(p2.equals(p3)); // true
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set); //[Person{name='小仙女', age=19}, Person{name='小美女', age=18}]
    }
}

LinkedHashSet conjunto de características:
la capa inferior es una tabla hash (array + lista / árbol negro) + lista: a multi-cadena (elementos de almacenamiento de grabación secuencial), para asegurar elemento ordenada

Los parámetros variables: Aparece característicos después de un nuevo JDK1.5
utilizarse siempre que:
Cuando se ha determinado el parámetro de proceso de tipo de lista de datos, pero el número de incertidumbre de los parámetros, puede utilizar parámetros variables
utilizando el formato: método utilizado en la definición de
修饰符 返回值类型 方法名(数据类型...变量名){}
un parámetro variable principio:
parámetro variable es una matriz inferior, en función del número de parámetros pasados, crea una matriz de diferentes longitudes, para almacenar estos parámetros
el número de parámetros pasados, y puede ser 0 (sin transmisión), una pluralidad de 1,2, ...
Notas parámetros variables:
la lista de argumentos 1. un método, sólo un parámetro variable
2. Si el final del método tiene varios parámetros, los parámetros variables deben estar escritos en la lista de parámetros

public class Demo01VarArgs {
    public static void main(String[] args) {
        int i = add(12,12);
        System.out.println(i);
    }
    /*
    定义计算（0-n）整数和的方法
    已知：计算整数的和，数据类型已经确定int
    但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数
     */
    public static int add(int...arr){
        //System.out.println(arr);
        int sum = 0;
        for (int i : arr) {
            sum =  sum + i;
        }
        return sum;
    }
//    public static int add(int a,int b){
//        return a+b;
//    }
}

Collections es una colección de herramientas para la operación de recogida. Como parte del método
-public static <T> boolean addAll(Collection<T>c,T...elements):往集合中添加一些元素
-public static void shuffle(List<?> list) 打乱集合顺序

estático public void sort (listado) para clasificar el conjunto, el valor predeterminado es ascendente
Nota:
el tipo usando premisa
Están conjunto de elementos almacenados en el interior ordenado, debe implementar Comparable, reglas de interfaz métodos definidos ordenaron volver a escribir compareTo

Interfaz de colación comparables:
propias (esto) - Parámetros: Ascendente

estático public void sort (listado, Comparador <Super T?>): Los elementos de la colección ordenados de acuerdo con las reglas especificadas

Comparador y diferencias comparables
Comparable: propio (este) la comparación y otros (parámetros), que necesitan para implementar la interfaz Comparable, reescribir las reglas de comparación compareTo método
de comparación: encontrar el equivalente de un árbitro de terceros para comparar dos

reglas de comparación:
ascendentes O1-O2, descendente y viceversa