Java 泛型与集合知识点总结

泛型

泛型的应用

• 在编译时通过一个标识表示类中某个 属性/方法/参数 的类型
• 编译时，检查添加元素的类型，提高安全性
• 减少类型转换的次数，提高效率

泛型的语法

1.泛型的声明

• 泛型类

  class 类名<K, V> {}

  interface 接口 {}

• 泛型方法

• 泛型方法可以定义于普通类或泛型类（区别方法使用泛型）

  public static T getMiddle(T… a) { }

2.泛型的使用

• 实例化

  在类名后面指定类型参数的值（类型）：

  List strList = new ArrayList ();

• 调用泛型方法

  调用泛型方法时，可以把<具体类型> 放在方法名前面：

  类.getMiddle()

泛型使用细节

• 参数类型只能是引用类型，不能是基本类型

• 不能创建参数化类型的数组

• 在给泛型指定具体类型后，可以传入该类型或者其子类类型

• 没有指定类型是，默认泛型是 Object

• 静态方法不能使用类的泛型

  静态和类相关，类加载时，对象还没创建，如果静态方法使用了类的泛型，JVM 就无法完成初始化

• 泛型不具备继承性

  List<Object> list = new ArrayList<String>(); error

通配符

• <?> : 表示支持任意泛型
• <? extends A>: 支持A 类及A 类的子类，规定了泛型的上限
• <? super A>: 支持A 类及A 类的父类，不限于直接父类，规定了泛型的下限

Todo(待补充)

• 类型擦除（伪泛型）

集合

集合框架体系

迭代器 Iterator

• next(), hasNext(), remove()

• 可以认为Java迭代器位于两元素之间

  当调用next 时，迭代器越过下一个元素，并返回越过的元素的引用，remove方法则删除上一次调用next返回的元素

Collection 接口

• 有些Collection的实现类可以存放重复元素，有些不可以
• Collection的实现接口 List 是有序的， Set 是无序的
• Collection 没有直接的实现子类，是通过它的子接口List 和 Set 来实现的

• Collection接口的元素遍历方式

  • 1.使用迭代器Iterator
  • 2.增强for循环（简化版的iterator）

List 接口

• List集合类中元素有序，且可重复
• List集合支持索引
• 常用方法
  • void add(int i, E element)
  • void addAll(int i, Collection<? extends E> elements)
  • E remove(int i) //删除指定位置元素并返回该元素
  • E get(int i)
  • E set(int i, E element)
  • int indexOf(Object element)
  • int lastIndexOf(Object element)

• List 接口的元素的遍历方式

  • 1.iterator迭代器
  • 2.增强for
  • 3.普通for + 索引

List 实现类 ArrayList

• 底层维护的是一个动态的数组
• 线程不安全的， Vector与其基本等同，除了Vector是线程安全的
• 创建和扩容流程 Debug
  • 调用无参构造器时，车市elementData容量为零，第一次添加元素时扩容为10， 若再次扩容，则扩容1.5倍
  • 调用有参构造器时指定容量，则出书elementData容量为所指定的大小，若再次扩容，也是扩容1.5倍

List 实现类 LinkedList

• 底层维护了一个双向链表
• LinkedList中维护了两个属性first， last分别指向 首节点和尾节点
• 添加和删除效率高

Set 接口

• Set集合类中元素无序，且不允许重复，最多只能有一个null
• Set集合类不能通过索引获取

• Set 接口的元素遍历方式

  • iterator 迭代器
  • 增强for

Set接口实现类 HashSet

• 底层是 HashMap（value 值都为空）
• 不保证顺序，更具hashcode确定索引
• 不能有重复元素，且只能有一个null

Set接口实现类 LinkedHashSet

• 是HashSet子类
• 底层是LinkedHashMap，维护了一个数组 + 双向链表
• 根据hashCode确定元素的存储位置，同时使用链表维护元素的次序

Queue 接口

• 双端队列Deque接口
• ArrayDeque和LinkedList类实现了Deque接口
• 常用方法
  • add()
  • offer()

  入队，将给定元素添加到队列的队尾，如果成功就返回true，若队列已满，add会抛出异常，offer会返回false

  • remove()
  • poll()

  出队，若队列不为空，删除并返回队列头的元素，若空队列，remove抛出异常，poll返回null

  • element()
  • peek（）

  返回队列头元素但不删除，若空队列，第一个抛出异常，第二个方法返回null

Map 接口

• Map 与Collection 并列存在，用于保存具有映射关系的元素
• key 和 value 可以是任意引用类型的数据
• key不允许重复，value可以重复
• key和value都可以为null，但key中只能有一个null
• 常用String类作为key

• Map 接口元素的遍历方式

  • map.keySet() -> 返回所有的key，再通过map.get(key)获取value
    • 增强for
    • 迭代器
  • 取出所有的values map.values()
    • 增强for
    • 迭代器
  • 通过EntrySet获取 k-v (Map.Entry<K, V>) ==》 Set set = map.entrySet()
    • 增强for
    • 迭代器

    Map.Entry 提供的 getKey() 和 getValue()

Map接口的实现类 HashMap

• 底层维护的是 数组 + 链表 + 红黑树
• 线程不安全
• 若添加相同的Key，会覆盖原来的Value
• 底层机制 Debug
  • 1.HashMap底层维护了Node类型的数组table，默认为null
  • 2.创建对象是，加载因子初始化为0.75
  • 3.添加Key-Value时，通过Key的哈希值得到在table的索引，判断该索引处是否有元素，若无，直接添加；若有，比较两个Key是否相等，若相等，替换value；若不相等还需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不足，需要扩容。
  • 4.第一次添加时table数组初始化容量为16，临界值时12（16*0.75），大于等于临界值时扩容
  • 5.以后在次扩容时table扩容为初始的两倍，临界值也发生改变
  • 6.Java8中，如果一条链表元素超过TREEIFY_THRESHOLD(默认8)，并且数组table大于等于MIN_TREEIFY_CAPACITY（默认64）时，将树华为红黑树，如果数组大小不满足，则数组扩容

Map接口的实现类 HashTable

• 线程安全的
• Key和Value都不能为null

Map接口的实现类 Properties

• 继承自HashTable
• 用于读取.properties配置文件

Collections 工具类

• 用于操作Set、List、Map等集合的工具类
• 提供一系列静态方法对集合中元素进行排序、查询和修改等操作

一、泛型

1.泛型定义

泛型是将数据类型参数化，即在编写代码时将数据类型定义成参数，这些类型参数在使用之前再进行指明。
泛型提高了代码的重用性，使得程序更加灵活、安全和简洁。

JDK 5.0之前，为了实现参数类型的任意化，都是通过Object类型来处理，缺点：代码臃肿，需要进行强制类型转换，参数类型必须已知，否则容易引起ClassCastException异常。
JDK 5.0之后，Java增加对泛型的支持，解决以上缺点。泛型经常在类、接口和方法的定义中，分别称为泛型类、泛型接口和泛型方法。

GenericDemo.java:

class Generic <T>{
    private T data;
    public Generic(){
    }
     public Generic(T data){
	this.data = data;
    }
    public T getData(){
	return data;
    }
     public void setData(T data){
	this.data = data;
    }
    public void showDataType(){
	//获取对象的类名并打印输出
	System.out.println("数据的类型是："+data.getClass().getName());
    }
}
public class GenericDemo{
    public static void main(String[] args){
	//采用带参数的构造方法实例化泛型对象
	Generic <String> strObj = new Generic <String>("欢迎使用泛型类");
	strObj.showDataType();
	System.out.println(strObj.getData());
	System.out.println("--------------------------------");
	Generic <Double> dObj = new Generic <>(3.1415);
	dObj.showDataType();
	System.out.println(dObj.getData());
	System.out.println("--------------------------------");
	Generic <Integer> intObj = new Generic <>(123);
	intObj.showDataType();
	System.out.println(intObj.getData());
	System.out.println("--------------------------------");
    }
}

2.泛型的限制

（1）实例化泛型时，类型参数只能是类类型（包括自定义类），如String、Integer等，不能是简单类型。
（2）同一个泛型类可以有多个版本（不同参数类型），不同版本的泛型类的实例是不兼容的，例如Generic 与Generic 的实例是不兼容的。
（3）定义泛型时，类型参数只是占位符，不能直接实例化，例如“new T()”是错误的。
（4）不能实例化泛型数组。
（5）泛型类不能继承Throwable及其子类，即泛型类不能是异常类。

二、集合概述

Java的集合类是一些常用的数据结构，如队列、栈、链表等。
Java集合就像一种“容器”，用于存储数量不等的对象，并按照规范实现一些常用的操作和算法。

1.集合框架

Java所有集合类都在java.util包下，
Java集合类主要有两个接口派生而成：Collection和Map，这两个接口是集合框架的根接口。
NoteBook.java：

import java.util.ArrayList;
public class NoteBook{
    private ArrayList<String> notes = new ArrayList<String>();//ArrayList是有序列表
    public void add(String s){
	notes.add(s);//添加数据
    }
    public int getSize(){
	return notes.size();//获取数据条数
    }
    public String getNote(int index){
	return notes.get(index);//根据下标找到数据
    }
    public void removeNote(int index){
	notes.remove(index);//删除下标为index的数据
    }
    public String[] list(){
	String a[] = new String[notes.size()];
	for(int i=0;i<notes.size();i++){
	    a[i] = notes.get(i);
	}
	return a;
    }
    public static void main(String[] args){
	NoteBook nb = new NoteBook();
	nb.add("first");
	nb.add("second");
	nb.add("third");
	System.out.println(nb.getSize());
	System.out.println(nb.getNote(1));
	nb.removeNote(1);
	String[] a = nb.list();
	for(String s:a)//获取数组a的每一个值并赋给s
	{
	    System.out.println(s);
	}	
    }
}

使用迭代器后：

import java.util.ArrayList;
import java.util.Iterator;
public class NoteBook{
    private ArrayList<String> notes = new ArrayList<String>();
    public void add(String s){
	notes.add(s);
    }
    public int getSize(){
	return notes.size();
    }
    public String getNote(int index){
	return notes.get(index);
    }
    public void removeNote(int index){
	notes.remove(index);
    }
    public void list(){
	Iterator<String> iterator = notes.iterator();
	while(iterator.hasNext()){
	   System.out.println(iterator.next());
	}	
    }
    public static void main(String[] args){
	NoteBook nb = new NoteBook();
	nb.add("first");
	nb.add("second");
	nb.add("third");
	System.out.println(nb.getSize());
	System.out.println(nb.getNote(1));
	nb.removeNote(1);
	nb.list();
    }
}

两种方式的运行结果一致如下：
（注意：默认下标从0开始）

2.迭代器接口

迭代器（Iterator）：可以采用统一的方式对Collection集合中的元素进行遍历操作。该接口是Collection接口的父接口。
方法：
boolean hasNext()：判断是否有下一个可访问的对象，有返回true，没有返回false。
E next()：返回可访问的下一个元素。
void remove()：移除迭代器返回的最后一个元素，该方法必须紧跟在一个元素的访问后执行。

三、集合类

1.Collection接口

Collection接口是Set、Queue和List接口的父接口。该接口中的方法可以操作这三个接口中的任一个集合。由接口的特点可知，其内部的方法都是抽象方法，在应用时需要重写。


注意：
（1）add()、addAll()、remove()、removeAll()和retainAll()方法可能会引发不支持该操作的UnsupportedOperationException异常。
（2）将一个不兼容的对象添加到集合中，将产生ClassCastException异常。
（3）Collection接口没有提供获取某个元素的方法，但可以通过iterator()方法获取迭代器来遍历集合中的所有元素。
（4）虽然Collection中可以存储任何Object对象，但不建议在同一个集合容器中存储不同类型的对象，建议使用泛型增强集合的安全性，以免引起ClassCastException异常。

2.List 接口及其实现类

List接口：有序、可重复的集合，与数组类似，List集合可以记住每次添加元素的顺序，因此可以根据元素的索引访问List集合中的元素，元素可以重复且长度是可变的（相当于可变长数组）。
ArrayList（数组列表）和Vector（向量）是List接口的两个典型实现类，两者功能类似，推荐使用前者。

ArrayListDemo.java：

import java.util.*;
public class ArrayListDemo{
    public static void main(String[] args){
	ArrayList <String> list = new ArrayList <>();
	//向集合中添加元素
	list.add("北京");
	list.add("上海");
	list.add("天津");
	list.add("济南");
	list.add("青岛");
	//错误，只能添加字符串
	//list.add(1);//错误原因：不同版本的泛型类的实例是不兼容的
	//使用foreach语句遍历
	System.out.println("使用foreach语句遍历");
	for(String e:list){
		System.out.println(e);
	}
	System.out.println("---------------------");
	System.out.println("使用迭代器遍历：");
	//获取ArrayList的迭代器
	Iterator <String> iterator = list.iterator();
	//使用迭代器遍历
	while(iterator.hasNext()){
		System.out.println(iterator.next());
	}
	System.out.println("---------------------");
	//删除下标索引是1的元素，即第二个元素“上海”
	list.remove(1);
	//删除指定元素
	list.remove("青岛");
	System.out.println("删除后剩下的数据：");
	for(String e:list){
		System.out.println(e);
	}
    }
}

运行结果：

3.Set 接口及其实现类

Set接口：类似一个罐子，将一个对象添加到Set集合时，Set集合无法记住添加的顺序，因此Set集合中的元素不能重复。
常用的实现类：HashSet、TreeSet、EnumSet。
**HashSet：**大多数使用Set集合时都使用该实现类，HashSet使用Hash算法来存储集合中的元素，具有良好的存、取以及可查找性。
**TreeSet：**采用“树”的数据结构来存储集合元素，可保证几何中的元素处于排序状态。
**EnumSet：**专为枚举类设计的集合类，所有元素必须是指定的枚举类型。

HashSetDemo.java：

import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo{
    public static void main(String[] args){
	HashSet <String> hs = new HashSet <>();
	//向集合中添加元素
	hs.add("北京");
	//添加重复元素
	hs.add("北京");
	hs.add("上海");
	hs.add("天津");
	hs.add("济南");
	hs.add("青岛");
	System.out.println(hs);//以数组形式输出
	//使用foreach语句遍历
	System.out.println("使用foreach语句遍历");
	for(String e:hs){
		System.out.println(e);
	}
	System.out.println("---------------------");
	
	//删除元素
	hs.remove("青岛");
	System.out.println("删除后剩下的数据：");
	Iterator <String> iterator = hs.iterator();
	//使用迭代器遍历
	while(iterator.hasNext()){
		System.out.println(iterator.next());
	}
    }
}

运行结果：

结果中北京并没有出现在第一位，且仅出现了一次，证明了Set集合无法记住添加的顺序，Set集合中的元素不能重复的特点。

4.Queue 接口及其实现类

Queue接口：以“先进先出（FIFO）”的方式排序各个元素。
Deque（双端队列）是Queue的子接口，LinkedList是Deque和List两个接口的实现类，兼具队列和列表两种特性，是最常使用的集合类之一。

LinkedListDemo.java：

import java.util.LinkedList;
public class LinkedListDemo{
    public static void main(String[] args){
	LinkedList <String> books = new LinkedList <>();
	//在队尾添加元素
	books.offer("Java Web开发技术详解");
	//在队头添加元素
	books.push("数据库原理");
	//在队头添加元素
	books.offerFirst("Java8基础应用与开发");
	//在队尾添加元素
	books.offerLast("C++程序设计");
	System.out.println(books);
	System.out.println("---------------------");
	//使用foreach语句遍历
	System.out.println("使用foreach语句遍历：");
	for(String e:books){
		System.out.println(e);
	}	
    }
}

运行结果：

注意：经检验知push与offerFirst等价，都可以实现将数据插入开头；offer与offerLast等价，都是将数据插入末尾。

5.Map 接口及其实现类

Map接口：以key-value键值对映射关系存储的集合，可以根据每个元素的key来访问对应的value，Map集合中的key不允许重复，value可以重复。key-value键值对映射关系的示意图如下所示。

Map接口的两个实现类：
HashMap：基于哈希算法的Map接口的实现类，该实现类提供所有映射操作，并允许使用null键和null值，但不能保证映射的顺序，即是无序的映射集合。
TreeMap：基于“树”接口来存储的Map接口实现类，可以根据键的自然顺序进行排序，或定制排序方式。在使用TreeMap时，不允许使用null键和null值，当使用get()方法获取元素时，没有指定的键时会返回null。

HashMapDemo.java：

import java.util.HashMap;
public class HashMapDemo{
    public static void main(String[] args){
	HashMap <Integer,String> hm = new HashMap <>();
	//添加数据，key-value键值对形式
	hm.put(1,"张三");
	hm.put(2,"李四");
	hm.put(3,"王二麻子");
	hm.put(4,"赵五");
	hm.put(5,"刘六");
	hm.put(null,null);
	//根据key值获取value
	System.out.println(hm.get(1));
	System.out.println(hm.get(3));
	System.out.println(hm.get(5));
	System.out.println(hm.get(null));

	//根据key删除
	hm.remove(1);

	//key为1的元素已经删除，返回null
	System.out.println(hm.get(1));	
    }
}

TreeMapDemo.java：

import java.util.TreeMap;
public class TreeMapDemo{
    public static void main(String[] args){
	TreeMap <Integer,String> tm = new TreeMap <>();
	//添加数据，key-value键值对形式
	tm.put(1,"张三");
	tm.put(2,"李四");
	tm.put(3,"王二麻子");
	tm.put(4,"赵五");
	tm.put(5,"刘六");
	//错误，不允许null键和null值
	//tm.put(null,null);
	//根据key值获取value
	System.out.println(tm.get(1));
	System.out.println(tm.get(3));
	System.out.println(tm.get(5));
	//错误，不允许null键和null值
	//System.out.println(tm.get(null));

	//根据key删除
	tm.remove(1);

	//key为1的元素已经删除，返回null
	System.out.println(tm.get(1));	
    }
}

四、集合转换（了解）

Map集合可以转换为Collection集合，方法：
entrySet()：返回一个包含了Map中元素的集合，每个元素都包括键和值。
keySet()：返回Map中所有键的集合。
values()：返回Map中所有值的集合。

MapChangeCollectionDemo.java：

import java.util.*;
import java.util.Map.Entry;
public class MapChangeCollectionDemo{
    public static void main(String[] args){
	HashMap <Integer,String> hm = new HashMap <>();
	//添加数据，key-value键值对形式
	hm.put(1,"张三");
	hm.put(2,"李四");
	hm.put(3,"王二麻子");
	hm.put(4,"赵五");
	hm.put(5,"刘六");
	//使用entrySet()方法获取Entry键值对集合，Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。
	Set<Entry <Integer,String>> set = hm.entrySet();
	System.out.println("所有Entry：");
	//遍历所有元素
	for(Entry <Integer,String> entry:set){
		System.out.println(entry.getKey()+":"+entry.getValue());
	}
	System.out.println("-----------------");

	//使用keySet()方法获取所有键的集合
	Set <Integer> keySet = hm.keySet();
	System.out.println("所有key：");
	for(Integer key:keySet){
		System.out.println(key);
	}
	System.out.println("-----------------");

	//使用values()方法获取所有值的集合
	Collection <String> valueSet = hm.values();
	System.out.println("所有value：");
	for(String value:valueSet){
		System.out.println(value);
	}

    }
}

五、集合工具类（了解）后期扩展

Java集合框架汇总还提供了两个辅助工具类：Collections和Arrays。
Collections工具类：提供了一些对Collection集合常用的静态方法，如排序、复制、查找以及填充等操作。
Arrays工具类：提供了针对数组的各种静态方法，如排序、复制、查找等操作。

总结

本章重点掌握前三个知识点，泛型是将数据类型参数化，提高了代码的重用性。集合类分别讲了Collection接口下的三个常用子接口：List=>ArrarList（下标从0开始，可重复）；Set=>HashSet（HashSet使用Hash算法来存储集合中的元素，具有良好的存、取以及可查找性，无序不可重复）；Queue=>LinkedList（先进先出队列，push=offerFirst，offer=offerLast）。Map接口：Map=>HashMap（有键值对，key值不可以重复，value值可以重复，无序，键值对可以为null）。

题目一

（一）自定义泛型类MyStack，模拟数据结构中的“栈”，并测试。该类中至少包含以下方法：
（1）压栈的方法push()。
（2）弹栈的方法pop()。
（3）获取栈顶元素的方法peek()。
（4）获取栈中元素的个数的方法size()。
源程序：

import java.util.ArrayList;

public class TestStack {
    public static void main(String[] args) {
        MyStack<String> ms = new MyStack<>();
        ms.push("张三");
        ms.push("李四");
        ms.push("王五");
        ms.push("赵六");
        System.out.println("栈顶元素:"+ms.peek());
        System.out.println("栈空间大小:"+ms.getSize());
        ms.pop();
        ms.pop();
        System.out.println("栈顶元素:"+ms.peek());
        System.out.println("栈空间大小:"+ms.getSize());
    }

}

class MyStack<T> {
    ArrayList<T> arr = new ArrayList<>();

    //压栈的方法push()
    public void push(T data) {
        arr.add(data);
    }

    //弹栈的方法pop()
    public void pop() {
        arr.remove(arr.size() - 1);
    }

    //获取栈顶元素的方法peek()
    public T peek() {
        T data = arr.get(arr.size() - 1);
        return data;
    }

    //获取栈中元素的个数的方法size()
    public int getSize() {
        return arr.size();
    }
}

测试结果截图：

题目二

（二）有下面的ArrayList，并使用foreach和迭代器遍历此链表。

使用foreach遍历链表的源程序：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

public class Test02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("java");
        list.add("python");
        list.add("c");
        list.add("c++");
        list.add("php");
        list.add("oc");
        //方法一 foreach
        for (String str : list
        ) {
            System.out.print(str + " ");
        }
    }
}

运行结果截图：

使用迭代器遍历链表的源程序：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

public class Test02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("java");
        list.add("python");
        list.add("c");
        list.add("c++");
        list.add("php");
        list.add("oc");     
        //方法二 迭代器
        System.out.println();
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
    }
}

运行结果截图：

题目三

（三）有下面的Map集合，使用两种方法遍历。
Map：

方法一源程序：

import java.util.Set;
import java.util.TreeMap;

public class Test03 {
    public static void main(String[] args) {

        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C");
        map.put(4, "C++");
        map.put(5, "PHP");
        //方法一 keySet()
        Set<Integer> keys = map.keySet();
        for (Integer key : keys
        ) {
            System.out.println(key+":" +map.get(key));
        }
    }
}

运行结果截图：

方法二源程序：

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test03 {
    public static void main(String[] args) {

        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(1, "Java");
        map.put(2, "Python");
        map.put(3, "C");
        map.put(4, "C++");
        map.put(5, "PHP");
        //方法二： entrySet()
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> entry : entries){
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }
}

运行结果截图：

题目四

（四）双色球共有49个数字。其中红色球33个（数字从1-33），篮色球16个（数字从1-16）。编写一个程序，实现自动选号，每次选出一组号码（6个红色球和1个蓝色球）。
源程序：

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

public class Test04 {
    public static Set<Integer> getNums(int n, int count) {
        HashSet<Integer> nums = new HashSet<>();
        Random r = new Random();
        while (true) {
            nums.add(r.nextInt(n) + 1);
            if (nums.size() == count) {
                break;
            }
        }
        return nums;
    }

    public static void main(String[] args) {
        System.out.println("红色球"+getNums(32,6));
        System.out.println("蓝色球"+getNums(32,6));
        System.out.println("绿色球"+getNums(32,6));
    }
}

运行结果截图：

收获：
1、 泛型、学会自定义泛型的定义以及应用。
2、通过arraylist模拟栈这种先进后出的数据结构，实现pop(),push(),peek(),getSize()等方法，并进行测试。
3、学会使用foreach和vector迭代器迭代输出数组中的元素。
4、泛型的好处1.类型安全2.能够避免在强转时出现问题
5、学会使用map里的keySet()和entrySet()方法。
6、了解掌握HashSet以及TreeSet的相关属性及其方法。