Java入门系列-19-泛型集合

集合

如何存储每天的新闻信息？每天的新闻总数是不固定的，太少浪费空间，太多空间不足。
如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象，可以使用Java集合框架。

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

接口 Collection 存储一组不唯一，无序的对象，它有两个子接口 List和Set。List 接口存储一组不唯一，有序(插入顺序)的对象。Set 接口存储一组唯一，无序的对象。

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

List 接口的实现类

ArrayList

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

下面演示使用及常用方法

//Book类存储书的信息
public class Book {

	private String name;//书名
	private float price;//价格
	
	public Book() {
		super();
	}
	
	public Book(String name, float price) {
		super();
		this.name = name;
		this.price = price;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
}

测试类

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

public class TestArrayList {
	public static void main(String[] args) {
		List books=new ArrayList();//创建集合
		//向集合中添加元素
		books.add(new Book("80天环游世界",34.6f));
		books.add(new Book("Java核心技术",88));
		books.add(new Book("Java编程思想",122));
		//获取集合的长度
		System.out.println("集合的长度："+books.size());
		//指定索引移除一个元素
		books.remove(0);
		System.out.println("移除后集合的长度："+books.size());
		//for循环遍历 ArrayList
		for (int i = 0; i < books.size(); i++) {
			Book book=(Book) books.get(i);
			System.out.println("书名："+book.getName()+" 价格："+book.getPrice());
		}
		//foreach 遍历 ArrayList
		for (Object object : books) {
			Book book=(Book) object;
			System.out.println("书名："+book.getName()+" 价格："+book.getPrice());
		}
		//插入元素到指定索引,其余元素自动后移
		books.add(0, new Book("明朝那些事儿",55));
		//移除指定索引元素
		books.remove(2);
		//清空所有元素
		books.clear();
		System.out.println("清空集合的长度："+books.size());
	}
}

这里面的方法在 Java API 文档中都能查到，一定要学会查看帮助文档。

LinkedList

LinkedList 采用链表存储方法。插入、删除元素时效率比较高。LinkedList提供了对头部和尾部元素进行添加和删除的方法。

下面看一下操作链表集合

import java.util.LinkedList;

public class TestLinkedList {
	public static void main(String[] args) {
		
		LinkedList books=new LinkedList();//创建链表集合
		//向集合中添加元素
		books.add(new Book("80天环游世界",34.6f));
		//向集合首部添加元素
		books.addFirst(new Book("Java核心技术",88));
		//向集合尾部添加元素
		books.addLast(new Book("Java编程思想",122));
		System.out.println(books.size());
		//获取第一个
		Book book1=(Book) books.getFirst();
		System.out.println("书的名字："+book1.getName());
		//获取最后一个
		Book lastBook=(Book) books.getLast();
		System.out.println("最后一本书的名字："+lastBook.getName());
		//移除第一个元素
		books.removeFirst();
		System.out.println("集合长度："+books.size());
		//移除最后一个元素
		books.removeLast();
		System.out.println("集合长度："+books.size());
	}
}

LinkedList也实现于List接口，所以在ArrayList示例中使用的方法LinkedList都有，LinkedList独有的方法在上例中，单独记忆即可。

Map

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

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

public class TestMap {
	public static void main(String[] args) {
		Map map=new HashMap();
		map.put("h", "hello");//向集合中添加键和值的映射
		map.put("b1", new Book("Java核心技术",88));
		System.out.println("集合长度："+map.size());
		map.remove("h");//通过指定的键移除键和值
		//根据键获取指定的值
		Book book=(Book) map.get("b1");
		System.out.println("书名："+book.getName());
		//遍历Map的值的集合
		for (Object temp : map.values()) {
			System.out.println(temp);
		}
		//清空集合
		map.clear();
		System.out.println("集合长度："+map.size());
	}
}

泛型集合

下面代码在使用时有没有问题：

Book book=(Book) books.get(i);

List和Map添加元素时都是Object类型，在强制类型转换时容易发生异常。JDK1.5使用泛型改写了集合框架中的接口和类。

使用泛型时要加上一对“<>”，在尖括号内写上限定的数据类型。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
	public static void main(String[] args) {
		List<String> names=new ArrayList<String>();
		names.add("张三");//只能添加 String 类型元素
		names.get(0).substring(0);//返回的类型也是指定的类型
		//Map在使用时需要同时指定键和值的类型
		Map<String,String> map=new HashMap<String,String>();
		map.put("h", "hello");//键和值都只能是指定的类型
	}
}

指定完类型后，元素就是指定的类型的元素，那这样在存数据和取数据都是指定类型，不需要类型转换。

使用泛型后，集合的遍历也更加方便,其中演示了foreach遍历Map的三种方法。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class TestEach {
	public static void main(String[] args) {
		//List的遍历
		List<Book> books=new ArrayList<Book>();
		books.add(new Book("80天环游世界",34.6f));
		books.add(new Book("Java核心技术",88));
		books.add(new Book("Java编程思想",122));
		//books.add("aaa");//去掉注释试试
		for (Book book : books) {
			System.out.println(book.getName());
		}
		//Map的遍历
		Map<String,Book> bookMap=new HashMap<String,Book>();
		bookMap.put("java", new Book("Java入门到精通",122));
		bookMap.put("docker", new Book("docker入门到精通",122));
		//1.遍历键获取值
		for (String key : bookMap.keySet()) {
			Book book=bookMap.get(key);
			System.out.println(book.getName());
		}
		System.out.println("==============");
		//2.遍历值
		for (Book book : bookMap.values()) {
			System.out.println(book.getName());
		}
		System.out.println("--------------");
		//3.同时遍历键和值
		for (Entry<String, Book> entry : bookMap.entrySet()) {
			String key=entry.getKey();
			Book value=entry.getValue();
			System.out.println("key:"+key+" value:"+value.getName());
		}
	}
}

map.keySet() 返回的是一个 Set 集合，这也是Map的键不能重复的原因。entrySet()方法返回了Entry的集合，Entry包含了键和值。

迭代器 Iterator

迭代器用来迭代集合，常用的两个方法：hasNext()返回布尔值，判断是否存在另一个可访问的元素。next()返回要访问的下一个元素，可以指定为泛型，这样不需要类型转换。

下面看一下 List 集合和 Map 使用迭代器。

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

public class TestIterator {

	public static void main(String[] args) {
		List<Book> books=new ArrayList<Book>();
		books.add(new Book("80天环游世界",34.6f));
		books.add(new Book("Java核心技术",88));
		books.add(new Book("Java编程思想",122));
		//获取迭代器
		Iterator<Book> i=books.iterator();
		while(i.hasNext()) {
			Book book=i.next();
			System.out.println("图书名字："+book.getName());
		}
		//Map可以迭代键或值
		Map<String,Book> bookMap=new HashMap<String,Book>();
		bookMap.put("java", new Book("Java入门到精通",122));
		bookMap.put("docker", new Book("docker入门到精通",122));
		//获取键的迭代器
		Iterator<String> iKey=bookMap.keySet().iterator();
		while(iKey.hasNext()) {
			String key=iKey.next();
			System.out.println(key);
		}
		//值的迭代器写法类似
		Iterator<Book> iValue=bookMap.values().iterator();
		while(iValue.hasNext()) {
			Book value=iValue.next();
			System.out.println(value.getPrice());
		}
	}
}

迭代器可以和其他循环用法结合，大家可以自己尝试。

包装类

先看一下这段代码是否能编译呢？

List<int> nums=new ArrayList<int>();

编译器会提示只能写引用类型，java为每个基本数据类型都提供了引用类型。

基本类型	引用类型
int	Integer
double	Double
float	Float
byte	Byte
long	Long

这些引用类型赋值时可以赋值对应的基本类型

Integer i=1;
Float f=2.2f;

也可以像引用类型那样初始化为null

Integer i=null;

这些包装类的方法过多，大家可以查阅文档。

欢迎将查阅到的包装类的方法发表到留言区