java基础集合框架——List、Set、Map概述(java集合一)

时间:2022-09-23 17:55:58


为什么会出现集合类?

面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,出现集合


数组与集合同是容器,有什么不同呢?

数组长度是固定的,集合长度是可变的

数组中可以存储基本数据类型,集合只能存储对象

集合类的特点

集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象

基本的集合框架如图

java基础集合框架——List、Set、Map概述(java集合一)



为什么会出现这么多的容器呢?

因为每一个容器对数据的存储方式都有不同,这个存储方式称为数据结构

集合框架分析

Collection子类

java.util.Collection [I]
+--java.util.List [I]
   +--java.util.ArrayList [C]
   +--java.util.LinkedList [C]
   +--java.util.Vector [C]
      +--java.util.Stack [C]

Set子类

    		  
+--java.util.Set [I]
   +--java.util.HashSet [C]
   +--java.util.SortedSet [I]
      +--java.util.TreeSet [C]

Map集合及子类

java.util.Map [I]
+--java.util.SortedMap [I]
   +--java.util.TreeMap [C]
+--java.util.Hashtable [C]
+--java.util.HashMap [C]
+--java.util.LinkedHashMap [C]
+--java.util.WeakHashMap [C]


表格分析

接口 实现类 历史实现类
List ArrayList Vector
  LinkedList stack
Set TreeSet  
  HashSet  
Map HashMap HashTable
  TreeMap Properties






      

List

List继承自Collection接口。List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组,List允许有重复元素


常用子类特点分析


Vector 内部是数组数据结构,是同步的,增删查询都很慢

ArrayList 内部是数组数据结构,是不同步的,查询速度快

LinkedList 内部是链表结构,是不同步的,增删元素很快


LinkedList

底层使用的链表数据结构,特点是:增删速度快,查询慢

LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。

    注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
List list = Collections.synchronizedList(new LinkedList(...));



LinkedList  l  = new LinkedList();
			l.addFirst("java");
			l.addFirst("java1");
			l.addFirst("java2");
			l.addFirst("java3");


* 在JDK1.6以后,出现的方法
* 
* offerFirst()
* offerLast()
* peekFirst()
* peekLast()
* 获取元素,但不删除元素,如果集合中没有元素,会出现null
* pollFirst()
* pollLast()
* 获取元素,但是元素被删除,如果集合中没有元素,会出现null





ArrayList

ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。

size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
    每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并 没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
    和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
底层使用的是数组结构,特点:查询速度很快,但是增删稍慢,默认长度是10;然后百分之50延长

ArrayList的常见操作

ArrayList arrayList = new ArrayList();
		// 添加元素
		arrayList.add("java1");
		arrayList.add("java2");
		arrayList.add("java3");
		arrayList.add("java4");

		//直接在控制台上输出集合中元素的信息
		System.out.println(arrayList);// [java1, java2, java3, java4]
		// 在指定位置添加元素
		arrayList.add(2, "world");
		System.out.println(arrayList);// [java1, java2, world, java3, java4]
		// 删除指定位置的元素
		arrayList.remove(2);
		System.out.println(arrayList);// [java1, java2, java3, java4]
		// 修改元素
		arrayList.set(2, "java224");
		System.out.println(arrayList);// [java1, java2, java224, java4]
		// 通过角标获取元素
		System.out.println(arrayList.get(1));// java2
		// 获取所有元素
		//第一种方法 
		for (int i = 0; i < arrayList.size(); i++) {
			System.out.println(arrayList.get(i));
		}
		//第二种方法
		Iterator it = arrayList.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

		// 通过indexOf获取对象的位置
		System.out.println(arrayList.indexOf("java2"));
		// 获取指定区域的元素
		List sb = arrayList.subList(1, 3);

去除ArrayList中的重复元素

/**
	 * 去除ArrayList中的重复元素
	 * @param l
	 * @return
	 */
    private static ArrayList med8(ArrayList<Object> l) {

    	ArrayList<Object> li = new ArrayList<Object>();
    	Iterator it = l.iterator();
    	while(it.hasNext()){
    		Object obj = it.next();
    		if(!li.contains(obj)){
    			li.add(obj);
    		}
    	}
    	return li;

    }

对ArrayList中的数据进行排序的操作


public static void main(String[] args) {
		//创建集合
		ArrayList<String> arrayList = new ArrayList<String>();
		//添加元素
		arrayList.add("adsf");
		arrayList.add("uytf");
		arrayList.add("hjk");
		arrayList.add("wedcv");
		arrayList.add("kngfsf");
		arrayList.add("wqqs");
		//没有进行排序前
		System.out.println(arrayList.toString());//[adsf, uytf, hjk, wedcv, kngfsf, wqqs]
		
		//对集合中的元素信息进行排序
		Collections.sort(arrayList);
		System.out.println(arrayList.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]
	
		//使用自定义比较器的方法,按照字符串的长度来进行排序
		Collections.sort(arrayList,new StringSortComparator());
		System.out.println(arrayList.toString());//[hjk, adsf, uytf, wqqs, wedcv, kngfsf]
	}

}

//自定义比较器,按照字符串的长度进行比较原则
class StringSortComparator implements Comparator<String>{

	@Override
	public int compare(String arg0, String arg1) {
		//比较两个字符串的长度
		int number = arg0.length()-arg1.length();
		//==0说明两个字符串的长度一样,再进行内容比较
		if(number==0){
			return arg0.compareTo(arg1);
		}
		return number;
	}
	
}


listIterator  List集合中特有的迭代器


在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificatinException异常

所以在使用迭代器的时候,只能用迭代器的方法操作元素,但是Iterator的方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作,如添加,修改等,就需要使用其接口,ListIterator

该接口只能通过List集合的listIterator方法获取


ArrayList<String> al = new ArrayList<String>();
		 ListIterator its= al.listIterator();
		 while(its.hasNext())
		 {
			 String  string = (String) its.next();
		 //its.hasNext())   判断迭代指针后是否有元素
		 //its.hasPrevious() 判断迭代指针前是否有元素
		             
		 }
		   //以倒着取出元素
		 while(its.hasPrevious())
		 {
			 String string = (String) its.previous();
		 }




Vector

Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常

底层是数组数据结构,线程同步,被ArrayList替代了,长度为10,然后百分之百延长

</pre><pre name="code" class="java">Vector<String> vector = new Vector<String>();
		// 向集合中添加元素
		vector.add("java");
		vector.add("java1");
		vector.add("java2");
		vector.add("java3");
		// 通过枚举的方式取出集合中的元素
		Enumeration en = vector.elements();
		while (en.hasMoreElements()) {
			String string = (String) en.nextElement();

		}
		// 通过迭代器的方式取出数据
		Iterator<String> iterator = vector.iterator();
		while (iterator.hasNext()) {
			String string = iterator.next();
		}



Stack

Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方 法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈

Set

Set继承自Collection接口。Set是一种不能包含有重复元素的集合,Set最多有一个null元素。

在使用Set集合的时候,应该注意:
1、为Set集合里的元素的实现类实现一个有效的equals(Object)方法。
2、对Set的构造函数,传入的Collection参数不能包含重复的元素。
常见子类及特点:
HashSet 内部数据结构是哈希表,是不同步的。
TreeSet 可以对Set集合中的元素进行排序,是不同步的


HashSet

<1> 此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证集合的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

<2> HashSet不是同步的,需要用以下语句来进行S同步转换

Set s = Collections.synchronizedSet(new HashSet(...));

<3> 是如何保证元素的唯一性?

是通过元素的两个方法,hashCode和equals来完成,如果元素的HashCode值相同,才会判断equals来完成

如果元素的HashCode值不同,不会调用equals

<4> 对于判断元素是否还在,以及删除等操作,依赖的方法是元素的hashCode和equals方法


往HashSet集合中存入自定义对象

public class ListDemoClass {  
  
    public static void main(String[] args) {  
        //新建集合  
                HashSet hs = new HashSet();  
                //向集合中添加元素  
                hs.add("java2");  
                hs.add("java3");  
                hs.add("java1");  
                hs.add("java4");  
                hs.add("java5");  
                //注:add方法的返回值为boolean true代表添加元素成功  
                  
                //使用迭代器的方法将集合中的元素数据取出  
                //获取迭代器  
                Iterator iterator = hs.iterator();  
                //取出数据  
                while(iterator.hasNext()){  
                    Object next = iterator.next();  
                    System.out.println("hs中的数据为  :"+next+"");  
                }  
    }  
  
} 


java基础集合框架——List、Set、Map概述(java集合一)


往HashSet集合中存入自定义对象

定义要进行存储的对象类

public class PersonInfo {  
    // 姓名和年龄相同为同一个人,重复元素  
    private String name;  
    private int age;  
  
    PersonInfo(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  
  
    public int hashCode() {  
        return name.hashCode();  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    //进行比较的方法  
    public boolean equals(Object obj) {  
        if (!(obj instanceof PersonInfo))  
            return false;  
        PersonInfo pe = (PersonInfo) obj;  
        return this.name.equals(pe.name) && this.age == pe.age;  
    }  
  
}

编写储存数据的测试类


public class ListDemoClass {  
  
    public static void main(String[] args) {  
        // 往hAashSet集合中存入自定义对象  
        // 姓名和年龄相同为同一个人,重复元素  
        HashSet hs = new HashSet();  
        //向集合中添加元素  
        hs.add(new PersonInfo("lishi", 22));  
        hs.add(new PersonInfo("lishi1", 23));  
        hs.add(new PersonInfo("lishi2", 24));  
        hs.add(new PersonInfo("lishi3", 25));  
        hs.add(new PersonInfo("lishi3", 25));  
        hs.add(new PersonInfo("lishi3", 25));  
        Iterator it = hs.iterator();  
        while (it.hasNext()) {  
            //取出集合中的元素  
            PersonInfo pe = (PersonInfo) it.next();  
            System.out.println( "person name is " + pe.getName()+"and age is "+pe.getAge());  
        }  
  
    } 

编译运行调试

java基础集合框架——List、Set、Map概述(java集合一)

可以看到,我们向其中添加了六条数据,但实际上集合中只添加了四条数据,因为其中有两条数据是相同的,也就是说那两条数据与我们集合中现有的数据name 各age 是一致的

TreeSet

<1> 可以对集合中的元素进行排序

<2> 里面存储的元素必须具有可比性

<3> TreeSet排序的第一种方式为  让元素自身具有比较性,元素需要实现compareable接口,覆盖compareTo方法,这种方式也是元素的自然顺序,或者叫默认顺序


向TreeSet中储存String类型的数据

public class ListDemoClass {  
  
    public static void main(String[] args) {  
  
        // 新建集合  
        TreeSet ts = new TreeSet();  
        //向集合中添加元素  
        ts.add("aaa");  
        ts.add("aoa");  
        ts.add("ara");  
        ts.add("aea");  
        //获取取迭代器  
        Iterator it = ts.iterator();  
        //循环取出集合中的元素,并将取出的元素输出在控制台上面  
        while (it.hasNext()) {  
            System.out.println(it.next());  
        }  
  
    }


java基础集合框架——List、Set、Map概述(java集合一)

可以看到,集合中储存的数据以按照其自然顺序进行了排序

//创建集合
		TreeSet<String> treeSet = new TreeSet<String>();
		//添加元素
		treeSet.add("adsf");
		treeSet.add("uytf");
		treeSet.add("hjk");
		treeSet.add("wedcv");
		treeSet.add("kngfsf");
		treeSet.add("wqqs");
		//输出储存的数据
		System.out.println(treeSet.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]
		

按照自定义的比较规则进行集合中元素排序

这里是按字符串的长度来进行排序

//创建集合
		TreeSet<String> treeSet = new TreeSet<String>();
		//添加元素
		treeSet.add("adsf");
		treeSet.add("uytf");
		treeSet.add("hjk");
		treeSet.add("wedcv");
		treeSet.add("kngfsf");
		treeSet.add("wqqs");
		//输出储存的数据
		System.out.println(treeSet.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]
		

//将集合中的String类型的数据进行降序排序 
		//创建集合
		TreeSet<String> treeSet = new TreeSet<String>(Collections.reverseOrder());
		//添加元素
		treeSet.add("adsf");
		treeSet.add("uytf");
		treeSet.add("hjk");
		treeSet.add("wedcv");
		treeSet.add("kngfsf");
		treeSet.add("wqqs");
		//输出储存的数据
		System.out.println(treeSet.toString());//[wqqs, wedcv, uytf, kngfsf, hjk, adsf]
		

//将集合中的String类型的数据按照自定义的比较方法按长度由大到小进行排序 
		//创建集合
		TreeSet<String> treeSet = new TreeSet<String>(Collections.reverseOrder(new StringSortComparator()));
		//添加元素
		treeSet.add("adsf");
		treeSet.add("uytf");
		treeSet.add("hjk");
		treeSet.add("wedcv");
		treeSet.add("kngfsf");
		treeSet.add("wqqs");
		//输出储存的数据
		System.out.println(treeSet.toString());//[kngfsf, wedcv, wqqs, uytf, adsf, hjk]
		
//自定义比较器,按照字符串的长度进行比较原则
class StringSortComparator implements Comparator<String>{

	@Override
	public int compare(String arg0, String arg1) {
		//比较两个字符串的长度
		int number = arg0.length()-arg1.length();
		//==0说明两个字符串的长度一样,再进行内容比较
		if(number==0){
			return arg0.compareTo(arg1);
		}
		return number;
	}
}


向TreeSet中储存自定义对象

在其中存储自定义对象的时候,必须使自定义对象具有可比性,那么可以实现 Comparable接口,然后复写compareTo方法,在其中定义比较对象顺序的方法发生

public class PersonBean implements Comparable {  
  
    private String name;  
    private int age;  
  
    PersonBean(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    @Override  
    public int compareTo(Object obj) {  
        if (!(obj instanceof PersonBean))  
            throw new RuntimeException();  
        /** 
         * 在这里定义比较对象大小的方法 
         * 先进行年龄的比较,年龄不相等再进行姓名的比较 
         * 如果年龄与姓名都相等,那么就代表同一个对象 
         */  
        PersonBean pe = (PersonBean) obj;  
        if (this.age > pe.age)  
            return 1;  
        if (this.age == pe.age) {  
            return this.name.compareTo(pe.name);  
        }  
  
        return -1;  
    }  
} 

建立测试类

public class ListDemoClass {  
  
    public static void main(String[] args) {  
  
        // 向这个集合中存储自定义对象  
        TreeSet ts = new TreeSet();  
        ts.add(new PersonBean("lishi", 22));  
        ts.add(new PersonBean("lishi1", 23));  
        ts.add(new PersonBean("lishi3", 25));  
        ts.add(new PersonBean("lishi4", 25));  
  
        //获取迭代器,取出其中的元素  
        Iterator it = ts.iterator();  
        while (it.hasNext()) {  
            PersonBean pe = (PersonBean) it.next();  
            System.out.println(pe.getAge() + "  " + pe.getName());  
        }  
  
    }

java基础集合框架——List、Set、Map概述(java集合一)

可以看到输出的结果 ,先按照年龄进行排序储存,如果年龄相同,再按照姓名进行排序储存,如果姓名也相同,则代表是同一对象 ,则不进行储存


向TreeSet中传入比较器进行排序

这时需要让容器自身具备比较性,

那么需要定义比较器 ,将比较器对象作为参数传递给TreeSet 集合的构造函数

当两种排序都存在时,以比较器为主

那么可以定义一个类,实现Comparator接口,覆盖compare方法

新建储存对象,并实现Comparator接口,在compare方法中宝比较规则

public class PersonBean implements Comparable {  
  
    private String name;  
    private int age;  
  
    PersonBean(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    @Override  
    public int compareTo(Object obj) {  
        if (!(obj instanceof PersonBean))  
            throw new RuntimeException();  
        /** 
         * 在这里定义比较对象大小的方法 
         * 先进行年龄的比较,年龄不相等再进行姓名的比较 
         * 如果年龄与姓名都相等,那么就代表同一个对象 
         */  
        PersonBean pe = (PersonBean) obj;  
        if (this.age > pe.age)  
            return 1;  
        if (this.age == pe.age) {  
            return this.name.compareTo(pe.name);  
        }  
  
        return -1;  
    }  
} 

自定义一个比较器

import java.util.Comparator;  
import java.util.HashSet;  
import java.util.Iterator;  
import java.util.TreeSet;  
  
class CustomCompare implements Comparator {  
    public int compare(Object obj1, Object obj2) {  
        //获取将要进行比较的两个对象  
        PersonBean p1 = (PersonBean) obj1;  
        PersonBean p2 = (PersonBean) obj2;  
        //先进行比较两个对象中的name是否相等,如果相等,那么将返回0  
        int num = p1.getName().compareTo(p2.getName());  
        //如果name相等,那么再比较age的大小   
        if (num == 0) {  
            if (p1.getAge() > p2.getAge())  
                return 1;  
            if (p1.getAge() == p2.getAge())  
                return 0;  
            return -1;  
        }  
        return num;  
    }  
} 

新建测试类:

public class ListDemoClass {  
  
    public static void main(String[] args) {  
  
        // 向这个集合中存储自定义对象  
        TreeSet ts = new TreeSet(new CustomCompare());  
        ts.add(new PersonBean("lishi", 22));  
        ts.add(new PersonBean("lishi1", 23));  
        ts.add(new PersonBean("lishi3", 25));  
        ts.add(new PersonBean("lishi3", 26));  
        ts.add(new PersonBean("lishi3", 24));  
        ts.add(new PersonBean("lishi4", 25));  
  
        // 取出集合中的元素数据,并将相关信息输出在控制台上  
        Iterator it = ts.iterator();  
        while (it.hasNext()) {  
            PersonBean pe = (PersonBean) it.next();  
            System.out.println(pe.getAge() + "  " + pe.getName());  
        }  
  
    } 


java基础集合框架——List、Set、Map概述(java集合一)


以字符串的长度为排序规则进对TreeSet集合中的String类型的数据进行排序

首先自定义一个比较器

class StringLengthCompare implements Comparator {  
    public int compare(Object obj1, Object obj2) {  
        //获取将要进行比较的字符串  
        String s = (String) obj1;  
        String s1 = (String) obj2;  
        int num = new Integer(s.length()).compareTo(new Integer(s1.length()));  
        if (num == 0) {  
            return s.compareTo(s1);  
  
        }  
        return num;  
    }  
} 

新建测试类:

    public class ListDemoClass {  
      
        public static void main(String[] args) {  
      
            // 按照字符长度排序  
            // 字符串具有比较性,但是不是所需要的  
            // 向这个集合中存储自定义对象  
            //新建TreeSet集合并将自定义比较 器传给集合  
            TreeSet ts = new TreeSet(new StringLengthCompare());  
            //向集合中添加不同长度的String字符串  
            ts.add("ggg");  
            ts.add("aaa");  
            ts.add("swed");  
            ts.add("asdfv");  
            ts.add("tyrfg");  
            //获取迭代器,循环取出集合中的数据并输出在控制台上  
            Iterator it = ts.iterator();  
            while (it.hasNext()) {  
                String s = (String) it.next();  
                System.out.println(s);  
            }  
      
        }  



Map


Map没有继承Collection接口。也就是说Map和Collection是2种不同的集合。Collection可以看作是(value)的集合,而Map可以看作是(key,value)的集合。
Map接口由Map的内容提供3种类型的集合视图,一组key集合,一组value集合,或者一组key-value映射关系的集合。

常见子类及特点
HashTable 底层是哈希表,是同步的,null不可以做键值进行储存
HashMap 底层是哈希不结表结构,不同步,null可以做键值进行储存
TreeMap 底层是二叉树结构,是不同步的,

Hashtable

Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方 法。


特别说明

   hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相 同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如 果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希 表的操作。
  
    如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
    Hashtable是同步的。


HashMap

HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null ke

// 新建一个集合
		Map<Integer, String> map = new HashMap<Integer, String>();
		// 向map中添加10条数据
		for (int i = 0; i < 10; i++) {
			map.put(i, "java" + i);
		}

		System.out.println(map);// {0=java0, 1=java1, 2=java2, 3=java3, ...}
		
		
		//删除指定位置的元素
		map.remove(0);
		System.out.println(map);//{1=java1, 2=java2, 3=java3,...}
		
		//判断指定位置的元素是否在在
		boolean containsKey = map.containsKey(0);
		System.out.println(containsKey);//false
		

取出map集合中的数据 方式一

//取出方式一 
		//获取集合中的元素
		//先获取所有的key,然后再去获取所的value
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> iterator = keySet.iterator();
		while (iterator.hasNext()) {
			//获取对应的key
			Integer next = iterator.next();
			//根据key值获取对应的值 
			String string = map.get(next);
			
		}


取出map集合中的数据 方式二

// 取出方式二
		//将map中的键值的映射关系 作为对象储存到set集合中去
		Set<Entry<Integer,String>> entrySet = map.entrySet();
		//获取迭代器
		Iterator<Entry<Integer, String>> iterator2 = entrySet.iterator();
		while(iterator2.hasNext()){
			Entry<Integer, String> entry = iterator2.next();
			//获取key
			Integer key = entry.getKey();
			//获取对应的value
			String value = entry.getValue();
		}


取出map集合中的数据 方式

//取出方式三
		Collection<String> values = map.values();
		Iterator<String> iterator3 = values.iterator();
		while(iterator3.hasNext()){
			String valueString = iterator3.next();
		}


TreeMap

创建一个类对象,作为key储存在TreeMap集合中
class Person {
	//定义对象的两个私有属性
	private String name = "张三";
	private String age = "22";
	private Person person;
	
	public Person() {
		super();
	}
	
	public Person(String name, String age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public String getAge() {
		return age;
	}
	



//创建一个集合
		TreeMap<Person,String> treeMap = new TreeMap<Person,String>();
		//向TreeMap中添加数据 
		treeMap.put(new Person("张三", "10"), "山西");
		treeMap.put(new Person("李四", "15"), "上海");
		treeMap.put(new Person("王五", "9"), "山西");
		treeMap.put(new Person("小六", "13"), "北京");
		//输出元素信息
		System.out.println(treeMap);



编译运行;出现错误
Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable
	at java.util.TreeMap.compare(Unknown Source)
	at java.util.TreeMap.put(Unknown Source)
	at MapDemoTest.main(MapDemoTest.java:15)

走到这里,我们可以看到在进行元素储存的过程的时候就已经出现错误了

解决方案 (一)

使我们的对象本身具有比较性,实现Comparable接口,在compareTo方法定义比较规则为根据姓名来排序

class Person implements Comparable<Person>{
	//定义对象的两个私有属性
	private String name = "张三";
	private String age = "22";
	private Person person;
	
	public Person() {
		super();
	}
	
	public Person(String name, String age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public String getAge() {
		return age;
	}

	@Override
	public int compareTo(Person arg0) {
		return this.name.compareTo(arg0.name);
	}
	
这样后,我们再进行编译运行就要吧发现可以进行了

解决方案(二)
定义一个比较器,然后将比较器传给集合
// 自定义一个比较器,在compare中定义比较规则
// 这里定义的比较规则是Person中的姓名进行比较
class MapSortCompar implements Comparator<Person> {

	@Override
	public int compare(Person o1, Person o2) {

		return o1.getName().compareTo(o2.getName());
	}

}

然后将比较器传递给集合
// 创建一个集合
		TreeMap<Person, String> treeMap = new TreeMap<Person, String>(new MapSortCompar());
		// 向TreeMap中添加数据
		treeMap.put(new Person("张三", "10"), "山西");
		treeMap.put(new Person("李四", "15"), "上海");
		treeMap.put(new Person("王五", "9"), "山西");
		treeMap.put(new Person("小六", "13"), "北京");
		// 输出元素信息
		Set<Person> keySet = treeMap.keySet();
		Iterator<Person> iterator = keySet.iterator();
		while(iterator.hasNext()){
			Person key = iterator.next();
			String values = treeMap.get(key);
			System.out.println("key is "+key.getName()+"value is "+values);
		}


编译运行:控制台会输出
key is 小六value is 北京
key is 张三value is 山西
key is 李四value is 上海
key is 王五value is 山西





注:add方法的参数类型是Object 以便于接收任意类型的对象

集合中存储的都是对象的引用(地址);

什么是迭代器呢?

其实就是集合的取出元素的方式

把取出方式定义在集合的内部,这样取出方式就可 直接访问集合内容的元素

那么取出方式就被定义在成了内部类

而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容---判断和取出,那么可以将写共性抽取,那么这些内部类都符合一个规则,该规则就是Iterator

如何获取集合的取出对象呢?

通过一个对外提供的方法

iterator()