javaee 易混淆知识点之集合类

1.单列集合(Collection)

1.1 单列集合概述

java.util.Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素。

单列集合：以单个对象作为存储元素的集合类型。

1.2 单列集合继承体系

java.util.List 有序单列集合接口

• 特点：元素有索引，元素有序(先进先出)、元素可重复
• 常用子类
  java.util.ArrayList 数组结构，查询快,增删慢,线程不安全
  java.util.LinkedList 链表结构，查询慢,增删快,线程不安全
  java.util.Vector 数组结构，查询较快,增删慢,线程安全
  java.util.Set` 无序单列集合接口
• 特点：元素无索引，元素无序、元素不可重复
• 常用子类
  java.util.HashSet 哈希结构，不可排序
  |-- java.util.LinkedHashSet 链表+哈希表结构，可排序
  java.util.TreeSet 二叉树结构，可排序

1.3单列集合(Collection)常用功能

1.3.1 构造方法

由于Collection是一个接口，不能创建对象，需要使用其子类ArrayLiist类型的创建对象。

1.3.2Collection集合常用功能

public boolean add(E e)：  把给定的对象添加到当前集合中 。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(Object obj): 判断当前集合是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中
public void clear():清空集合中所有的元素。

tips: 有关Collection中的方法可不止上面这些，其他方法可以自行查看API学习。

1.3.3演示单列集合常用功能
需求：通过ArrayList类演示单列集合常用功能

import java.util.Collection;

public class Arraylisttest {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c1 = new ArrayList<>();
        //public boolean add(E e)  向集合中添加元素
        c1.add("abc");
        c1.add("def");
        c1.add("hij");
        System.out.println(c1);
        System.out.println("------------------");
        //public boolean remove(E e)  删除集合中元素
        c1.remove("abc");
        System.out.println(c1);
        System.out.println("------------------");
        //public boolean contains(Object obj)  判断是否包含指定的元素

        System.out.println(c1.contains("hij"));
        System.out.println(c1.contains("ab"));
        System.out.println("------------------");
        //public boolean isEmpty() 判断是否为空
        System.out.println(c1.isEmpty());
        System.out.println("------------------");
        //public int size() 获取集合的长度
        System.out.println(c1.size());
        System.out.println("------------------");
        //public Object[] toArray()  将集合转换成一个数组
        Object[] array = c1.toArray();
        System.out.println("打印的是地址值:"+array);
        //循环遍历数组
        for (Object o : array) {
            System.out.println(o);

        }

    }
}

测试结果

[abc, def, hij]
------------------
[def, hij]
------------------
true
false
------------------
false
------------------
2
------------------
打印的是地址值:[Ljava.lang.Object;@4554617c
def
hij

2.list集合

• List的常用子类

目标:

• 了解List接口的实现类

步骤:

• ArrayList集合
• LinkedList集合常用方法
• 演示LinkedList集合常用方法

讲解:

5.3.1ArrayList集合

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

但不建议随意地使用ArrayList完成任何需求，并不严谨，需要根据需求考虑。

ArrayList集合特点：查询快,增删慢,线程不安全

5.3.2LinkedList集合

java.util.LinkedList集合数据存储的结构是双向链表结构。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

双链表原理图

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。

3.Collections工具类

3.1概述

java.utils.Collections是集合工具类，用来对集合进行操作。

3.2常用方法

• public static void shuffle(List<?> list):打乱集合顺序。
• public static void sort(List list):将集合中元素按照默认规则排序。

3.3演示Collections的工具的使用

package com.itheima.demo3_集合类;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);
        //打乱集合顺序 public static void shuffle(List<?> list)
        Collections.shuffle(list);
        System.out.println("打乱后的顺序为:"+list);
        //public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。
        Collections.sort(list);
        System.out.println("恢复原顺序:"+list);



    }

}

输出结果

[a, b, c, d, e]
打乱后的顺序为:[e, a, b, c, d]
恢复原顺序:[a, b, c, d, e]

4.Comparator比较器

4.1概述

	public interface Comparator<T>  定义比较对象规则的接口

4.2常用方法

public int compare(T  o1,T  o2) 比较用来排序的两个参数
	o1一般代表正着添加的元素，o2表示已经添加过的元素。根据第o1与o2的比较结果，返回负整数、零或正整数实现排序。
	默认使用方式
 		升序   根据o1的值与o2的值做比较(o1-o2)
 		降序   根据o2的值与o1的值做比较(o2-o1)

4.3 应用场景

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

4.4演示Comparator比较器的应用

需求：演示Comparator在集合工具类排序功能中的使用

package com.itheima.demo3_集合类;

import java.util.*;

/**
 * @author BieBer
 */
public class Comparator比较器 {
    public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(6);
        list.add(3);
        list.add(5);
        list.add(4);
        System.out.println(list);
        System.out.println("--------");

        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
                return o1-o2;
                //降序
               // return o2-o1;
            }
        });
        System.out.println(list);


    }
}

测试结果

[1, 6, 3, 5, 4]
--------
[1, 3, 4, 5, 6]

5.Set接口2.1.1Set集合概述

• java.util.Set接口继承自Collection接口，是单列集合的一个重要分支。实现了Set`接口的对象称为Set集合。

• Set集合没有对于Collection功能的额外扩充,但是有更加完善的存储机制。

• Set集合无索引，只能是用增强for和迭代器遍历

5.1Set接口特点

• 元素无索引,元素存取无序,元素不可重复(唯一)

5.2Set集合常用子类

java.util.HashSet：哈希表结构集合

java.util.LinkedHashSet：链表结构集合

java.util.TreeSet：树结构集合

6.HashSet基本使用

6.1概述

java.util.HashSet是Set接口的一个实现类

底层的实现其实是一个java.util.HashMap支持

根据对象的哈希值来确定元素在集合中的存储位置，具有良好的存储和查找性能

元素唯一，底层依赖hashCode与equals方法。

6.2特点

• 元素无索引,元素存取无序,元素不可重复(唯一)

6.3演示HashSet的使用

需求：在测试类中演示HashSet的基本使用

package com.itheima.demo3_集合类;

import java.util.HashSet;

public class HashSet类 {
    public static void main(String[] args) {
        HashSet<String> hs = new HashSet<>();
        hs.add("abc");
        hs.add("def");
        System.out.println(hs);
        hs.add("ghi");
        hs.add("abc");
        System.out.println(hs);
    }
}

[abc, def]
[abc, def, ghi]

7.map类

7.1Map集合概述

java.util.Map双列集合的顶层接口，用来存储具备映射关系对象的集合接口定义。

映射关系：生活中类似IP地址与主机名、身份证号与个人等一一对应的对应关系。

Map集合中存储的内容根据映射关系分为两部分，称为键值对

• 键(Key)不能包含重复的键，
• 值(Value)可以重复；
• 每个键只能对应一个值。

7.2Map集合与Collection集合区别

• Collection集合中的元素，是以单个的形式存储。称为单列集合
• Map集合中的元素，是以键值对的形式存储。称为双列集合

7.3Map的常用子类介绍

HashMap<K,V>

• 存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
• 由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap<K,V>

• HashMap的子类，存储数据采用的哈希表结构+链表结构。
• 通过链表结构可以保证元素的存取顺序一致；
• 通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

TreeMap<K,V>

• TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；
• 可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

7.4Map的常用方法

常用方法

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • 若指定的键(key)在集合中不存在，则集合中没有这个键对应的值，返回null，并把指定的键和值添加到集合中；
  • 若指定的键(key)在集合中存在，则返回集合中该键对应的原值，并把指定键所对应的值，替换成指定的新值。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
• public boolean containKey(Object key):判断该集合中是否有此键。

演示Map的常用方法

需求：通过HashMap演示Map集合常用方法

7.5测试类代码

package com.itheima.demo3_集合类.map类;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
- public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
  - 若指定的键(key)在集合中不存在，则集合中没有这个键对应的值，返回null，并把指定的键和值添加到集合中；
  - 若指定的键(key)在集合中存在，则返回集合中该键对应的原值，并把指定键所对应的值，替换成指定的新值。
- 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集合)。
- public boolean containKey(Object key):判断该集合中是否有此键。

 */

public class test {
    public static void main(String[] args) {
        //创建Map集合子类对象
        HashMap<String, String> map = new HashMap<>();
        // public V put(K key, V value)

        map.put("1","a");
        map.put("2","b");
        map.put("2","c");//覆盖上一个元素
        System.out.println(map);
        System.out.println("----------------");
        //public V remove(Object key)
        map.remove("2");
        System.out.println(map);
        System.out.println("----------------");
        // public V get(Object key)
        System.out.println(map.get("1"));
        System.out.println(map.get("2"));
        System.out.println("----------------");
        // public Set<K> keySet()
        map.put("3","c");
        Set<String> strings = map.keySet();
        System.out.println(strings);
        System.out.println("----------------");
        // public Set<Map.Entry<K,V>> entrySet()
        Set<Map.Entry<String, String>> ens = map.entrySet();
        System.out.println(ens);
        System.out.println("----------------");
        // public boolean containKey(Object key)
        System.out.println(map.containsKey("1"));
        System.out.println(map.containsKey("2"));
        System.out.println(map.containsKey("3"));

    }
}

结果

{1=a, 2=c}
----------------
{1=a}
----------------
a
null
----------------
[1, 3]
----------------
[1=a, 3=c]
----------------
true
false
true

8.Map的遍历

8.1方式1:键找值

通过元素中的键，获取键所对应的值

步骤：

• 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
• 遍历键的Set集合，得到每一个键。
• 根据键，获取键所对应的值。方法提示:get(K key)

8.2方式2:键值对

通过集合中每个键值对(Entry)对象，获取集合中所有键值对(Entry)对象中的键与值。

Map中存放的是两种对象，一种称为key(键)，一种称为value(值).

java.util.Map.Entry 将键值对的对应关系封装成了对象。Map的内部接口定义，具体功能由Map子类负责具体实现。

Entry中的常用方法

• public K getKey()：获取Entry对象中的键。
• public V getValue()：获取Entry对象中的值。

Map中获取所有键值对对象Set集合：public Set<Map.Entry<K,V>> entrySet()

步骤：

• 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
• 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
• 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()

tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

8.3演示两种遍历方式

需求：演示Map集合的两种遍历方式

//测试类代码

package com.itheima.demo3_集合类.map类;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class biabliTest {
    public static void main(String[] args) {
        //定义Map集合，并存储元素。
        HashMap<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        //遍历方式1:使用键获取值
        // 步骤1:使用keySet获取键的集合
        Set<String> strings = map.keySet();
        // 步骤2:遍历键的集合，利用获取的键得到对应的值
        for (String key : strings) {
            String value = map.get(key);
            System.out.println(key + "=" + value);

        }
        System.out.println("-------------");
        //遍历方式2:使用键值对对象遍历
        // 步骤1:使用entrySet获取键值对对象的集合
        Set<Map.Entry<String, String>> ens = map.entrySet();
        // 步骤2:遍历键值对集合，获取每一个键值对对象
        for (Map.Entry<String, String> en: ens){
            // 步骤3:使用键值对对象类中的getKey()获取键，使用getValue()获取值。
            String key = en.getKey();
            String value = en.getValue();
            System.out.println(key+"="+value);

        }

    }
}

结果

1=a
2=b
-------------
1=a
2=b