Java笔记——Java集合框架_java 集合框架-优快云博客

本文链接：https://blog.youkuaiyun.com/a25847a/article/details/144443516

7.1 Java集合框架概念

数组长度固定不变

数组长度固定不变

不便存储具有映射关系的数据

不便存储具有映射关系的数据

数据变更效率低下

数据变更效率低下

定义一个数组不确定长度，太少浪费空间，太多空间不足
如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架

7.1.1 集合框架

集合中的元素全部是对象

集合中的元素全部是对象

不同的集合类有不同的功能和特点，适合不同的场合

不同的集合类有不同的功能和特点，适合不同的场合

注意

Java 的集合类主要由两个接口派生而成：Collection 接口和 Map 接口。

Java 的集合类主要由两个接口派生而成：Collection 接口和 Map 接口。

Collection 接口和 Map 接口是 Java集合框架的根接口，这两个接口又包括一些子接口或实现类。

Collection 接口和 Map 接口是 Java集合框架的根接口，这两个接口又包括一些子接口或实现类。

其中Collection 接口常用的子接口包含 List 接口和Set 接口；另外一个重要接口是 Map 接口，它是独立一支，

其中Collection 接口常用的子接口包含 List 接口和Set 接口；另外一个重要接口是 Map 接口，它是独立一支，

以上三者都是集合接口。

以上三者都是集合接口。

Java 集合框架还包括相关的工具类(Iterator 迭代器接口、Arrays 类和Collections 类)。

Java 集合框架还包括相关的工具类(Iterator 迭代器接口、Arrays 类和Collections 类)。

7-1表 Java 集合框架常用接口说明

名称

描述

Collection

>单值集合的根接口，是最基本的集合接口，单值集合的父类。

>一个Collection 代表一组Object。Java 不提供实现类，只提供子接口(如List 接口和Set 接口)。

>Collection 接口存储一组可重复的无序对象

Set

继承 Collection 接口，存储一组不可重复的无序对象。

List

>继承 Collection 接口，存储一组可重复的有序对象。

>元素顺序以元素插入的次序放置元素，不会重新排序。

>List 接口常用的实现类有 ArrayList 类和 LinkedList 类

Map

>存储成对数据根接口，可存储一组"键-值对"对象。

>提供键(key) 到值(value) 的映射，Map 中的键不要求有序，不允许重复。值同样不要求有序，但允许重复。

>可以通过键找到对应的值。

Iterator

集合迭代器，能够遍历集合元素的接口

Collections

>与 Collection 是不同的概念，它提供了对集合对象进行基本操作的通用接口方法。

>包含各种有关集合操作的静态方法。

>是一个工具类，不能实例化。

7.1.2 Collection 接口

Collection 接口是 List 接口、Set 接口的父接口，该接口中定义的方法即可用于操作 Set 集合，也可以用于操作 List 集合。

7-2表 Collection 接口常用方法

方法

描述

boolean add(Oject o)

用于向集合中添加一个元素，如果集合不允许重复且已包含了置顶元素，则返回false

boolean addAll(Collection c)

将集合 c 里的所有元素添加到置顶集合里，添加成功返回 true

void clear()

清楚集合中所有的元素，将集合长度变成0

boolean contains(Object 0)

判断集合中是否包含置顶元素

boolean containsAll(Collection c)

判断集合中是否包含集合 c 里所有的元素

boolean remove(Object o)

删除集合中的置顶元素 o，当集合中包含了一个或多个元素 o 时，这些元素将被删除，删除成功则返回true

int size()

返回集合里元素的个数

boolean retainAll(Collection c)

从集合中删除集合 c 里不包含的元素(相当于把调用该方法的集合变成该集合和集合c 的交集)，如果该操作改变了调用该方法的集合，则该方法返回true。

boolean removeAll(Collection c)

从集合中删除集合 c 里包含的所有元素（相当于用调用该方法的集合减集合 c），如果删除了一个或一个以上的元素，则该方法返回true。

boolean isEmpty()

如果此集合中不包含任何一个元素，则该方法返回true

Objeect[] toArray()

把集合转换成一个数组，所有集合元素变成对应的数组元素

示例

package OOP07.课前预习.Collction; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; public class ArratList { public static void main(String[] args) { Collection collection=new ArrayList(); //添加元素 System.out.println("*********添加元素add（）"); collection.add("小老虎"); collection.add("熊猫"); collection.add("狗"); collection.add("孔雀"); collection.add(2); //打印元素 System.out.println("第一个集合里的元素:"+collection); //删除元素 remove() System.out.println("*********删除元素************"); collection.remove(2); System.out.println("第一个集合里删除后的元素:"+collection); //获取集合元素的个数size() System.out.println("**********获取元素个数***********"); System.out.println("第一个集合共添加了"+collection.size()+"个动物信息"); //判断是否包含指定元素 contains() System.out.println("**********判断是否包含指定元素 contains()*******"); //返回值为布尔类型 System.out.println("第一个集合中是否包含了小猫动物"+collection.contains("小猫")); System.out.println("***********判断集合包含关系***********"); //第二个集合 Collection collection2=new HashSet(); //添加元素 System.out.println("*********添加元素add（）"); collection2.add("小老虎"); collection2.add("熊猫"); collection2.add("狗"); collection2.add("小猫"); collection2.add("骆驼"); System.out.println("**********第二个集合的元素*************"); System.out.println("第二个集合的元素:"+collection2); //判断是否这个集合是否包含另一个集合 System.out.println("第二个集合是否包含第一个集合?:"+collection2.containsAll(collection)); //只有第一个集合里的所有元素第二个集合里都有 结果才为真 collection.remove("孔雀"); System.out.println("第二个集合是否包含第一个集合?:"+collection2.containsAll(collection)); System.out.println("****************只保留集合中的共同元素 retainAll()***********"); collection2.retainAll(collection); System.out.println("第二个集合的元素:"+collection2); System.out.println("***************删除集合2全部元素 clear()****************"); collection2.clear(); System.out.println("第二个集合中的元素:"+collection2); } }

提示

Java 集合中的元素全部是对象，是引用类型，不能存储基本数据类型元素。如果强制添加，则其会自动封装成对象。列如:int 会变成Integer

Java 集合中的元素全部是对象，是引用类型，不能存储基本数据类型元素。如果强制添加，则其会自动封装成对象。列如:int 会变成Integer

集合中存储的元素都为 Object 类的对象，想要使用其他类型接收，需要强制转换。

集合中存储的元素都为 Object 类的对象，想要使用其他类型接收，需要强制转换。

7.1.3 集合的遍历

1.使用 Iterator 接口遍历集合元素

Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法

Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法

Iterator（迭代器）该类主要用于遍历集合对象，该类描述了遍历集合的常见方法

Iterator（迭代器）该类主要用于遍历集合对象，该类描述了遍历集合的常见方法

1.表7-3 Iterator 接口定义的方法

方法

boolean hasNext()

判断是否存在下一个遍历元素，存在则返回true

Object next()

返回遍历的下一个元素

void remove()

删除集合里上一次next()方法返回的元素

#####2.实例

创建一个动物类(Animal) 定义两个属性一个名字(name)、一个体重(weight) 使用构造函数在创建对象的时候把值传递过来、在定义一个方法输出动物的名字和体重

package OOP07.课前预习.IterAtor.实例; import java.util.WeakHashMap; public class Animal { String name;//名字 double weight;//体重 public Animal(){} public Animal(String name,double weight){ this.name=name; this.weight=weight; } public void Show() { System.out.println(name+"小动物体重:"+ weight); } }

**创建一个测试类在Main 方法里实现向集合添加数据和遍历循环判断集合

package OOP07.课前预习.IterAtor.实例; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.List; public class Test { public static void main(String[] args) { //构造函数传值 Animal animal1=new Animal("小猫",18.5); Animal animal2=new Animal("老虎",89); Animal animal3=new Animal("熊猫",108); //new 一个HashSet 把定义好对象的值传递给HashSet Collection collection=new HashSet(); //添加 collection.add(animal1); collection.add(animal2); collection.add(animal3); //创建一个迭代器 Iterator iterator=collection.iterator(); while (iterator.hasNext()){//判断有没有下一个元素 //有下一个元素，就将遍历好的值用Animal 动物类对象接收 强制转换一下 Animal animal=(Animal)iterator.next(); //最后展示一下动物信息 animal.Show(); } } }

在这里插入图片描述

从代码中可以看出

Iterator 接口的使用必须依赖于 Collection 对象，若有一个 Iterator 对象，则必然有一个与之关联的Collection 集合。

Iterator 接口的使用必须依赖于 Collection 对象，若有一个 Iterator 对象，则必然有一个与之关联的Collection 集合。

没有集合的 Iterator 接口就像无本无木，无法发挥作用。

没有集合的 Iterator 接口就像无本无木，无法发挥作用。

Iterator 类提供了两个方法访问 Collection 集合里的元素，并且可通过 remove() 方法删除集合中上一次遍历的集合元素。

Iterator 类提供了两个方法访问 Collection 集合里的元素，并且可通过 remove() 方法删除集合中上一次遍历的集合元素。

但 Iterator 接口仅用于遍历集合,本身并不提供存储数据的功能。

但 Iterator 接口仅用于遍历集合,本身并不提供存储数据的功能。

注意:当使用 Iterator 接口遍历 Collection 集合元素时，使用 remove()方法删除元素

Iterator iterator=collection.iterator(); while (iterator.hasNext()){ Animal animal=(Animal)iterator.next(); if(animal.name.equals("小猫")) { //iterator.remove(); 这样删除不会有什么影响 collection.remove(animal1); }else { animal.Show(); } }

在对 Collection 集合里的元素进行遍历操作时，其中的元素不能被改变，不能使用集合自带的remove() 方法删除集合元素本身。

在对 Collection 集合里的元素进行遍历操作时，其中的元素不能被改变，不能使用集合自带的remove() 方法删除集合元素本身。

删除会引发 ConcurrentModificationException 修改异常

而使用 Iterator 接口对集合元素进行遍历时，并不是把集合元素值传给了迭代器。

而使用 Iterator 接口对集合元素进行遍历时，并不是把集合元素值传给了迭代器。

而是把集合元素的值传给了迭代器，所以修改迭代器的值对集合本身没有任何影响

而是把集合元素的值传给了迭代器，所以修改迭代器的值对集合本身没有任何影响

####2.使用 foreach 循环遍历集合元素

除了使用 Iterator 接口遍历 Collection 集合中的元素外，使用foreach 循环遍历集合会更加便捷。

语法

for (数据类型 type 迭代变量名 value:迭代对象 Object)

实例

package OOP07.课前预习.IterAtor.实例; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.List; public class Test { public static void main(String[] args) { Animal animal1=new Animal("小猫",18.5); Animal animal2=new Animal("老虎",89); Animal animal3=new Animal("熊猫",108); Collection collection=new HashSet(); collection.add(animal1); collection.add(animal2); collection.add(animal3); Iterator iterator=collection.iterator(); for (Object object:collection) { Animal animal=(Animal) object; animal.Show(); } } }

7.2 List

###7.2.1 List概述

List 集合是一类存储元素有序，可重复的集合，集合中每个元素都有其对应的索引。

List 集合是一类存储元素有序，可重复的集合，集合中每个元素都有其对应的索引。

List 允许使用重复元素。

List 允许使用重复元素。

可以通过索引(下标)访问指定位置的集合元素。

可以通过索引(下标)访问指定位置的集合元素。

void add(int index,Object o)

在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间

boolean addAll(int index,Collection c)

将元素(element) 插入List集合的指定位置(index)

Object get(int index)

返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换

int indexOf(Object o)

返回对象 o 在 List 集合中第一次出现的位置索引

int LastIndexOf(Object o)

返回对象 o 在 List 集合中最后一次出现的位置索引

Object remove(int index)

从列表中删除指定位置元素，起始索引位置从0开始

boolean remove(Object o)

从列表中删除元素

Object set(int index,Object element)

将index 索引处的袁旭替换成 Element 对象，返回新元素

List subList(int fromIndex,int toIndex)

返回从索引包含 (fromIndex)到索引不包含(toIndex)处所有集合元素组成的子集合

所有LIst 集合都可以调用以上这些方法操作集合元素。

所有LIst 集合都可以调用以上这些方法操作集合元素。

List 集合比Collection 接口扩充了更多的方法，而且这些方法操作起来很方便。

List 集合比Collection 接口扩充了更多的方法，而且这些方法操作起来很方便。

需要通过List 接口的子类实例化调用。

需要通过List 接口的子类实例化调用。

常用的子类有 ArrayList 类和 LinkedList 类，

常用的子类有 ArrayList 类和 LinkedList 类，

ArrayList 类对数字进行了封装，实现了长度可变的数组。ArrayList 集合存储数据的方式和数据相同，都是在内存中分配连续的空间。
在这里插入图片描述
LinkedList 集合存储数据的方式为双向链表存储方式，如图，它的每一个节点中都有两个指针，分别指向直接后继和直接前驱。

它提供了额外的 addFirst()、addLast()、removeFirst()和removeLast()等方法。可以在链表的首部或尾部进行插入或删除数据。
在这里插入图片描述
7.2.2 ArrayList 集合类

向集合中添加信息

向集合中添加信息

向指定排序位置新增信息

向指定排序位置新增信息

删除指定排序位置的信息

删除指定排序位置的信息

更新指定排序位置的信息

更新指定排序位置的信息

分析

元素个数不确定，但一定有顺序,可以使用List 接口的实现类 ArrayList 完成该需求

元素个数不确定，但一定有顺序,可以使用List 接口的实现类 ArrayList 完成该需求

创建多个 Animal 对象，将其添加到 ArrayList 集合对象中。

创建多个 Animal 对象，将其添加到 ArrayList 集合对象中。

使用 remove(int index)、remove(object o)方法是实现删除。

使用 remove(int index)、remove(object o)方法是实现删除。

使用 set() 方法实现更新指定位置水果信息。

使用 set() 方法实现更新指定位置水果信息。

使用 subList()方法实现截取子集合。

使用 subList()方法实现截取子集合。

package OOP07.课前预习.List.实例; public class Animal { String name;//名字 double weight;//体重 public Animal(){} public Animal(String name,double weight){ this.name=name; this.weight=weight; } public void Show() { System.out.println(name+"小动物体重:"+ weight); } }

package OOP07.课前预习.List.实例; import java.util.*; public class Test { public static void main(String[] args) { List list=new ArrayList(); Animal animal1=new Animal("大熊猫",109); Animal animal2=new Animal("小狗",55); Animal animal3=new Animal("狼",44); Animal animal4=new Animal("骆驼",100); System.out.println("***********向集合中存储信息***************"); //1.添加 list.add(animal1); list.add(animal2); list.add(animal3); showData(list); System.out.println("*************将新的对象插入第2个位置****************"); //2.将新的字符串对象插入第2个位置 list.add(1,animal4); showData(list); System.out.println("*************删除第3个元素**************"); //3.删除第三个元素 list.remove(2); showData(list); //4.将第二个元素替换成新元素 list.set(1,new Animal("山羊",100)); showData(list); //5.将集合的第2个元素(包含)到第3个元素(不包括)截取成子集合 showData(list.subList(1,2)); } public static void showData(List list){ for (Object object:list) { Animal animal=(Animal)object; animal.Show(); } } }

在这里插入图片描述
由于 List 集合可以使用索引访问集合元素，所以List 集合增加了一种新的遍历集合的方式——使用for循环来遍历集合，详见showData()方法。

由于 List 集合可以使用索引访问集合元素，所以List 集合增加了一种新的遍历集合的方式——使用for循环来遍历集合，详见showData()方法。

由于List 集合中存放的都是Object 类型对象，所以 add(Object o) 方法的参数是Object 类的对象，即使在调用时实际参数是 Fruit类的对象，但系统认为里面只是Object 类的参数，所以在通过 get(int i)方法获取元素时必须进行强制类型转换。

Animal animal=(Animal)list.get(i);

Animal animal=(Animal)list.get(i);

删除集合有多种方法，可以按索引删除，如:“list.remove(2)”,也可以按照对象删除，如:“list.remove(animal1)”;

删除集合有多种方法，可以按索引删除，如:“list.remove(2)”,也可以按照对象删除，如:“list.remove(animal1)”;

调用 set(int index,Object o)方法改变List 集合指定索引处的元素时，指定的索引必须是List 集合的有效索引，例如长度是4，不饿能指定替换 index 值为4的元素，即该方法不会改变List 集合的长度。

7.2.3 LinkedList 集合类

特征

在插入、删除操作比较频繁时，可以考虑使用LinkedList 集合提高效率

在插入、删除操作比较频繁时，可以考虑使用LinkedList 集合提高效率

LinkedList 类是 List 接口的实现类，所以LinkedList 集合和ArrayList 集合都是一个List 集合，可以根据索引随机访问集合中的元素。

LinkedList 类是 List 接口的实现类，所以LinkedList 集合和ArrayList 集合都是一个List 集合，可以根据索引随机访问集合中的元素。

LinkedList 集合还具有双向链表结构，更加方便实现添加和删除操作。

LinkedList 集合还具有双向链表结构，更加方便实现添加和删除操作。

####表 7-5 LinkedList 集合实现链表操作的常用方法

void addFirst(Object o)

在列表的首部添加元素

void addLast(Object o)

在列表的末尾添加元素

Object getFirst()

返回列表中的第一个元素

Object getLast()

返回列表中的最后一个元素

Object removeFirst()

删除并返回列表中的第一个元素

Object removeLast()

删除并返回列表中的最后一个元素

如果需要在集合二的首部或尾部添加、获取和删除对象，代码如下:

package OOP07.课前预习.List.实例.LinkedList; public class Animal { String name;//名字 double weight;//体重 public Animal(){} public Animal(String name,double weight){ this.name=name; this.weight=weight; } public void Show() { System.out.println(name+"小动物体重:"+ weight); } }

package OOP07.课前预习.List.实例.LinkedList; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class Test { public static void main(String[] args) { //1.创建集合及元素对象 LinkedList list=new LinkedList(); Animal animal1=new Animal("大熊猫",109); Animal animal2=new Animal("小狗",55); Animal animal3=new Animal("狼",44); Animal animal4=new Animal("骆驼",100); System.out.println("***********向集合中存储信息***************"); //2.向集合中添加元素 list.add(animal1); list.add(animal2); list.add(animal3); showData(list); //3.查看集合中第一条动物信息 System.out.println("************查看集合中第一条动物信息*******"); Animal FirstAnimal=(Animal) ((LinkedList)list).getFirst(); System.out.println("集合中第一条动物信息："+FirstAnimal.name); //4.查看集合中第一条动物信息 System.out.println("**************查看集合中最后一条动物信息"); Animal lastAnimal=(Animal) ((LinkedList)list).getLast(); System.out.println("集合中最后一条动物信息:"+lastAnimal.name); //5.删除集合中最后一条和最后一条信息 list.removeFirst(); list.removeLast(); System.out.println("删除后的动物信息如下:"); showData(list); } public static void showData(List list){ for (Object object:list) { Animal animal=(Animal)object; animal.Show(); } } }

在这里插入图片描述
小结

ArrayList 集合和 LinkeedList 集合对比如下:

ArrayList 集合和 LinkeedList 集合对比如下:

ArrayList的实现是基于动态数组，在内存中分配连续的空间

ArrayList的实现是基于动态数组，在内存中分配连续的空间

LinkedList 是以元素链表的形式存储它的数据，每一个元素都和它的前一个和后一个链接在一起

LinkedList 是以元素链表的形式存储它的数据，每一个元素都和它的前一个和后一个链接在一起

ArrayList查询快，增删慢

ArrayList查询快，增删慢

LinkedList查询慢，增删快

LinkedList查询慢，增删快

7.3 Set

Set 接口和 List接口一样，都是 Collection 的子接口，都是容器。

Set 接口和 List接口一样，都是 Collection 的子接口，都是容器。

Set集合里的多个对象没有明显的顺序。

Set集合里的多个对象没有明显的顺序。

Set 集合与 Collection 集合基本上一样，没有提供额外的方法，只是行为上略有不同，Set 集合不允许包含重复的元素。

Set 集合与 Collection 集合基本上一样，没有提供额外的方法，只是行为上略有不同，Set 集合不允许包含重复的元素。

7.3.1 HashSet 集合

HashSet 类是Set 接口的典型实现，使用 HashSet 集合可以实现对无序不重复数据的存储，具有很好的存取和查找新跟那个。

不允许存储重复的元素。

不允许存储重复的元素。

没有索引，没有包含索引的方法，不能使用索引遍历。

没有索引，没有包含索引的方法，不能使用索引遍历。

是无序集合，存储元素和取出元素的顺序可能不一致。

是无序集合，存储元素和取出元素的顺序可能不一致。

使用 HashSet 集合存储数据，

package OOP07.课前预习; public class Animal { public String name;//名字 public double weight;//体重 public Animal(){} public Animal(String name, double weight){ this.name=name; this.weight=weight; } public void Show() { System.out.println(name+"小动物体重:"+ weight); } }

package OOP07.课前预习.Set.实例.HashSet; import OOP07.课前预习.Animal; import java.util.HashSet; import java.util.Set; public class Test { public static void main(String[] args) { //1.创建一个 Set 集合和多条水果数据 Set set=new HashSet(); Animal animal1=new Animal("大熊猫",109); Animal animal2=new Animal("小狗",55); Animal animal3=new Animal("狼",44); set.add(animal1); set.add(animal2); set.add(animal3); System.out.println("添加重复元素，是否成功?"+set.add(animal1)); //3.遍历集合 for (Object o:set){ Animal animal=(Animal) o; ((Animal) o).Show(); } } }

在这里插入图片描述
可以看到 Set 集合中添加重复的对象 animal1 时，添加操作失败。

可以看到 Set 集合中添加重复的对象 animal1 时，添加操作失败。

在执行该操作的时候，程序会将新添加的对象依次和集合中现有的元素进行比较。

在执行该操作的时候，程序会将新添加的对象依次和集合中现有的元素进行比较。

判断集合中是否存在与所添加对象相同的元素(通过执行集合元素的 hascode()方法和 equals()方法进行判断)。

判断集合中是否存在与所添加对象相同的元素(通过执行集合元素的 hascode()方法和 equals()方法进行判断)。

如不存在则添加成功，否则添加失败

如不存在则添加成功，否则添加失败

初次之外，由于 Set 集合中存储的元素时无序的，无法使用索引，所以不能使用索引进行遍历，这是和 List 集合明显的区别。

初次之外，由于 Set 集合中存储的元素时无序的，无法使用索引，所以不能使用索引进行遍历，这是和 List 集合明显的区别。

7.4 Map

List 集合和 Set 集合都可以存储一组数据元素，每个元素是一个对象。

当需要一组成对的键-值对象，而不是单值数据，这样通过List 集合和Set集合无法实现，需要使用到Map集合。

7.4.1 Map概述

Map 集合可以存储若干个成对的键-值对象，提供键(key) 到值的映射。

Map 集合可以存储若干个成对的键-值对象，提供键(key) 到值的映射。

其中 key 为 Set 集合类型，不要求有序，不允许重复；

其中 key 为 Set 集合类型，不要求有序，不允许重复；

value 同样不要求有序，但允许重复。

value 同样不要求有序，但允许重复。

因为Map 接口与 Collection 接口不存在继承关系，所以Mao集合对象不能使用Collection 接口中定义的方法。

因为Map 接口与 Collection 接口不存在继承关系，所以Mao集合对象不能使用Collection 接口中定义的方法。

Map接口常用的方法

Map接口常用的方法

表7-6 Map接口的常用方法

方法名

说明

Object put(Object key, Object val)

以“键-值对”的方式进行存储

Object get (Object key)

根据键返回相关联的值，如果不存在指定的键，返回null

int size()

返回元素个数

Object remove (Object key)

删除由指定的键映射的“键-值对”

Set keySet ()

返回键的集合

Collection values ()

返回值的集合

boolean containsKey (Object key)

如果存在由指定的键映射的“键-值对”，返回true

Set entrySet ()

返回"键-值对" 集合

boolean isEmpty

若不存在"键-值对"元素，则返回true

vaid clear()

删除该Map 对象中的所有"键-值对"

7.4.2 HasgMap 集合类

建立动物全程与简称对照关系表。

package OOP07.课前预习.Map.实例; import java.util.HashMap; import java.util.Map; public class HasgMap { public static void main(String[] args) { Map map=new HashMap(); //1.添加 键-值对 map.put("xm","小猫"); map.put("dxm","大熊猫"); map.put("xg","小狗"); //2.显示简称为xm 的全称 System.out.println("*******显示简称为xm 的全称*************"); String a=(String)map.get("xm"); System.out.println("xm key值对照的value值是:"+a); //3.显示集合中元素个数 System.out.println("共记录了"+map.size()+"组数据"); //4.两次判断Map集合二中是否存在 xg 键 System.out.println("是否记录简称为 xg 的动物:"+map.containsKey("xg")); //删除简称为 xg 的数据 map.remove("xg"); System.out.println("是否记录简称为 xg 的动物:"+map.containsKey("xg")); //5.分别显示键集、值集和 键-值对 System.out.println(map.keySet()); System.out.println(map.values()); System.out.println(map); //6.清空 HashMap 集合并判断 map.clear(); if(map.isEmpty()) { System.out.println("已清空全部数据"); } } }

在这里插入图片描述
代码可以看出

Map 集合可以存储成对出现的"键-值对"元素，如"xg-小狗"，一个Map对象由若干个"键-值对"组成，

Map 集合可以存储成对出现的"键-值对"元素，如"xg-小狗"，一个Map对象由若干个"键-值对"组成，

使用put() 方法添加数据是以"键-值对"为单位进行添加。

使用put() 方法添加数据是以"键-值对"为单位进行添加。

7.4.3 HashMap 集合的遍历

对于Map 接口来说，本身是不能直接使用迭代(如 Iterator、foreach)进行输出的。Map中的每个位置都是"键-值对"，而Iterator 迭代器每次只能找个一个值。

1.通过KeySet()方法返回键的集合为Set集合。

2.循环遍历键的集合，获取每个键对应的值

package OOP07.课前预习.Map.实例; import OOP07.课前预习.Animal; import java.util.*; public class HashMap集合遍历 { public static void main(String[] args) { Map map=new HashMap(); Animal animal1=new Animal("大熊猫",109); Animal animal2=new Animal("小狗",55); Animal animal3=new Animal("狼",44); map.put(animal1.name,animal1); map.put(animal2.name,animal2); map.put(animal3.name,animal3); //3.通过迭代器依次输出集合中所有动物信息 System.out.println("所有动物信息如下"); Set keys=map.keySet(); Iterator iterator=keys.iterator(); while (iterator.hasNext()){ String key=(String)iterator.next(); Animal animal=(Animal) map.get(key); animal.Show(); } } }

在这里插入图片描述
###7.4.4 Map.Entry

Map.Entry是Map的一个内部接口

用来保存形如 “键(key)-值(value)” 的元素

Map.Entry接口的常用方法

Object getKey ()

取得此 “键(key)-值(value)” 对应的 key 值

Object getValue ()

取得此 “键(key)-值(value)” 对应的 value 值

int hashCode()

返回该 “键(key)-值(value)” 的哈希码值

Object setValue(Object value)

用指定的值替换该 “键(key)-值(value)” 的 Value 值

import java.util.*; public class Test02 { public static void main(String[] args) { HashMap map=new HashMap(); map.put(1,"一"); map.put(2,"二"); map.put(3,"三"); map.put(4,"四"); //获取键-值对 Set map1=map.entrySet(); //遍历集合 Iterator iterator=map1.iterator(); while (iterator.hasNext()){ //转为Map.Entry 类型 Map.Entry me=(Map.Entry)iterator.next(); //获取键 key System.out.print(me.getKey()); //获取值 System.out.println(me.getValue()); } } }

###7.5泛型集合

####7.5.1 泛型概念

规范容器内的数据类型,约束集合中元素的类型

语法 :

集合类型 <要规范的类型> 集合名=new 集合类型 <要规范的类型>();

示例

public class Test03 { public static void main(String[] args) { //集合内只可以存储Integer对象 List<Integer> list=new ArrayList<Integer>(); list.add(1); list.add(2); list.add(3); //因为已经设置了泛型，所以不需要再转换类型 int num= list.get(1); } }