Java 集合框架

前言

1、ArrayList

关键字 简介
add 增加
contains 判断是否存在
get 获取指定位置的对象
indexOf 获取对象所处的位置
remove 删除
set 替换
size 获取大小
toArray 转换为数组
addAll 把另一个容器所有对象都加进来
clear 清空
关键字 简介
for 用 for 循环遍历
iterator 迭代器遍历
for: 用增强型 for 循环

1.1 List 接口

  • List 接口ArrayList 实现了接口 List。常见的写法会把引用声明为接口 List 类型。

    1
    List heros = new ArrayList();

1.2 泛型

  • 泛型:不指定泛型的容器,可以存放任何类型的元素。指定了泛型的容器,只能存放指定类型的元素以及其子类。

    1
    2
    3
    4
    5
    // 不使用泛型的容器
    List heros1 = new ArrayList();

    // 使用泛型的容器,后面的泛型可以用 <> 来代替
    List<Hero> heros2 = new ArrayList<Hero>();

1.3 ArrayList 和 Vector 的区别

  • 类的声明一模一样,Vector 是线程安全的类,而 ArrayList 是非线程安全的。

2、LinkedList

  • 序列分先进先出 FIFO,先进后出 FILO。FIFO 在 Java 中又叫 Queue 队列。FILO 在 Java 中又叫 Stack 栈。

  • LinkedList 是一个双向链表结构的 list。

    • ArrayList 一样,LinkedList 也实现了 List 接口,诸如 add,remove,contains 等等方法。
    • LinkedList 还实现了双向链表结构 Deque,可以很方便的在头尾插入删除数据。
    • LinkedList 还实现了队列 Queue 接口。
  • 双向链表结构 常用方法

关键字 简介
addFirst 在最前面插入元素
addLast 在最后插入元素
getFirst 查看最前面元素
getLast 查看最后面元素
removeFirst 取出最前面元素
removeLast 取出最后面元素
  • 队列 常用方法
关键字 简介
offer 在最后添加元素
peek 查看第一个元素
poll 取出第一个元素

2.1 ArrayList 与 LinkedList 的区别

  • ArrayList vs LinkedList

    • ArrayList 插入,删除数据慢。
    • LinkedList 插入,删除数据快。
    • ArrayList 是顺序结构,所以定位很快。
    • LinkedList 是链表结构,所以定位慢。

3、二叉树

  • 二叉树由各种节点组成。

  • 二叉树特点

    • 每个节点都可以有左子节点,右子节点。
    • 每一个节点都有一个值。
  • 二叉树排序

    • 排序的第一个步骤是把数据插入到该二叉树中,插入基本逻辑是,小、相同的放左边,大的放右边。
    • 接下来要做的是看,把这些已经排好序的数据,遍历成我们常用的 List 或者数组的形式。二叉树的遍历分左序,中序,右序。

4、HashMap

  • HashMap 储存数据的方式是 键值对。key 是唯一的,不可以重复。

    1
    HashMap<String, Object> dictionary = new HashMap<>();
  • 常用方法

关键字 简介
put 增加、替换
get 获取对象
clear 清空

4.1 HashMap 与 Hashtable 的区别

  • HashMap vs Hashtable

    • HashMapHashTable 都实现了 Map 接口,都是键值对保存数据的方式。

    • 区别 1:

      • HashMap 可以存放 null。
      • Hashtable 不能存放 null。
    • 区别 2:

      • HashMap 不是线程安全的类。
      • Hashtable 是线程安全的类。

5、HashSet

  • Set 中的元素,没有顺序。严格的说,是没有按照元素的插入顺序排列。

  • HashSet 中的元素,不能重复。

    1
    HashSet<Object> names = new HashSet<>();
  • HashSet 的具体顺序,既不是按照插入顺序,也不是按照 hashcode 的顺序。

  • 常用方法

关键字 简介
add 插入
  • 几种 Set

    • HashSet:无序
    • LinkedHashSet:按照插入顺序
    • TreeSet:从小到大排序

5.1 ArrayList 与 HashSet 的区别

  • ArrayList vs HashSet

    • ArrayList 有顺序。
    • HashSet 无顺序。
    • ArrayList 中的数据可以重复。
    • HashSet 中的数据不能够重复。

6、Collection

  • Collection 是 Set List Queue(队列)和 Deque(双向链表)的接口。

  • CollectionMap 之间没有关系,Collection 是放一个一个对象的,Map 是放键值对的。

  • Deque 继承 Queue,间接的继承了 Collection

7、Collections

  • Collections 是一个类,容器的工具类,就如同 Arrays 是数组的工具类。

    1
    2
    3
    List<Integer> numbers = new ArrayList<>();

    Collections.reverse(numbers);
  • 常用方法

关键字 简介
reverse 反转
shuffle 混淆
sort 排序
swap 交换
rotate 滚动
synchronizedList 线程安全化

8、hashcode 原理

  • hashcode 原理:所有的对象,都有一个对应的 hashcode(散列值)。

9、比较器

9.1 Comparator

  • 按照对象中的某个属性进行排序,直接调用 sort 会出现编译错误,因为类中有各种属性,引入 Comparator,指定比较的算法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import java.util.Comparator;
    import java.util.Collections;

    List<Hero> heros = new ArrayList<>();

    Comparator<Hero> cp = new Comparator<Hero>() { // 引入 Comparator,指定比较的算法
    @Override
    public int compare(Hero h1, Hero h2) {
    if (h1.hp >= h2.hp) { // 按照 hp 进行排序
    return 1; // 正数表示 h1 比 h2 要大
    } else {
    return -1;
    }
    }
    };

    Collections.sort(heros, cp);
  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.util.Comparator;
    import java.util.Collections;

    List<Hero> heros = new ArrayList<>();

    Collections.sort(heros, new Comparator<Hero>() { // 匿名方法
    @Override
    public int compare(Hero h1, Hero h2) {
    return (int)(h1.hp - h2.hp);
    }
    });

9.2 Comparable

  • 使类实现 Comparable 接口,在类里面提供比较算法,Collections.sort 就有足够的信息进行排序了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class Hero implements Comparable<Hero> {
    ...

    public int hp;

    @Override
    public int compareTo(Hero anotherHero) {
    if (hp < anotherHero.hp) {
    return 1;
    } else {
    return -1; // 如果返回 -1, 就表示当前的更小,否则就是更大
    }
    }
    }
    1
    2
    3
    4
    5
    import java.util.Collections;

    List<Hero> heros = new ArrayList<>();

    Collections.sort(heros); // Hero 类实现了接口 Comparable,即自带比较信息。Collections 直接进行排序,无需额外的 Comparator

10、聚合操作

  • JDK8 之后,引入了对集合的聚合操作,可以非常容易的遍历,筛选,比较集合中的元素。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import java.util.Comparator;
    import java.util.Collections;

    List<Hero> heros = new ArrayList<>();

    String name = heros // 通过聚合操作找出来的 hp 第三高的英雄名称
    .stream()
    .sorted((h1, h2) -> h1.hp > h2.hp ? -1 : 1)
    .skip(2)
    .map(h -> h.getName())
    .findFirst()
    .get();
  • 要用好聚合,必须先掌握 Lambda 表达式

文章目录
  1. 1. 前言
  2. 2. 1、ArrayList
    1. 2.1. 1.1 List 接口
    2. 2.2. 1.2 泛型
    3. 2.3. 1.3 ArrayList 和 Vector 的区别
  3. 3. 2、LinkedList
    1. 3.1. 2.1 ArrayList 与 LinkedList 的区别
  4. 4. 3、二叉树
  5. 5. 4、HashMap
    1. 5.1. 4.1 HashMap 与 Hashtable 的区别
  6. 6. 5、HashSet
    1. 6.1. 5.1 ArrayList 与 HashSet 的区别
  7. 7. 6、Collection
  8. 8. 7、Collections
  9. 9. 8、hashcode 原理
  10. 10. 9、比较器
    1. 10.1. 9.1 Comparator
    2. 10.2. 9.2 Comparable
  11. 11. 10、聚合操作
隐藏目录