06-集合框架

集合框架

一、Collection集合

集合：Java中提供的一种容器，用来存储多个数据。Collection是单列集合类的根接口。

集合和数组的区别:
1.数组的长度是固定。集合的长度是可变的。
2.数组中存储的是同一类型元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以
  不一致。

Collection常用功能

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迭代器

原理：

首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素：
在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾。
```
/*public E next() :返回迭代的下一个元素。
public boolean hasNext() :如果仍有元素可以迭代，则返回 true。*/

 //使用迭代器 遍历  每个集合对象都有自己的迭代器
    Iterator<String> it = collection.iterator();
    // 泛型指的是 迭代出 元素的数据类型
    while(it.hasNext()){ //判断是否有迭代元素
      String s = it.next();//获取迭代出的元素
      System.out.println(s);
    }
```
增强for

增强for循环，专门用来遍历数组和集合的，内部原理其实是Iterator迭代器。
```
for(元素的数据类型  变量 : Collection集合or数组){
    //写操作代码
}
```

二、泛型

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

设计原则:只要在编译时期没有处出现警告，则运行时期就不会出现ClassCastExpection异常。

ArrayList<E>中的E称为类型参数变量 
ArrayList<Integer>中的Integer称为实际类型参数 
整个称为ArrayList<E>泛型类型
整个ArrayList<Integer>称为参数化的类型ParameterizedType

为什么需要泛型

早期Java是使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全

首先，我们来试想一下：没有泛型，集合会怎么样
- Collection、Map集合对元素的类型是没有任何限制的。本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，是没有任何语法错误的。
- 把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。外边获取该对象，还需要强制转换
有了泛型以后：
- 代码更加简洁【不用强制转换】
- 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
- 可读性和稳定性【在编写集合的时候，就限定了类型】

泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来

/*
    1:把泛型定义在类上
    2:类型变量定义在类上,方法中也可以使用
 */
public class ObjectTool<T> {
    private T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

泛型方法

泛型方法，泛型是先定义后使用的，用户传递进来的是什么类型，返回值就是什么类型了。

 //定义泛型方法..
    public <T> void show(T t) {
        System.out.println(t);
    }

   public static void main(String[] args) {
        //创建对象
        ObjectTool tool = new ObjectTool();
        //调用方法,传入的参数是什么类型,返回值就是什么类型
        tool.show("hello");
        tool.show(12);
        tool.show(12.5);
    }

类型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

基本使用：

public static void main(String[] args) {
  Collection<Intger> list1 = new ArrayList<Integer>();
  getElement(list1);
  Collection<String> list2 = new ArrayList<String>();
  getElement(list2);
}
//？代表可以接收任意类型
public static void getElement(Collection<?> coll){}

受限泛型：

之前设置泛型的时候，实际上是可以任意设置类的，但是在JAVA的泛型中可以指定一个泛型的上线和下限。

泛型的上限：

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

泛型的下限：

格式：类型名称 <? super 类 > 对象名称

意义：只能接收该类型及其父类型

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>();
 
  getElement(list1);
  getElement(list2);//报错
  getElement(list3);
  getElement(list4);//报错

  getElement2(list1);//报错
  getElement2(list2);//报错
  getElement2(list3);
  getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

三、数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树

栈

栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。先进先出（存进去的元素，要在它后面的元素依次取出后，才能取出该元素）

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

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

队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。先进先出（存进去的元素，要在它前面的元素依次取出后，才能取出该元素）
数组

数组：Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。查找元素快：通过索引，可以快速访问指定位置的元素。增删元素慢：增加元素时需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置；删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。
链表

链表（单向链表）：linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。多个结点之间，通过地址进行连接。查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素；增删元素快：只需要修改连接下个元素的地址。（双向链表除了有一个指向下一结点的指针外，还有一个指向前一结点的指针，可以通过prev()快速找到前一结点，顾名思义，单链表只能单向读取而双向链表可双向读取。【从存储结构来看，每个双链表的节点要比单链表的节点多一个指针，而长度为n就需要 n*length（这个指针的length在32位系统中是4字节，在64位系统中是8个字节）的空间，这在一些追求时间效率不高应用下并不适应，因为它占用空间大于单链表所占用的空间；这时设计者就会采用以时间换空间的做法，这时一种工程总体上的衡量。https://blog.csdn.net/kangxidagege/article/details/80211225】）
红黑树

二叉树：binary tree ,是每个结点不超过2的有序树（tree）。二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。红黑树：红黑树本身就是二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。特点：速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍
- 红黑树的约束：
  1. 节点可以是红色的或者黑色的
  2. 根节点是黑色的
  3. 叶子节点(特指空节点)是黑色的
  4. 每个红色节点的子节点都是黑色的
  5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

三、List集合

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

List特点：
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

常用方法：

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的子类：

ArrayList集合

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

LinkedList集合

java.util.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。

四、Set集合

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

Set集合存储元素不重复的原理：

HashSet集合

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
- HashSet集合存储数据的结构（哈希表）
  
  哈希表：JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。
  
  HashSet存储流程：
- HashSet存储自定义类型元素
  
  给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。
LinkedHashSet集合

HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序可以使用在HashSet下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。

五、Collections类和Comparator比较器

Collections

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

public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按照指定规则排序。

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

Comparator比较器

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

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        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 接口完成。

Comparator接口public static <T> void sort(List<T> list，Comparator<? super T> )位于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<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) ‐ o1.charAt(0);
            }
        });
        System.out.println(list); //[sba, nba, cba, aba]
    }
}

Comparable和Comparator的区别

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

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

使用Comparator 比较器

/**
 * 年龄比较器，根据年龄比较
  comparator是比较器，可以直接执行。采用了策略模式，一个实体对象根据需要设计可以设计多     个比较器。隔离性好，方便。
 */

public class AgeCompator implements Comparator<Student> {
@Override
public int compare(Student stu1, Student stu2) {
        return stu1.getAge() - stu2.getAge();
    }
}

public void compare() {
    List<Student> students = new ArrayList<>();
    Student stu1 = new Student();
    stu1.setScore(100);
    stu1.setAge(27);
    students.add(stu1);

    Student stu2 = new Student();
    stu2.setScore(56);
    stu2.setAge(29);
    students.add(stu2);

    Student stu3 = new Student();
    stu3.setScore(90);
    stu3.setAge(28);
    students.add(stu3);

    Collections.sort(students, new AgeCompator());

    for (Student stu : students) {
        System.out.println(stu.getAge());
    }
}

使用Comparable比较

//Student类
//comparable 通过比较实体对象来调用的。但是一个实体只能实现一个接口，所以扩展性不是很     好，跟类绑定了。
public class Student implements Comparable<Student>{
    private Integer age;
    private String name;
    private Integer score;

    @Override
    public int compareTo(Student stu) {
        return this.getAge() - stu.getAge();
    }
}

//比较的功能类
  public void compareable(){
    List<Student> students = new ArrayList<>();
    Student stu1 = new Student();
    stu1.setScore(100);
    stu1.setAge(27);
    students.add(stu1);

    Student stu2 = new Student();
    stu2.setScore(56);
    stu2.setAge(29);
    students.add(stu2);

    Student stu3 = new Student();
    stu3.setScore(90);
    stu3.setAge(28);
    students.add(stu3);

    //在Collections的sort方法这种方式，最后通过student类对象调用了comparable方法。
    Collections.sort(students);

    for (Student stu : students) {
        System.out.println(stu.getAge());
    }
}

六、Map集合

Map集合与Collection集合的区别：

Collection中的集合称为单列集合， Map 中的集合称为双列集合。Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式储。Map中的集合，元素是成对存在的(key-value)。每个元素由键与值两部分组成，通过键可以找对所对应的值。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map常用方法

public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。
public V remove(Object key)：把指定的键所对应的键值在Map集合中删除，返回被删除元素的值。
public V get(Object key)： 根据指定的键，在Map集合中获取对应的值。
public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

Entry键值对对象

Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在 Map 中是一一对应关
系，这一对对象又称做 Map 中的一个 Entry( 项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：
public K getKey() ：获取Entry对象中的键。
public V getValue() ：获取Entry对象中的值。
在Map集合中也提供了获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

public class MapDemo02 {
    public static void main(String[] args) {
        // 创建Map集合对象
        HashMap<String, String> map = new HashMap<String,String>();
        // 添加元素到集合
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");
        // 获取 所有的 entry对象  entrySet
        Set<Entry<String,String>> entrySet = map.entrySet();
        // 遍历得到每一个entry对象
        for (Entry<String, String> entry : entrySet) {
           // 解析  
            String key = entry.getKey();
            String value = entry.getValue(); 
            System.out.println(key+"的CP是:"+value);
        //tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
        }
    }
}

Map集合遍历键找值：

Map集合遍历键值对象找值方式:

HashMap和LinkedHashMap

Map接口描述，主要有HashMap集合、LinkedHashMap集合。
HashMap ：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap ：HashMap的子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的
hashCode()方法、equals()方法。
tips：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。

七、补充知识

在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。实例化集合，几个 add方法
调用，使得代码重复。Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

public class HelloJDK9 { 
    public static void main(String[] args) { 
        Set<String> str1=Set.of("a","b","c"); 
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合 
        System.out.println(str1); 
        Map<String,Integer> str2=Map.of("a",1,"b",2); 
        System.out.println(str2); 
        List<String> str3=List.of("a","b"); 
        System.out.println(str3); 
    } 
}public class HelloJDK9 { 
    public static void main(String[] args) { 
        Set<String> str1=Set.of("a","b","c"); 
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合 
        System.out.println(str1); 
        Map<String,Integer> str2=Map.of("a",1,"b",2); 
        System.out.println(str2); 
        List<String> str3=List.of("a","b"); 
        System.out.println(str3); 
    } 
}
/**
*需要注意以下两点：
*1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如
*  HashSet，ArrayList等待；
*2:返回的集合是不可变的；
*/

来源：https://www.cnblogs.com/dongdedong/p/11964527.html

标签

泛型