Java之List 与 Set 接口

一.set与List        二.List接口         一. ArrayList  与 LinkedList

                          三.Set                 一. HashSet      二. LinkedHashSet

                 四. hashCode  与 toString原理                Set集合不重复原理                         Collection 工具类

一.set与List

  1.set 与List 都是 Collection 接口的子类            

     1.List接口主要的实现类      ArrayList  LinkedList  Vector....      2.set集合实现类:  HashSet    LinkedHashSet

二.List接口

    1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)

    2.有索引,包含了一些带索引的方法 ,  允许存储重复的元素

    3. List接口中带索引的方法(相对于set集合特有)                        操作索引的时候,一定要防止索引越界异常

           - public void add(int index, E element):       将指定的元素，添加到该集合中的指定位置上。
           - public E get(int index):                              返回集合中指定位置的元素。
           - public E remove(int index):                       移除列表中指定位置的元素, 返回的是被移除的元素。
           - public E set(int index, E element):         用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

    4.List集合遍历的三种方式                  List<String> list = new ArrayList<>();  多态

            1.普通循环 :使用 public E get(int index):   索引方法

            2.迭代器 :   Iterator<String> it = list.iterator();        while(it.hasNext()){      String s = it.next();   System.out.println(s);   }

            3.增强for 循环:     for (String s : list) {       System.out.println(s);   }

一. ArrayList  与 LinkedList

     1. ArrayList是数组结构 数组结构的地址是连续的      所以查询快 ,增删慢  

     2.LinkedList是一个双向链表结构 头尾操作方法多     所以查询慢, 增删快

      注意:使用LinkedList集合特有的方法,不能使用多态

        - public void addFirst(E e):           将指定元素插入此列表的开头。
        - public void addLast(E e):            将指定元素添加到此列表的结尾。 与add() 一样
        - public void push(E e):                 将元素推入此列表所表示的堆栈。 与addfirst() 一样

        - public E getFirst():                      返回此列表的第一个元素。
        - public E getLast():                       返回此列表的最后一个元素。

        - public E removeFirst():               移除并返回此列表的第一个元素。           与remove()一样
        - public E removeLast():               移除并返回此列表的最后一个元素。
        - public E pop():                            从此列表所表示的堆栈处弹出一个元素。 删除第一个元素 与remove()一样

      Vector    是jdk1.1 的同步 

三.Set

   1.Set接口的特点:            1.不允许存储重复的元素       2.没有索引,没有带索引的方法,所以不能使用普通的for循环遍历

  一. HashSet

     1.是一个无序的集合,存储元素和取出元素的顺序有可能不一致           2.底层是一个哈希表结构(查询的速度非常的快)

     3.遍历使用 迭代器 或者 增强 for 循环

     4.HashSet存储自定义类型元素       存储的元素(String,Integer,...Student,Person...),必须重写hashCode方法和equals方法

HashSet<Person> set = new HashSet<>();         存储自定义类型
 @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);
    }

 二. LinkedHashSet

     1.底层是一个哈希表(数组+链表/红黑树)+链表:     多了一条链表(记录元素的存储顺序),保证元素有序

四. hashCode  与 toString原理

   1.如果直接打印数组  是一个 内存地址 toString方法的源码:

        return getClass().getName() + "@" + Integer.toHexString(hashCode());    所以Collection集合都重写了objec的tostring方法

  2.哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的          物理地址)     所以值不一样也可能 哈希值一样  就是哈希冲突  这时,就会用equals 方法去比较  内容

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

Set集合不重复原理

Collection 工具类

    1.public static <T> boolean addAll(Collection<T> c, T... elements):               往任意集合中添加一些元素。

          ArrayList<String> list = new ArrayList<>();                     Collections.addAll(list,"a","b","c","d","e");

    2.List 集合特有方法

       1.public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。              Collections.shuffle(list);     无返回值

       2.public static <T> void sort(List<T> list):        将集合中元素按照默认规则排序。  数字英文默认是升序

         想要排序自定义数据类型   列如Person 这个类必须实现  Comparable 接口   并且重写   compareTo 方法

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    @Override                               //重写排序的规则 
    public int compareTo(Person o) {            
        return o.getAge() - this.getAge();  //年龄升序排序    //return 0;认为元素都是相同的
    }

ArrayList<Person> list03 = new ArrayList<>();
list03.add(new Person("张三",18));
list03.add(new Person("李四",20));
list03.add(new Person("王五",15));
Collections.sort(list03);  按照年龄排序

       第二种方法  Comparator 

ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        Collections.sort(list01, new Comparator<Integer>() {        匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {             //重写比较的规则
                return o2-o1; //降序                                //return o1-o2;升序
            } 
        });

    2.不需要重写Student类 

ArrayList<Student> list02 = new ArrayList<>();
        list02.add(new Student("a迪丽热巴",18));
        list02.add(new Student("古力娜扎",20));
        list02.add(new Student("杨幂",17));
        list02.add(new Student("b杨幂",18));
        //扩展:了解
        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result =  o1.getAge()-o2.getAge(); //按照年龄升序排序
                if(result==0){                        //如果两个人年龄相同,再使用姓名的第一个字比较
                    result =  o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return  result;
            }

        });