集合【LinkedList、HashSet、Collection集合体系】

集合【LinkedList、HashSet、Collection集合体系】

第1章    数据结构

1.1    List集合存储数据的结构

List接口下有很多个集合，它们存储元素所采用的结构方式是不同的，这样就导致了这些集合有它们各自的特点，供给我们在不同的环境下进行使用。数据存储的常用结构有：堆栈、队列、数组、链表。我们分别来了解一下：

l  堆栈，采用该结构的集合，对元素的存取有如下的特点：

n  先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

n  栈的入口、出口的都是栈的顶端位置

n  压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

n  弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

l  队列，采用该结构的集合，对元素的存取有如下的特点：

n  先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。

n  队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

l  数组，采用该结构的集合，对元素的存取有如下的特点：

n  查找元素快：通过索引，可以快速访问指定位置的元素

n  增删元素慢：

u  指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

u  指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

l  链表，采用该结构的集合，对元素的存取有如下的特点：

n  多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

n  查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

n  增删元素快：

u  增加元素：操作如左图，只需要修改连接下个元素的地址即可。

u  删除元素：操作如右图，只需要修改连接下个元素的地址即可。

        

1.2     LinkedList集合

LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。如下图

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

方法演示：

        LinkedList<String>link = newLinkedList<String>();

        //添加元素

        link.addFirst("abc1");

        link.addFirst("abc2");

        link.addFirst("abc3");

        //获取元素

        System.out.println(link.getFirst());

        System.out.println(link.getLast());

        //删除元素

        System.out.println(link.removeFirst());

        System.out.println(link.removeLast());

       

        while(!link.isEmpty()){//判断集合是否为空

            System.out.println(link.pop());//弹出集合中的栈顶元素

       }

第2章     Set接口

查阅Set集合的API介绍，通过元素的equals方法，来判断是否为重复元素，它是个不包含重复元素的集合。Set集合取出元素的方式可以采用：迭代器、增强for。

Set集合有多个子类，这里我们介绍其中的HashSet、LinkedHashSet这两个集合。

2.1    HashSet集合介绍

查阅HashSet集合的API介绍：此类实现Set接口，由哈希表支持（实际上是一个 HashMap集合）。HashSet集合不能保证的迭代顺序与元素存储顺序相同。

HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。

2.2     HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

哈希表底层使用的也是数组机制，数组中也存放对象，而这些对象往数组中存放时的位置比较特殊，当需要把这些对象给数组中存放时，那么会根据这些对象的特有数据结合相应的算法，计算出这个对象在数组中的位置，然后把这个对象存放在数组中。而这样的数组就称为哈希数组，即就是哈希表。

当向哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法其实就是Object类中的hashCode方法。由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。

总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

2.3     HashSet存储JavaAPI中的类型元素

给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。

l  创建HashSet集合，存储String对象。

publicclass HashSetDemo {

    publicstaticvoidmain(String[] args) {

        //创建HashSet对象

        HashSet<String>hs = newHashSet<String>();

        //给集合中添加自定义对象

        hs.add("zhangsan");

        hs.add("lisi");

        hs.add("wangwu");

        hs.add("zhangsan");

        //取出集合中的每个元素

        Iterator<String>it = hs.iterator();

        while(it.hasNext()){

            Strings = it.next();

            System.out.println(s);

        }

    }

}

输出结果如下，说明集合中不能存储重复元素：

wangwu

lisi

zhangsan

2.4     HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

l  创建自定义对象Student

publicclass Student {

    private String name;

    privateintage;

    public Student(String name, int age) {

        super();

        this.name= name;

        this.age= age;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(String name) {

        this.name= name;

    }

    publicint getAge() {

        returnage;

    }

    publicvoid setAge(intage) {

        this.age= age;

    }

    @Override

    public String toString() {

        return"Student[name=" + name+ ", age=" + age + "]";

    }

    @Override

    publicint hashCode() {

        finalint prime = 31;

        int result = 1;

        result = prime * result + age;

        result = prime * result + ((name == null) ? 0 : name.hashCode());

        return result;

    }

    @Override

    publicboolean equals(Object obj) {

        if (this == obj)

            returntrue;

        if(!(obj instanceof Student)){

            System.out.println("类型错误");

            returnfalse;

        }

        Student other = (Student) obj;

        returnthis.age==  other.age&&this.name.equals(other.name);

    }

}

 

l  创建HashSet集合，存储Student对象。

publicclass HashSetDemo {

    publicstaticvoidmain(String[] args) {

        //创建HashSet对象

        HashSeths = newHashSet();

        //给集合中添加自定义对象

        hs.add(newStudent("zhangsan",21));

        hs.add(newStudent("lisi",22));

        hs.add(newStudent("wangwu",23));

        hs.add(newStudent("zhangsan",21));

        //取出集合中的每个元素

        Iteratorit = hs.iterator();

        while(it.hasNext()){

            Students = (Student)it.next();

            System.out.println(s);

        }

    }

}

输出结果如下，说明集合中不能存储重复元素：

Student[name=lisi, age=22]

Student[name=zhangsan, age=21]

Student[name=wangwu, age=23]

第3章    判断集合元素唯一的原理

3.1     ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时，传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。

3.2     HashSet的add/contains等方法判断元素是否重复原理

Set集合不能存放重复元素，其添加方法在添加时会判断是否有重复元素，有重复不添加，没重复则添加。

HashSet集合由于是无序的，其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下：

先判断新元素与集合内已经有的旧元素的HashCode值

l  如果不同，说明是不同元素，添加到集合。

l  如果相同，再判断equals比较结果。返回true则相同元素；返回false则不同元素，添加到集合。

所以，使用HashSet存储自定义类型，如果没有重写该类的hashCode与equals方法，则判断重复时，使用的是地址值，如果想通过内容比较元素是否相同，需要重写该元素类的hashcode与equals方法。

第4章    Collection总结

4.1     知识点总结

l  Collection:

    |- List 可以存储重复元素,有序的(元素存取顺序)

            |- ArrayList

               |- LinkedList

        |- Set 不能存储重复元素,无序的(元素存取顺序)

        |- HashSet

|- LinkedHashSet

l  Collection方法：

n  boolean add(Object e) 把给定的对象添加到当前集合中

n  void clear() 清空集合中所有的元素

n  boolean remove(Object o) 把给定的对象在当前集合中删除

n  boolean contains(Object o) 判断当前集合中是否包含给定的对象

n  boolean isEmpty() 判断当前集合是否为空

n  Iterator iterator() 迭代器，用来遍历集合中的元素的

n  int size() 返回集合中元素的个数

n  Object[] toArray() 把集合中的元素，存储到数组中

l  Iterator :  迭代器

n  Object next()返回迭代的下一个元素

n  boolean hasNext()如果仍有元素可以迭代，则返回 true。

l  List与Set集合的区别？

List:

                                   它是一个有序的集合(元素存与取的顺序相同)

                                   它可以存储重复的元素                          

                          Set:

                                   它是一个无序的集合(元素存与取的顺序可能不同)

                          它不能存储重复的元素

l  List集合中的特有方法

n  void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上

n  Object get(int index)返回集合中指定位置的元素。

n  Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素

n  Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

l  ArrayList:

         底层数据结构是数组，查询快，增删慢

         线程不安全，效率高

l  LinkedList:

         底层数据结构是链表，查询慢，增删快

         线程不安全，效率高

l  泛型： 用来约束数据的数据类型

n  泛型的格式：

                 <数据类型>

                 泛型可以使用在 类，接口，方法，变量上

n  泛型的好处

                 A:提高了程序的安全性

                 B:将运行期遇到的问题转移到了编译期

                 C:省去了类型强转的麻烦

l  增强for

         简化数组和Collection集合的遍历

                 格式：

                 for(元素数据类型 变量 : 数组或者Collection集合) {

                          使用变量即可，该变量就是元素

                 }

         好处：简化遍历

l  HashSet:

         元素唯一不能重复

         底层结构是 哈希表结构

         元素的存与取的顺序不能保证一致

         如何保证元素的唯一的？

                 重写hashCode() 与 equals()方法

l  LinkedHashSet:

         元素唯一不能重复

         底层结构是 哈希表结构 + 链表结构

         元素的存与取的顺序一致

 ======================================================================

01.集合_回顾_Java集合体系结构
Collection(接口):单列集合
|--List(接口):1.有序的；2.可以存储重复元素
|--ArrayList(子类):数组实现
|--LinkedList(子类):链表实现
|--Set(接口):1.无序的;2.不能存储重复元素
|--HashSet(子类):哈希表实现
|--LinkedHashSet(子类--有序):链表、哈希表实现
Map(接口):双列集合
02.集合_回顾_Collection接口的常用方法
1).boolean add(E e):将元素e添加到集合中。返回值：存储成功返回true(对于List集合基本都返回true)，存储失败返回false(对于Set集合如果存储重复元素返回false)
2).void clear() : 清空集合。
3).boolean contains(Object o) : 判断集合中是否包含元素o
4).boolean remove(Object o) : 在集合中移除元素o。如果有多个，只移除一个。
5).int size():获取集合大小。
6).Object[] toArray() : 将集合内的元素封装到一个Object[]数组中返回。将集合转换为数组。
7).Iterator<E> iterator():获取一个迭代器，用于遍历集合元素。
03.集合_Collection接口中contains方法判断元素重复的原理
Collection<String> strList = new ArrayList<>();
String s1 = new String("黄渤");
strList.add(s1);
String s2 = new String("黄渤");
System.out.println("集合中是否有黄渤：" + strList.contains(s2));//调用s2的equals()跟已经存储的每个元素依次比较，如果哪个返回true，说明找到。
04.集合_Collection存储自定义Person对象重写equals方法
1).定义Person类
2).在Person类中重写equals()方法
    Eclipse下-->shift + alt + s --> 松手 --> h --> 代码生成后可以去掉hashCode()方法    
---------------------------------------------------------------
05.集合_List集合特点_特有方法
1.特点：
1).有序的；
2).可以存储重复元素；
2.特有方法：
1).void add(int index, E element):在index位置上添加元素element。原index位置上的元素及其后续其它元素依次后移。
2).E get(int index) : 获取index位置上的元素：

Collection<String> strList = new ArrayList<>();
for(int i = 0;i < strList.size(); i++){
System.out.println(strList.get(i));//编译错误
}
3).ListIterator<E> listIterator():获取一个ListIterator迭代器；双向迭代器(Iterator--单向迭代器)
4).E remove(int index) : 移除index位置上的元素；区分Collection中的remove(Object obj)。
5).E set(int index,E element):将index位置上的元素替换为element。返回：被替换的元素。
6).List<E> subList(int fromIndex, int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图，原集合不变。
06.集合_Set集合特点
1).特点：
1).无序的；
2).不能存储重复元素
2).特有方法：
【无】全部继承自Collection
---------------------------------------------------------------
07.集合_数据结构_栈
1).特点：先进后出
08.集合_数据结构_队列
1).特点：先进先出
09.集合_数据结构_数组
1).特点：查询快(因为使用索引直接作为数组的索引)
         增删慢(因为要创建新数组，复制原数组的内容)
10.集合_数据结构_链表
1).特点：
查询慢(因为从第一个节点开始找)
增删快(仅指：增删两个操作本身，只需要赋值两个引用即可，但增删也是基于查询的)
---------------------------------------------------------------
11.集合_LinkedList的基本使用
1).作为普通的List集合使用：
LinkedList<String> strList = new LinkedList<>();
strList.add("黄渤");
strList.add("孙红雷");
strList.add("王宝强");
strList.add("黄磊");
for(String s : strList){
System.out.println(s);
}
12.集合_LinkedList模拟栈结构
1).栈的特点：先进后出
2).LinkedList的特有方法：
1).addFirst():将元素添加到链表的首位。
   addLast():将元素添加到链表的末尾；
2).getFirst():获取链表的第一个元素(但不删除)
   getLast():获取链表的最后一个元素(但不删除)
3).removeFirst():移除链表的第一个元素
   removeLast():移除链表的最后一个元素
4).pop():移除并返回此列表的第一个元素(可以实现弹栈)
5).push():压栈。将该元素插入此列表的开头
6).isEmpty():判断集合是否为空。
3).代码实现栈结构：
LinkedList<String> strList = new LinkedList<>();
strList.push("aaa");//压栈
strList.push("bbb");
strList.push("ccc");
System.out.println(strList);
while(!strList.isEmpty()){
System.out.println(strList.pop());
}
---------------------------------------------------------------
13.集合_HashSet的基本使用-存储字符串
Set<String> strSet = new HashSet<>();
strSet.add("aaa");
strSet.add("bbb");
strSet.add("ccc");
strSet.add("ddd");
strSet.add("ddd");//不存储
strSet.add("ddd");//不存储
for(String s : strSet){
System.out.println(s);//无序的
}
14.集合_HashSet存储自定义对象
Set<Student> stuSet = new HashSet<>();

stuSet.add(new Student(1.70,20));
stuSet.add(new Student(1.70,20));//重写hashCode()和equals()之后，不存储了。

System.out.println(stuSet.size());
for(Student stu : stuSet){
System.out.println(stu.height + "--" + stu.age);
}
15.集合_哈希表结构
16.集合_自定义对象重写equals方法和hashCode方法
怎样重写：Eclipse-->shift + alt + s -->松手 --> h (生成两个方法：hashCode()和equals())
17.集合_LinkedHashSet集合
1).LinkedHashSet:数据结构：链表 + 哈希表；
   链表：保证元素的顺序；
   哈希表：保证元素的唯一；
                 它是Set的特例，它是有序的Set
2).示例：
LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ccc");//不存储
for(String s : set){
System.out.println(s);//aaa,bbb,ccc(有序的)
}