java-集合笔记-CSDN博客

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

3、Collection集合的遍历方式

（1）迭代器

Iterator<String> it = lists.iterator();
while (it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
}

（2）增强for循环

for (String ele : lists) {
            System.out.println(ele);

}

增强for循环：既能遍历集合，也能遍历数组

修改第三方变量值不会影响到集合中的元素

（3）lambda表达式

        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        lists.forEach(s -> {
            System.out.println(s);
        });

        lists.forEach(s -> System.out.println(s));
        lists.forEach(System.out::println);

三、List系列集合

1.List集合特点

ArrayList、LinkedList：有序、可重复、有索引

2.List集合特有方法

方法名称	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

3.List的实现类的底层原理

ArrayList底层是基于数组实现的，根据查询元素快，增删相对慢。

LinkedList底层基于双链表实现的，查询元素慢，增删首尾元素是非常快的。

4.List集合的遍历方式

a.迭代器

b.增强for循环

c.Lambda表达式

d.for循环（因为List集合存在索引）

        //for循环
        for (int i = 0; i < lists.size(); i++) {
            String ele = lists.get(i);
            System.out.println(ele);
        }
        System.out.println("----------------");

        //迭代器
        Iterator<String> it = lists.iterator();
        while (it.hasNext()) {
            String ele = it.next();
            System.out.println(ele);
        }
        System.out.println("----------------");

        //foreach
        for (String ele : lists) {
            System.out.println(ele);
        }
        System.out.println("----------------");

        //lambda表达式
        lists.forEach(s -> System.out.println(s));
        lists.forEach(System.out::println);

5.ArrayList集合底层原理

ArrayList底层是基于数组实现的：根据索引定位元素快，增删需要做元素的移位操作。

第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组。

6.LinkedList集合的特有功能

方法名称	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

四、集合的并发修改异常问题

1.问题引出

当我们从集合中找出某个元素并删除的时候可能出现一种并发修改异常问题。

2.哪些遍历存在问题？

迭代器遍历集合且直接用集合删除元素的时候可能出现。

增强for循环遍历集合且直接用集合删除元素的时候可能出现。

3.哪种遍历且删除元素不出问题？

迭代器遍历集合但是用迭代器自己的删除方法操作可以解决。

        while(it.hasNext()){
            String ele=it.next();
            if ("java".equals(ele)){
//                list.remove(ele);//报错
                it.remove();//使用迭代器删除当前位置的元素 保证不后移 能够成功遍历到全部元素
            }
        }
        System.out.println(list);

使用for循环遍历并删除元素不会存在这个问题。

        for (int i = 0; i < list.size(); i++) {
            String ele = list.get(i);
            if ("java".equals(ele)) {
                list.remove(ele);
                i--;
            }
        }

五、泛型

1.泛型概述

JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

2.泛型的格式

<引用数据类型>

集合体系的全部接口和实现类都是支持泛型的使用的。

3.泛型的好处

统一数据类型。

把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型就能确定下来。

4.泛型分类

泛型可以在类、方法声明上、接口后面进行定义，即泛型类、泛型方法、泛型接口。

a.泛型类

泛型类的格式：修饰符 class 类名<泛型变量>{ }

范例：public class MyArrayList<T> { }

此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等。

作用：编译阶段可以指定数据类型，类似于集合的作用。

泛型类的核心思想：把出现泛型变量的地方全部替换成传输的真实数据类型。

b.泛型方法

泛型方法的格式：修饰符 <泛型变量> 方法返回值方法名称(形参列表){}

范例： public <T> void show(T t) { }

作用：方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性。

c.泛型接口

泛型接口的格式：修饰符 interface 接口名称<泛型变量>{}

范例： public interface Data<E>{}

作用：泛型接口可以让实现类选择当前功能需要操作的数据类型

5.泛型通配符

通配符：？

? 可以在“使用泛型”的时候代表一切类型。

E T K V 是在定义泛型的时候使用的。

6.泛型的上下限

? extends Car: ?必须是Car或者其子类泛型上限

? super Car ： ?必须是Car或者其父类泛型下限

六、Set系列集合

1.Set系列集合特点

无序、不重复、无索引。

2.Set集合实现类特点

HashSet：无序、不重复、无索引

LinkedHashSet：有序、不重复、无索引

TreeSet：排序、不重复、无索引

3.HashSet集合元素无序的底层原理：哈希表

HashSet集合底层采取哈希表存储的数据。

哈希表是一种对于增删改查数据性能都较好的结构。

过程：

创建一个默认长度16的数组，数组名table

根据元素的哈希值跟数组的长度求余计算出应存入的位置（哈希算法）

判断当前位置是否为null，如果是null直接存入

如果位置不为null，表示有元素，则调用equals方法比较

如果一样，则不存，如果不一样，则存入数组，当数组存满到16*0.75=12时，自动扩容到原先的两倍

JDK 7新元素占老元素位置，指向老元素

JDK 8中新元素挂在老元素下面

4.HashSet集合元素去重复的底层原理

同上：哈希表

如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法，idea中可自动生成。

5.扩展：哈希表

（1）哈希值

是JDK根据对象的地址，按照某种规则算出来的int类型的数值。

Object类的API：public int hashCode()：返回对象的哈希值。

（2）对象的哈希值特点：

同一个对象多次调用hashCode()方法返回的哈希值是相同的。

默认情况下，不同对象的哈希值是不同的。

（3）哈希表的组成：

JDK8之前的，底层使用数组+链表组成。

JDK8开始后，底层采用数组+链表+红黑树组成。

当挂在元素下面的数据过多时，查询性能降低，从JDK8开始后，当链表长度超过8的时候，自动转换为红黑树。

6.LinkedHashSet

该实现类的有序指的是保证存储和取出的元素顺序一致。

原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序。

7.TreeSet

（1）特点

可排序：按照元素的大小默认升序（有小到大）排序。

TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好。

注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。

（2）TreeSet集合默认的规则

对于数值类型：Integer , Double，官方默认按照大小进行升序排序。

对于字符串类型：默认按照首字符的编号升序排序。

对于自定义类型如Student对象，TreeSet无法直接排序。

（3）自定义排序规则

方式一

让自定义的类（如学生类）实现Comparable接口重写里面的compareTo方法来定制比较规则。

方式二

TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序。

七、Collection体系的特点、使用场景总结

1.如果希望元素可以重复，又有索引，索引查询要快？

用ArrayList集合，基于数组的。（用的最多）

2. 如果希望元素可以重复，又有索引，增删首尾操作快？

用LinkedList集合，基于链表的。

3. 如果希望增删改查都快，但是元素不重复、无序、无索引。

用HashSet集合，基于哈希表的。

4. 如果希望增删改查都快，但是元素不重复、有序、无索引。

用LinkedHashSet集合，基于哈希表和双链表。

5. 如果要对对象进行排序。

用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。

八、补充：可变参数

1.可变参数的格式

数据类型...参数名称

2.可变参数的作用

接收参数非常灵活，方便。可以不接收参数，可以接收1个或者多个参数，也可以接收一个数组

可变参数在方法内部本质上就是一个数组。

3.注意事项

1.一个形参列表中可变参数只能有一个

2.可变参数必须放在形参列表的最后面

九、集合工具类：Collections

1.Collections常用的API

方法名称	说明
public static <T> boolean addAll(Collection<? super T> c, T... elements)	给集合对象批量添加元素
public static void shuffle(List<?> list)	打乱List集合元素的顺序

2.Collections排序相关的API

排序方式1：

方法名称	说明
public static <T> void sort(List<T> list)	将集合中元素按照默认规则排序

注意：本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。

排序方式2：

方法名称	说明
public static <T> void sort(List<T> list，Comparator<? super T> c)	将集合中元素按照指定规则排序

十、案例：斗地主游戏

package d4_collection_test;

public class Card {
    private String size;
    private String color;
    private int index;

    public Card() {
    }

    public Card(String size, String color, int index) {
        this.size = size;
        this.color = color;
        this.index = index;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    @Override
    public String toString() {
        return size + color;
    }
}

package d4_collection_test;

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

public class GameDemo {
    //定义集合存储54张牌
    public static List<Card> allCards = new ArrayList<>();

    //初始化
    static {
        String[] sizes = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] colors = {"♥", "♠", "♣", "♦"};
        int index = 0;//记录牌的大小
        for (String size : sizes) {
            index++;
            for (String color : colors) {
                Card c = new Card(size, color, index);
                allCards.add(c);
            }
        }
        Card c1 = new Card("", "小joker", ++index);
        Card c2 = new Card("", "大joker", ++index);
        Collections.addAll(allCards, c1, c2);
        System.out.println("新牌:" + allCards);
    }

    public static void main(String[] args) {
        //打乱
        Collections.shuffle(allCards);
        System.out.println("洗牌后:" + allCards);
        //定义三个玩家
        List<Card> first = new ArrayList<>();
        List<Card> second = new ArrayList<>();
        List<Card> third = new ArrayList<>();
        //发牌
        for (int i = 0; i < allCards.size() - 3; i++) {
            Card c = allCards.get(i);
            if (i % 3 == 0) {
                first.add(c);
            } else if (i % 3 == 1) {
                second.add(c);
            } else if (i % 3 == 2) {
                third.add(c);
            }
        }
        List<Card> LastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());
        //排序
        sortCards(first);
        sortCards(second);
        sortCards(third);
        //输出
        System.out.println("玩家一号:" + first);
        System.out.println("玩家二号:" + second);
        System.out.println("玩家三号" + third);
        System.out.println("三张底牌:" + LastThreeCards);

    }

    private static void sortCards(List<Card> cards) {
        Collections.sort(cards, (Card o1, Card o2) -> o2.getIndex() - o1.getIndex());
    }

}

十一、Map集合体系

1.Map集合概述和使用

Map集合是一种双列集合，每个元素包含两个数据。

Map集合的每个元素的格式：key=value(键值对元素)。

Map集合也被称为“键值对集合”。

2.Map集合整体格式

Map集合的完整格式：{key1=value1 , key2=value2 , key3=value3 , ...}

3.Map集合体系特点

Map集合的特点都是由键决定的。

Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复）。

Map集合后面重复的键对应的值会覆盖前面重复键的值。

Map集合的键值对都可以为null。

4.Map集合实现类特点

HashMap:元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）

LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

TreeMap：元素按照建是排序，不重复，无索引的，值不做要求。

5.Map集合常用API

方法名称	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

6.Map集合的遍历方式

（1）键找值

先获取Map集合全部的键，再根据遍历键找值。

涉及到的API：

方法名称	说明
Set<K> keySet()	获取所有键的集合
V get(Object key)	根据键获取值

        //键找值
        Set<String> keys = maps.keySet();
        for (String key : keys) {
            int value = maps.get(key);
            System.out.println(key + "--->" + value);
        }

（2）键值对

把“键值对“看成一个整体。

先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型。

遍历Set集合，然后提取键以及提取值。

键值对涉及到的API：

方法名称	说明
Set<Map.Entry<K,V>> entrySet()	获取全部键值对对象的集合
K getKey()	获取键
V getValue()	获取值

        //键值对
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "-->" + value);
        }

（3）lambda表达式

Map结合Lambda遍历的API：

方法名称	说明
default void forEach(BiConsumer<? super K, ? super V> action)	结合lambda遍历Map集合

//        maps.forEach(new BiConsumer<String, Integer>() {
//            @Override
//            public void accept(String key, Integer value) {
//                System.out.println(key + "-->" + value);
//            }
//        });
        maps.forEach((key, value) -> System.out.println(key + "-->" + value));

7.实现类HashMap

（1）HashMap的特点

HashMap是Map里面的一个实现类。特点都是由键决定的：无序、不重复、无索引

没有额外需要学习的特有方法，直接使用Map里面的方法就可以了。

（2）HashMap的底层原理

HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，只是HashMap的每个元素包含两个值而已。

依赖hashCode方法和equals方法保证键的唯一。

如果键要存储的是自定义对象，需要重写hashCode和equals方法。

基于哈希表。增删改查的性能都较好。

实际上：Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

8.实现类LinkedHashMap

由键决定：有序、不重复、无索引。

这里的有序指的是保证存储和取出的元素顺序一致

原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。

9.实现类TreeMap

（1）TreeMap集合概述和特点

由键决定特性：不重复、无索引、可排序

可排序：按照键数据的大小默认升序（有小到大）排序。只能对键排序。

注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序

TreeMap跟TreeSet一样底层原理是一样的。

（2）TreeMap集合自定义排序规则

有2种

类实现Comparable接口，重写比较规则。

集合自定义Comparator比较器对象，重写比较规则。

十二、集合的嵌套

package d9_map_impl;

import java.util.*;

public class MapTest04 {
    public static void main(String[] args) {
        //要求记录每个学生选择的情况 每个学生可以进行多个选择
        //使用Map集合存储
        Map<String, List<String>> data = new HashMap<>();

        //把学生选择的数据存进去
        List<String> selects = new ArrayList<>();
        Collections.addAll(selects, "A", "B");
        data.put("张三", selects);

        List<String> selects1 = new ArrayList<>();
        Collections.addAll(selects1, "A", "B", "C");
        data.put("李四", selects1);

        List<String> selects2 = new ArrayList<>();
        Collections.addAll(selects2, "C", "D");
        data.put("王五", selects);

        System.out.println(data);

        //统计学生选择的个数
        Map<String, Integer> infos = new HashMap<>();

        Collection<List<String>> values = data.values();
        System.out.println(values);

        for (List<String> value : values) {
            for (String s : value) {
                if (infos.containsKey(s)) {
                    infos.put(s, infos.get(s) + 1);
                } else {
                    infos.put(s, 1);
                }
            }
        }
        System.out.println(infos);
    }
}