Java新手小白入门篇 API - 集合容器

• Java新手小白入门篇系列持续更新中…

---

---

一、集合

1. 集合是什么

集合指的是 java.util 包下提供的一些类，我们又称为容器。
提到容器实际我们能联想到是用来装东西的，想到我们之前学习过的数组。没错，两者之间确实有很多相似的地方，但是集合和数组之间也有些区别：数组是固定长度的，集合是可变长度的，数组的访问比较单一，增删改查操作有些比较繁琐，而集合相对比较灵活。

2. 常用的集合类有哪些

Collection 和 Map 接口是所有集合容器的父接口
常用的集合类：

• Collection 接口
  • List 接口
    • ArrayList（常用）
    • LinkedList（常用）
    • CopyOnWriteArrayList
  • Set 接口
    • HashSet（常用）
    • TreeSet
    • LinkedHashSet
  • Queue 接口
    • Deque
• Map接口
  • HashMap（常用）
  • TreeMap
  • ConcurrentHashMap

二、Collection

1. 常用方法

方法	返回值类型	方法描述
add(E e)	boolean	将指定的对象添加到集合中
addAll(Collection c)	boolean	将指定的集合添加到原有的集合中
remove(Object o)	boolean	将指定的对象从集合中移除
removeAll(Collection c)	boolean	删除集合中共有的元素
isEmpty()	boolean	判断当前集合是否为空
size()	int	返回集合的长度
contains(Object o)	boolean	判断集合中是否包含指定元素
containsAll(Collection c)	boolean	判断集合中是否包含指定集合
retainAll(Collection c)	boolean	取两个集合的交集(公共元素)
toArray()	Object[]	将此集合转化为对象数组
clear()	void	清空集合
iterator	Iterator<E>	返回在此集合元素上的迭代器，用于遍历集合中的对象

2. Collection 练习

public class CollectionDemo {
    public static void main(String[] args) {
        // Collection c = new Collection(); // 报错,因为Collection是接口,不能直接new接口
        Collection c = new ArrayList(); // 向上造型

        // add(E e) 将指定的对象添加到集合中
        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);
        System.out.println(c); // [100, 200, 300, 400, 500]

        // size() 返回集合的长度
        int size = c.size();
        System.out.println(size); // 5

        // isEmpty() 判断当前集合是否为空
        boolean empty = c.isEmpty();
        System.out.println(empty); // false

        // contains(Object o) 判断集合中是否包含指定元素
        boolean contains = c.contains(200);
        System.out.println(contains); // true

        Collection c2 = new ArrayList();
        c2.add(300);
        c2.add(400);

        // containsAll(Collection c) 判断集合中是否包含指定集合
        boolean containsAll = c.containsAll(c2);
        System.out.println(containsAll); // true

        // remove(E e) 将指定的对象从集合中移除
        c.remove(200);
        System.out.println(c); // [100, 300, 400, 500]

        // toArray() 将此集合转化为对象数组
        Object[] objects = c.toArray();
        System.out.println(Arrays.toString(objects)); // [100, 300, 400, 500]

        // removeAll(Collection c) 删除集合中共有的元素
        c.removeAll(c2);
        System.out.println(c); // [100, 500]

        // clear() 清空集合
        c.clear();
        System.out.println(c); // []

        // addAll(Collection c) 将指定的集合添加到原有的集合中
        c.addAll(c2);
        System.out.println(c); // [300, 400]

        /**
         * 迭代集合/遍历集合
         * 1) 获取集合的迭代器对象  c.iterator()
         * 2) 判断集合是否有下一个可迭代的元素 it.hasNext()
         * 3) 获取当前迭代到的元素 it.next()
         */
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
        
        Collection c3 = new ArrayList();
        c3.add(300);
        c3.add(600);
        
        // retainAll(Collection c) 取两个集合的交集(共有的元素),赋值给集合c
        c.retainAll(c3);
        System.out.println(c); // [300]
        System.out.println(c3); // [300, 600]
    }
}

三、泛型

1. 概念

泛型是 JDK5 的一个新特性，通常用来和集合对象一起使用，它是程序的增强器，是目前主流的开发方式。
泛型实际是一种 语法糖 ，编译器识别而虚拟机识别。我们在使用集合的时候定义这个泛型的类型，实际就是一种约束作用，用来约束集合中能存放的类型。编译器可以在编译期对泛型约束提供一种类型的安全检查，这样可以避免一些在运行时出现的不必要错误。但是由于它是编译器识别虚拟机不识别，编译之后这个泛型就会被删除掉。

2. 集合的种类

• <E> 通常在集合中使用

  • E
    • Element

• <T> 通常表示类

  • T
    • Type

• <K,V> 通常表示键值对

  • K
    • Key
  • V
    • Value

• ? 表示泛型通配符

例子：

public interface Collection<E> extends Iterable<E> {
	boolean add(E e);
	boolean addAll(Collection<? extends E> c);
	boolean containsAll(Collection<?> c);
	<T> T[] toArray(T[] a);
}

public interface Map<K,V> {}

集合中只能存放引用类型，不能存放基本类型

Collection<Integer> c = new ArrayList();
c.add(1);
Collection<int> c2 = new ArrayList(); // 报错,泛型中只能使用引用类型,也表示集合中只能存放引用类型

练习题/面试题

1. 集合中能存储基本类型嘛

2. Collection，List，Set，Map是接口还是类，它们之间有什么关系

3. 集合的遍历使用什么

4. 迭代器是干什么的

5. 迭代的过程中是否能产出元素，如果能怎么删除，如果不能说明原因

6. 新循环（增强for循环）3个参数分别代表什么

7. 数组和集合有哪些区别