集合与泛型

泛型

泛型，就是限制数据的类型

• 泛型类

  • 把泛型定义在类上

  • 格式:public class 类名<泛型类型1,…>

    泛型类型必须是引用类型

• 泛型方法

  • 把泛型定义在方法上
  • 格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

• 泛型接口

  • 把泛型定义在接口上
  • 格式:public interface 接口名<泛型类型1…>

集合

集合分为两大类：Collection、Map。都是接口

Collection

功能【抽象方法】

• 添加、删除与包含

  • 针对单个元素
    • boolean add(E e)
    • boolean remove(Object o)
    • boolean contains(Object o)
  • 针对多个元素
    • boolean addAll(Collection c)：添加一个集合进入到另一个集合，使两个集合的元素进行合并
    • boolean removeAll(Collection c)：删除另一个集合与自身相同的元素
    • boolean containsAll(Collection c)：要完整包含另一个集合才返回true

• 清空集合

  • void clear()

• 判断集合是否为空

  • boolean isEmpty()

• 获取集合的元素个数【集合的长度】

  • int size()

• 求集合的交集

  • boolean retainAll(Collection c)：求与指定的集合共有的元素

    注意：使用Arrays.asList()创建的集合不可以改变长度，换句话说，只能查询，不能修改

集合的遍历

集合的遍历有三种方式：转数组、迭代器、增强for循环

遍历集合

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class exer5 {
    public static void main(String[] args) {
        ArrayList<Integer> arr1 = new ArrayList<>();
        arr1.add(1);
        arr1.add(2);
        arr1.add(3);
        arr1.add(4);
        arr1.add(5);
        // 使用转数组的方式遍历
        Object[] array1 = arr1.toArray();
        System.out.println(Arrays.toString(array1));
        // 使用迭代器的方式遍历
        Iterator<Integer> iterator = arr1.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + "\t");
        }
        System.out.println();
        // 使用增强for循环遍历
        for (Integer i : arr1) {
            System.out.print(i + "\t");
        }
    }
}

转换成数组的形式，获取的数组元素类型是Object，所以要想获取元素本身的特有方法或者属性，要进行向下转型

Collection分类

Collection有分为两大类：List、Set

List

List特有的方法

• 通过索引添加元素：void add(int index,E element)

• 通过索引获取元素：E get(int index)

• 通过索引修改元素：E set(int index,E element)

• 专属于List的迭代器：ListIterator listIterator()：

  特点：游标会随之更改，因此可以用迭代器遍历元素的同时添加元素

List的特点

• 元素有序【指添加输出有序】
• 可重复
• 有索引

List的分类

• ArrayList

  • 多态实现：Collection c = new ArrayList();
  • 特点：底层数据结构是数组，查询快，增删慢，线程不安全，效率高

• Vector

  • 多态实现：Collection c = new Vector<>();
  • 特点：底层数据结构是数组，查询快，增删慢，线程安全，效率低
  • Vector类特有功能【很少用，我们直接用实现的Collection的方法】
    • public void addElement(E obj)
    • public E elementAt(int index)
    • public Enumeration elements()

• LinkedList

  • 特点：底层数据结构是链表，查询慢，增删快，线程不安全，效率高
  • LinkedList类特有功能
    • 在首尾添加元素：public void addFirst(E e)及addLast(E e)
    • 获取首尾的元素：public E getFirst()及getLast()
    • 删除首尾的元素：public E removeFirst()及public E removeLast()

Set

Set特有的方法

Set的特点

• 元素不可重复
• 元素无序
• 没有索引

Set的分类

• HashSet

  • 特点：不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变【每一次输出的顺序不一定相同】
  • 保证元素的唯一性
    • 底层数据结构是哈希表(元素是链表的数组)
    • 哈希表依赖于哈希值存储
    • 添加功能底层依赖两个方法：
      1. boolean equals(Object obj)
      2. int hashCode()

• TreeSet

  • 特点：底层数据结构是红黑树(红黑树是一种自平衡的二叉树)，可以对元素进行排序

  • 排序的方式

    • 使用无参构造器时,用的是自然排序，此时需要实现Comparable接口，通过compareTo()方法进行排序
    • 使用有参构造器时，用的是比较器排序，此时需要实现Comparator接口，通过compare()方法进行 排序

    注意事项：要保证排序的类型实现了对应的接口，然后重写相应的方法

Map

概述

• 将键映射到值的对象
• 一个映射不能包含重复的键
• 每个键最多只能映射到一个值
• Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序

Map和Collection的区别

• Map是双列的,Collection是单列的
• Map的键唯一,Collection的子体系Set是唯一的
• Map集合的数据结构值针对键有效，跟值无关
• Collection集合的数据结构是针对元素有效

Map的方法

基本功能

• 添加元素：V put(K key,V value)

• 删除元素：V remove(Object key)

• 清空元素：void clear()

• 判断是否包含key：boolean containsKey(Object key)

• 判断是否包含value：boolean containsValue(Object value)

• 判断集合是否为空【指没有元素的那种空，而不是地址值为null】：boolean isEmpty()

• 获取集合的长度【元素的个数】：int size()

高级功能

• 通过key获取value：V get(Object key)
• 获取所有的key返回成一个集合：Set keySet()
• 获取所有的value返回成一个集合：Collection values()
• 获取所有的key-value返回成一个集合：Set<Map.Entry<K,V>> entrySet()
  • 获取键值对的键：K getKey()
  • 获取键值对的值：V getValue()

Map集合遍历

两种方式：

1. 获取所有的key，然后通过所有的key去获取相应的值
2. 获取所有的key-value，然后分别获取相应的key和value

遍历

public class exer6 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1, "java");
        map1.put(2, "hadoop");
        map1.put(3, "python");
        map1.put(4, "hive");
        // 获取key的集合，然后进行遍历
        Set<Integer> mapKeys = map1.keySet();
        for (Integer mapKey : mapKeys) {
            System.out.println(mapKey + "\t" + map1.get(mapKey));
        }
        // 获取所有的key-value然后遍历
        Set<Map.Entry<Integer, String>> keyValues = map1.entrySet();
        for (Map.Entry<Integer, String> keyValue : keyValues) {
            System.out.println(keyValue.getKey() + "\t" + keyValue.getValue());
        }
    }
}

分为两类：HashMap、TreeMap

HashMap类概述

• 键是哈希表结构，可以保证键的唯一性

TreeMap类概述

• 键是红黑树结构，可以保证键的排序和唯一性
• 排序参考上面的TreeSet,实现方式是一样的

Collections工具类

概述

针对集合操作的工具类。

前面的一些集合【比如ArrayList、Vector】即便Vector线程安全，我们也不怎么使用，而是通过一些途径让线程不安全的ArrayList变得安全

Collections成员方法

• 对集合进行排序：public static void sort(List list)
• 对集合进行二分查找：public static int binarySearch(List<?> list,T key)
• 求集合里面的最大值：public static T max(Collection<?> coll)
• 对集合进行反转：public static void reverse(List<?> list)
• public static void shuffle(List<?> list)

集合的使用场景

• 考虑是单个元素还是键值对

  • 单个元素：Collection
  • 键值对元素：Map

• 是否要进行排序？

  • 单个元素：TreeSet
  • 键值对元素：TreeMap

• 单个元素的时候，要不要去重？

  • 要：HashSet
  • 不要：ArrayList

• 在没有特殊要求的情况下，单个元素优先使用ArrayList居多，键值对元素优先使用HashMap居多。