Java OOP 7 JAVA 集合框架

Java OOP 第七章 JAVA 集合框架

一、学习目标

1. 掌握集合框架结构
2. 理解Collection中的常用方法
3. 掌握使用Iterator遍历集合
4. 掌握ArrayList、LinkedList集合的用法
5. 掌握HashMap集合的用法
6. 掌握泛型集合的用法

二、数组存在的缺陷

丰收季节，使用一个长度为5的一维数组记录每家果商需要的水果品类数量

结论：

1. 数组长度固定不变
2. 不便存储具有映射关系的数据
3. 数据变更效率低下

经验

• 如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象，可以使用Java集合框架

三、Java集合框架

Java 集合框架

1. 提供了一套性能优良、使用方便的接口和类
2. 位于java.util包中
3. 集合中的元素全部是对象，即Object类的实例
4. 不同的集合类有不同的功能和特点，适合不同的场合

Collection 接口存储一组不唯一，无序的对象

Map接口存储一组键值对象，提供key到value的映射

四、Collection接口

Collection接口是List、Set接口的父接口

接口里定义的方法即可用于操作Set集合，也可用于操作List集合

常用方法

方法	描述
boolean add(Object o)	用于向集合中添加一个元素 如果集合不允许重复且已包含了指定元素，则返回false
boolean addAll(Collection c)	将集合c里所有元素添加到指定集合里。添加成功返回true
void clear()	清除集合中所有元素，将集合长度变为为0
boolean contains(Object o)	判断集合中是否包含指定元素
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里包含的所有元素 如果删除了一个或一个以上的元素，则返回true
boolean isEmpty()	如果此集合中不包含任何元素，则返回true
Object[] toArray()	该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素

五、Collection接口示例

使用Collection集合实现下面功能

1. 存储果商采购的水果品类信息
2. 获取水果品类总数
3. 删除指定的品类数据
4. 判断集合中是否包含指定数据
5. 输出全部水果品类信息
6. 清空集合

package com.aiden.Collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
 * Collection中的常用方法使用
 */
public class CollectionTest {
    public static void main(String[] args){
        Collection fruitList1 = new ArrayList();
        String aa = "a";
        //添加元素
        System.out.println("********添加元素add()**********");
        fruitList1.add("香水梨") ;
        fruitList1.add("苹果梨");
        fruitList1.add("皇冠梨") ;
        fruitList1.add(5);  //虽然集合里不能放基本类型值，但是Java支持自动封装
        System.out.println("第1个集合里的元素："+fruitList1);

        System.out.println("********删除元素remove()**********");
        fruitList1.remove(5);
        System.out.println("第1个集合里的元素："+fruitList1);

        System.out.println("********获取元素个数size()**********");
        System.out.println("第1个集合一共添加了"+fruitList1.size()+"类水果信息。");

        System.out.println("********判断集合是否包含指定元素contains()**********");
        System.out.println("第1个集合中是否包含富士苹果？"+fruitList1.contains("富士苹果"));

        System.out.println("********判断集合包含关系containsAll()**********");
        Collection fruitList2 = new HashSet();
        fruitList2.add("香水梨");
        fruitList2.add("苹果梨");
        fruitList2.add("富士苹果");
        fruitList2.add("金帅苹果");
        System.out.println("第2个集合里的元素："+fruitList2);
        System.out.println("第2个集合是否包含第1个集合？"+fruitList2.containsAll(fruitList1));
        fruitList1.remove("皇冠梨");
        System.out.println("第2个集合是否包含第1个集合？"+fruitList2.containsAll(fruitList1));

        System.out.println("********只保留集合共同元素retainAll()**********");
        fruitList2.retainAll(fruitList1);
        System.out.println("第2个集合里的元素："+fruitList2);

        System.out.println("********删除集合2全部元素clear()**********");
        fruitList2.clear();
        System.out.println("第2个集合里的元素："+fruitList2);
    }
}

注意：

• 集合中存储元素为Object类型对象，属于引用数据类型，默认调用Object类toString()方法执行输出操作
• 本示例输出集合元素时，调用String类重写的toString()方法

六、迭代器Iterator

System.out.println()方法以[ele1,ele2,…]形式输出集合全部元素

• 因为所有的Collection实现类都重写了toString()方法

如果遍历集合的每一个元素，并对其进行操作呢？

方法一：使用Iterator接口遍历集合元素

• 获取Iterator ：Collection 接口的iterator()方法
• Iterator接口定义的方法

方法	描述
boolean hasNext()	是否存在下一个迭代元素，存在则返回true
Object next()	返回迭代的下一个元素
void remove()	删除集合里上一次next()方法返回的元素

方法二：使用foreach循环遍历集合元素

记录水果更完整的信息，除了品类之外，还需要记录每类水果的价格，遍历集合输出每类水果的品类和价格信息

苹果梨,每斤2.0元。
金帅苹果,每斤3.0元。
香水梨,每斤2.5元。
富士苹果,每斤3.5元。

使用Iterator对象实现

• 定义Fruit类，描述水果对象
• 定义测试类，向集合中添加数据和遍历集合

package com.aiden.collections.demo2;

/**
 * 水果类
 */
public class Fruit {
    private String brand; //水果品种
    private double price;  //价格
    
    //省略 getter\setter...

    public Fruit() { }

    public Fruit(String brand, double price) {
        this.brand = brand;
        this.price = price;//每斤价格
    }

    //输出信息
    public void show() {
        System.out.println(this.brand + ",每斤" + this.price + "元。");
    }
}

Iterator

• Iterator的使用必依赖于Collection对象
• Iterator仅用于遍历集合，并不提供储存数据的功能
• 使用Iterator迭代访问Collection集合时，可调用Iterator的remove()方法删除集合元素

package com.aiden.collections.demo2;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

/**
 * 使用Iterator遍历集合
 */
public class IteratorTest {
    public static void main(String[] args){
        //创建一个集合
        Collection fruits = new HashSet();
        Fruit fruit1 = new Fruit("香水梨",2.5);
        Fruit fruit2 = new Fruit("苹果梨",2.0);
        Fruit fruit3 = new Fruit("富士苹果",3.5);
        Fruit fruit4 = new Fruit("金帅苹果",3.0);
        //添加元素
        fruits.add(fruit1);
        fruits.add(fruit2);
        fruits.add(fruit3);
        fruits.add(fruit4);

        //获取集合迭代器
        Iterator it = fruits.iterator();
        while(it.hasNext()){
            Fruit fruit = (Fruit)it.next();
            fruit.show();
            //删除元素
            if(fruit.getBrand().equals("苹果梨")){
                //it.remove():删除迭代器中存储的值不会影响集合中保存的元素
                it.remove();
            }else {
                fruit.show();
             }
        }
    }
}

注意事项

• 使用Iterator对集合元素进行迭代时，是把集合元素的值传给迭代器，因此，删除迭代器中存储的值不会影响集合中保存的元素

常见错误

• 对Collection集合进行遍历操作时，其中的元素不能被改变

Iterator it = fruitList.iterator();
while(it.hasNext()) {
     Fruit fruit = (Fruit)it.next();
     if(fruit.brand.equals("苹果梨")) {
           fruit.remove();
      } else {
           fruit.show();
      }
}

运行结果 引发ConcurrentModificationException异常

七、使用foreach循环遍历集合元素

foreach循环

• JDK1.5引入的语法结构，也称为增强for循环
• 可用于遍历集合和数组

for(数据类型type 迭代变量名value:迭代对象object) {
     //引用迭代变量value的语句
}

使用foreach循环遍历水果品类集合

for(Object obj:fruits) {
    Fruit fruit = (Fruit)obj;
    fruit.show();
}

注意：

• 与Iterator接口类似，foreach循环中迭代变量也不是集合元素本身，系统只是依次把集合元素的值赋给迭代变量。因此，在foreach循环中修改迭代变量的值也没有任何实际意义

八、List接口

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

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

通过索引访问数组元素，索引从0开始

根据索引操作集合元素的方法

方法	描述
void add(int index,Object element)	将元素(element)插入到List的指定位置（index）处
boolean addAll(int index,Collection c)	将集合c所包含的所有元素都插入List集合指定位置（index）处
Object get(int index)	返回集合index索引处的元素
int indexOf(Object o)	返回对象o在List集合中第一次出现的位置索引
int lastIndexOf(Object o)	返回对象o在List集合中最后一次出现的位置索引
Object remove(int index)	从集合中删除指定位置的元素
boolean remove(Object o)	从集合中删除指定对象
Object set(int index,Object element)	将index索引处的元素替换成element对象，返回新元素
List subList(int fromIndex,int toIndex)	返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成的子集合

List集合

是List接口所有实现类组成的集合

ArrayList类实现长度可变的数组

遍历元素和随机访问元素的效率比较高

LinkedList类采用双向链表存储方式

插入、删除元素时效率比较高

示例

• 使用集合对象存储多类水果信息后，根据需求执行相关操作
  1. 向集合中添加水果信息
  2. 向指定排序位置新增水果信息
  3. 删除指定排序位置的水果信息
  4. 更新指定排序位置的水果信息
  5. 截取指定部分的水果信息集合

分析：

水果的种类数不确定，但有一定顺序，可使用

• List接口的实现类ArrayList

实现的具体步骤

1. 创建多个水果对象，添加到ArrayList类集合中
2. 使用remove(int index)、remove(object o)方法删除集合里的水果
3. 使用set()方法实现向指定位置新增水果
4. 使用subList()方法实现截取子集合

package com.aiden.collections.demo4;

import java.util.ArrayList;
import java.util.List;

/**
 * 使用ArrayList集合存储数据
 */
public class ArrayListTest {
    public static void main(String[] args) {
        //创建一个集合
        List fruits = new ArrayList();
        Fruit fruit1 = new Fruit("苹果1号", 2.5);
        Fruit fruit2 = new Fruit("苹果2号", 2.0);
        Fruit fruit3 = new Fruit("苹果3号", 3.5);
        Fruit fruit4 = new Fruit("苹果4号", 3.0);
        System.out.println("*******向集合中存储信息********");
        fruits.add(fruit1);
        fruits.add(fruit2);
        fruits.add(fruit3);
        showData(fruits);
        System.out.println("******将4号苹果插入到第2个位置******");
        //将新字符串对象插入到第2个位置
        fruits.add(1, fruit4);
        showData(fruits);
        System.out.println("********删除元素********");
        fruits.remove(2);//按索引删除
        //fruits.remove(new Fruit("苹果1号",2.5));//这一条无法删除
        //fruits.remove(fruit1);//按对象删除
        showData(fruits);
        System.out.println("*******将第2个位置替换成新元素********");
        fruits.set(1, new Fruit("无名苹果", 1));
        showData(fruits);
        System.out.println("*******截取子字符串********");
        showData(fruits.subList(1, 2));//将集合的第二个元素（包含）到第3个元素（不包含）截取成子集合
    }

    /**
     * 遍历集合
     */
    public static void showData(List list) {
        for (int i = 0; i < list.size(); i++) {
            Fruit fruit = (Fruit) list.get(i);
            fruit.show();
        }
    }
}

使用List集合的注意事项

• 可以使用索引访问List集合元素

• 可以使用for循环遍历List集合

• List集合中存放的都是Object类对象

  • add(Object o)方法的参数是Object类对象
  • 在通过get(int i)方法获取元素时必须进行强制类型转换
  • Fruit fruit = (Fruit)list.get(i);

• 删除集合元素的方法

  • 按索引删除 fruits.remove(2);
  • 按对象删除 fruits.remove(fruit3);

• 调用set(int index,Object o)方法改变List集合指定索引的元素时，指定的索引必须是List集合的有效索引

• set(int index,Object o)方法不会改变List集合的长度

九、LinkedList类

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

除了具有List接口扩展的方法外，还提供了实现链表操作的方法

方法	描述
void addFirst(Object o)	在链表的首部添加元素
void addLast(Object o)	在链表的末尾添加元素
Object getFirst()	返回链表中第一个元素
Object getLast()	返回链表中最后一个元素
Object removeFirst()	删除并返回链表中的第一个元素
Object removeLast()	删除并返回链表中的最后一个元素

集合的首部或尾部添加、获取和删除水果对象

实现思路及关键代码

1. 创建集合及元素对象
2. 向集合中添加元素
3. 查看集合中第一条水果信息
4. 查看集合中最后一条水果信息
5. 删除集合中第一条和最后一条信息

package com.aiden.collections.demo5;

import java.util.LinkedList;
import java.util.List;
/**
 * 使用LindkedList集合存储数据
 */
public class LinkedListTest {
    public static void main(String[] args) {
        //1.创建集合及元素对象
        LinkedList fruits = new LinkedList();
        Fruit fruit1 = new Fruit("苹果1号", 2.5);
        Fruit fruit2 = new Fruit("苹果2号", 2.0);
        Fruit fruit3 = new Fruit("苹果3号", 3.5);
        Fruit fruit4 = new Fruit("苹果4号", 3.0);
        //2.向集合中添加元素
        fruits.add(fruit1);
        fruits.add(fruit2);
        fruits.add(fruit3);
        fruits.add(fruit4);
        System.out.println("集合中包含水果信息如下：");
        showData(fruits);
        //3.查看集合中第一条水果信息
        Fruit firstFruit = (Fruit) ((LinkedList) fruits).getFirst();
        System.out.println("集合中第一类水果："+firstFruit.getBrand());
        //4.查看集合中最后一条水果信息
        Fruit LastFruit = (Fruit) ((LinkedList) fruits).getLast();
        System.out.println("集合中最后一类水果："+LastFruit.getBrand());
        //5.删除集合中第一条和最后一条信息
        fruits.removeFirst();
        fruits.removeLast();
        System.out.println("删除部分信息后还有"+fruits.size()+"条水果信息。如下：");
        showData(fruits);
    }
        /**
         *遍历集合
         */
    public static void showData(List list) {

        for(int i=0;i<list.size();i++){
            Fruit fruit = (Fruit)list.get(i);
            fruit.show();
        }
    }
}

ArrayList类和LinkedList类对比

ArrayList类和LinkedList类的共同点

• 可以容纳所有类型的元素对象，包括null
• 元素值可以重复
• 元素按顺序存储

ArrayList类特点

• 底层是数组
• 优点：基于数组实现，读取操作效率高
• 缺点：不适合频繁进行插入和删除操作，因为每次执行该类操作都需要频繁移动其中的元素

LinkedList类特点

• 由双向链表实现，任意一个节点都可以方便地访问它的前驱节点和后继节点
• 优点：增加、删除操作只需修改链表节点指针，不需进行频繁的移动
• 缺点：遍历效率较低

十、Set接口

• 和List接口一样，也是Collection的子接口
• 集合里的多个对象之间没有明显的顺序
• 不允许包含重复的元素

• 与Collection接口基本一样，没有提供额外的方法，只是行为上略有不同

• 继承关系

  

十一、HashSet类

是Set接口的典型实现

可以实现对无序不重复数据的存储，具有很好的存取和查找性能

特征

• 不允许存储重复的元素
• 没有索引，没有包含索引的方法，不能使用索引遍历
• 无序集合，存储元素和取出元素的顺序可能不一致

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

• 通过执行集合元素的hascode()方法和equals()方法进行判断
• 如果集合中不存在所添加的元素，则添加成功；否则，添加失败

不能使用索引进行遍历

---

使用HashSet集合存储水果信息数据

关键代码

package com.aiden.collections.demo6;

import java.util.HashSet;
import java.util.Set;

/**
 * 使用HashSet集合存储数据
 */
public class HashSetTest {
    public static void main(String[] args) {
        //1.创建一个Set集合和多条水果数据
        Set fruits = new HashSet();
        Fruit fruit1 = new Fruit("金帅苹果", 2.5);
        Fruit fruit2 = new Fruit("富士苹果", 2.0);
        //2.向集合中添加元素
        fruits.add(fruit1);
        fruits.add(fruit2);
        System.out.println("添加重复元素，是否成功："+fruits.add(fruit1));//false
        //3.遍历集合
        for(Object o:fruits){
            Fruit fruit = (Fruit)o;
            fruit.show();
        }
    }
}

十二、Map接口

查阅汉英字典，可以通过中文找到对应的英文单词

• 由一对一关系的一组中英文数据组成
• 是一组成对的键-值对象，而不是单值数据

Java中，使用List和Set无法实现，怎么办？

• 使用Map接口

Map接口专门处理键值映射数据的存储

• 根据键（key）实现对值（value）的操作
  • Key：不要求有序，不允许重复
  • Value：不要求有序，但允许重复

与Collection接口不存在继承关系

常用方法

方法	描述
Object put(Object key,Object value)	以“键-值对”的方式进行存储
Object get（Object key）	返回指定键所对应的值。如果不存在指定的键，返回null
int size()	返回元素个数
boolean remove(Object key)	删除指定的键映射的“键-值对”
Set keyset()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在指定的键映射的“键-值对”，则返回true
Set entrySet()	返回“键-值对”集合
boolean isEmpty()	若不存在“键-值对”元素，则返回true
void clear()	删除该Map对象中的所有“键-值对”

最常用的实现类是HashMap

存储成对出现的“键-值对”元素

• ​ 如：京—北京市

一个Map对象由若干个“键-值对”组成

查询指定元素效率高

使用HashMap集合类实现下面功能

1. 建立中国省份或直辖市全称与简称对照关系表
2. 通过删除键实现对键值的删除

实现思路及关键代码

1. 使用HashMap存储多组省份全称和简称的键值对
2. 显示简称为"京"的省份或直辖市全称
3. 显示集合中元素个数
4. 两次判断Map中是否存在"闽"键
5. 分别显示键集、值集和键值对集
6. 清空 HashMap并判断

代码示例：

package com.aiden.collections.demo7;

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

/**
 * 使用HashMap存储数据
 */
public class MapTest {
    public static void main(String[] args) {
        //1.使用HashMap存储多组省份全称和简称的键值对
        Map provinces = new HashMap();
        provinces.put("京", "北京市");
        provinces.put("沪", "上海市");
        provinces.put("闽", "福建省");
        provinces.put("湘", "湖南省");
        
        //2.显示简称为"京"的省份或直辖市全称
        String province = (String) provinces.get("京");
        System.out.println("“京”对应的省份或直辖市:" + province);
        
        //3.显示集合中元素个数
        System.out.println("共记录了" + provinces.size() + "组数据。");
        
        /*4.两次判断Map中是否存在"闽"键*/
        System.out.println("是否记录简称为“闽”的省份或直辖市?" +
                provinces.containsKey("闽"));
        provinces.remove("闽");
        System.out.println("是否记录简称为“闽”的省份或直辖市?" +
                provinces.containsKey("闽"));
        
        /* 5.分别显示键集、值集和键值对集*/
        System.out.println(provinces.keySet());
        System.out.println(provinces.values());
        System.out.println(provinces);
        
        /* 6.清空 HashMap并判断*/
        provinces.clear();
        if (provinces.isEmpty()) {
            System.out.println("已清空全部数据！");
        }
    }
}

十三、Map的遍历

使用HashMap集合类存储并输出水果信息
实现思路及关键代码

• 创建水果对象

• 创建Map集合对象并添加水果元素

• 通过迭代器依次输出集合中所有水果信息

使用Iterator迭代器遍历Map集合的步骤

• 通过KeySet()方法返回键的集合为Set集合
• 循环遍历键的集合，获取每个键对应的值

package com.aiden.collections.demo8;

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

/**
 * 遍历Map集合
 */
public class MapIteratorTest {
    public static void main(String[] args) {
        //1.创建多个水果对象
        Fruit fruit1 = new Fruit("香水梨", 2.5);
        Fruit fruit2 = new Fruit("苹果梨", 2.0);
        Fruit fruit3 = new Fruit("富士苹果", 3.5);
        Fruit fruit4 = new Fruit("金帅苹果", 3.0);
        //2.创建Map集合对象并添加水果元素
        Map fruitMap = new HashMap();
        fruitMap.put(fruit1.getBrand(), fruit1);
        fruitMap.put(fruit2.getBrand(), fruit2);
        fruitMap.put(fruit3.getBrand(), fruit3);
        fruitMap.put(fruit4.getBrand(), fruit4);
        //3.通过迭代器依次输出集合中所有水果信息
        System.out.println("所有水果数据如下：");
        Set keys = fruitMap.keySet();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            String key = (String) it.next();  //取出key
            Fruit fruit = (Fruit) fruitMap.get(key); //根据key取出对应的value(水果对象)
            fruit.show();
        }
    }
}

注意：

Set集合中每个元素都是一个Map.Entry对象，进行键和值的分离，由于是Object类型，在获取对象之前还需要进行必要的类型转换

十四、Map.Entry接口

用于保存“键-值对”元素

常用方法

方法	描述
Object getKey()	取得此“键-值对”对应的key值
Object getValue()	取得此“键-值对”相对应的value值
int hashCode()	返回该“键-值对”的哈希码值
Object setValue(Object value)	用指定的值替换该“键-值对”的value值

运用Map.Entry接口遍历集合

• 通过entrySet()方法获取所有“键-值”对元素的集合
• 遍历集合中每个元素，进行键和值的分离

Set allSet = fruitMap.entrySet();  //获取键值对集合
Iterator it = allSet.iterator();
while(it.hasNext()){
    Map.Entry me = (Map.Entry)it.next();
    System.out.println(me.getKey()+" "+((Fruit)me.getValue()).getPrice());
}

十五、Hashtable类

与HashMap类具有相似的特征，也可以存储“键-值对”元素
是一个古老的Map接口实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P6zKEiaV-1649119722301)(E:\BDQN\BCSP\课件笔记\JavaOOP\OOP 07.assets\1649081663618.png)]

Hashtable类和HashMap类之间存在的区别

Hashtable	HashMap
继承自Dictionary类	Java1.2引进的Map interface的一个实现
比HashMap要古老	是Hashtable的轻量级实现
线程安全	线程不安全
不允许有null的键和值	允许有null的键和值
效率稍低	效率稍高

经验：实际开发中，HashMap类使用更多

十六、类型安全

考虑下面代码出现的问题

List fruits = new ArrayList();
Fruit fruit1 = new Fruit("香水梨",2.5);
Fruit fruit2 = new Fruit("苹果梨",2.0);
Fruit fruit3 = new Fruit("富士苹果",3.5);
Fruit fruit4 = new Fruit("金帅苹果",3.0);
//添加元素
fruits.add(fruit1);
fruits.add(fruit2);
fruits.add(fruit3);
fruits.add(fruit4);
fruits.add("无名水果");//能否加入一个String对象？
//循环迭代
Iterator it = fruits.iterator();
for(int i=0;i<fruits.size();i++){
    Fruit fruit = (Fruit)fruits.get(i);//遍历这个集合是否有问题？
    fruit.show();
}

使用集合存储数据时容易出现的问题
（1）对象存储不易控制
（2）类型转换容易出错

解决方案 使用泛型集合

约束录入集合的元素类型，大大提高数据安全性
从集合中取出数据无需进行类型转换，让代码更加简洁，程序更加健壮
JDK1.5使用泛型改写了集合框架中的所有接口和类

语法

List<E> //E:形参的类型
Map<K,V>//K,V:形参的类型

将List和ArrayList应用泛型实现，存储若干水果信息

package com.aiden.collections.demo9;

import java.util.ArrayList;
import java.util.List;

/**
 * 对List应用泛型
 */
public class Test {
    public static void main(String[] args) {
        //创建一个集合
        List<Fruit> fruits = new ArrayList<>();//标记元素类型
        Fruit fruit1 = new Fruit("香水梨", 2.5);
        Fruit fruit2 = new Fruit("苹果梨", 2.0);
        Fruit fruit3 = new Fruit("富士苹果", 3.5);
        Fruit fruit4 = new Fruit("金帅苹果", 3.0);
        //添加元素
        fruits.add(fruit1);
        fruits.add(fruit2);
        fruits.add(fruit3);
        fruits.add(fruit4);
        //fruits.add("无名水果");//编译错误提示
        //循环迭代
        for (Fruit fruit : fruits) {
            fruit.show();//无需类型转换
        }
    }
}

对Map接口和HashMap集合类应用泛型, 存储若干水果信息

package com.aiden.collections.demo9_1;

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

/**
 * 对Map应用泛型
 */
public class MapIteratorTest {
    public static void main(String[] args) {
        //创建多个水果对象
        Fruit fruit1 = new Fruit("香水梨", 2.5);
        Fruit fruit2 = new Fruit("苹果梨", 2.0);
        Fruit fruit3 = new Fruit("富士苹果", 3.5);
        Fruit fruit4 = new Fruit("金帅苹果", 3.0);
        //2.创建Map集合对象并添加水果元素
        Map<String, Fruit> fruitMap = new HashMap<String, Fruit>();
        fruitMap.put(fruit1.getBrand(), fruit1);
        fruitMap.put(fruit2.getBrand(), fruit2);
        fruitMap.put(fruit3.getBrand(), fruit3);
        fruitMap.put(fruit4.getBrand(), fruit4);
        //3.通过迭代器依次输出集合中所有水果信息
        System.out.println("所有水果数据如下：");
        Set<String> keys = fruitMap.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            String key = (String) it.next();  //取出key
            Fruit fruit = fruitMap.get(key); //根据key取出对应的值，无需类型转换
            fruit.show();
        }
    }
}

十七、本章总结