Java高级特性_1 集合框架及泛型 #36

Qingquan-Li · 2017-02-23T17:20:02Z

参考:
https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html
http://docs.oracle.com/javase/8/docs/api/
http://www.javatpoint.com/collections-in-java
http://www.runoob.com/java/java-collections.html

为什么使用集合框架？

开发应用程序中，如果想储存多个不同类型的数据，可以用数组来实现，但采用数组存在一些明显的缺陷：

数组长度固定不变，不能很好适应元素数量动态变化的情况；

可通过 数组名 .length 获取数组长度，却无法直接获取数组中实际储存的元素个数；

数组采用在内存中分配连续空间的储存方式，根据元素信息查找时效率低，需要多次比较。

Java 集合框架提供了一套性能优良、使用方便的接口和类，它们位于 java.util 包中。

虚线框表示接口（或者抽象类），实线框表示实现类，粗实线框表示开发中常用的类。
Java 的集合类主要由 Collection 接口和 Map 接口派生而来，其中 Collection 接口有两个常用的子接口（ List 和 Set ）。所以通常说 Java 集合框架由三大类接口构成（ List 接口、 Set 接口、 Map接口）。
其中， Iterator 接口表示对集合进行迭代的迭代器。 Iterator 接口为集合而生，专门实现集合的遍历。
除了集合，该框架也定义了 Map 接口及其实现类。Map 里存储的是键/值对。尽管 Map 不是 Collections，但是它们完全整合在集合中。
为了方便的对 Collection 对象、 Array 对象进行操作，Java中提供了 Collections 工具类（集合操作工具类）和 Arrays 工具类对其进行操作。
其中 Arrays 和 Collections 中所有的方法都为静态的，以方便直接传入对象引用，执行相应的功能。http://blog.csdn.net/qq_29663071/article/details/51377334

Java 集合框架

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

List 接口：存储一组不唯一，有序（插入顺序）的对象

Set 接口：存储一组唯一(不重复)，无序的对象

Map 接口：存储一组键值对象

List 接口存储一组不唯一，有序（插入顺序）的对象:

0	1	2	3	4	5
aaaa	dddd	cccc	aaaa	eeee	dddd

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

   eeee
       aaaa
dddd         cccc

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

 -------     --------      -------
|  CHN  |    |  USA  |    |  JPN  |
 -------      -------      -------
| China |    |America|    | Japan |
 -------      -------      -------

Collection 接口

List 接口

ArrayList 集合类(实现类)：遍历元素和随机访问元素的效率比较高

LinkedList 集合类(实现类)：插入、删除元素时效率比较高

ArrayList 实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

0	1	2	3	4	5
aaaa	dddd	cccc	aaaa	eeee	dddd

LinkedList 采用链表存储方式。插入、删除元素时效率比较高

ArrayList 集合类

参考：
http://docs.oracle.com/javase/8/docs/api/
http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

实例一：展现 ArrayList 常用方法

/*（1）导入  ArrayList 集合类*/
import java.util.ArrayList;

public class ArrayList_Demo {
    public static void main(String[] args){
        /*（2）创建  ArrayList 对象，并添加数据。
        使用 boolean add(Object o) 方法添加元素（注意：添加到集合中的数据将转换成 Object 类型）*/
        ArrayList list = new ArrayList();
        list.add("张三丰");
        list.add("郭靖");
        list.add("杨过");
        list.add("Fatli");
        /*（3）判断集合中是否包含“李莫愁”。
        使用 boolean contains(Object o) 判断列表中是否存在指定元素*/
        System.out.println(list.contains("李莫愁"));    //输出 false
        /*（4）把索引为 0 的数据移除;把 Fatli 移除。
        使用 Object remove(int index) 从列表中删除指定位置的元素；
        使用 boolean remove(Object o) 从列表中删除元素*/
        list.remove(0);
        list.remove("Fatli");
        /*（5）把索引为 1 的元素替换为"黄蓉"。
        使用 void set(int index,Object obj) 将index 索引位置的元素替换为 obj 元素；*/
        list.set(1,"黄蓉");
        /*（6）输出集合中所有的元素。
        使用 Object get(int index) 返回指定索引位置处的元素（取出的元素是 Object 类型，使用前需要进行强制类型转换）
        还使用 int size() 返回列表中的元素个数；*/
        for(int i = 0;i < list.size();i++){
            String name = (String)list.get(i);
            System.out.print(name+" ");    //输出：郭靖 黄蓉
        }
        /*使用增强 for 循环比普通 for 循环更加简单方便，而且不用考虑下标越界的问题。
        for(Object obj:list){
            String name = (String)obj;
            System.out.println(name);
        }
        */
        /*（7）输出“小龙女”所在的索引位置。
        使用 int indexOf(Object obj) 返回元素在集合中出现的索引位置*/
        System.out.println(list.indexOf("小龙女"));    //因集合中没有该元素，输出: -1
        /*（8）清空 ArrayList 集合中的数据。
        使用 void clear() 移除此列表中的所有元素*/
        list.clear();
        /*判断 ArrayList 集合中是否包含数据。
        使用 boolean isEmpty() 判断 ArrayList 集合是否为空*/
        System.out.println(list.isEmpty());    //输出: true
    }
}

多态：
上面（2）处 ArrayList list = new ArrayList(); 也可以写成 List list = new ArrayList(); 并导入 java.util.List 工具包。
这是将接口 List 的引用指向实现类 ArrayList 的对象，在编程中将接口的引用指向实现类的对象是 Java 实现多态的一种形式，也是软件开发过程中实现低耦合的方式之一。

实例二（实体类+实现类）：新闻管理系统：1.可以储存各类新闻标题（包含 ID、名称、创建者）；2.可以获取新闻标题总数；3.可以逐条打印新闻标题

package entity;
/**
 * 实体类（同下 LinkedList_Demo 的实体类）
 * @author Fatli
 */
public class NewsTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	
	public NewsTitle() {	   //无参构造方法
	}
	public NewsTitle(int id, String titleName, String creater) {//有参构造方法(构造方法重载)
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}

	public void setCreater(String creater) {
		this.creater = creater;
	}
}

package test;

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

import entity.NewsTitle;

public class ArrayList_Demo2 {
	public static void main(String[] args) {
		// 具体实现步骤
		// 1、创建多个各类新闻标题对象
		NewsTitle politics = new NewsTitle(1, "政治", "管理员");
		NewsTitle economy = new NewsTitle(2, "经济", "管理员");
		// 2、创建存储各类新闻标题的集合对象
		List newsTitleList = new ArrayList();
		// 3、按照顺序依次添加各类新闻标题
		newsTitleList.add(politics);
		newsTitleList.add(economy);
		// 4、获取新闻标题的总数
		System.out.println("新闻标题数目为：" + newsTitleList.size() + "条"); //输出：新闻标题数目为：2条
		// 5、根据位置获取相应新闻标题、逐条打印每条新闻标题的名称，也就是我们常说的遍历集合对象
		for (int i = 0; i < newsTitleList.size(); i++) {
			NewsTitle title = (NewsTitle) newsTitleList.get(i);		
			System.out.print(i + 1 + ":" + title.getTitleName()+" ");	//输出：1:政治 2:经济
		}
	}
}

LinkedList 集合类

LinkedList 类是 List 接口（ Collection 接口的子接口）的一个具体实现类
LinkedList 类用于创建链表数据结构
插入或者删除元素时，它提供更好的性能

LinkedList 常用方法：

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

实例：增、删、获取头条/末条新闻标题

package entity;
/**
 * 实体类（同上 ArrayList_Demo2 的实体类）
 * @author Fatli
 */
public class NewsTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	
	public NewsTitle() {	   //无参构造方法
	}
	public NewsTitle(int id, String titleName, String creater) {//有参构造方法(构造方法重载)
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}

	public void setCreater(String creater) {
		this.creater = creater;
	}
}

package test;

import java.util.LinkedList;//util工具包
import entity.NewsTitle;	//entity实体包

public class LinkedList_Demo {
	public static void main(String[] args) {
		/*（1）创建多个新闻标题。*/
		NewsTitle politics = new NewsTitle(1,"政治","管理员");
		NewsTitle economy = new NewsTitle(2,"经济","管理员");
		NewsTitle technology = new NewsTitle(3,"科技","管理员");
		NewsTitle entertainment = new NewsTitle(4,"娱乐","管理员");
		/*（2）创建储存新闻标题的集合对象，并添加数据。
		使用 boolean add(Object o) 方法添加元素（注意：添加到集合中的数据将转换成 Object 类型）*/
		LinkedList newsTitleList = new LinkedList();
		newsTitleList.add(politics);	//政治
		newsTitleList.add(economy);		//经济
		/*（3）添加头条新闻标题 和 末条新闻标题。
		使用 void addFirst(Object o) 在列表的首部添加元素 
		使用 void addLast(Object o) 在列表的末尾添加元素 */
		newsTitleList.addFirst(technology);		//科技
		newsTitleList.addLast(entertainment);	//娱乐
		/*（4）获取头条 及 最末条新闻。
		使用 Object getFirst() 返回列表中的第一个元素 
		使用 Object getLast() 返回列表中的最后一个元素 */
		NewsTitle first = (NewsTitle) newsTitleList.getFirst();
		NewsTitle last = (NewsTitle) newsTitleList.getLast();
		/*（5）删除头条和最末条新闻。
		使用 Object removeFirst() 删除并返回列表中的第一个元素 
		使用 Object removeLast() 删除并返回列表中的最后一个元素*/
		newsTitleList.removeFirst();
		newsTitleList.removeLast();
		/*遍历所有新闻标题。使用增强 for 循环。*/
		for(Object obj : newsTitleList){
			NewsTitle nt = (NewsTitle)obj;
			System.out.print(nt.getTitleName()+" ");//输出：政治 经济
		}
	}
}

Set 接口

Set 接口存储一组唯一（不重复），无序的对象
HashSet 是 Set 接口常用的实现类
Set 中存放对象的引用

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

public class SetDemo {
	public static void main(String[] args) {
		Set set=new HashSet();
		String s1=new String("java");
		String s2=s1;
//	  String s3=new String("java");    //输出：1
		String s3=new String("JAVA");    //输出：2
		set.add(s1);
		set.add(s2);
		set.add(s3);
		System.out.println(set.size());
	}
}

HashSet 集合类

HashSet 是 Java 集合框架提供的一个查找效率高的集合类。HashSet 是 Set 接口常用的实现类。

HashSet 集合类的常用方法：

方法	说明
boolean add(Object o)	如果此 Set 中尚未包含指定元素（因为 Set 存储的是唯一不重复的对象），则添加指定元素
void clear()	从此 Set 中移除所有元素
int size()	返回 Set 中的元素数量（ Set 的容量）
boolean isEmpty()	如果此 Set 不包含任何元素，则返回 true
boolean contains(Object o)	如果此 Set 包含指定元素，则返回 true
boolean remove(Object o)	如果指定元素存在于此 Set 中，则将其移除

Set newsTitleSet = new HashSet(); 
NewTitle car = new NewTitle(1, "汽车", "管理员"); 
// …… 继续增加元素 
newsTitleSet.add(car); 
// …… 继续获取元素个数 
System.out.println("新闻标题数目为：" + newsTitleList.size() + "条");

Set 接口不存在 get() 方法，错误示范： newsTitleSet.get(0); 思考为什么，以及怎样实现元素输出？——使用 Iterator 迭代器或者 for 循环遍历输出。

附：Java集合框架_hashCode() & equals()

Iterator 迭代器

Iterator 接口表示对集合进行迭代的迭代器。 Iterator 接口为集合而生，专门实现集合的遍历。

Iterator 接口的两个主要方法：

boolean hasNext(): 判断是否存在下一个可访问的元素，如果仍有元素可以迭代，则返回 true。
Object next(): 返回要访问的下一个元素。

另外，凡是由 Collection 接口派生而来的接口或者实现类，都实现了 iterate() 方法， iterator() 方法返回一个 Iterator 对象。

package entity;
/**
 * 实体类（同上 ArrayListDemo2 、 LinkedList_Demo 一样的实体类）
 * @author Fatli
 */
public class NewsTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	
	public NewsTitle() {	   //无参构造方法
	}
	public NewsTitle(int id, String titleName, String creater) {//有参构造方法(构造方法重载)
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}

	public void setCreater(String creater) {
		this.creater = creater;
	}
}

package test;

import java.util.HashSet;
import java.util.Iterator; //导入 Iterator 接口
import java.util.Set;

import entity.NewsTitle;

public class IteratorDemo {
	public static void main(String[] args) {
		// 1. 创建多个各类新闻标题对象
		NewsTitle politics = new NewsTitle(1, "政治", "管理员");
		NewsTitle economy = new NewsTitle(2, "经济", "管理员");
		// 2. 创建存储各类新闻标题的集合对象
		Set newsTitleList = new HashSet();
		// 3. 按照顺序依次添加各类新闻标题
		newsTitleList.add(politics);
		newsTitleList.add(economy);
		// 4. 获取新闻标题的总数
		System.out.println("新闻标题数目为：" + newsTitleList.size() + "条"); //2
		// 5. 使用 iterator() 方法获取 Iterator 对象
		//凡是由 Collection 接口派生而来的接口或者实现类，都实现了 iterate() 方法， iterator() 方法返回一个 Iterator 对象
		Iterator it = newsTitleList.iterator();
		// 6. 使用 Iterator 遍历集合
		//使用 Iterator 的 hasNext() 方法判断是否存在下一个可访问的元素；使用 Iterator 的 next() 方法返回要访问的下一个元素。
		while(it.hasNext()){
			NewsTitle title = (NewsTitle) it.next();
			System.out.print(title.getTitleName()+" "); //输出：政治 经济（也可能输出：经济 政治。因为 Set 存储的是一组无序的对象 ）
		}
		System.out.println("");
		// 7. 方法二：使用增强型 for 遍历集合
		for(Object obj:newsTitleList){
			NewsTitle title = (NewsTitle)obj;
			System.out.print(title.getTitleName()+" "); //输出：政治 经济（也可能输出：经济 政治。因为 Set 存储的是一组无序的对象 ）
		}
	}
}

Map 接口

Map 接口专门处理键值映射数据的存储，可以根据键实现对值的操作。
最常用的实现类是 HashMap

Map 接口的常用方法

方法名	说明
Object put(Object key, Object value)	以 “键-值” 对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回 null
Object remove(Object key)	删除由指定的键映射的 “键-值对”
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	如果存在由指定的键映射的 “键-值对”，返回 true

实例：建立国家英文简称和中文全名间的键值映射，并通过 key 对 value 进行操作

package test;

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

public class MapDemo {
	public static void main(String[] args) {
        // 1、使用 HashMap 存储多组国家英文简称和中文全称的键值对
        Map countries = new HashMap();
	    countries.put("CHN", "中华人民共和国");
	    countries.put("USA", "美利坚合众国");
	    countries.put("JPN", "日本国");
        // 2、显示"CHN"对应国家的中文全称
        String country = (String) countries.get("CHN");
        System.out.println("CHN 对应的国家是:" + country);
        // 3、显示集合中元素个数
        System.out.println("Map 中共有"+countries.size()+"组数据"); // 3
        /*4、两次判断 Map 中是否存在 "USA" 键*/
        System.out.println("Map 中包含 USA 的 key 吗?" + 
        countries.containsKey("USA"));    //输出：Map 中包含 USA 的 key 吗?true
        countries.remove("USA");
        System.out.println("Map 中包含 USA 的 key 吗?" + 
        countries.containsKey("USA"));    //输出：Map 中包含 USA 的 key 吗?false
        /* 5、分别显示 键集、值集和键值对集*/
        System.out.println(countries.keySet()); //输出：[CHN, JPN]
        System.out.println(countries.values()); //输出：[中华人民共和国, 日本国]
        System.out.println(countries);			//输出：{CHN=中华人民共和国, JPN=日本国}
        /* 3、清空 HashMap 并判断*/
        countries.clear();
        if(countries.isEmpty())
        	System.out.println("已清空Map中数据！");//输出：已清空Map中数据！
    }
}

泛型

将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性，这就是泛型。泛型的本质就是参数化类型。

泛型的本质就是参数化类型，也就是说所操作的数据类型都被指定为一个参数，使代码可以应用于多种类型。简单来说， Java 语言引入泛型的好处是安全简单，且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型的定义语法：

类1或者接口<类型实参> 对象 = new 类2<类型实参>();

实例一：

ArrayList<String> list = new ArrayList<String>();

实例二：

//创建学员集合 
ArrayList<Student> students = new ArrayList<Student>();
//创建学员类对象 
Student student = new Student(); 
//创建诗类对象 
Poem poem = new Poem(); 
//将两个对象添加到list集合中           
students.add(student);  //由于创建时已指定 Student 类型，所以这里会报错 
students.add(poem);

泛型集合

JDK5.0 使用泛型改写了集合框架中的所有接口和类

泛型在集合中的应用：
例如在 List 接口中的 add() 方法的参数是 Object 类型，在通过 get() 方法取出集合中的元素时必须进行强制类型转换，还可能出现 ClassCastException 异常。另外， Map 接口中使用 put() 和 get() 方法存取对象时，使用 Iterator 接口的 next() 方法取元素时存在同样的问题。
使用泛型集合在创建集合对象时指定集合中元素的类型，从集合中取出时无需进行类型强制转换。如果把非指定类型对象放入集合，会出现编译错误。

List 和 ArrayList 的泛型形式是 List<E> 和 ArrayList<E> 。 <E> 表示该泛型集合中的元素类型。

//省略 NewsTitle 实体类。 关键代码：
//使用泛型
List<NewsTitle> newsTitleList = new ArrayList();
//添加集合元素
newsTitleList.add(politics);
newsTitleList.add(economy);
//遍历输出新闻标题
for(NewsTitle nt : newsTitleList){
	System.out.print(nt.getTitleName());
}
/*不再需要类型强制转换：
for(Object obj : newsTitleList){
	NewsTitle nt = (NewsTitle)obj;
	System.out.print(nt.getTitleName()+" ");//输出：政治 经济
}*/

Map 于 HashMap 的泛型形式是 Map<K,V> 和 HashMap<K,V> 。因为它们的每个元素都包含两个部分，即 key 和 value ，所以，在应用泛型时，要同时指定 key 的类型和 value 的类型。 <K,V> 表示该泛型集合中的元素类型，其中， K 表示 key 的类型， V 表示 value 的类型。

package entity;

public class Student {
	private String name; // 学员姓名
	private String sex; // 学员性别
	public Student() {
	}
	public Student(String name, String sex) {
		this.name = name;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	//重写 toString() 方法
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + "]";
	}
}

package test;

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

import entity.Student;

public class HashMapDemo {
	public static void main(String[] args) {
		// 1.创建学员对象
		Student student1 = new Student("权权", "男");
		Student student2 = new Student("坪坪", "女");
		// 2.创建保存“键-值对”的集合对象
		Map<String,Student> students = new HashMap<String,Student>();
		// 3.把英文名称与学员对象按照“键-值对”的方式存储在 HashMap 中
		students.put("Fatli", student1);
		students.put("Xenia", student2);
		// 4.打印键集
		System.out.println("键集："+students.keySet());	//键集：[Fatli, Xenia]
		// 5.打印值集
		System.out.println("值集："+students.values());	//值集：[Student [name=权权, sex=男], Student [name=坪坪, sex=女]] 
														//如果不在实体类 Student 添加（重写）  toString() 方法，输出的是哈希值： [entity.Student@2e7227a8, entity.Student@48899e6a]
		// 6.打印键-值对集合
		System.out.println("键-值对集合:"+students);		//键-值对集合:键-值对集合:{Fatli=Student [name=权权, sex=男], Xenia=Student [name=坪坪, sex=女]}
														//如果不在实体类 Student 添加（重写）  toString() 方法，输出的是哈希值：{Fatli=entity.Student@2e7227a8, Xenia=entity.Student@48899e6a}
		// 7.判断是否存在“Fatli”这个键
		String key = "Fatli";
		if(students.containsKey(key)){
		    // 8.如果存在，根据键获取相应的值
			Student student = students.get(key);
			System.out.println("学员姓名："+student.getName());	//学员姓名：权权
		}
	}
}

泛型类、泛型接口、泛型方法

在集合中使用泛型只是泛型应用的其中一种，在类、接口、方法中也有着广泛的应用。

泛型类

泛型类，就是具有一个或者多个类型变量的类。

定义泛型类的的语法：

[访问修饰符] class className<TypeList>

泛型接口

泛型接口，就是具有一个或者多个类型变量的接口。

定义泛型接口的的语法：

[访问修饰符] interface interface<TypeList>

泛型方法

泛型方法，实际上就是带有类型参数的方法。

定义泛型方法的语法：

访问修饰符 <类型参数> 返回值 方法名 （类型参数列表）

实例：

public <String> void showName (String s) {}

The text was updated successfully, but these errors were encountered:

Qingquan-Li added the Java label Feb 23, 2017

Qingquan-Li mentioned this issue Feb 21, 2018

Python3数据类型 #81

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Java高级特性_1 集合框架及泛型 #36

Java高级特性_1 集合框架及泛型 #36

Qingquan-Li commented Feb 23, 2017 •

edited

Loading

Java高级特性_1 集合框架及泛型 #36

Java高级特性_1 集合框架及泛型 #36

Comments

Qingquan-Li commented Feb 23, 2017 • edited Loading

为什么使用集合框架？

Java 集合框架

List 接口存储一组不唯一，有序 （插入顺序）的对象:

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

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

ArrayList 实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

LinkedList 采用链表存储方式。插入、删除元素时效率比较高

ArrayList 集合类

实例一：展现 ArrayList 常用方法

实例二（实体类+实现类）：新闻管理系统：1.可以储存各类新闻标题（包含 ID、名称、创建者）；2.可以获取新闻标题总数；3.可以逐条打印新闻标题

LinkedList 集合类

LinkedList 常用方法：

实例：增、删、获取头条/末条新闻标题

Set 接口

HashSet 集合类

HashSet 集合类的常用方法：

附：Java集合框架_hashCode() & equals()

Iterator 迭代器

Map 接口

Map 接口的常用方法

实例：建立国家英文简称和中文全名间的键值映射，并通过 key 对 value 进行操作

泛型

泛型集合

泛型类、泛型接口、泛型方法

泛型类

泛型接口

泛型方法

Qingquan-Li commented Feb 23, 2017 •

edited

Loading

List 接口存储一组不唯一，有序（插入顺序）的对象: