Java Collection、List、Map、Set

最新推荐文章于 2022-02-06 12:30:45 发布

伍Wu哈Ha

最新推荐文章于 2022-02-06 12:30:45 发布

阅读量1.1k

点赞数

分类专栏： Java 文章标签： java 集合

Java 专栏收录该内容

36 篇文章 5 订阅

订阅专栏

Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。使程序员操作成批的数据或对象元素极为方便。
　　Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
　　这些接口和类有很多对抽象数据类型操作的API，而这是我们常用的且在数据结构中熟知的。例如Map，Set，List等。并且Java用面向对象的设计对这些数据结构和算法进行了封装，这就极大的减化了程序员编程时的负担。
　　程序员也可以以这个集合框架为基础，定义更高级别的数据抽象，比如栈、队列和线程安全的集合等，从而满足自己的需要。

Java集合主要分为三种类型：

Set(集)
List(列表)
Map(映射)

注意，这里的 Collection、List、Set和Map都是接口，不是具体的类实现。

常用集合类的继承结构如下：

Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Map<--SortedMap<--TreeMap
Map<--AbstractMap<--HashMap

public interface List<E> extends Collection<E>

public interface Collection<E> extends Iterable<E>

public interface Iterable<T>

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

集合与数组：数组也是用来存储操作对象，但，数组长度固定，不可变；数组只能存储基本数据类型，例如int,String等；集合长度可变，且一个集合可存储不同类型的对象

集合分类:根据每种容器（集合）对数据的存储方式（数据结构）不同。
collection—(List,Set),
List----(ArrayList（底层是数组数据结构）,linkedList（底层是链表数据结构）,Vector（底层数据结构是数组）)
Set----(HashSet(底层数据结构是哈希表)，TreeSet（底层数据结构是二叉树）)

List：元素有序（可索引，所以有很多和索引有关的方法），元素可重复；
Set：元素无序（存入和取出的顺序不一定一致）且不允许重复；其中，HashSet能保证元素唯一性（利用HashCode方法和equals方法）；TreeSet可以对集合中元素进行排序（自然顺序）

Map相当于和Collection一个级别的；Map< K,V>该集合存储键值对，且要求保持键的唯一性；
Map----(HashMap,Hashtable,TreeMap)。
其中，HashTable：底层是哈希表数据结构，不可以存null键、null值，且线程同步
HashMap:底层数据结构是哈希表，允许使用null键和值，其余于HashMap的用法相同，且线程不同步；
TreeMap：底层是数据机构是二叉树，可以用于给map中的键排序，且线程不同步。

List接口

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
　　
　　与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。
　　
　　List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。

List list = new ArrayList();

这是我们平常经常使用的创建一个新的List的语句， List是接口，ArrayList才是具体的类。

Set 接口

一种不包含重复的元素的无序的 Collection。

List - ArrayList

public class ArrayList<E> 
	extends AbstractList<E> 
	implements List<E>, RandomAccess, Cloneable, Serializable

底层用数组实现的List ，查询效率高，增删效率低、轻量级、线程不安全。

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
　　
　　在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
　　
　　**注意，此实现不是同步的。**如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

 List list = Collections.synchronizedList(new ArrayList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败(faill-fast)的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。
###ArrayList 常用方法

类型	方法	描述
boolean	add(E e)	将指定的元素添加到此列表的尾部。
void	add(int index,E element)	将指定的元素插入此列表中的指定位置。
boolean	addAll(Collection<? extends E> c)	按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean	addAll(int index, Collection< ? extends E> c)	从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void	clear()	移除此列表中的所有元素。
Object	clone()	返回此 ArrayList 实例的浅表副本。
boolean	contains(Object o)	如果此列表中包含指定的元素，则返回 true。
void	ensureCapacity(int minCapacity)	如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E	get(int index)	返回此列表中指定位置上的元素。
int	indexOf(Object o)	返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean	isEmpty()	如果此列表中没有元素，则返回 true
int	lastIndexOf(Object o)	返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E	remove(int index)	移除此列表中指定位置上的元素。
boolean	remove(Object o)	移除此列表中首次出现的指定元素（如果存在）。
protected void	removeRange(int fromIndex, int toIndex)	移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E	set(int index, E element)	用指定的元素替代此列表中指定位置上的元素。
int	size()	返回此列表中的元素数。
Object[]	toArray()	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
< T> T[]	toArray(T[] a)	按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void	trimToSize()	将此 ArrayList 实例的容量调整为列表的当前大小。

增

import java.util.ArrayList;

public class Arraylist2 {
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		/**
		 *  依次添加数据
		 */
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");		
		System.out.println("顺序添加list：" + list);
		// [a, b, c, d]
		
		/**
		 * 在第X个元素后面添加数据
		 * list必须要有足够多的数据，才能在某个元素下添加
		 * IndexOutOfBoundsException 数组越界
		 */
		list.add(1,"list1");
		System.out.println("在第X个元素后面添加数据list：" + list);
		// [a, list1, b, c, d]
		
		/**
		 * 把一个链表复制到另一个
		 */
		ArrayList<String> list2 = new ArrayList<>();
		list2.addAll(list);
		System.out.println("复制整个链表："+list2);
		// [a, list1, b, c, d]
		
		/**
		 * 把一个链表中的数据添加到另一个链表的第某个元素后
		 * IndexOutOfBoundsException 数组越界
		 */
		ArrayList<String> list3 = new ArrayList<>();
		list3.add("list3");
		list3.addAll(1,list);
		System.out.println("复制整个链表给特定区域："+list3);
		// [list3, a, list1, b, c, d]
		
	}
}

删

import java.util.ArrayList;

public class Arraylist {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();

		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("f");

		/**
		 * 删除某个数据
		 */
		list.remove(2);// 把c删除
		System.out.println(list);
		// [a, b, d, e, f]

		/**
		 * 按内容删除
		 */
		list.remove("d");
		System.out.println(list);
		// [a, b, e, f]

		/**
		 * 按照某个链表删除
		 * 
		 */
		ArrayList<String> list2 = new ArrayList<>();

		list2.add("a");
		list2.add("b");
		list.removeAll(list2);
		System.out.println(list);
		// [e, f]
		
		/**
		 * 清空链表
		 */
		list.clear();
		System.out.println(list);
		// []
	}
}

改,查

import java.util.ArrayList;
/**
 * 改,查
 * Title: Arraylist3
 * Description: 
 * Company: 
 * @author Peng
 * @date 下午4:55:55
 */
public class Arraylist3 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();

		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("f");
		
		/**
		 * 修改指定位置的元素
		 * 位置从0开始计算(0、1、2、3...)
		 */
		list.set(1, "修改2");
		System.out.println(list);
		// [a, 修改2, c, d, e, f]
		
		/**
		 * 获取指定位置的元素
		 */		
		String num = list.get(2);
		System.out.println("第二个元素:"+num);
		// c
		
	}
}

遍历

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
/**
 * 遍历
 * Title: Arraylist4
 * Description: 
 * Company: 
 * @author Peng
 * @date 上午10:30:17
 */
public class Arraylist4 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();

		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("f");
		
		/**
		 * ArrayList与数组转换
		 */
		Object [] obj = (Object[]) list.toArray();
		
		for(Object c:obj){
			System.out.printf("%2s",c);
		}
		
		/**
		 * 迭代器遍历ArrayList
		 */
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String str = (String) it.next();
			System.out.println(str);
		}
		/**
		 *  Arrays遍历ArrayList
		 */
		System.out.println(Arrays.toString(obj));
		/**
		 * foreach遍历ArrayList
		 * 	
		 */
		for(String s:list){
			System.out.println(s);
		}
	}
}

List -LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

底层用双向循环链表链式结构实现的List ，链表内存是散乱的,查询效率低，增删效率高
每个节点含有一个数据和下一个节点的引用

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列
　　此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。
　　注意，此实现不是同步的。
　　
LinkedList笔记：http://blog.csdn.net/peng_hong_fu/article/details/52637143#t10

List - Vector

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作

import java.util.Vector;
/**
 * 基于数组结构的集合
 * Title: TestVector
 * Description: 
 * Company: 
 * @author Peng
 * @date 下午3:11:35
 */
public class TestVector {
	public static void main(String[] args) {
		Vector<Object> v = new Vector<>();
		v.add("hello");
		v.add(1);
		v.addElement(2);
		v.addElement(new Integer(5));
		v.insertElementAt("三", 3);
		v.add(null);
		v.add("");
		v.add("bye");
		v.add("bye");
		
		System.out.println(v.get(3));
		System.out.println(v);
	}
}

三
[hello, 1, 2, 三, 5, null, , bye, bye]

Set - HashSet

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

这个也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key不能有重复。

import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet {
	public static void main(String[] args) {
		HashSet<Object> h = new HashSet<Object>();

		h.add("1st");
		h.add("2nd");
		h.add(new Integer(3));
		h.add(new Double(4.0));
		h.add("2nd"); // 重复元素，未被添加
		h.add(new Integer(3)); // 重复元素，未被添加
		h.add(new Date());

		System.out.println("开始：size=" + h.size());

		Iterator<Object> it = h.iterator();
		System.out.println("----所有元素，每次读取，位置不定----");
		while (it.hasNext()) {
			Object o = it.next();
			System.out.println(o);
		}
		System.out.println("----------");
		h.remove("2nd");

		System.out.println("移除元素后：size=" + h.size());
		System.out.println(h);
	}
}

开始：size=5
----所有元素，每次读取，位置不定----
4.0
Mon Oct 10 14:53:12 CST 2016
1st
3
2nd
----------
移除元素后：size=4
[4.0, Mon Oct 10 14:53:12 CST 2016, 1st, 3]

Set - TreeSet

基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

构造方法

TreeSet()
          构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。
TreeSet(Collection<? extends E> c)
          构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? super E> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序。
TreeSet(SortedSet<E> s)
          构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

Student.java

import java.util.Iterator;
import java.util.TreeSet;

public class MyTreeSet {
	public static void main(String[] args) {
		TreeSet<Student> mytree = new TreeSet<>();
		Student st1, st2, st3,st4,st5;
		st1 = new Student(178, "老霍");
		st2 = new Student(176, "胖子");
		st3 = new Student(158, "阳祯");
		st4 = new Student(158, "小溪");// 身高相同,重复内容未添加
		st5 = new Student(160, "秀");// 比较准则中没有比较姓名，可以添加
		
		mytree.add(st1);
		mytree.add(st2);
		mytree.add(st3);
		mytree.add(st4);
		mytree.add(st5);
		Iterator<Student> te = mytree.iterator();// 迭代器
		System.out.println("按升高从矮到高：");
		while (te.hasNext()) {
			Student stu = te.next();
			System.out.println("" + stu.name + " " + stu.height + " cm");// 按身高从矮到高
		}
	}
}

按升高从矮到高：
阳祯 158 cm
秀 160 cm
胖子 176 cm
老霍 178 cm

Map 接口

public interface Map<K,V>

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。

Map 是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。对于键对象来说，像Set一样，一个 Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求，你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。
Map有两种比较常用的实现：HashMap和TreeMap。

HashMap也用到了哈希码的算法，以便快速查找一个键

TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。
键和值的关联很简单，用put(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。

Map - HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

HashMap 的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

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

public class TestMap {
	public static void main(String[] args) {
				
		/**
		 * 哈希码代表对象的特征
		 * String类的hashCode.根据String类包含的字符串的内容，
		 * 根据一种特殊算法返回哈希码，只要字符串所在的堆空间相同，返回的哈希码也相同。
		 */
		String a ="run";
		String b= "run"; 
		// a,b指向堆中同一个字符串地址
		String c= "123";
		System.out.println("a==b:"+(a==b));// true
		String d = new String("run");
		String e = new String("run");
		
		System.out.println(d==e); // false
		System.out.println(a.hashCode()+" "+b.hashCode()+" "+c.hashCode()+" "
		+d.hashCode()+" "+e.hashCode());
		System.out.println("--------------------");		
	    Map<String , Double> map = new HashMap<String , Double>();   
	    map.put("语文" , 80.0);   
	    map.put("数学" , 89.0);   
	    map.put("英语" , 78.2);
	    
	    System.out.println(map);
	    System.out.println(map.values());
	    System.out.println(map.keySet());
	    System.out.println(map.get("数学"));
	}
}

a==b:true
false
113291 113291 48690 113291 113291
{数学=89.0, 语文=80.0, 英语=78.2}
[89.0, 80.0, 78.2]
[数学, 语文, 英语]
89.0

HashMap和Hashtable的区别

HashMap和Hashtable是一组相似的键值对集合,HashMap和Hashtable的区别：

1、Hashtable是线程安全的，Hashtable所有对外提供的方法都使用了synchronized，也就是同步，而HashMap则是线程非安全的

2、Hashtable不允许空的value，空的value将导致空指针异常，而HashMap则无所谓，没有这方面的限制

Map - TreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
详细介绍：http://blog.csdn.net/chenssy/article/details/26668941

import java.util.Collections;
import java.util.Iterator;
import java.util.TreeMap;

public class TestTreeMap2 {
	public static void main(String[] args) {
		TreeMap<String,Number> map = new TreeMap<>();
		map.put("Apple", 2013);
		map.put("apple", 2014);
		map.put("banana", 2015);
		map.put("Dog", 2016);
		map.put("cat", 2017);
		//键 区分大小写 
		
		System.out.println(map);
		/**
		 * 遍历1
		 */
		Iterator<String> it = map.keySet().iterator();
		while(it.hasNext()){
			String str = it.next();// 得到键
			Integer id = (Integer) map.get(str); // 得到值
			System.out.println(str+" "+id);			
		}
		System.out.println("----------------");
		/**
		 * 遍历2
		 */
		for(Iterator<String> it1 = map.keySet().iterator();it1.hasNext();){			
			String str = it1.next();
			Number id = map.get(str);
			System.out.println(str+" "+id);
		}
		System.out.println("--------------");
		/**
		 * 逆序遍历
		 */
		TreeMap<String,Number> map2 = new TreeMap<>(Collections.reverseOrder());
		map2.putAll(map);
		Iterator<String> it2 = map2.keySet().iterator();
		while(it2.hasNext()){
			String str = it2.next();// 得到键
			Integer id = (Integer) map2.get(str); // 得到值
			System.out.println(str+" "+id);			
		}
	}
}

{Apple=2013, Dog=2016, apple=2014, banana=2015, cat=2017}
Apple 2013
Dog 2016
apple 2014
banana 2015
cat 2017
----------------
Apple 2013
Dog 2016
apple 2014
banana 2015
cat 2017
--------------
cat 2017
banana 2015
apple 2014
Dog 2016
Apple 2013

Person.java

public class Person {
	Integer id_card;
	String name;
	
	public Person(String name,Integer id_card) {
		super();
		this.id_card = id_card;
		this.name = name;
	}
	
	public Integer getId_card() {
		return id_card;
	}

	public String getName() {
		return name;
	}	
}

TestTreeMap.java

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
	public static void main(String[] args) {
		
		Person person1 = new Person("阳祯", 220181);
		Person person2 = new Person("胖子", 220193);
		Person person3 = new Person("小赖", 220186);

		Map<Number, Person> map = new HashMap<Number, Person>();
		map.put(person1.getId_card(), person1);
		map.put(person2.getId_card(), person2);
		map.put(person3.getId_card(), person3);

		// HashMap
		System.out.println("HashMap，无序：");
		
		for (Iterator<Number> it = map.keySet().iterator(); it.hasNext();) {
			Person person = map.get(it.next());
			System.out.println(person.getId_card() + " " + person.getName());
		}

		// TreeMap
		System.out.println("TreeMap，升序：");
		TreeMap<Number, Person> treeMap = new TreeMap<Number, Person>();
		treeMap.putAll(map);
		for (Iterator<Number> it = treeMap.keySet().iterator(); it.hasNext();) {
			Person person = treeMap.get(it.next());
			System.out.println(person.getId_card() + " " + person.getName());
		}

		System.out.println("TreeMap，降序：");
		/**
		 * reverseOrder() 方法用于获取一个比较有否就实现Comparable接口的对象的集合的自然顺序相反
		 */
		TreeMap<Number, Person> treeMap2 = new TreeMap<Number, Person>(Collections.reverseOrder());
		treeMap2.putAll(map);
		for (Iterator<Number> it = treeMap2.keySet().iterator(); it.hasNext();) {
			Person person = (Person) treeMap2.get(it.next());
			System.out.println(person.getId_card() + " " + person.getName());
		}

	}
}

HashMap，无序：
220193 胖子
220181 阳祯
220186 小赖
TreeMap，升序：
220181 阳祯
220186 小赖
220193 胖子
TreeMap，降序：
220193 胖子
220186 小赖
220181 阳祯

伍Wu哈Ha

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java Collection、List、Map、Set

Collection　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。使程序员操作成批的数据或对象元素极为方便。　　这些接口和类有很多对抽象数据类型操作的API，而这是我们常用的且在数据结构中熟知的。例如Map，Set，List等。并且Java用面向对象的设计对这些数据结
复制链接

扫一扫