day10【单列集合、泛型】

妖狐艹你老母 2022-09-02 12:51 287阅读 0赞

# day10【单列集合、泛型】 #

# 一、List集合 #

## 1.1 List集合概述 ##

List接口是单列集合的一个重要分支，下面主要有两个实现 `ArrayList`和`LinkedList`，List类型接口的特点是存储的元素是有序的，即存放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组；

List接口特点：

1.  List接口存储的数据是有序排列的，原来存储的时候是什么顺序，取出来就什么顺序（Set接口存储的是无序的）；
2.  List接口为存储的每一个元素都分配了一个索引，通过索引我们可以精确的来访问某一个指定的元素；
3.  List接口存储的数据允许存在重复，这与Set接口不同（Set接口不允许存储相同的元素）；

## 1.2 List接口常用方法 ##

List是Collection的子接口，因此Collection中存在的方法List都存在；因为List的特点是存在索引，因此除此之外List还添加了许多与索引相关的方法；

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

使用示例：

package com.dfbz.demo01;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            // 创建List集合对象
            List cities = new ArrayList<String>();
    
            cities.add("济南");         // 索引: 0
            cities.add("石家庄");        // 索引: 1
            cities.add("昆明");         // 索引: 2
    
            System.out.println(cities);     // [济南, 石家庄, 昆明]
            cities.add(1, "福州");      		// 原来的元素往后推
    
            System.out.println(cities);         // [济南, 福州, 石家庄, 昆明]
    
            // 删除索引位置为2的元素,返回被删除元素
            System.out.println(cities.remove(2));           // 石家庄
    
            System.out.println(cities);            // [济南, 福州, 昆明]
    
            // 在指定位置 进行 元素替代（改）
            cities.set(0, "银川");
            System.out.println(cities);             // [银川, 福州, 昆明]
    
            // 获取指定位置元素
            System.out.println(cities.get(0));      // 银川
    
            System.out.println("---------");
            // 跟size() 方法一起用 来 遍历的
            for (int i = 0; i < cities.size(); i++) { 
                System.out.println(cities.get(i));
            }
    
            System.out.println("---------");
            //还可以使用增强for
            for (Object city : cities) { 
                System.out.println(city);
            }
        }
    }

## 1.3 ArrayList 集合 ##

ArrayList底层采用**数组**这种数据结构来实现的；因此ArrayList元素查询速度快、增删相对较慢；我们在开发过程中，数据一般都是"读多写少"，因此ArrayList非常常用；

> ArrayList的方法之前我们都使用过了，这里就不再练习了；

## 1.4 LinkedList 集合 ##

### 1.4.1 LinkedList概述 ###

LinkedList底层采用链表这种数据结构来实现的，因此增删速度较快，查询速度较慢；

> LinkedList底层是一个双向链表，对比与单向链表多了一个指针指向上一个元素；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

### 1.4.2 LinkedList常用方法 ###

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

*  `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集合也可以作为栈、队列的结构使用。

使用示例1：链表方法

package com.dfbz.demo01;
    
    import java.util.LinkedList;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
            LinkedList cities = new LinkedList<String>();
    
            // 添加元素到头部
            cities.addFirst("广西");      // cities: [广西]
            cities.addFirst("陕西");      // cities: [陕西, 广西]
            cities.addFirst("山西");      // cities: [山西, 陕西, 广西]
            cities.addFirst("江西");      // cities: [江西, 山西, 陕西, 广西]
    
            System.out.println(cities);                 // [江西, 山西, 陕西, 广西]
    
            // 获取链表头部元素
            System.out.println(cities.getFirst());      // 江西
    
            // 获取链表尾部元素
            System.out.println(cities.getLast());       // 广西
    
            // 删除链表头部元素并返回
            System.out.println(cities.removeFirst());   // 江西
    
            // 删除链表尾部元素并返回
            System.out.println(cities.removeLast());   // 广西
    
            System.out.println(cities);                 // [山西, 陕西]
        }
    }

使用示例2：栈相关方法

*  `public void push(E e)`：将元素推入此列表所表示的堆栈（栈顶），类似于addFirst()。

*  `public E pop()`：从此列表所表示的堆栈（栈顶）处弹出一个元素，类似于removeFirst()。

package com.dfbz.demo01;
    
    import java.util.LinkedList;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) { 
    
            LinkedList cities = new LinkedList<String>();
    
            // 将元素添加到栈顶
            cities.push("南京");      // cities: [南京]
            cities.push("南宁");      // cities: [南宁, 南京]
            cities.push("南昌");      // cities: [南昌, 南宁, 南京]
    
            System.out.println(cities);                 // [南昌, 南宁, 南京]
    
            // 从栈顶弹出一个元素并返回
            System.out.println(cities.pop());       // 南昌
            System.out.println(cities.pop());       // 南宁
    
            System.out.println(cities);             // [南京]
        }
    }

使用示例3：队列相关方法

*  `public boolean offer(E e)`：将元素添加到队列尾部，类似于addLast()。
 *  `public boolean offerFirst(E e)`：将元素添加到队列头部，类似于addFirst()。
 *  `public boolean offerLast(E e)`：将元素添加到队列尾部，类似于addLast()。

package com.dfbz.demo01;
    
    import java.util.LinkedList;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) { 
    
            LinkedList cities = new LinkedList<String>();
    
            // 将元素添加到队列尾部
            cities.offer("西宁");      // cities: [西宁]
            cities.offer("兰州");      // cities: [西宁, 兰州]
            cities.offer("银川");      // cities: [西宁, 兰州, 银川]
    
            System.out.println(cities);                 // [西宁, 兰州, 银川]
    
            // 将元素添加到队列头部
            cities.offerFirst("成都");      // [成都, 西宁, 兰州, 银川]
    
            // 将元素添加到队列尾部
            cities.offerLast("贵阳");
            System.out.println(cities);       // [成都, 西宁, 兰州, 银川, 贵阳]
    
        }
    }

# 二、Set集合 #

## 2.1 Set集合概述 ##

Set接口和List接口一样，继承与Collection接口，也是一个单列集合；Set集合中的方法和Collection基本一致；并没有对`Collection`接口进行功能上的扩充，只是底层实现的方式不同了（采用的数据结构不一样）；

## 2.2 HashSet 集合 ##

### 2.2.1 HashSet数据结构 ###

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

HashSet底层数据结构在JDK8做了一次重大升级，**JDK8之前采用的是Hsah表，也就是数组+链表来实现；到了JDK8之后采用数据+链表+红黑树来实现；**

> 关于红黑树：我们暂时理解为红黑树就是一颗平衡的二叉树（即使他不是绝对平衡）；

我们知道hash表数据结构的特点是：根据元素（key）的hash值计算存储的位置，当hash值计算的槽位在同一个时，那么会导致同一个槽位存储的元素过多，会导致查询速度降低；

如图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

上述图中是一个hash表数据结构（数组+链表），也是JDK8之前的HashSet底层存储结构；

当存储的元素越来越多，hash也越来越多时，势必造成链表长度非常长，查找元素时性能会变得很低；在JDK8中当链表长度大于指定阈值8，并且数组容量达到了64时，将链表转换为红黑树，这样大大降低了查询的时间；

如图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

### 2.2.2 HashSet去重原理 ###

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

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解：

package com.dfbz.demo01;
    
    import java.util.HashSet;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            //创建 Set集合
            HashSet set = new HashSet<String>();
    
            //添加元素
            set.add(new String("河北"));
            set.add("湖北");
            set.add("河北");
            set.add("湖北");
    
            //遍历
            for (Object name : set) { 
                System.out.println(name);
            }
        }
    }

运行结果：

河北
    湖北

我们存储了两遍的"河北"、“湖北”，发现HashSet中只存储了一遍；

*  分析：

HashSet在存储元素时，都会调用对象的hashCode()方法计算该对象的hash值，如果hash值与集合中的其他元素一样，则调用equals方法对冲突的元素进行对比，如果equals方法返回true，说明两个对象是一致的，HashSet并不会存储该对象，反之则存储该元素；

**一般情况下**，不同对象的hash值计算出来的结果是不一样的，但还是有某些情况下，同一个对象的hash值计算成了同一个，这种情况我们称为**hash冲突**；当hash冲突时，HashSet会调用equals方法进行对比，默认情况下equals方法对比的是对象内存地址值，因此如果对象不是同一个，equals返回的都是false；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

一般情况下不同的对象的hashCode都是不一样的：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
    
            System.out.println("hello".hashCode());         // 99162322
            System.out.println("hello world".hashCode());   // 1794106052
            System.out.println("abc".hashCode());           // 96354
            System.out.println("ABC".hashCode());           // 64578
        }
    }

如果将上述几个字符串存储到HashSet中，仅通过hashCode就可以判断这几个对象应该存储，就不需要调用equals方法进行对比了，效率高；

> tips：做一次hash算法的运行远比`==`去对对比内存地址值要快得多；

但hashCode也有冲突的时候，如：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
    
            System.out.println("Aa".hashCode()); // 2112
            System.out.println("BB".hashCode()); // 2112
        }
    }

如果将上述字符串对象存储到HashSet中，HashSet是能够存储上面两个字符串的，因为hashCode相同时，还会调用equals方法进行对比，而"Aa".equals(“BB”)肯定返回的是false；因此即使上面两个hashCode一致，HashSet还是会存储两个字符串；

### 2.2.3 HashSet存储测试 ###

我们已经了解到，HashSet的去重原理是依靠对象的hashCode和equals方法来决定是否要存储这个对象的；如果不同的两个对象其hashCode是不同的，即使hash冲突了，equals也不可能相同；

但是在实际开发中，地址值并不是我们用来判断两个对象是否相等的依据，我们的习惯是，对象中的属性相等即判断两个对象是同一个对象；

*  定义一个Person类：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Person { 
    
        private String name;
        private Integer age;
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Person() { 
        }
    
        public Person(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    }

*  测试类：

package com.dfbz.demo01;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
            Set persons = new HashSet<>();
    
            persons.add(new Person("小灰", 20));
            persons.add(new Person("小灰", 20));
    
            System.out.println(persons.size());         // 2
        }
    }

我们在实际开发中，即使new了两个对象，但是里面的属性是完全一样的，我们就认为两个对象是同一个对象，HashSet应该帮我们去除这样的重复对象；

我们可以重写hashCode和equals方法：

@Override
    public boolean equals(Object o) { 
    
        System.out.println("equals执行了...");
        // 为了测试,这样固定死是毫无意义的
        return false;
    }
    
    @Override
    public int hashCode() { 
        
        System.out.println("hashCode执行了...");
        // 为了测试,这样固定死是毫无意义的
        return 1;
    }

测试代码：

package com.dfbz.demo01;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
    
            Set persons = new HashSet<>();
    
            persons.add(new Person("小灰", 20));
            persons.add(new Person("小蓝", 18));
    
            System.out.println(persons.size());         // 1
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

分析：

1）存储第一个Person对象时，调用这个Person对象的hashCode方法得出：1，并将其存储起来

2）存储第二个Person对象时，调用这个Person对象的hashCode方法得出：1，发现集合中已经有了hashCode为1的对象，因此调用Person对象的equals方法，将冲突了的Person对象传入（第一次添加的那个Person对象），然后equals方法返回的是true，因此不存这个Person对象（第二个Person对象），最终persons.size()为1；

真正的hashCode与equals的方法内部逻辑应该是：相同属性的对象的hashCode应该是一样的，也就是说hashCode应该根据对象属性来计算，并且equals对比的应该是对象属性的值；

使用idea快捷键：`alt+insert`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

一直回车，生成hashCode和equals方法：

@Override
    public boolean equals(Object o) { 
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }
    
    @Override
    public int hashCode() { 
        return Objects.hash(name, age);
    }

此时再执行测试类：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

将Person属性都改为一样的：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

## 2.3 TreeSet 集合 ##

### 2.3.1 TreeSet 简介 ###

与HashSet一样，TreeSet存储的元素也是无序，并且唯一；存储的元素虽然是无序的，但TreeSet可以根据排序规则对存储的元素进行排序，可以对集合中的元素提供排序功能；需要注意的是TreeSet存储的元素必须实现了`Comparable`接口，否则将抛出`ClasscastException`

TreeSet的特点：

1.  TreeSet每存储一个元素都会将该元素提升为Comparable类型，如果元素未实现Comparable接口，则抛出`ClasscastException`异常；
2.  存储的数据是无序的，即存取顺序不一致，但TreeSet提供排序功能；
3.  存储的元素不再是唯一，具体结果根据compareTo方法来决定；

### 2.3.2 Comparable接口 ###

Comparable接口是一个比较器，通过其compareTo方法进行两个对象的比较，具体比较的内容、规则等可以由开发人员来决定，compare方法的返回值有3类；

TreeSet底层依赖平衡二叉树算法，TreeSet得到CompareTo方法三类不同的值的含义如下：

*  1）正数：返回正数代表存储在树的右边
 *  2）负数：存储在树的左边
 *  3）0：不存储这个元素

public interface Comparable<T> { 
        public int compareTo(T o);
    }

### 2.3.3 TreeSet使用 ###

TreeSet存储的元素默认按照字典顺序进行排序；

package com.dfbz.demo02;
    
    import java.util.Set;
    import java.util.TreeSet;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        public static void main(String[] args) { 
            Set set=new TreeSet();
    
            set.add("b");
            set.add("a");
            set.add("c");
            set.add("d");
            set.add("e");
    
            // 默认按照字典顺序进行排序
            System.out.println(set);            // [a, b, c, d, e] 
        }
    }

String类是重写了Compable接口的，因此可以被存储到TreeSet集合中：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

使用TreeSet存储自定义对象：

*  定义一个Person对象：

package com.dfbz.demo02;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Person { 
    
        private String name;
        private Integer age;
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Person() { 
        }
    
        public Person(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    }

测试类：

package com.dfbz.demo02;
    
    import java.util.Set;
    import java.util.TreeSet;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
    
        public static void main(String[] args) { 
            Set set=new TreeSet();
    
            set.add(new Person("小灰",20));
            set.add(new Person("小蓝",18));
            set.add(new Person("小刘",16));
            set.add(new Person("小静",22));
    
            System.out.println(set);
        }
    }

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

TreeSet在存储元素时会将元素提升为Comparable类型，然后调用compareTo方法进行比较；如果元素没有实现Comparable接口，则提升为Comparable类型时肯定会出现类型转换异常；

实现Compareable接口：

public class Person implements Comparable { 
    
        private String name;
        private Integer age;
    
        @Override
        public int compareTo(Object o) { 
    
            Person person = (Person) o;
    
            return this.getAge() - person.getAge();
        }
        
        // get/set/toString...
    }

### 2.3.4 TreeSet存储原理 ###

TreeSet底层采用**平衡二叉树**算法来存储元素的，根据compareTo方法的返回值来确定存储在左子树还是右子树；

**0）小灰存入到TreeSet集合；**

**1）小灰传递小灰调用compareTo方法；结果为0，不存储此次的小灰（因为已经存储过一次了）**

> this：小灰；传递进来的对象：小灰

**2）存储小蓝时，使用小蓝调用CompareTo方法，并将根元素（小灰）当做参数传递给compareTo方法，结果为-2，将小蓝存储在左子树；**

> this：小蓝；传递进来的对象：小灰；

**3）存储小刘时，使用小刘调用CompareTo方法，并将根元素（小灰）当做参数传递给compareTo方法，结果为-4，将小刘存储在左子树；**

> this：小刘；传递进来的对象：小灰；

**4）又跟小蓝比较，使用小刘调用compareTo方法，把小蓝当做参数传递给compareTo方法，结果为-2，存储在小蓝的左子树节点；此时树已经不再平衡，需要调整为平衡二叉树；**

> this：小刘；传递进来的对象：小蓝；

**5）存储小静时，使用小静调用compareTo方法，将根元素（此时根元素是小蓝）当做参数传递给compareTo方法，结果为4，存储在小蓝的右子数；**

> this：小静；传递进来的对象：小蓝；

**6）又跟小灰比较，使用小静调用compareTo方法，把小灰当做参数传递给compareTo，结果为2，存储在小灰的右子树；**

> this：小静；传递进来的对象：小灰；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

在compareTo方法打印比较内容：

@Override
    public int compareTo(Object o) { 
    
        System.out.println("this: " + this + "-----------" + "传递进来的对象: " + o);
        Person person = (Person) o;
    
        return this.getAge() - person.getAge();
    }

> 口诀：
> 
>  *  正序（从小到大）：this-传递的对象
>  *  倒序（从大到小）：传递的对象-this

运行测试类，结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

> 树的读取结果是从左往右读取，因此排序顺序是：（小刘，16）、（小蓝，18）、（小灰，20）、（小静，22）；

运行上述案例，查看运行结果：

package com.dfbz.demo02;
    
    import java.util.Iterator;
    import java.util.Set;
    import java.util.TreeSet;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
    
        public static void main(String[] args) { 
            Set set = new TreeSet();
    
            set.add(new Person("小灰", 20));
            set.add(new Person("小蓝", 18));
            set.add(new Person("小刘", 16));
            set.add(new Person("小静", 22));
    
            // 获取迭代器(Set接口也是继承与Collection接口,因此也有iterator方法)
            Iterator iterator = set.iterator();
    
            // 遍历结果集
            while (iterator.hasNext()) { 
                Person person = (Person) iterator.next();
                System.out.println(person);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

## 2.4 LinkendHashSet 集合 ##

### 2.4.1 LinkedHashSet 概述 ###

LinkedHash继承与HashSet，和HashSet一样，同样是根据元素的hashCode值来决定元素的存储位置，其底层和HashSet所采用的数据结构是一致的；

与HashSet不同的是，\*\*LinkedHsahSet底层新增了一个双向链表来保存节点的访问顺序，因此LinkedHashSet存储的元素是有序的；\*\*当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。LinkedHashSet在迭代访问Set中的全部元素时，性能比HashSet好，但是插入时性能稍微弱于HashSet。

### 2.4.2 LinkedHashSet使用 ###

示例代码：

package com.dfbz.demo03;
    
    import java.util.LinkedHashSet;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
    
            Set<String> cities = new LinkedHashSet<>();
            cities.add("云南");
            cities.add("湖南");
            cities.add("河南");
            cities.add("云南");
            cities.add("湖南");
            System.out.println(cities);         // [云南, 湖南, 河南]
        }
    }

> 特点：存取有序且去重；

# 三、泛型 #

## 3.1 泛型概述 ##

泛型：**把类型明确的工作延迟到创建对象或调用方法的时候才去明确的特殊的类型；**

例如，我们知道集合是可以存储任意元素的，那么这样一想，add方法上的参数应该是Object（所有类的父类），但是这样会引入一个新的问题，我们知道，子类都是比父类强大的，我们在使用的时候肯定是希望获取的是当初存进去的具体子类对象；因此我们每次都需要进行强制转换；

但add方法真的是Object吗？

查看ArrayList的add方法：

class ArrayList<E>{  
        public boolean add(E e){  }
    
        public E get(int index){  }
       	....
    }

Collection类：

public interface Collection<E> extends Iterable<E> { 
    }

上面的E就是泛型，集合的定义者也不知道我们需要存储什么元素到集合中，**具体的类型只能延迟到创建对象时来决定了**；

## 3.2 集合泛型的使用 ##

### 3.2.1 未使用泛型 ###

定义一个City对象：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class City { 
    
        private String name;                        // 名称
        private String shortName;                    // 简称
        private String location;                    // 所属区域
    
    
        public void intro() { 
            System.out.println("名称: " + name + ",简称: " + shortName + ",所属地区: " + location);
        }
    
        public City() { 
        }
    
        public City(String name, String shortName, String location) { 
            this.name = name;
            this.shortName = shortName;
            this.location = location;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getShortNme() { 
            return shortNme;
        }
    
        public void setShortName(String shortName) { 
            this.shortName = shortName;
        }
    
        public String getLocation() { 
            return location;
        }
    
        public void setLocation(String location) { 
            this.location = location;
        }
        
        @Override
        public String toString() { 
            return "City{" +
                    "name='" + name + '\'' +
                    ", shortName='" + shortName + '\'' +
                    ", location='" + location + '\'' +
                    '}';
        }
    }

测试类：

package com.dfbz.demo01;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
    
            Collection list = new ArrayList();
    
            // 往集合存储对象
            list.add(new City("台湾", "台","华东"));
            list.add(new City("澳门", "澳","华南"));
            list.add(new City("香港", "港","华南"));
            list.add(new City("河北", "冀","华北"));
    
            // 获取迭代器
            Iterator iterator = list.iterator();
    
            while (iterator.hasNext()) { 
    
                // 集合中的元素都被提升为Object对象了
                Object obj = iterator.next();
    
                // 强制转换为子类
                City city = (City) obj;
    
                // 调用子类特有的功能
                city.intro();
            }
        }
    }

我们没有给泛型进行明确的定义，对象存储到集合中都被提升为Object类型了，取出来时需要强制转换为具体子类，非常麻烦；

不仅如此，这样的代码还存在这隐藏的风险，集合中可以存储任意的对象，如果往集合中存储其他对象呢？

定义个Book对象：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Book { 
        private String name;
        private String price;
    
        public void detail() { 
            System.out.println("书名: " + name + ",价格: " + price);
        }
    
        public Book() { 
        }
    
        public Book(String name, String price) { 
            this.name = name;
            this.price = price;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getPrice() { 
            return price;
        }
    
        public void setPrice(String price) { 
            this.price = price;
        }
    }

测试类：

package com.dfbz.demo01;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
    
            Collection list = new ArrayList();
    
            // 添加几个城市
            list.add(new City("山西", "晋","华北"));
            list.add(new City("河南", "豫","华中"));
            list.add(new City("江西", "赣","华东"));
    
            // 添加几本书
            list.add(new Book("《史记》","司马迁"));
            list.add(new Book("《三国志》","陈寿"));
    
            // 获取迭代器
            Iterator iterator = list.iterator();
    
            while (iterator.hasNext()) { 
    
                // 集合中的元素都被提升为Object对象了
                Object obj = iterator.next();
    
                // 强制转换为子类
                City city = (City) obj;         // 不可以将Book转换为City(存在隐藏问题)
    
                // 调用子类特有的功能
                city.intro();
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

上述代码编译时是没有什么问题，但运行时出现了类型转换异常：`ClassCastException`；

### 3.2.2 使用泛型 ###

*  查看List源码：

public interface List<E> extends Collection<E> { 
        boolean add(E e);
       	....
    }

> 集合的定义者发现，无法在定义集合类时就确定该集合存储的具体类型，因此使用泛型进行占位，使用者创建集合时明确该泛型的类型；

*  指定泛型后：

class List<City>{  
        boolean add(City ctiy);
       	....
    }

> 在创建对象时指定泛型的类型，泛型一旦指定了具体的类型，原来泛型的占位符（E），都将变为此类型；

如何指定泛型类类型？

格式如下：

List<泛型的具体类型> list=new ArrayList();

测试类：

package com.dfbz.demo01;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Iterator;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) { 
    
            // 创建集合,并确定好泛型(存储的类型)
            List<City> list = new ArrayList();
    
            // 往集合存储对象
            list.add(new City("甘肃", "甘|陇","西北"));
            list.add(new City("陕西", "陕|秦","西北"));
            list.add(new City("贵州", "贵|黔","西南"));
            list.add(new City("云南", "云|滇","西南"));
            list.add(new City("四川", "川|蜀","西南"));
    
            // 获取City类型的迭代器
            Iterator<City> iterator = list.iterator();
    
            while (iterator.hasNext()){ 
    
                // 直接获取City类型
                City city = iterator.next();
        
                city.intro();
            }
        }
    }

## 3.3 泛型类 ##

很明显，Collection、List、Set以及其下的子类都是泛型类，我们根据使用情况也可以定义泛型类；**让泛型类的类型延迟到创建对象的时候指定；**

*  使用格式：

修饰符 class 类名<代表泛型的变量> { }

例如，API中的List接口：

class List<E>{  
        boolean add(E e);
       	....
    }

**在创建对象的时候确定泛型**

例如，`List<String> list = new ArrayList<String>();`

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

public interface List<String> extends Collection<String> { 
         boolean add(String e);
         ...
    }

再例如，`ArrayList<Integer> list = new ArrayList<Integer>();`

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

public interface List<Integer> extends Collection<String> { 
         boolean add(Integer e);
         ...
    }

举例自定义泛型类：

package com.dfbz.demo02;
    
    public class GetClass<C> { 
    
        // 使用泛型类型,C具体的类型还不明确,等到GetClass对象时再明确C的类型
        private C c;
    
        public C getC() { 
            return c;
        }
    
        public void setC(C c) { 
            this.c = c;
        }
    }

使用:

package com.dfbz.demo02;
    
    import com.dfbz.demo01.City;
    
    public class Demo01 { 
    
        public static void main(String[] args) { 
    
            // 创建对象,并明确泛型类型为City
            GetClass<City> getClass = new GetClass<>();
    
            // setC(City city)
            getClass.setC(new City("新疆","新","西北"));
    
            // City getC()
            City city = getClass.getC();
    
            city.intro();
        }
    }

## 3.4 泛型方法 ##

泛型类是在创建类时定义泛型类型，在创建对象时确定泛型类型；

泛型方法则是在创建方法是定义泛型类型，在调用方法时确定泛型类型；

*  定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

例如：

package com.dfbz.demo03;
    
    public class GetClassMethod { 
    
        // 定义泛型方法
        public <C> C GetClass(C c){ 
            return c;
        }
    }

使用格式：**调用方法时，确定泛型的类型**

package com.dfbz.demo03;
    
    import com.dfbz.demo01.City;
    
    public class Demo01 { 
        public static void main(String[] args) { 
    
            GetClassMethod getClassMethod = new GetClassMethod();
    
            // City getClass(City city)
            City city = getClassMethod.GetClass(new City("西藏", "藏", "西北"));
    
            city.intro();
        }
    }

## 3.5 泛型类的继承 ##

定义一个父类，带有泛型：

public class 类名<泛型类型> {  }

例如，

package com.dfbz.demo04;
    
    public class Fu<E> { 
        public void show(E e) { 
            System.out.println(e.toString());
        }
    }

使用格式：

*  **1、定义类时确定泛型的类型**

例如

package com.dfbz.demo04;
    
    import com.dfbz.demo01.City;
    
    /** * 在定义子类时就确定好泛型的类型 */
    public class Zi1 extends Fu<City> { 
    
        @Override
        public void show(City city) { 
            super.show(city);
        }
    }

此时，泛型E的值就是String类型。

*  **2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型**

例如

package com.dfbz.demo04;
    
    /** * 子类也变为泛型类,泛型类型具体到创建对象的时候再确定 * @param <C> */
    public class Zi2<C> extends Fu<C> { 
    
        @Override
        public void show(C c) { 
            super.show(c);
        }
    }

确定泛型：

package com.dfbz.demo04;
    
    import com.dfbz.demo01.City;
    
    public class Demo01 { 
    
        public static void main(String[] args) { 
    
            // 注意: Zi1类以及不是一个泛型类了,不能够指定泛型
    // Zi1<Book> zi1=new Zi1(); // 报错
            
            // 创建子类时确定泛型类型
            Zi2<City> zi2=new Zi2<>();
            zi2.show(new City("青海","青","西北"));
        }
    }

## 3.4 泛型通配符 ##

当我们明确了泛型类型后，在进行方法传参时不仅要符合形参本身的类型，还要符合形参中泛型的类型；

例如：

public void show(List<String> list);

在调用show方法时，需要传递`List<String>`这样的类型，泛型必须要匹配为String，如果只是List接口类型，但泛型不是String那么也会造成编译失败；这样调用方法的局限性就很大了；泛型通配符正是来解决这一问题的；

### 3.4.1 通配符的使用 ###

泛型的通配符：**不知道使用什么类型来接收的时候，此时可以使用?，?表示未知通配符。**

*  示例：

package com.dfbz.demo05;
    
    import com.dfbz.demo01.City;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class Demo01 { 
        public static void main(String[] args) { 
            Collection<Integer> list1 = new ArrayList<Integer>();
            getElement(list1);
    
            Collection<String> list2 = new ArrayList<String>();
            getElement(list2);
            
            Collection<City> list3= new ArrayList();
            getElement(list3);
        }
    
        // ?代表可以接收任意类型
        public static void getElement(Collection<?> collection){ 
            // 被?通配符匹配后的类型都提升为Object类型了
            for (Object obj : collection) { 
                System.out.println(obj);
            }
        }
    }

> 需要注意的是，被<?>接收过的类型都将提升为Object类型；

### 3.4.2 泛型上下边界 ###

我们在指定泛型类时是可以任意设置的，只要是类就可以设置。但是在Java的泛型中可以指定一个泛型的**上限**和**下限**。

利用泛型的通配符可以指定泛型的边界；

**泛型的上限**：

*  **格式**： `类型名称 <? extends 类> 对象名称`
 *  **含义**： `只能接收该类型及其子类`

**泛型的下限**：

*  **格式**： `类型名称 <? super 类> 对象名称`
 *  **含义**： `只能接收该类型及其父类型`

Number类的继承体系：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]

可以看到基本数据类型的包装类都是继承与Number类；

*  测试泛型上下边界：

package com.dfbz.demo05;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class Demo02 { 
        public static void main(String[] args) { 
            Collection<Integer> list1 = new ArrayList<Integer>();
            Collection<String> list2 = new ArrayList<String>();
            Collection<Number> list3 = new ArrayList<Number>();
            Collection<Object> list4 = new ArrayList<Object>();
    
            getElement1(list1);     // Integer 是Number类型的子类
    // getElement1(list2); // 报错,String不是Number类型的子类
            getElement1(list3);     // Number类型可以传递
    // getElement1(list4); // 报错,Object不是Number类型的子类
    
    // getElement2(list1); // 报错,Integer不是Number类型的父类
    // getElement2(list2); // 报错,String不是Number类型的父类
            getElement2(list3);     // Number类型可以传递
            getElement2(list4);     // Object是Number类型的父类
        }
    
        // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
        public static void getElement1(Collection<? extends Number> coll) { 
        }
    
        // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
        public static void getElement2(Collection<? super Number> coll) { 
        }
    }

--------------------

**上一篇**：[day09【双列集合、异常】][day09]

**下一篇**：[day11【多线程、锁机制、lock锁】][day11_lock]

**目录**：【JavaSE零基础系列教程目录】

--------------------

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/84645650a042426eb31c57869dd5a29f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/d75b3b5296af4b67b5b5c162750b8021.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/771048e99ce24c1cb16225f8ea2a3701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/e5446ed7351f457d963f33e824975bc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/e82a1ef412f04ab4954f838b6d1116a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/a0b67b3eaa3b4d80909b9e44a0d343be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/1b1980f2add342fc8931352ea7986188.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/ed1a906a08864ffa8e19e77e88bfea6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/37e534d2a42b4b44b7d209f68d348468.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/5b6c0427c23c4211b0bc630e45137935.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/043f833dacc44ec2a418b1146f3f87c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/7b24a1e9e7b34eaea7a2783e41923c93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/fdea4db8547f494e84710f5c4ec728bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/abc336344cf14ddd8aacad285ee5a0ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/33cf43984cfb4a9192abb9547e970cf2.png
[day09]: https://blog.csdn.net/Bb15070047748/article/details/119348196?spm=1001.2014.3001.5501
[day11_lock]: https://blog.csdn.net/Bb15070047748/article/details/119350110?spm=1001.2014.3001.5501