Set interface and set sub implementation classes

1.Set Interface

1.Set Interface features : No repeating elements , Element uniqueness 
			  Disorder 
2.Set and List The same access method 

2.HashSet aggregate

1. When calling HashSet Of add() Method to store elements , Will call first hashCode() Method , Get hash value , Calculate a storage location based on the hash value of the object , If the position has no elements , Then deposit ; If there are elements in that location , Call equals() Method to compare the currently stored element with the element at that location . return false, Store elements in a collection , return true, Then discard the element .
    Custom types need to be overridden hashCode() and equals() Method 

3.TreeSet aggregate

1. The underlying dependence TreeMap,TreeMap The underlying data structure is a red black tree structure 
2. Use different construction methods , Will choose different sorting methods 
     Natural ordering :TreeSet(), Interface Comparable, rewrite compareTo Method 
     Comparator sort :TreeSet(Comparator<E> comparator)
        	 Interface Comparator,compare Method 

3.1 Natural sorting implementation code

public class Student implements Comparable<Student>{
    
    private String name;
    private int age;
   // Here is the reference structure , No arguments structure ,get/set Method 
    @Override
    public String toString() {
    
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    // rewrite compareTo Method 
    public int compareTo(Student s){
    
         int num  = this.age - s.age ;// From small to large 
    int num2 = (num==0)?(this.name.compareTo(s.name)):num ;
        return num2;
    }
}

3.2 Comparator sorting implementation code

 Mode one : Define sub implementation classes 
	public class MyComparator implements Comparator<Student> {
    
    @Override
    public int compare(Student s1, Student s2) {
    
        int num = s1.getAge() - s2.getAge() ;
        int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
        return num2;
    }
}
	TreeSet<Student> ts = new TreeSet<>(new MyComparator()) ;

 Mode two : Anonymous inner class 
	   TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
    
            @Override
            public int compare(Student s1, Student s2) {
    
                int num = s2.getAge() - s1.getAge() ;
                int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
                return num2;
            }
        }) ;

 Mode three : lambda expression 
          TreeSet<Student> ts = new TreeSet<>((s1,s2) ->{
    
                int num = s2.getAge() - s1.getAge() ;
                int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
                return num2;
            }
        ) ;

4. Generic

<?>: arbitrarily java type 
<? extends E>: Down limit ,E This type and its subclasses 
<? super E>: Limit upward ,E This type and its parent class 

5.ArrayList Set nesting

public class Test{
    
    main(){
    
        ArrayList<ArrayList<Student>> bigArray = new ArrayList<>();
        ArrayList<Student> array1 = new ArrayList<>() ;
        // Create a small collection 
        ArrayList<Student> array1 = new ArrayList<>() ;
         ArrayList<Student> array1 = new ArrayList<>() ;
        Student s1 = new Student(" Liu bei ",35) ;
        Student s2 = new Student(" Cao Cao ",40) ;
        array1.add(s1) ;
        array1.add(s2) ;
        // Add a small set to a large set 
        bigArray.add(array1) ;


        // Second subset 
        ArrayList<Student> array2 = new ArrayList<>() ;
        // Add two student data 
        Student s3 = new Student(" Tang's monk ",50) ;
        Student s4 = new Student(" The Monkey King ",42) ;
        array2.add(s3) ;
        array2.add(s4) ;
        // Add a small set to a large set 
        bigArray.add(array2) ;

        // The third subset 
        ArrayList<Student> array3 = new ArrayList<>() ;
        // Add two student data 
        Student s5 = new Student(" Song Jiang ",39) ;
        Student s6 = new Student(" ximen qing ",28) ;
        array3.add(s5) ;
        array3.add(s6) ;
        // Add a small set to a large set 
        bigArray.add(array3) ;

        // Easy to traverse ----> enhance for
        // The data type of the current large collection : ArrayList<ArrayList<Student>>
        System.out.println(" The student information is as follows ");
        for(ArrayList<Student> myArray:bigArray){
    
            // subset ArrayList<Student> ---> The data type inside is Student
            for(Student s :myArray){
    
                System.out.println("\t"+s.getName()+"\t"+s.getAge());
    }
}