List与Set集合

今日内容：

• List集合

• Set集合

• Collections集合工具类

LinkedList集合

java.util.LinkedList集合数据存储的结构底层是一个链表结构，是一个双向链表结构，方便元素的添加和删除。

我们在开发中对一个链表集合中的元素大量的都是采用首尾结点操作(添加和删除)：常用的API方法如下：

• public void addFirst(E e)：将指定的元素添加此列表的开头。

• public void addLast(E e)：将指定的元素添加此列表的末尾。

• public E getFirst()：获取此列表的首节点元素

• public E getLast()：获取此列表的尾节点元素

• public E removeFirst()：删除此列表的首节点元素

• public E removeLast()：删除此列表的尾节点元素

• public E pop()：从此列表所表示的堆栈中弹出一个元素(首元素)

• public void push(E e):将元素推入此列表所表示的堆栈中(首元素)

• public boolean isEmpty()：如果此列表不包含任何元素，返回true

LinkedList是List的子类，List当中的方法LinkedList都是可以使用的。我们只了解LinkedList独有的方法，

在开发当中，LinkedList集合也可以作为堆栈、队列结构使用(了解)

LinkedList集合的特点：
            1.底层是一个链表结构：查询慢，增删快
            2.里面包含了大量的首尾节点操作的方法
            3.允许所有元素（包括 null)
            4.此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步
            5.元素是有序的。
方法：

public void addFirst(E e)：将指定的元素添加此列表的开头。
-     public void addLast(E e)：将指定的元素添加此列表的末尾。
-     public E getFirst()：获取此列表的首节点元素
-     public E getLast()：获取此列表的尾节点元素
-     public E removeFirst()：删除此列表的首节点元素
-     public E removeLast()：删除此列表的尾节点元素
-     public E pop()：从此列表所表示的堆栈中弹出一个元素(首元素)
-     public void push(E e):将元素推入此列表所表示的堆栈中(首元素)
-     public boolean isEmpty()：如果此列表不包含任何元素，返回true

demo示例如下：

public class LinkedListDemo01 {

    public static void main(String[] args) {
        show03();

    }

    /*
         public E removeFirst()：删除此列表的首节点元素
         public E removeLast()：删除此列表的尾节点元素
         public E pop()：从此列表所表示的堆栈中弹出一个元素(首元素)
     */
    public static void show03() {
//        Vector
        new ArrayList<>();

        // 构建一个LinkedList集合对象
        LinkedList<String> linkedList = new LinkedList<>();
        // 添加一些元素
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        System.out.println(linkedList);

        String str01 = linkedList.removeFirst();
        System.out.println("被移除的首元素为：" + str01);// a
        String strLast = linkedList.removeLast();
        System.out.println("被移除的最后一个元素为：" + strLast);// c
        // pop
        String str02 = linkedList.pop();
        System.out.println("被移除的首元素为：" + str02);// b
        System.out.println("===========================");
        System.out.println(linkedList);// []
    }



    /*
             public E getFirst()：获取此列表的首节点元素
             public E getLast()：获取此列表的尾节点元素
     */
    public static void show02() {
        // 构建一个LinkedList集合对象
        LinkedList<String> linkedList = new LinkedList<>();
        // 添加一些元素
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        System.out.println(linkedList);
        //linkedList.clear(); 清空集合当中的元素，再次获取直接抛出java.util.NoSuchElementException
        // java.util.NoSuchElementException
        if (!linkedList.isEmpty()) {
            String str01 = linkedList.getFirst();
            System.out.println(str01);// a
            String str02 = linkedList.getFirst();
            System.out.println(str02);// a
            String strLast = linkedList.getLast();
            System.out.println(strLast);// c
        }


    }

    /*
        public void addFirst(E e)：将指定的元素添加此列表的开头。
        public void addLast(E e)：将指定的元素添加此列表的末尾。
        public void push(E e):将元素推入此列表所表示的堆栈中(首元素)
     */
    public static void show01() {
        // 构建一个LinkedList集合对象
        LinkedList<String> linkedList = new LinkedList<>();
        // 添加一些元素
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        System.out.println(linkedList);
        System.out.println("====================");
        linkedList.addFirst("www");
        linkedList.addFirst("zhiyou100");
        linkedList.addFirst("com");
        System.out.println(linkedList);// [a, b, c, www, zhiyou100, com]
        System.out.println("============================");

        linkedList.addLast("java");
        linkedList.addLast("python");
        linkedList.addLast("php");
        System.out.println(linkedList);
        System.out.println("============================");

        linkedList.push("小孙");
        linkedList.push("小王");

        System.out.println(linkedList);


    }
}

Set接口

java.util.Set接口和java.util.List接口是一样的，都是继承自Collection接口，它与Collection接口中的方法基本一样，没有对Collection接口进行功能上的扩展，只是比Collection接口更加严格。与List接口不同的是，Set接口中的元素是无序的，并且都会以某种规则保证存入的元素不重复。

Set接口有很多个子类，我们主要介绍两个重要子类：java.util.HashSet和java.util.LinkedHashSet集合

Set集合取出元素的方式可以采用：迭代器、增强for循环。

Set接口的特点：
            1. 不允许存储重复性的元素
            2. 没有索引，没有带索引的方法，也不能使用普通的for循环进行遍历

     java.util.HashSet implements Set接口

public class Demo01Set {
    public static void main(String[] args) {
        // 构建Set集合
        Set<Integer> set = new HashSet<>();
        // 使用add方法往集合当中存储一些元素
        set.add(123);
        set.add(125);
        set.add(120);
        set.add(123);
        // 查看set集合当中的元素
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            Integer num = iterator.next();
            System.out.println(num);
        }
        System.out.println("=================");
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }

}

HashSet集合介绍

java.util.HashSet是Set接口的一个实现类，它存储的元素是不可重复的，并且元素都是无序的（存取顺序不一致）。java.util.HashSet底层的实现其实是一个java.util.HashMap支持的。

HashSet是根据对象的哈希值来确定元素在集合当中的存储位置，因此它具有良好的存取和查找性能。保证元素唯一性的方式依赖于hashCode和equals方法

HashSet集合的特点：
             1. 不允许存储重复性的元素
             2. 没有索引，没有带索引的方法，也不能使用普通的for循环进行遍历
             3. 是一个无序的集合，存储的元素顺序和取出元素的顺序可能不一致
             4. 底层是一个哈希表结构(查询的速度非常的快)

示例代码：

// Set集合不允许存储重复性的元素
public class Demo02HashSet {

	public static void main(String[] args) {
		// 创建HashSet集合对象
		HashSet<String> hashset = new HashSet<>();
		String str01 = new String("abc");
		String str02 = new String("abc");
		hashset.add(str01);
		hashset.add(str02);
		hashset.add("重地");
		hashset.add("通话");
		hashset.add("abc");
		System.out.println(hashset);
		// 依赖于hashCode和equals方法

	}

}

HashSet集合存储数据的结构(哈希表)

什么是哈希表呢？

在JDK1.8之前，哈希表的底层采用的是数组+链表实现，即使用链表处理哈希冲突，同一哈希值的链表都存储在一个链表里，但是当位于一个链中的元素较多时，即hash值相等的元素较多时，通过key值依次查找的效率很低下。在JDK1.8中，哈希表存储结构采用数组+链表/红黑树实现的，当链表的长度超过阈值(8)时，将链表转换成红黑树结构，这样的好处是大大减少了查找的时间

如图展示：

 

总而言之，JDK1.8之后引入红黑树结构大大优化了HashMap的性能，那么对于我们来讲保证HashSet元素唯一不重复，其实是根据对象的hashCode和equals方法来决定的。如果我们往集合当中存储的是自定义的对象，需要保证对象的唯一性，就必须重写HashCode和equals方法，来自定义当前对象的比较方式。

public class People{

    //重写hashCode

    @Override
    public int hashCode() {
        return 1;
    }

}

/*

     哈希值：是一个十进制的整数，由系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址)
     是由Object类中有一个方法，可以获取对象的哈希值
     int hashCode() 返回该对象的哈希码值
          查看源码：public native int hashCode();
          native: 代表的是该方法调用的是本地操作系统中的方法。
 */
public class Demo03HashSet {

    public static void main(String[] args) {
        People p1 = new People();
        People p2 = new People();
        People p3 = new People();
        System.out.println("p1的哈希值："+p1.hashCode());// 460141958   1
        System.out.println("p2的哈希值："+p2.hashCode());// 1163157884  1
        System.out.println("p3的哈希值："+p3.hashCode());// 1956725890  1
        int i = "abc".hashCode();
        System.out.println(i);
        int i1 = "重地".hashCode();
        System.out.println(i1);
        System.out.println("===================");
        int i2 = "通话".hashCode();
        System.out.println(i2);
        System.out.println(p1 == p2);// false
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);

    }

}

public class Student {

    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        // 向下转型 类型判断
        if (o instanceof Student) {
            Student student = (Student)o;
            // 同名同年龄的人为同一个人 true
            return student.getName().equals(name) && student.getAge() == age;
        }
        return false;
    }

    @Override
    public int hashCode(){
         // 使用Objects类中的hash方法
        return Objects.hash(name,age);
    }


}

/*

    HashSet存储自定义类型的元素

   要求：
       同名同年龄的人，认定为同一个人，只能存储一次。
 */
public class Demo04HashSet {

	public static void main(String[] args) {
		// 创建一个HashSet集合对象
		HashSet<Student> hashSet = new HashSet<>();
		// 构建多个学生对象
		Student s1 = new Student("小孙", 20);
		Student s2 = new Student("小孙", 20);
		Student s3 = new Student("小孙", 20);
		System.out.println(s1.hashCode());// 460141958 23373803
		System.out.println(s2.hashCode());// 1163157884 23373803
		System.out.println(s3.hashCode());// 1956725890 23373803

		System.out.println(s1 == s2);// false false
		System.out.println(s1.equals(s2));// false true

		hashSet.add(s1);
		hashSet.add(s2);
		hashSet.add(s3);
		// [Student{name='小孙', age=20}, Student{name='小孙', age=20}, Student{name='小孙',
		// age=20}]
		System.out.println(hashSet);// [Student{name='小孙', age=20}]

	}

}

/*

       java.util.LinkedHashSet集合 extends java.util.HashSet集合
       LinkedHashSet集合：
        底层是一个哈希表(数组+链表/红黑树) + 链表：多了一条链表(记录元素的存储的顺序)，从而来保证元素的有序。
        具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，
        后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，
        即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。
 */
public class Demo05LinkedHashSet {

	public static void main(String[] args) {
		// 构建一个HashSet集合对象
		HashSet<String> hashSet = new HashSet<>();
		hashSet.add("www");
		hashSet.add("zhiyou100");
		hashSet.add("com");
		hashSet.add("abc");
		hashSet.add("abc");
		System.out.println(hashSet);// [com, abc, www, zhiyou100] 无序的 不重复的

		// 构建一个LinkedHashSet集合对象
		LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
		linkedHashSet.add("www");
		linkedHashSet.add("zhiyou100");
		linkedHashSet.add("com");
		linkedHashSet.add("abc");
		linkedHashSet.add("abc");
		linkedHashSet.add("java");
		linkedHashSet.add("python");
		// [www, zhiyou100, com, abc, java, python]
		System.out.println(linkedHashSet);// [www, zhiyou100, com, abc] 有序的，不重复的

	}

}

 

HashSet存储自定义类型的元素

一般需要重写对象当中的hashCode和equals方法，建立自己的比较方式。才能保证HashSet集合中元素的唯一性。

代码示例：

 @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        // 向下转型 类型判断
        if (o instanceof Student) {
            Student student = (Student)o;
            // 同名同年龄的人为同一个人 true
            return student.getName().equals(name) && student.getAge() == age;
        }
        return false;
    }
​
    @Override
    public int hashCode(){
         // 使用Objects类中的hash方法
        return Objects.hash(name,age);
    }

LinkedHashSet集合

我们知道HashSet保证元素的唯一，可是存进去的元素是没有顺序的，那么如何保证存进去的元素是有序的？

在java.util.HahSet类的下面还有一个子类java.util.LinkedHashSet,它是链表和哈希表的组合的一个数据存储结构。 代码示例：

    // 构建一个LinkedHashSet集合对象
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("www");
        linkedHashSet.add("zhiyou100");
        linkedHashSet.add("com");
        linkedHashSet.add("abc");
        linkedHashSet.add("abc");
        linkedHashSet.add("java");
        linkedHashSet.add("python");
        // [www, zhiyou100, com, abc, java, python]
        System.out.println(linkedHashSet);// [www, zhiyou100, com, abc] 有序的，不重复的

可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数的数据类型一致，那么我们可以简化成如下格式：

修饰符 返回值类型  方法名(参数类型... 形参名){
    //...
}

其实上面的格式完全等价于：

修饰符 返回值类型  方法名(参数类型[] 参数名){
    //....
}

只是后面的写法，在方法调用时，必须传递一个数组类型，而前者可以直接传递参数数据。

JDK1.5之后，出现的这种简化操作。"..."用在参数上，我们称之为可变参数。

同样是代表数组，但是在方法调用这个带有可变参数时，不用创建数组，而是直接将数组当中的元素作为实际参数进行传递，其实编译生成的class文件，本质是将这些元素封装到了一个数组当中，再进行数据传递，这些动作都在编译生成.class文件的时候，自动完成了。

  可变参数：是JDK1.5之后出现的新特性
       使用的前提：
            当方法的参数列表的数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
       可变参数的原理：
            可变参数底层是定义了一个数组，根据传递参数的个数不同，会创建不同长度的数组，来存储这些参数
            传递的参数个数，可以是0个(不传递)，1,2，...多个

public class DemoVarParameter {

    public static void main(String[] args) {
        // 实现一个功能：通过传递的参数来计算这些参数的和  int
        add(10,20);

    }
    /*
        可变参数的终极写法 不建议用
     */
    //public static void methodFinal(Object ... obj){}

    /*
        可变参数的注意事项：
                1. 一个方法的参数列表，只能有一个可变参数
                2. 如果方法的参数有多个，类型不止一种，那么可变参数必须写在参数列表的末尾位置
     */
    //public static void method01(int... a,String... str){}
    //public static void method02(String str, double[] num, int ... arr){}

    // 求和
    /*
        参数的个数可以是任意指定，可以是0个，1,2,3，。。。。n个
     */
    public static void add(int... arr) {
        //System.out.println(arr);// [I@1b6d3586 底层就是一个数组
        //System.out.println(arr.length);//0
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum); // 30

    }

}

代码示例：

 public static void add(int... arr) {
        //System.out.println(arr);// [I@1b6d3586 底层就是一个数组
        //System.out.println(arr.length);//0
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum); // 30
    }

备注：

可变参数的注意事项：
       1. 一个方法的参数列表，只能有一个可变参数
       2. 如果方法的参数有多个，类型不止一种，那么可变参数必须写在参数列表的末尾位置

Collections集合工具类

常用功能

• java.util.Collections是集合工具类，用来操作集合对象中的元素， 方法如下：

• public static <T> boolean addAll(Collection<? super T> c,T... elements)：往集合中一次性添加多个元素。

• public static <T> void shuffle(List<?> list)：打乱集合中的元素顺序。

• public static <T> void sort(List<T> list)：将集合中的元素按照默认规则排序。

• public static <T> void sort(List<T> list,Comparator<? super T> c)：将集合中的元素按照指定的规则进行排序。

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

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

    }

    // 重写排序规则
    @Override
    public int compareTo(Student o) {
        // return 0：代表的是两个元素相同
        // 自定义排序规则：按照年龄进行排序
        // this参数，o参数
        // this.getAge() - o.getAge()// 升序排序
        // o.getAge() - this.getAge() 降序排序
        System.out.println("========");
        System.out.println(o.getAge()-this.getAge());
        return o.getAge() - this.getAge();// 降序排序
    }
}

/*

        public static <T> boolean addAll(Collection<? super T> c,T... elements)：往集合中一次性添加多个元素。
        public static <T> void shuffle(List<?> list) 打乱集合中的元素顺序。
 */
public class Demo01Collections {

	public static void main(String[] args) {
		ArrayList<String> strs = new ArrayList<>();
		// 往集合当中存储元素
		/*
		 * strs.add("abc"); strs.add("小孙"); strs.add("小刘"); strs.add("小赵");
		 */

		// 使用一下Collections集合工具类中的addAll()
		// 所有通用的 Collection 实现类（通常通过它的一个子接口间接实现 Collection）
		Collections.addAll(strs, "abc", "小孙", "小刘", "小赵", "a", new String());
		System.out.println(strs);// [abc, 小孙, 小刘, 小赵]
		System.out.println("====================");

		// 打乱顺序 public static <T> void shuffle(List<?> list)
		Collections.shuffle(strs);
		System.out.println(strs);// [小刘, 123, 小赵, a, 小孙, abc]

	}

}

/*

    public static <T> void sort(List<T> list)：将集合中的元素按照默认规则排序。
    public static <T> void sort(List<T> list,Comparator<? super T> c)`：将集合中的元素按照指定的规则进行排序。

 */
public class Demo02Collections {

	public static void main(String[] args) {
		ArrayList<Integer> list01 = new ArrayList<>();
		list01.add(123);
		list01.add(127);
		list01.add(125);
		list01.add(126);
		System.out.println(list01);// [123, 127, 125, 126]
		System.out.println("==============================");

		// 使用集合工具类Collections中的sort方法
		Collections.sort(list01);
		System.out.println(list01);// [123, 125, 126, 127]
		System.out.println("==============================");

		ArrayList<String> list02 = new ArrayList<>();
		Collections.addAll(list02, "a", "c", "ab", "c", "d", "abc", "ac", "ba", "abcd");
		System.out.println(list02);// [a, c, ab, c, d]

		Collections.sort(list02);
		System.out.println(list02);
		System.out.println("---------------------------------------");

		ArrayList<Student> list03 = new ArrayList<>();
		list03.add(new Student("小孙", 20));
		list03.add(new Student("小王", 21));
		/*
		 * list03.add(new Student("小赵", 18)); list03.add(new Student("小周", 15));
		 */
		System.out.println(list03);
		Collections.sort(list03);
		System.out.println(list03);
		// Comparator

	}

}

代码演示：

Comparable类

Comparator类