Java collection framework (3) -Interfaz de configuración

Interfaz de recopilación dos (Establecer interfaz):

1. Establecer: almacenar colecciones no ordenadas, no repetibles, la parte inferior es una lista vinculada

Establecer la clase de implementación de interfaz:

1. HashSet: como la clase de implementación principal de la interfaz establecida, el subproceso no es seguro y puede almacenar valores nulos
2. LinkedHashSet: como una subclase de HashSet, al atravesar sus datos internos, se puede atravesar en el orden de adición. Para operaciones transversales frecuentes, eficiencia Alto
3. TreeSet: puede ordenar según los atributos especificados del objeto agregado

Resumen

1. No hay métodos adicionales definidos en la interfaz Set, y todos son métodos declarados en la Colección utilizada.
2. Requisito 1: si desea agregar datos en Set, la clase en la que se encuentra debe reescribir hashCode () y equals () -> generalmente usar el acceso directo para generar el
requisito 2: reescribir hashCode () y equals () tanto como sea posible Consistencia: los objetos iguales deben tener el mismo valor hash
1) Para ==, si actúa sobre una variable de un tipo de datos básico, compare directamente si el "valor" almacenado es igual;
si actúa sobre una variable de un tipo de referencia, compare Es la dirección del objeto señalado
2) Para el método igual, tenga en cuenta que el método igual no se puede aplicar a las variables del tipo de datos básico.
Si el método igual no se reescribe, se compara la dirección del objeto señalado por la variable del tipo de referencia;
Si clases como String y Date reescriben el método igual, se compara el contenido del objeto señalado.

Segundo, el proceso de implementación de Set

Conjunto: almacena un conjunto no ordenado, no repetible (HashSet)
1. Desorden: no es igual a la aleatoriedad.
Los datos almacenados no se agregan en el orden del índice de la matriz en la matriz subyacente, sino que se determinan de acuerdo con el valor hash de los datos.

2. No repetibilidad: para garantizar que el elemento agregado no pueda ser verdadero cuando se juzga de acuerdo con equals (). Es decir: solo puede haber uno del mismo elemento.
3. Añadir los elementos del proceso: la HashSet subyacente con un ejemplo: array + lista (JDK7)
método que añadir elementos a un HashSet, la primera HashCode llamada una clase del elemento (), los elementos de un valor hash se calcula,
este ha Luego, Xixi calcula la posición de almacenamiento de la matriz en la parte inferior del HashSet (es decir, la posición del índice) a través de un algoritmo para determinar
si hay un elemento en esta posición en la matriz:
si no hay ningún elemento en esta posición, se agrega con éxito. -> Caso 1
Si hay otro elemento b en esta posición (o hay varios elementos en forma de una lista vinculada), compare los valores hash del elemento a y el elemento b:
si los valores hash son diferentes, el elemento a se agrega con éxito—> caso 2
Si el valor hash es el mismo, y luego llamar al método equals () de la clase de elemento a
equals () devuelve verdadero, entonces la adición del elemento a falla.
Si equals () devuelve falso, el elemento a se agrega con éxito. -> Caso 3
Para el caso 2 y el caso 3 donde la adición es exitosa: el elemento a ya existe. Los datos en la posición de índice especificada se almacenan en forma de una lista vinculada.
Jdk 7: el elemento a se coloca en la matriz, apuntando al elemento original (inserción de cabeza)
JDK 8: elemento original en la matriz, el punto de elemento de un (adición de cola)
resumen: perturbado

   @Test
    public void  test(){
        Set set = new HashSet();
        set.add(123);
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("AA");
        set.add("BB");
        set.add(new Person("Tom",22));
        set.add(false);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() +"\t");
            //AA	BB	Person{name='Tom', age=22}	false	456	123
        }

Tres, el uso de LinkedHashSet

LinkedHashSet como una subclase de HashSet, mientras agrega datos, también mantiene dos referencias, registrando los datos anteriores y los últimos.

Ventajas: alta eficiencia para operaciones transversales frecuentes

    @Test
  public void  test1(){
      Set set = new LinkedHashSet();
      set.add(123);
      set.add(123);
      set.add(456);
      set.add("AA");
      set.add("AA");
      set.add("BB");
      set.add(new Person("Tom",22));
      set.add(false);

      Iterator iterator = set.iterator();
      while(iterator.hasNext()){
          System.out.print(iterator.next() +"\t");
         //123	456	AA	BB	Person{name='Tom', age=22}	false
      }
  }

Cuatro, el uso de TreeSet

1. Los datos agregados al TreeSet requieren objetos de la misma clase
2. Dos métodos de clasificación: clasificación natural (implementando la interfaz Comparable en la clase de uso para anular el método compareTo) y clasificación personalizada
3. Clasificación natural: comparación de dos objetos El mismo estándar es: compareTo () devuelve 0, no es igual a ()

  @Test
    public void  test3(){
        TreeSet set = new TreeSet();

        //错误
//        set.add(123);
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add("AA");
//        set.add("BB");
//        set.add(new Person("Tom",22));
//        set.add(false);
        //一
//        set.add(133);
//        set.add(456);
//        set.add(-145);
//        set.add(12);
//        set.add(6);
        //二
        //  //详细可见Java集合框架(一)-----Collection接口中的Person类
        set.add(new Person("Tom",23));
        set.add(new Person("FAS",15));
        set.add(new Person("SDF",45));
        set.add(new Person("WER",32));
        set.add(new Person("AF",20));
        //如果compareTo没有重写年龄的话，就只会有一个对象
        set.add(new Person("AF",50));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() +"\t");
        }
    }

4. Orden personalizado de TreeSet El
estándar para comparar si dos objetos son iguales es: compare () de Comparator devuelve 0, no es igual a ()

 @Test
   public void  test4() {
       Comparator com = new Comparator() {
           //按照年龄从小到大排列
           @Override
           public int compare(Object o1, Object o2) {
               if (o1 instanceof Person && o2 instanceof Person){
                   Person p1 = (Person)o1;
                   Person p2 = (Person)o2;
                   return Integer.compare(p1.getAge(),((Person) o2).getAge());
               }else {
                   throw new RuntimeException("输入的类型不匹配！");
               }
           }
       };

       TreeSet set = new TreeSet(com);
       set.add(new Person("Tom",23));
       set.add(new Person("FAS",15));
       set.add(new Person("SDF",45));
       set.add(new Person("AEE",45));
       set.add(new Person("WER",32));
       set.add(new Person("AF",20));
       //如果compareTo没有重写年龄的话，就只会有一个对象
       set.add(new Person("AF",50));

       Iterator iterator = set.iterator();
       while(iterator.hasNext()){
           System.out.println(iterator.next());
       }
   }

Practica

  public static List duplicateList(List list){
      HashSet set =  new HashSet();
      set.addAll(list);
      return new ArrayList(set);
  }
  @Test
  public void test5(){
      List list = new ArrayList();
      list.add(new Integer(1));
      list.add(new Integer(2));
      list.add(new Integer(2));
      list.add(new Integer(3));
      list.add(new Integer(3));
      List list1 = duplicateList(list);
      for (Object integer : list1){
          System.out.println(integer);
      }
  }
  @Test
  public void test6(){
      HashSet set = new HashSet();
      Person p1 = new Person("AA",1001);
      Person p2 = new Person("BB",1002);

      set.add(p1);
      set.add(p2);

      p1.name = "CC";
      set.remove(p1);
      System.out.println(set);

      set.add(new Person("CC",1001));
      System.out.println(set);
      set.add(new Person("AA",1001));
      System.out.println(set);
  }
}