16.集合类

16.1 为什么使用集合框架

如果想要对定长的数据操作，可以使用数组：
- 例如：存储一个班学员信息，假定一个班容纳20名学员
如果想要对不定长的数据操作，可以使用集合：
- 例如：在购物车中保存用户购买的产品
如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架
集合概述
- Java中集合类是用来存放对象的
- 集合相当于一个容器，里面包容着一组对象 —— 容器类
- 其中的每个对象作为集合的一个元素出现
- Java API提供的集合类位于java.util包内
Java中数组与集合的比较
- 数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
- 数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象
Java中集合框架层次结构

16.2 Collection接口

一组称为元素的对象
一个Collection中可以放不同类型的数据
是Set接口和List接口的父类
是否有特定的顺序以及是否允许重复，取决于它的实现
- Set －无序的集合；不允许重复
  - HashSet
- List －有序的集合；允许重复
  - ArrayList
  - LinkedList

Collection接口常用方法

方法	含义
boolean add(Object)	集合中加入一个对象，成功时返回true
boolean addAll(Collection)	集合中加入另外一个集合对象
int size()	集合内容纳的元素数量
boolean isEmpty()	集合是否为空
boolean contains(Object)	集合内是否含有参数对象
Iterator iterator()	产生一个迭代器
Object[] toArray()	返回一个包含所有元素的对象数组

方法	含义
boolean remove(Object)	从集合中删除对象
boolean removeAll(Collection)	清空指定集合
boolean containsAll(Collection)	判断集合内是否包含子集
boolean retainAll(Collection)	仅保留此 collection 中那些也包含在指定 collection 的元素

16.3 Set接口

Set接口
- Collection的子接口
- 用来包含一组无序无重复的对象
  - 无序 — 是指元素存入顺序和集合内存储的顺序不同；
  - 无重复 — 两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。
Set接口的实现类
- HashSet — HashSet的特性在于其内部对象的散列存取，即采用哈希技术
- TreeSet — TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的
使用foreach方式遍历Set集合

java

package com.neusoft.collets;

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

/**
 * 项目：      javaadvice
 * 类名:       MySet
 * 创建时间：  2020/11/20  8:47
 * 描述 :
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 */
public class MySet {


    /**
     * HashSet
     */

    public static void main(String[] args) {
        //类的构造
        Set set =  new HashSet(); //面向接口编程

        //add
        set.add(50);
        set.add(60); //int     Integer
        set.add(200);
        set.add(new Integer(200));

        //size() 获取集合长度
        System.out.println("set.size()\t"+set.size());


        //使用另外一个集合构造set对象
//        Set set2 = new HashSet(set);
        Set set2 = new HashSet();
        set2.addAll(set);
        System.out.println("set2.size()\t"+set2.size());


        //isEmpty 是否为空
        System.out.println("set2.isEmpty()\t"+set2.isEmpty());

        System.out.println( "set2.contains(60)\t"+set2.contains(60));
        System.out.println( "set2.contains(200)\t"+set2.contains(new Integer(200)));


        //迭代器 遍历Set
        Iterator it = set2.iterator();

        while(it.hasNext()){
            Object item = it.next();
            System.out.println("item\t"+item);
        }
       
        //移除元素， 通过equals 和hashcode 判断是否存在元素
        set.remove(50);
        System.out.println("remove.size()\t"+set.size());


        Set set3 = new HashSet();
        set3.add("abc");
        set3.add("def");
        set3.add("ghi");


        Set set4 = new HashSet();
        set4.add("abc");
        set4.add("def");

        System.out.println("set3.size\t"+set3.size());
//        set3.removeAll(set4);
//        System.out.println("removeAll.size\t"+set3.size());
        set3.retainAll(set4);
        System.out.println("retainAll.size\t"+set3.size());
        for (Object o : set3) {
            System.out.println("set3-item\t"+o);
        }
        set3.clear();
        System.out.println(set3.size()); //0
    }


}

16.3.1 课堂练习

使用Set集合，生成1-25之内不重复的7个随机整数
给定数组如 [5,6,10,5,20,6,4] 将数组中的元素去重（利用Set）

答案

System.out.println("+====================================================");
//使用Set集合，生成1-25之内不重复的7个随机整数
Random rnd = new Random();

Set rndSet = new HashSet();
while (true){

	if(rndSet.size()>=7){
		break;
	}

	rndSet.add( rnd.nextInt(25)+1);

}

//        for( Iterator it2 = rndSet.iterator() ; it2.hasNext(); ){
//            Object  item = it2.next();
//            System.out.println(item);
//        }

//使用lambda表达式
rndSet.forEach(System.out::println);

System.out.println("+====================================================");
//给定数组如 [5,6,10,5,20,6,4] 将数组中的元素去重（利用Set）
int[] arrs = {5,6,10,5,20,6,4};
Set arrSet = new HashSet();
for (int arr : arrs) {
	arrSet.add(arr);
}

16.4 List口

List接口
- Collection的子接口
- 用来包含一组有序有重复的对象
- List中的元素都对应一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素
- List有两种主要的集合实现类：
  - ArrayList
  - LinkedList
两个实现类的区别：
- ArrayList
  - ArrayList是线性顺序存储的，是一种线性表
  - 它的特性和数组很接近，数组大小是不变的，而ArrayList的大小是可以动态改变的
- LinkedList
  - 是数据结构中链表的java实现
  - 相对于List来说，LinkedList最主要的功能方面的增强是可以在List的头部和尾部添加、删除、取得元素，直接提供了这些方法的实现。所以它可以非常方便的实现我们数据结构中的常见的Stack(栈)、queue(队列)等

16.4.1 List接口常用方法

方法	含义
void add(int index,Object element)	在列表中的index位置，添加element元素
Object get(int index)	返回列表中指定位置的元素
int indexOf(Object o)	在list中查询元素的索引值，如不存在，返回－1。
int lastIndexOf(Object o)	List中如果存在多个重复元素，indexOf()方法返回第一个匹配元素的index。lastIndexOf(o)是返回最后一个匹配元素的index.
ListIterator listIterator()	返回列表中元素的列表迭代器
Object remove(int index)	移除列表中指定位置的元素
Object set(int index,Object element)	用指定元素替换列表中指定位置的元素

16.4.2 ArrayList

java

package com.neusoft.collets;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 项目：      javaadvice
 * 类名:       MyArrayList
 * 创建时间：  2020/11/20  10:27
 * 描述 :
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 */
public class MyArrayList {

    public static void main(String[] args) {
        //
        List list1 = new ArrayList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");

        System.out.println("list1.size()\t"+list1.size());

        List list2 = new ArrayList(list1);
        System.out.println("list2.size()\t"+list2.size());

        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }

        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }

        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator() ; it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));


        System.out.println("=======================add(index,Object el)=================================");

        List list3 =new  ArrayList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");

        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));

        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1

        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }



        //listIterator
        ListIterator listIter = list3.listIterator(list3.size()-1);
        while (listIter.hasPrevious()){
            System.out.println("listIter.previous()\t"+listIter.previous());
        }
    }


}

16.4.3 LinkedList

ArrayList与LinkedList的比较
- 存储结构
  - ArrayList是线性顺序存储
    - LinkedList对象间彼此串连起来的一个链表
- 操作性能
  - ArrayList适合随机查询的场合
  - LinkedList元素的插入和删除操作性高
  - 从功能上，LinkedList要多一些

java

package com.neusoft.collets;

import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 项目：      javaadvice
 * 类名:       MyLinkedList
 * 创建时间：  2020/11/20  10:27
 * 描述 :
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 */
public class MyLinkedList {

    public static void main(String[] args) {
        //
        List list1 = new LinkedList();
        list1.add("张三");
        list1.add("李四");
        list1.add("李四");
        list1.add("王五");

        System.out.println("list1.size()\t"+list1.size());

        List list2 = new LinkedList(list1);
        System.out.println("list2.size()\t"+list2.size());

        System.out.println("========================================================");
        //通过下标的形式访问每一个元素
//        System.out.println("list1.get(0)\t"+list1.get(0));
//        System.out.println("list1.get(1)\t"+list1.get(1));
//        System.out.println("list1.get(2)\t"+list1.get(2));
        for (int i = 0; i < list1.size(); i++) {
            System.out.println("list1.get("+i+")\t"+list1.get(i));
        }

        System.out.println("=======================增强for遍历=================================");
        for (Object o : list2) {
            System.out.println("item\t"+o);
        }

        System.out.println("=======================Iterator遍历=================================");
        for(Iterator it = list2.iterator() ; it.hasNext() ; ){
            System.out.println("iterator Item \t"+it.next());
        }
        System.out.println("=======================forEach遍历=================================");
//        list2.forEach(System.out::println);
        list2.forEach(x->System.out.println("forEach item\t"+x));


        System.out.println("=======================add(index,Object el)=================================");

        List list3 =new  LinkedList();
        list3.add("abc");
        list3.add("def");
        list3.add("jqk");

        //list3 add(index ,el)
        list3.add(1,"insert");
        list3.forEach(x->System.out.println("list3 item\t"+x));
        System.out.println("=======================add(index,Object el)=================================");
        //list3 update(index ,el)
        list3.set(1,"update");
        list3.forEach(x->System.out.println("list3 item\t"+x));

        //indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1

        System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
        //判断def是否重复
        if(list3.indexOf("def") != list3.lastIndexOf("def")){
            System.out.println("def重复了");
        }

        System.out.println("================================================");

        ListIterator listIter = list3.listIterator();
        while (listIter.hasNext()){
            System.out.println("listIter.next()\t"+listIter.next());
        }
        System.out.println("=============================");
        //listIterator
//        ListIterator listIter2 = list3.listIterator(list3.size());
//        while (listIter2.hasPrevious()){
//            System.out.println("listIter2.previous()\t"+listIter2.previous());
//        }


        LinkedList lList = new LinkedList();
        lList.addAll(list3);

        Object popItem = lList.pop(); //如果没有元素会抛异常
        Object pollItem = lList.poll();

        System.out.println(pollItem);



    }

}

16.5 Iterator迭代器

方法	含义
Object next()	返回游标右边的元素并将游标移动到下一个位置
boolean hasNext()	判断游标右边是否有元素
void remove()	删除游标左边的元素，在执行完next之后，该操作只能执行一次

Iterator实现过程

java

package com.neusoft.collets;

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

/**
 * 项目：      javaadvice
 * 类名:       MyIterator
 * 创建时间：  2020/11/20  11:34
 * 描述 :
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 */
public class MyIterator {


    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("abc");
        list.add("def");
        list.add("QQQ");
        list.add("aaa");
        list.add(2);

        //remove（index| Object）
//        list.remove(2 );// index
//        list.remove("def" ); //Object

        System.out.println("list.size()"+list.size());

        for (Iterator it = list.iterator(); it.hasNext(); ) {
            Object next =  it.next();
            System.out.println("next\t"+next);
//            list.remove(next);
            it.remove();
        }

        System.out.println("list.size\t"+list.size());
    }
}

16.6 Collections工具类

Collections类是类似于Arrays类的公用工具类 ,它提供了一些static方法供集合类使用或操作集合类。

Collections类中的方法

方法	含义
Object max(Collection c,Comparator comp)	max算法采用Comparator比较算法
Object max(collection c)	返回集合中的最大元素，需要考虑比较接口的实现
Object min(Collection c)	返回集合中的最小元素
void reverse(Collection c)	把集合中的元素顺序反转
void copy(List dest,List src)	src集合中元素复制到dest集合
void fill(List list,Object o)	填充list集合，填充元素为o
int binarySearch(List list,Object key)	对排序后的集合list进行查询元素操作
void sort(List list)	对一种List做排序

16.6.1 idea中打jar包

16.6.2 常用方法调用

Student.java

java

package com.neusoft.collets;

/**
 * 项目：      javaadvice
 * 类名:       Student
 * 创建时间：  2020/11/21  8:48
 * 描述 :
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 *
 *  实体类 --> 表
 *
 *
 */
public class Student implements Comparable<Student> {
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
}

Teacher.java

java

package com.neuedu.entity;

public class Teacher {
    private String name;
    private Integer age;

    public Teacher() {
    }

    public Teacher(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return this.age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String toString() {
        return "Teacher{name='" + this.name + '\'' + ", age=" + this.age + '}';
    }
}

Collections的测试类

java

package com.neusoft.collets;



import com.neuedu.entity.Teacher;

import java.util.*;

/**
 * 项目：      javaadvice
 * 类名:       MyCollections
 * 创建时间：  2020/11/21  8:44
 * 描述 :     集合的工具类测试
 * 作者 :     张金山
 * QQ :     314649444
 * Site:      https://jshand.gitee.io
 */
public class MyCollections {


    public static void main(String[] args) {

        Set set = new HashSet();
        set.add(10);
        set.add(8);
        set.add(20);


        List<Student> stuList = new ArrayList();
        stuList.add(new Student("张飞",50));
        stuList.add(new Student("张飞1",36));
        stuList.add(new Student("张飞2",20));
        stuList.add(new Student("张飞3",58));
        //stuList.add(100); //

        //数值类型可以直接比较
        Comparable maxNum = Collections.max(set);
        System.out.println("maxNum\t"+maxNum);


        //类如果是Comparable的类型也可以比较
        Comparable max = Collections.max(stuList);
        System.out.println("max\t"+max);

        Comparable min = Collections.min(stuList);
        System.out.println("min\t"+min);


        System.out.println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        //Teacher类不是 Comparable 子类型，在比较的时候需要传递比较反感
        List<Teacher> teachers = new ArrayList();
        teachers.add(new Teacher("张飞",50));
        teachers.add(new Teacher("张飞1",36));
        teachers.add(new Teacher("张飞2",20));
        teachers.add(new Teacher("张飞3",58));


        Teacher maxTeacher = Collections.max(teachers, ( o1,  o2) ->   o1.getAge() - o2.getAge() );
        System.out.println(maxTeacher);


        //sort排序
        System.out.println("+++++++++++++++++++++++++sort+++++++++++++++++++++++++++++++++");
        List<Integer> list = Arrays.asList(10,20,30,6,4,20,4);
        Collections.sort(list);
        list.forEach(System.out::println);

        System.out.println("++++++++++++++++++++++++++++sort++++++++++++++++++++++++++++++");
        Collections.sort(teachers, ( o1,  o2) ->   o1.getAge() - o2.getAge() );
        teachers.forEach(System.out::println);


        System.out.println("++++++++++++++++++++++++++++reverse++++++++++++++++++++++++++++++");
        Collections.reverse(teachers);
        teachers.forEach(System.out::println);

        System.out.println("++++++++++++++++++++++++++++copy++++++++++++++++++++++++++++++");
        List<Teacher> dest = new ArrayList();
        dest.add(null);
        dest.add(null);
        dest.add(null);
        dest.add(null);
        dest.add(null);
        Collections.copy(dest,teachers);
        dest.forEach(System.out::println);

        System.out.println("++++++++++++++++++++++++++++fill++++++++++++++++++++++++++++++");
        List initList = new ArrayList();
        initList.add(null);
        initList.add(null);
        initList.add(null);
        initList.add(null);
        initList.add(null);

        Collections.fill(initList,10);
        initList.forEach(System.out::println);


        System.out.println("++++++++++++++++++++++++++++binarySearch++++++++++++++++++++++++++++++");
        List<Integer> numList = new ArrayList();
        numList.add(10);
        numList.add(12);
        numList.add(8);
        numList.add(6);
        Collections.sort(numList);
        int index = Collections.binarySearch(numList, 8); //二分查找法
        System.out.println("binarySearch:\t"+index);
    }
    
}

16.6.3 练习

从控制台得到一组整数，按照升序打印
从控制台得到一组整数，按照降序打印

答案

16.7 Map接口

Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象
Map是不同于Collection的另外一种集合接口
Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
Map接口有两个实现：
- HashMap — key/value对是按照Hash算法存储的 TreeMap — key/value对是排序 (按key排序)存储的

16.7.1 常用方法

方法	含义
Object put(Object key,Object value)	将指定的值与此映射中的指定键相关联
void putAll(Map t)	将映射t中所有映射关系复制到此映射中
Object get(Object key)	返回此映射中映射到指定键的值
Object remove(Object key)	若存在此键的映射关系,将其从映射中移除
boolean containsKey(Object key)	若此映射包含指定键的映射关系，返回 true
boolean containsValue(Object value)	若此映射为指定值映射一个或多个键,返回 true
int size()	返回此映射中的键-值映射对数
void clear()	从此映射中移除所有映射关系
boolean isEmpty()	若此映射未包含键-值映射关系,返回 true
Set keySet()	返回此映射中包含的键的 set 视图

16.7.2 HashMap类

HashMap类是Map接口的实现类基于哈希表的 Map 接口的实现

java

package com.neusoft.collets;

import java.util.*;

/**
 * 项目：      javaadvice
 * 类名:       MyMap
 * 创建时间：  2020/11/21  11:20
 * 描述 :
 * 作者 :     张金山
 * QQ :       314649444
 * Site:      https://jshand.gitee.io
 */
public class MyMap {
    public static void main(String[] args) {

        //对象的创建
        Map<String,Student> map = new HashMap<>();


        List<Student> stuList = new ArrayList();
        stuList.add(new Student("张飞",50));
        stuList.add(new Student("张飞1",36));
        stuList.add(new Student("张飞2",20));
        stuList.add(new Student("张飞3",58));

        //如果要查找某一个元素的属性，需要遍历集合后查找元素才能获取舒心
        for (Student student : stuList) {
            if("张飞3".equals(student.getName())){
                System.out.println("student.age\t"+student.getAge());
                break;
            }
        }



        //put key不可以重复
        map.put("张飞",new Student("张飞",50));
        map.put("张飞1",new Student("张飞1",36));
        map.put("张飞2",new Student("张飞2",20));
        map.put("张飞3",new Student("张飞3",58));

        //get根据key获取指定的元素,底层使用hash计算索引，快速查找元素
        Student stu = (Student) map.get("张飞3");
        System.out.println(stu.getAge());


        /**
         * int size()
         * void clear()
         * boolean isEmpty()
         */

//        map.clear();
        System.out.println("map.size\t"+map.size());
        System.out.println("map.isEmpty\t"+map.isEmpty());

        Map map2 = new HashMap();
        map2.put("张飞3",new Student("张飞3",999));
        map2.put("张飞4",new Student("张飞4",20));
        Student zf5 = new Student("张飞5", 58);
        map2.put("张飞5",zf5);


        map.putAll(map2);
        System.out.println("map.size\t"+map.size());

        System.out.println("map.get(\"张飞3\")\t"+map.get("张飞3").getAge());

        System.out.println("map.containsKey(\"张飞\")\t"+map.containsKey("张飞"));
        System.out.println("map.containsKey(\"张飞99\")\t"+map.containsKey("张飞99"));


        System.out.println("map.containsValue(new Student(\"张飞5\",58)\t"+map.containsValue(zf5));

        System.out.println("========================size==============================");
        System.out.println("map.size\t"+map.size());
        map.remove("张飞3");
        System.out.println("map.size\t"+map.size());

        //HashMap的遍历

        Set<String> keySet = map.keySet();
//        for (String key : keySet) {
//            System.out.printf("key:%s\tvalue:%s\r\n",key,map.get(key).toString());
//        }

        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Map.Entry<String, Student> stringStudentEntry : entrySet) {
            String key = stringStudentEntry.getKey();
            Student value = stringStudentEntry.getValue();
            System.out.printf("key:%s\tvalue:%s\r\n",key,value.toString());
        }
    }
}

16.7.3 HashMap与TreeMap的比较

HashMap基于哈希表实现。
TreeMap基于树实现。
HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。
TreeMap没有调优选项，因为该树总处于平衡状态
HashMap性能优于TreeMap。

16.7.4 HashMap与Hashtable的比较

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许用null。

16.8 课后作业

请使用LinkedList来模拟一个队列(先进先出的特性): [必做题]
拥有放入对象的方法void put(Object o)
取出对象的方法Object get()
判断队列当中是否为空的方法boolean isEmpty()；并且，编写测试代码，验证你的队列是否正确。
假设顺序列表ArrayList中存储的元素是整型数字1~5，遍历每个元素，将每个元素顺序输出。 [必做题]
在一个列表中存储以下元素：apple,grape,banana,pear
- 返回集合中的最大的和最小的元素
- 将集合进行排序，并将排序后的结果打印在控制台上 [必做题]
编写一个程序，创建一个 HashMap对象，用于存储银行储户的信息(其中储户的主要信息有储户的ID，姓名和余额)。另外，计算并显示其中某个储户的当前余额。 [选做题]
从控制台输入若干个单词（输入回车结束）放入集合中，将这些单词排序后（忽略大小写）打印出来。 [选做题]

16.集合类 ​

16.1 为什么使用集合框架 ​

16.2 Collection接口 ​

16.3 Set接口 ​

16.3.1 课堂练习 ​

16.4 List口 ​

16.4.1 List接口常用方法 ​

16.4.2 ArrayList ​

16.4.3 LinkedList ​

16.5 Iterator迭代器 ​

16.6 Collections工具类 ​

16.6.1 idea中打jar包 ​

16.6.2 常用方法调用 ​

16.6.3 练习 ​

16.7 Map接口 ​

16.7.1 常用方法 ​

16.7.2 HashMap类 ​

16.7.3 HashMap与TreeMap的比较 ​

16.7.4 HashMap与Hashtable的比较 ​

16.8 课后作业 ​

16.集合类

16.1 为什么使用集合框架

16.2 Collection接口

16.3 Set接口

16.3.1 课堂练习

16.4 List口

16.4.1 List接口常用方法

16.4.2 ArrayList

16.4.3 LinkedList

16.5 Iterator迭代器

16.6 Collections工具类

16.6.1 idea中打jar包

16.6.2 常用方法调用

16.6.3 练习

16.7 Map接口

16.7.1 常用方法

16.7.2 HashMap类

16.7.3 HashMap与TreeMap的比较

16.7.4 HashMap与Hashtable的比较

16.8 课后作业