文章目录

Collection集合框架体系
- 集合
- 一、List集合（interface）
- - 1.ArrayList实现类（class）
  - 2.LinkedList实现类（class）
  - 3.二者区别（底层理解）
- 二、Set集合（interface）
- - 1.HashSet实现类（class）
  - - HashSet的底层理解：
  - 2.TreeSet实现类（class）
- 三、遍历
- - 1.传统for循环
  - 2.高级for循环
  - 3.lambda表达式
  - 4.迭代器
  - 5.lambda表达式遍历迭代器
Map集合（interface）
- 1.HashMap实现类
- 2.TreeMap实现类
- 3.Map集合的遍历
- - （1）高级for循环，结合entries实现遍历（针对键值都需要的情况）
  - （2）for-each循环（只针对Key或者Value）
  - （3）迭代器遍历 Iterator
  - （4）通过Key找Value遍历
泛型（集合框架的规范）
- 简介

下图是本文所讲述的整个Java集合框架基本内容，共分为俩大部分，Collection接口和Map接口

Collection集合框架体系

集合

概念
对象的容器，实现了对对象常用的操作，类似数组功能。

集合和数组的区别

1.数组的长度是固定的，集合长度不固定
2.数组可以储存基本类型和引用类型，集合只能储存引用类型
3.数组的长度是固定的，一旦数据量超出容量，则不可继续储存数据，但是对于集合来说，当数据量超过容量的时候，集合会自动扩容，舒服了~~~

一、List集合（interface）

List实现了Collection接口，它具有俩个常用的实现类：ArrayList类和LinkedList类。

1.ArrayList实现类（class）

Java API文档

ArrayList实现类除了包含Collection接口中的所有方法之外，还包括List接口中提供的一些常用方法。

如下表：

方法名称	说明
E get(int index)	获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
int index(Object o)	返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
int lastIndexOf(Object o)	返回此集合中最后一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
E set(int index, Eelement)	将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素
List subList(int fromlndex, int tolndex)	返回一个新的集合，新集合中包含起始索引到末尾索引之间的所有元素，包前不包后

常用操作：增删改查

public class Demo02 {public static void main(String[] args) {List<String> aList = new ArrayList<String>();aList.add("shuyv2019");aList.add("shuyv2020");aList.add("shuyv2021");System.out.println(aList);List<Integer> bList = new ArrayList<Integer>();bList.add(2019);bList.add(2020);bList.add(2021);System.out.println(bList);//删除集合中指定下标处的数据aList.remove(1);//aList.remove("shuyv2019");aList.forEach(temp->{System.out.println(temp);});//根据内容删除Object o = 2020;bList.remove(o);for (Integer temp : bList) {System.out.println(temp);}//清空集合中的所有元素//aList.clear();//bList.clear();//修改集合中的元素aList.set(0,"凌2019");aList.forEach(temp->{System.out.println(temp);});}
}

注意上述代码中的删除操作，remove删除有俩种方式，一种是根据索引进行删除（int），另一种是直接根据内容删除（Object）。

2.LinkedList实现类（class）

由上述图片所描述的Collection集合框架体系可知，Link集合接口继承了Collection接口，所以说LinkedList实现类包含Collection接口和List接口的所有方法，除此之外，LinkedList实现类当中还包含一些特别的方法。

如下表：

方法名称	说明
void addFirst(E e)	将指定元素添加到此集合的开头
void addLast(E e)	将指定元素添加到此集合的末尾
E getFirst()	返回此集合的第一个元素
E getLast()	返回此集合的最后一个元素
E removeFirst()	删除此集合中的第一个元素
E removeLast()	删除此集合中的最后一个元素

代码演示：

public class Demo01 {public static void main(String[] args) {// 创建集合对象LinkedList<String> products = new LinkedList<String>();String str1 = new String("shuyv2019");String str2 = new String("shuyv2020");String str3 = new String("shuyv2021");String str4 = new String("shuyv2022");products.add(str1);products.add(str2);products.add(str3);products.add(str4);System.out.println(products);//在集合末尾添加元素String str5 = new String("shuyv2023");products.addFirst(str5);System.out.println(products);//返回集合的第一个元素String the_first = products.getFirst();System.out.println(the_first);}
}

3.二者区别（底层理解）

ArrayList类和LinkedList类都是List集合接口的实现类，因此都实现了List的所有未实现方法，只是实现方式不同。

此二者最大的区别，则是底层储存数据的方式不同，ArrayList是基于顺序表数据结构而实现，访问速度快。LinkedList是基于链表数据结构而实现，占用内存较大，适合批量插入或者删除数据。

二、Set集合（interface）

Set集合当中的对象不按照特定的方式排序。
Set集合中不能包含重复的对象，并且最多只允许包含一个null元素。
Set集合实现了Collection接口，它主要有俩个常用的实现类：HashSet和TreeSet

1.HashSet实现类（class）

顾名思义，HashSet集合底层是按照Hash算法来储存集合中的元素。因此具有良好的存取和查找性能。

HashSet具有以下特点：

1.不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
2.HashSet不是同步的，如果多个线程同时访问或者修改一个HashSet，则必须通过代码来保证q其同步。
3.集合元素值可以是null。
4.具有很好的存取和查找性能。

代码演示：

public class Demo01 {public static void main(String[] args) {HashSet hashSet = new HashSet();String str1 = new String("shuyv2019");String str2 = new String("shuyv2020");String str3 = new String("shuyv2021");String str4 = new String("shuyv2022");String str5 = new String("shuyv2022");hashSet.add(str1);hashSet.add(str2);hashSet.add(str3);hashSet.add(str4);hashSet.add(str5);System.out.println("2019-2022年的shuyv：" + hashSet);Iterator<String> it = hashSet.iterator();while (it.hasNext()) {System.out.println((String) it.next());}System.out.println(hashSet.size());}
}

执行结果如下：

2019-2022年的shuyv：[shuyv2019, shuyv2020, shuyv2022, shuyv2021]
shuyv2019
shuyv2020
shuyv2022
shuyv2021
4

通过上述代码可知，如果向Set集合中添加俩个相同的元素，则后添加的元素会覆盖前面添加的元素，即在Set集合中不会出现相同的元素。

HashSet的底层理解：

当我们向HashSet存入一个元素的时候，HashSet会调用该对象的hashCode()方法来获取该对象的hashCode值（十六进制哈希值，也就是内存地址值），然后根据该hashCode值决定该对象在HashSet中的存储位置。所以要特别注意一点，虽然HashSet中不能出现重复的元素，但是也有特殊情况，比如当使用equals()方法来比较俩个元素时，如果返回值为true，但是这俩个元素的hashCode不相等，HashSet会把这俩个元素放在不同的位置，依然可以添加成功。

2.TreeSet实现类（class）

TreeSet类同时实现了Set接口和SortedSet接口。SortedSet接口是Set接口的子接口，可以实现对集合进行字然排序，因此使用TreeSet类实现的Set接口默认情况下是自然排序的，这里的自然排序是指升序。

这里的自然排序也有局限性，因为*TreeSet只能对实现了Comparable接口的类对象进行排序*。

Comparable接口请查询Java API文档进行了解
Java API文档

TreeSet实现类除了实现Collection接口所有的方法之外，还提供了一些常用方法。

如下表：

方法名称	说明
E first()	返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型
E last()	返回此集合中的最后一个元素
E poolFirst()	获取并移除此集合中的第一个元素
E poolLast()	获取并移除此集合中的最后一个元素
SortedSet subSet(E fromElement,E toElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement。。对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象
SortedSet headSet<E toElement〉	返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象
SortedSet tailSet(E fromElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象

注意：方法看上去多一些，但其实只是一些简单的集合元素获取，还有截取，注意索引范围。

代码举例：

public class Demo02 {public static void main(String[] args) {TreeSet<Double> treeSet = new TreeSet<Double>();Double num1 = 2020.0;Double num2 = 2019.0;Double num3 = 2021.0;Double num4 = 2022.0;Double num5 = 2022.0;treeSet.add(num1);treeSet.add(num2);treeSet.add(num3);treeSet.add(num4);treeSet.add(num5);System.out.println("treeSet中的元素：" + treeSet);//返回集合中的第一个元素和最后一个元素System.out.println(treeSet.first());System.out.println(treeSet.last());//集合截取Object newSet = treeSet.subSet(2020.0,2022.0);System.out.println(newSet);Iterator<Double> it = treeSet.iterator();while (it.hasNext()) {System.out.println(it.next());}}
}

三、遍历

1.传统for循环

传统的for循环，就是最普通最简单的形式，如下代码举例：

for (int i = 0; i < aList.size(); i++) {System.out.println(aList.get(i));
}

2.高级for循环

语法格式：

for(数据类型 变量名 : 集合/数组) {代码块
};

注意：在高级for循环中定义的变量，每次循环都会被集合中的元素赋值，也就是说，该变量接受的是集合中的每个元素。

代码演示：

for (Object temp : aList) {System.out.println(temp);
}

3.lambda表达式

匿名函数，是在高级for循环的基础上，再次简化语法。

语法格式如下：

集合.forEach(临时变量->{代码块
});

代码演示：

aList.forEach(temp->{System.out.println(temp);
});

注意：

1.在使用lambda表达式的时候，不需要指定数据类型，它会自动识别。
2.lambda表达式只针对集合，不可以遍历数组。

4.迭代器

Iterator（迭代器）是一个接口，它的作用就是遍历容器内的所有元素，迭代器不同于Collection和Map系列的集合，Collection和Map系列集合主要是用于盛装其他对象，而Iterator则主要用于遍历访问Collection中的元素。

Iterator接口中定义的方法：

方法名	作用
boolean hasNext()	如果被迭代的集合没有被遍历完，则返回true
Object next()	返回集合里的下一个元素
void remove()	删除集合里上一次next方法返回的元素
void forEachRemaining(Consumer action)	这是Java8当中新增的默认方法，该方法可使用Lambda表达式来遍历集合元素

代码演示：

public class IteratorTest {public static void main(String[] args) {// 创建一个集合，多态语法（基于继承）Collection the_Set = new HashSet();the_Set.add("shuyv2019");the_Set.add("shuyv2020");the_Set.add("shuyv2020");the_Set.add("shuyv2021");the_Set.add("shuyv2022");System.out.println(the_Set);// 调用forEach()方法遍历集合，，注：lambda表达式System.out.println("使用lambda表达式遍历结果如下：");the_Set.forEach(temp->{System.out.println(temp);});System.out.println("-----------------------------------");System.out.println("使用迭代器遍历结果如下：");// 迭代器遍历Iterator it = the_Set.iterator(); // 获取迭代器对象itwhile (it.hasNext()) {// it.next()返回的数据类型是Object类型，因此需要强制类型转换String obj = (String) it.next();System.out.println(obj);if (obj.equals("shuyv2020")) {// 从集合中删除上一次next()方法返回的元素it.remove();}}System.out.println("------------------------迭代过程中删除了shuyv2020，集合结果如下：");System.out.println(the_Set);}
}

代码执行结果如下：

[shuyv2019, shuyv2020, shuyv2022, shuyv2021]
使用lambda表达式遍历结果如下：
shuyv2019
shuyv2020
shuyv2022
shuyv2021
-----------------------------------
使用迭代器遍历结果如下：
shuyv2019
shuyv2020
shuyv2022
shuyv2021
------------------------迭代过程中删除了shuyv2020，集合结果如下：
[shuyv2019, shuyv2022, shuyv2021]

注意事项：
Iterator（迭代器）必须依附于Collection对象，如若有一个Iterator对象，那么必然有一个Collection对象。

当使用Iterator（迭代器）访问Collection集合元素的时候，Collection集合里的元素不能改变，只有通过Iterator中的remove()方法删除上一次next()方法返回的集合元素才可以，否则会引发“java.util.ConcurrentModificationException”异常

5.lambda表达式遍历迭代器

根据3、4小节直接通过代码展示

public class Demo02 {public static void main(String[] args) {// 创建一个集合Collection objs = new HashSet();objs.add("shuyv2019");objs.add("shuyv2020");objs.add("shuyv2021");// 获取objs集合对应的迭代器Iterator it = objs.iterator();// 使用lambda表达式遍历迭代器it.forEachRemaining(temp->{System.out.println("迭代集合元素：" + temp);});}
}

运行结果如下

迭代集合元素：shuyv2019
迭代集合元素：shuyv2020
迭代集合元素：shuyv2021

Map集合（interface）

Map是一种键值对（key-value）集合，Map集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。Map集合用于保存具有映射关系的数据。

注意：

1.Map结合中的key和value都可以是任何引用数据类型。
2.Map中的key不允许重复，value可以重复。而且使用equals方法来比较key的时候返回值永远是false。
3.key和value一一对应，通过key来访问value。

Map结合接口主要有来个实现类：HashMap类和TreeMap类。
HashMap类底层由哈希算法来存取键对象，TreeMap类可以对键对象进行排序。

Java API文档

1.HashMap实现类

以下表格是一些常用方法

方法名称	方法作用
void clear()	删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key)	查询 Map 中是否包含指定的 key，如果包含则返回 true。
boolean containsValue(Object value)	查询 Map 中是否包含一个或多个 value，如果包含则返回 true。
V get(Object key)	返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型。通过键获取值
V put(K key, V value)	向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m)	将指定 Map 中的 key-value 对复制到本 Map 中。
V remove(Object key)	从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
boolean remove(Object key, Object value)	这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。
Set entrySet()	返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
Set keySet()	返回 Map 集合中所有键对象的 Set 集合
boolean isEmpty()	查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。
int size()	返回该 Map 里 key-value 对的个数
Collection values()	返回该 Map 里所有 value 组成的 Collection

案例演示：
创建HashMap集合用来保存NBA球员信息，然后通过上述表格的常用方法对集合进行操作。

public class Demo01 {public static void main(String[] args) {HashMap players = new HashMap();players.put("James","36");players.put("Durant","30");players.put("ZiMu","24");players.put("HaDen","29");players.put("Yao","40");System.out.println("------------------------------NBA运动员-------------------------------");System.out.println(players);System.out.println("Keys:  " + players.keySet());System.out.println("values:  " + players.values());//通过key获取valueSystem.out.println("Yao's age is " + players.get("Yao") + " years old");System.out.println("---------------------------------------------------------------------");// 获取Map键集合的迭代器对象Iterator it = players.keySet().iterator();while (it.hasNext()) {// 遍历Object key = it.next();Object value = players.get(key);System.out.println(key + "今年" + value + "岁。");}Scanner scanner = new Scanner(System.in);System.out.println("---------------------------------------------------------");System.out.println("请输入要删除的球员");String input = scanner.next();if (players.containsKey(input)) {// 判断输入的键是否被集合包含，如果在集合当中，则删除players.remove(input);} else {System.out.println("NBA没有这个球员！");}System.out.println("删除后球员后的集合-----------------------------------------------------");Iterator iterator = players.keySet().iterator();while (iterator.hasNext()) {// 遍历Object key = iterator.next();Object value = players.get(key);System.out.println(key + "今年" + value + "岁。");}}
}

Scanner输入：Durant
执行结果如下

------------------------------NBA运动员-------------------------------
{James=36, Yao=40, HaDen=29, Durant=30, ZiMu=24}
Keys:  [James, Yao, HaDen, Durant, ZiMu]
values:  [36, 40, 29, 30, 24]
Yao's age is 40 years old
---------------------------------------------------------------------
James今年36岁。
Yao今年40岁。
HaDen今年29岁。
Durant今年30岁。
ZiMu今年24岁。
---------------------------------------------------------
请输入要删除的球员
Durant
删除后球员后的集合-----------------------------------------------------
James今年36岁。
Yao今年40岁。
HaDen今年29岁。
ZiMu今年24岁。

2.TreeMap实现类

TreeMap使用的方法和HashMap相同，唯一的不同就是，TreeMap可以对键对象进行排序。

3.Map集合的遍历

Map集合的遍历和上文当中Collection中的遍历方式没有太大的区别。

（1）高级for循环，结合entries实现遍历（针对键值都需要的情况）

高级for循环结合entries实现遍历，这是最常见的方式，并且在大多数情况下也是最可取的遍历方式。在键值都需要的时候使用。

public class Demo02 {public static void main(String[] args) {Map<String,String> map = new HashMap<String, String>();map.put("凌薇","2020");map.put("shuyv","2019");for (Map.Entry<String,String> entry : map.entrySet()) {String mapKey = entry.getKey();String mapValue = entry.getValue();System.out.println(mapKey + ":" + mapValue);}}
}

执行结果如下：

凌薇:2020
shuyv:2019

（2）for-each循环（只针对Key或者Value）

使用for-each循环遍历key或者values，一般只适用于只需要key或者values时使用。性能上比entrySet较好。

注意：这边的for-each循环和lambda表达式forEach不一样。

public class Demo03 {public static void main(String[] args) {Map<String,String> map = new HashMap<String, String>();map.put("凌薇","2020");map.put("shuyv","2019");// for循环打印输出结合中的keyfor (String key : map.keySet()) {System.out.println(key);}// 打印值集合for (String value : map.values()) {System.out.println(value);}}
}

执行结果如下：

凌薇
shuyv
2020
2019

（3）迭代器遍历 Iterator

public class Demo04 {public static void main(String[] args) {Map<String, String> map = new HashMap<String, String>();map.put("凌薇","2020");map.put("shuyv","2019");Iterator<Map.Entry<String,String>> entries = map.entrySet().iterator();while (entries.hasNext()) {Map.Entry<String,String> entry = entries.next();String key = entry.getKey();String value = entry.getValue();System.out.println(key + ":" + value);}}
}

执行结果如下：

凌薇:2020
shuyv:2019

（4）通过Key找Value遍历

通过键找值遍历，这种方式的效率比较低，因为本身从键去找值就是比较耗时的操作。

代码演示如下

for(String key : map.keySet()){String value = map.get(key);System.out.println(key+":"+value);
}

泛型（集合框架的规范）

简介

Java的集合有缺点，当把对象放进集合当中时，该集合不能够记录这个对象是什么类型的，所以设计者们把集合设计成能接受任何类型的对象，从而使集合更加灵活。但是，集合中的对象都被编译成了Object类型（当然在运行过程中该对象的类型没有改变）。

所以在使用集合的时候会出现下问题：

1.集合对元素类型没有任何限制，这样可能会引发一些问题，例如，当我们想创建一个保存Dog对象的集合，但程序也可以轻易的将Cat对象丢进去，所以引发异常。
2.由于把对象丢进集合当中时，集合丢失了对象的状态信息，就是说集合不知道该对象的数据类型，直接认为该对象是Object类型，因此取出集合元素通常还需要强制类型转换，这种强制类型转换既增加了编译的复杂程度，也容易引发ClassCastException异常。

所以为了解决该类问题，Java出现了泛型。泛型可以在编译的时候检查类型安全，并且所有的强制类型转换都是自动的和隐式的，提高了代码的重用率。

Java集合框架讲解【泛型、Collection接口、Map接口、以及子接口和实现类、集合的遍历形式等】相关推荐

java内部类、接口、集合框架、泛型、工具类、实现类
一.内部类 1.成员内部类. (1)成员内部类的实例化: 外部类名.内部类名变量名=外部类对象.new 内部类名(); class Person{class Test{}}Person p=ne ...
Java集合框架总结（5）——Map接口的使用
Java集合框架总结(5)--Map接口的使用 Map用于保存具有映射关系的数据(key-vlaue).Map的key不允许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回fa ...
【Java高级特性】集合框架和泛型（一）
1.认识集合 Java中可以使用数组存储多个类型相同的数据,但是使用数组存在如下缺陷: 数组长度固定,不能很好的适应元素动态变化的情况: 可以通过数组名.length获取数组的长度,但是不能直接获取数 ...
Java之集合框架图及 Collection和Collections的区别及用法总结
Java中Collection和Collections的区别: 1.Java集合框架图: 2.Collection接口: java.util.Collection是一个集合接口,其中定义了对集合对象有 ...
Java集合框架概述及Collection接口方法讲解
Java集合框架概述一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储.另一方面,使用Array存储对象方面具有一些弊端,而Java 集合就像一种容 ...
史上最全的集合框架讲解 ----- Java 集合框架（3）---- Map 相关类最全解析
引言好了,步入正题,上篇文章Java 集合框架(2)---- List 相关类解析中我们一起看了一下 List 接口的相关具体类(ArrayList.LinkedList-.),这篇开始我们开始探索 ...
Java自学第6期——Collection、Map、迭代器、泛型、可变参数、集合工具类、集合数据结构、Debug
欢迎访问我的个人网站:https://bengtian.club 集合:集合是java中提供的一种容器,可以用来存储多个数据. 集合和数组既然都是容器,它们有啥区别呢? 数组的长度是固定的.集合的长度 ...
（Java集合框架）集合框架概述和Collection常用功能及遍历
文章目录集合概述集合框架 Collection 常用功能代码演示集合遍历 Iterator接口迭代器的实现原理增强for 代码演示集合概述集合:集合是java中提供的一种容器,可以用来 ...
Java集合框架--List、Set、Map
Java集合框架接口和类的层次结构: java.util.Collection [I] +--java.util.List [I]+--java.util.ArrayList [C]+--java.u ...
面试宝典JAVA集合框架 List、Set、Map
一.集合框架(*,必须掌握) 定义:集合与数组类似,只不过集合中的数据量可以动态的变化. 1.List集合:存放的数据可以重复,并且有顺序 ArrayList:底层是Object数组.增删很慢,查询很 ...

Java集合框架讲解【泛型、Collection接口、Map接口、以及子接口和实现类、集合的遍历形式等】

文章目录

Collection集合框架体系

集合

一、List集合（interface）

1.ArrayList实现类（class）

2.LinkedList实现类（class）

3.二者区别（底层理解）

二、Set集合（interface）

1.HashSet实现类（class）

HashSet的底层理解：

2.TreeSet实现类（class）

三、遍历

1.传统for循环

2.高级for循环

3.lambda表达式

4.迭代器

5.lambda表达式遍历迭代器

Map集合（interface）

1.HashMap实现类

2.TreeMap实现类

3.Map集合的遍历

（1）高级for循环，结合entries实现遍历（针对键值都需要的情况）

（2）for-each循环（只针对Key或者Value）

（3）迭代器遍历 Iterator

（4）通过Key找Value遍历

泛型（集合框架的规范）

简介

Java集合框架讲解【泛型、Collection接口、Map接口、以及子接口和实现类、集合的遍历形式等】相关推荐

最新文章

热门文章