2.Collection集合学习总结

Collection集合学习总结

第一章 Collection集合

集合**：集合是java中提供的一种容器，可以用来存储多个数据。(基本本质就是一工具，它存放在java.util包中。在Collection接口定义着单列集合框架中最最共性的内容。)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FR5TxgDv-1604249058047)(G:\ziliao\国家机密\day02\resource\01_集合框架介绍.bmp)]

​ 集合和数组的区别：

1.数组的长度是固定的，集合的长度是可以改变的。

2.数组中存储的都是同一类型的元素，可以存储基本的数据类型值。

集合的存储都是对象，而且对象的类型可以不一致。在开发中对象多的时候，使用集合来存储。

（Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象，jdk5之后新增泛型的语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。：可以在类或方法中预支地使用未知的类型。一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。）

​ 集合框架

JAVASE提供了满足各种需求的API，灵活使用的前提便是要了解其继承和接口操作结构，才能了解何时使用哪个类和类之间如何合作，达到灵活使用。

集合按照其存储结构又分为2大类，单列集合java.util.Collection和双列集合java.util.Map.

1.Collection:单列集合的根接口，用于存储符合某种规则的元素，有2个重要的子接口，java.util.List和jav.autil.Set.

List的特点是有序，元素可重复。List接口的主要实现类有ArryList和LinkedList

Set的特点是元素无序，且不可重复。Set接口的主要实现类有Hashet和TreeSet.

​ Collection 常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

*public boolean add(E e)`： 把给定的对象添加到当前集合中 。

*public void clear()` :清空集合中所有的元素。

*public boolean remove(E e): 把给定的对象在当前集合中删除。

*public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。

*public boolean isEmpty()`: 判断当前集合是否为空。

*public int size()`: 返回集合中元素的个数。

*public Object[] toArray()`: 把集合中的元素，存储到数组中。

第二章 Iterator迭代器

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

迭代：Collection 集合元素的获取方式，取元素之前要判断集合是否含有元素，如果有的话就取出来继续判断，一直把集合中的所有元素取出来，这种取出的方式被称为迭代。

Iterator接口的常用方法如下：

public E next();返回（获取）迭代的下一个元素

public boolen hasNext();判断是是否有下一个元素，有的话则返回true

public class IteratorDemo {
public static void main(String[] args) {
​ // 使用多态方式 创建对象
​ Collection coll = new ArrayList();

    // 添加元素到集合
    coll.add("串串星人");
    coll.add("吐槽星人");
    coll.add("汪星人");
    //遍历
    //使用迭代器 遍历   获取迭代器对象 每个集合对象都有自己的迭代器
    Iterator<String> it = coll.iterator();
    //  泛型指的是 迭代出 元素的数据类型
    while(it.hasNext()){ //判断是否有迭代元素
        String s = it.next();//获取迭代出的元素
        System.out.println(s);
    }
}

}

tips:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

2.2 迭代器的实现原理

我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

terator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示Iterator对象迭代元素的过程：

在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

2.3 增强for

强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

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

//写操作代码
}

*它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

第三章 泛型

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

public class GenericDemo {
​ public static void main(String[] args) {
​ Collection coll = new ArrayList();
​ coll.add(“abc”);
​ coll.add(“itcast”);
​ coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
​ Iterator it = coll.iterator();
​ while(it.hasNext()){
​ //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
​ String str = (String) it.next();
​ System.out.println(str.length());
​ }
​ }
}

程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？ Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预支地使用未知的类型。

tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

使用泛型的好处

上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？

• 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

• 避免了类型强转的麻烦。

• 泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

• public class GenericDemo2 {
  ​ public static void main(String[] args) {
  ​ Collection list = new ArrayList();
  ​ list.add(“abc”);
  ​ list.add(“itcast”);
  ​ // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
  ​ // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
  ​ Iterator it = list.iterator();
  ​ while(it.hasNext()){
  ​ String str = it.next();
  ​ //当使用Iterator控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
  ​ System.out.println(str.length());
  ​ }
  ​ }
  }

  第四章 List集合

  1.1 List接口介绍

  ​ java.util.list接口继承于Collection接口，是单列集合的一个重要分支，习惯性的把实现list接口的对象成为List集合，在List集合中可以出现重复的元素，所有的元素是以一种线性 方式进行存取的，在程序中通过索引来访问集合中的指定元素。另外一个特点就是元素有序，即元素的存入和取出都是顺序一致的。

  通过API总结List接口的特点：

  ​ 1.存取有序，

  ​ 2.跟数组一样是有索引的。通过索引的精确操作集合中的元素个人理解即增删改。(索引道理跟数组 一样)

  ​ 3.集合中可以拥有重复 元素，根据equals来比较是否为重复的元素。

  1.2 List接口中常用方法

  ​ List作为Conllection的子接口，不仅继承了其所有的方法，而且增加了一些根据元素索引来操作集合的特有方法。

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

  public E get(int index):返回集合中指定位置的元素。

  public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。

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

  第五章 List的子类

  3.1 ArrayList集合

  java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

  许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

  3.2 LinkedList集合

  java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

  LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzA9YOCV-1604249057806)(G:\ziliao\国家机密\day03\就业班-day03-List、Set、数据结构、Collections\img\双向链表.png)]

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而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集合也可以作为堆栈，队列的结构使用。（了解即可）

  方法演示：

  第四章 Set接口

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

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

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

  HashSet集合介绍

  HashSet是Set接口的一个实现类，存储的元素是不可以重复的，而且元素都不可以重复。而且是无序的（即存取的顺序是无序的）java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。

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

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

  哈希表

  JDK1.8以前哈希表底层采用数组+链表实现，即使使用链表处理冲突，同一哈希值的链表都存储到一个链表中，但是当位于一个桶中的元素较多的时候，即哈希值相同的元素比较多的时候，通过Key值依次查找 的效率比较低，jdk1.8以后哈希表的存储采用数组+链表+红黑树实现，链表长度超过阈值（8）时将链表结构转化为红黑树，这样大大减少了查找时间。

  简单来说哈希表是由数组、链表+红黑树(jdk1.8之后增加了红黑树部分)实现的。实现图

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9n8MhWu3-1604249057807)(G:\ziliao\国家机密\day03\就业班-day03-List、Set、数据结构、Collections\img\哈希表.png)]

存储流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qctc2iEo-1604249057810)(G:\ziliao\国家机密\day03\就业班-day03-List、Set、数据结构、Collections\img\哈希流程图.png)]

2.3 HashSet存储自定义类型元素（没理解）

​ shiro中元素去重时有应用到

Collection<String> perms=new HashSet<>();
for(SysPermission perm:permissions){
    perms.add(perm.getPermName());
}

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

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 boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || getClass() != o.getClass())
        return false;
    Student student = (Student) o;
    return age == student.age &&
           Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

}

public class HashSetDemo2 {
​ public static void main(String[] args) {
​ //创建集合对象 该集合中存储 Student类型对象
​ HashSet stuSet = new HashSet();
​ //存储
​ Student stu = new Student(“于谦”, 43);
​ stuSet.add(stu);
​ stuSet.add(new Student(“郭德纲”, 44));
​ stuSet.add(new Student(“于谦”, 43));
​ stuSet.add(new Student(“郭麒麟”, 23));
​ stuSet.add(stu);

    for (Student stu2 : stuSet) {
        System.out.println(stu2);
    }
}

}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

2.3 LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

演示代码如下:

public class LinkedHashSetDemo {
​ public static void main(String[] args) {
​ Set set = new LinkedHashSet();
​ set.add(“bbb”);
​ set.add(“aaa”);
​ set.add(“abc”);
​ set.add(“bbc”);
​ Iterator it = set.iterator();
​ while (it.hasNext()) {
​ System.out.println(it.next());
​ }
​ }
}
结果：
bbb
aaa
abc
bbc

1.9 可变参数

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

修饰符 返回值类型 方法名(参数

类型… 形参名){ }

其实这个书写完全等价与

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

第五章 Collections

2.1 常用功能

java.utils.Collections`是集合工具类，用来对集合进行操作。部分方法如下：

public static boolean addAll(Collection c, T… elements) `:往集合中添加一些元素。

public static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。

public static void sort(List list)`:将集合中元素按照默认规则排序。

public static void sort(List list，Comparator<? super T> )`:将集合中元素按照指定规则排序。

public class CollectionsDemo {
​ public static void main(String[] args) {
​ ArrayList list = new ArrayList();
​ //原来写法
​ //list.add(12);
​ //list.add(14);
​ //list.add(15);
​ //list.add(1000);
​ //采用工具类 完成 往集合中添加元素
​ Collections.addAll(list, 5, 222, 1，2);
​ System.out.println(list);
​ //排序方法
​ Collections.sort(list);
​ System.out.println(list);
​ }
}
结果：
[5, 222, 1, 2][1, 2, 5, 222]

我们发现还有个方法没有讲，`public static void sort(List list，Comparator<? super T>

将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

2.2 Comparator比较器

public static void sort(List list)`:将集合中元素按照默认规则排序。

不过这次存储的是字符串类型

public class CollectionsDemo2 {
​ public static void main(String[] args) {
​ ArrayList list = new ArrayList();
​ list.add(“cba”);
​ list.add(“aba”);
​ list.add(“sba”);
​ list.add(“nba”);
​ //排序方法
​ Collections.sort(list);
​ System.out.println(list);
​ }
}

[aba, cba, nba, sba]

我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成。

那么我们采用的public static <T> void sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

public final class String implements java.io.Serializable, Comparable, CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用

public static void sort(List list，Comparator<? super T> )`方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

public int compare(String o1, String o2)：比较其两个参数的顺序。

• 两个对象比较的结果有三种：大于，等于，小于。

  如果要按照升序排序，
  则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
  如果要按照降序排序
  则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

操作如下:

public class CollectionsDemo3 {
​ public static void main(String[] args) {
​ ArrayList list = new ArrayList();
​ list.add(“cba”);
​ list.add(“aba”);
​ list.add(“sba”);
​ list.add(“nba”);
​ //排序方法 按照第一个单词的降序
​ Collections.sort(list, new Comparator() {
​ @Override
​ public int compare(String o1, String o2) {
​ return o2.charAt(0) - o1.charAt(0);
​ }
​ });
​ System.out.println(list);
​ }
}

[sba, nba, cba, aba]

2.3 简述Comparable和Comparator两个接口的区别。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

*Comparator**强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

ntln(list);
​ }
}

[sba, nba, cba, aba]

2.3 简述Comparable和Comparator两个接口的区别。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

*Comparator**强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。