黑马程序员-----程序员之路_____集合框架

最新推荐文章于 2023-04-17 13:15:24 发布

小瓶子的瓶子

最新推荐文章于 2023-04-17 13:15:24 发布

阅读量697

点赞数

本文链接：https://blog.csdn.net/u012871223/article/details/16901813

版权

----------android培训、Java培训、期待与您交流！----------

一、集合类框架

集合框架图

二、集合类容器

1、Collection

package day14;
/*
 1,add方法的参数类型是Object。以便于接收任意类型对象
 2集合中存储的都是对象的引用（地址）
*/
import java.util.*;
class CollectionDemo 
{
	
	public static void main(String[] args) 
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList a1=new ArrayList();
	//1，添加元素
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");
		
	//打印原集合
		sop(a1);
	//3，删除元素
		//a1.clear();
		a1.remove("java02");
	//2获取个数，集合长度。
	sop("size:"+a1.size());
	//打印改变后的集合
		sop(a1);
		//判断元素
		sop("java03是否存在"+a1.contains("java03"));
		sop("集合是否为空？"+a1.isEmpty());
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2、集合框架的工具类Collections：

package day17;
/*
 集合框架的工具类。
 Collections：
 */
import java.util.*;
class CollectionsDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//binarySearchDemo();
		sortDemo();
	}
	public static void binarySearchDemo()
	{
		List<String>list=new ArrayList<String>();
		list.add("aaaa");
		list.add("afs");
		list.add("sfsggdg");
		list.add("zz");
		list.add("afs");	
		Collections.sort(list,new StrLenComparator());
		sop(list);
		//int index=Collections.binarySearch(list, "afs");
		
		//int index=halfSearch(list,"aaaaa");
		int index=halfSearch(list,"aaaaa",new StrLenComparator());
		sop("index="+index);
	}
	
	public static int halfSearch(List<String>list,String key)
	{
		int max,min,mid;
		max=list.size()-1;
		min=0;
		while(min<=max)
		{
			mid=(max+min)>>1;//    /2
		String str=list.get(mid);
		str.compareTo(key);
		int num=str.compareTo(key);
		if(num>0)
			max=mid-1;
		else if(num<0)
			min=mid+1;
		else
			return mid;
		
		}
		
		return-min -1;
	}
	public static int halfSearch(List<String>list,String key,Comparator<String>cmp)
	{
		int max,min,mid;
		max=list.size()-1;
		min=0;
		while(min<=max)
		{
			mid=(max+min)>>1;//    /2
		String str=list.get(mid);
		str.compareTo(key);
		int num=cmp.compare(str, key);
		if(num>0)
			max=mid-1;
		else if(num<0)
			min=mid+1;
		else
			return mid;
		
		}
		
		return-min -1;
	}
	public static void maxDemo()
	{
		List<String>list=new ArrayList<String>();
		list.add("aaaa");
		list.add("afs");
		list.add("sfsggdg");
		list.add("zz");
		list.add("afs");
		
		Collections.sort(list);
		sop(list);
		String max=Collections.max(list,new StrLenComparator());
		sop("max=:"+max);
	}
	public static void sortDemo()
	{
		List<String>list=new ArrayList<String>();
		list.add("aaaa");
		list.add("afs");
		list.add("sfsggdg");
		list.add("cd");
		list.add("afs");
		
		sop(list);
		//Collections.sort(list);
		//Collections.sort(list,new StrLenComparator());
		
		Collections.swap(list, 1, 2);//角标1和角标2交换位置。
		sop(list);
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}
/*
class Student
{
	
}
list.add(new Student());
public static <T extends Comparable<? super T)>>void sort(List<T> list)
{
	
}
*/

3、什么是迭代器呢？其实就是集合的取出元素的方式

package day14;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 什么是迭代器呢？
 * 其实就是集合的取出元素的方式
 * */
class CollectionDemo1
{

	public static void main(String[] args)
	{
		//method_2();
		method_get();
	}
	public static void method_get()
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList al=new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		/*
		Iterator it=al.iterator();//获取迭代去，用于取出集合中的元素。
		
		while(it.hasNext())
		{
		sop(it.next());
			}
			*/
		for(Iterator it=al.iterator();it.hasNext();)
		{
			sop(it.next());
		}
		}
	public static void method_2()
	{
		ArrayList al1=new ArrayList();
		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");
		
		ArrayList al2=new ArrayList();
		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");
		
		//al1.retainAll(al2);//区交集,al1中只会保留和al2中相同的元素
		al1.removeAll(al2);
		
		sop("al1"+al1);
		sop("al2"+al2);
		
	}
	public static void base_method()
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
				ArrayList al=new ArrayList();
			//1，添加元素
				al.add("java01");
				al.add("java02");
				al.add("java03");
				al.add("java04");
				
			//打印原集合
				sop(al);
			//3，删除元素
				//a1.clear();
				al.remove("java02");
			//2获取个数，集合长度。
			sop("size:"+al.size());
			//打印改变后的集合
				sop(al);
				//判断元素
				sop("java03是否存在"+al.contains("java03"));
				sop("集合是否为空？"+al.isEmpty());
				

			}
			
			public static void sop(Object obj)
			{
				System.out.println(obj);
			}
	}

三、Set集合

|---Set:元素是无序的（存入和取出的顺序不一致），元素不可以重复
|--Hashset：底层数据结构是哈希表。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，HashCode和equals来完成的
如果元素的HashCode值相同，才会判断equals是否是ture
如果元素的hashcode值不同，才会调用equals
注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

|--Treeset：可以对Set集合中的元素进行排序。
Set集合的功能和Collection是一致的

class HashSetDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		//先创立集合。
		HashSet hs=new HashSet();
		
		sop(hs.add("java01"));
		sop(hs.add("java01"));//内容对象都是一样的判断就不存了//添加失败就为假
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		hs.add("java03");		
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

1、HashSet是如何保证元素唯一性的呢？

如果两元素的hashCode值不同，则不会调用equals方法

如果两元素的hashCode值相同，则继续判断equals是否返回true；

hashCode和equals方法虽然定义在自定义对象类里面，但不是我们手动调用

而是往HashSet集合里面存储元素的时候，集合底层自己调用hashCode

和equals它自己拿对象去判断，自己判断两元素是否是同一个元素。

往hashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素

import java.util.*;
 class HashSetTest
 {
public static void sop(Object obj)
{
	System.out.println(obj);
}
	public static void main(String[] args)
	{
		HashSet hs=new HashSet();
		hs.add(new Person_1("a1",11));
		hs.add(new Person_1("a2",12));
		hs.add(new Person_1("a3",13));
		//hs.add(new Person_1("a1",12));
		//hs.add(new Person_1("a1",14));
		
		//sop("a1:"+hs.contains(new Person_1("a1",11)));//先判断哈希值，然后在比较equals
		hs.remove(new Person("a3",13));
		
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			Person_1 p=(Person_1)it.next();
			sop(p.getName()+":::"+p.getAge());		
		}
	}
}
 class Person_1
 {
	 private String name;
	 private int age;
	 Person_1(String name,int age)
	 {
		 this.name=name;
		 this.age=age;
	 } 
	 
	 public int hashCode()
	 {
		 System.out.println(this.name+"...hashCode");
		 return name.hashCode()+age*21;//保证哈希值的唯一性
	 }
	 public boolean equals(Object obj)
	 {
		 if(!(obj instanceof Person_1))
			 return false;
		 Person_1 p=(Person_1)obj;
		 
		 System.out.println(this.name+"..equals"+p.name);//这句话打印就说明equals被调用了
		 return this.name.equals(p.name)&&this.age==p.age;
	 }
	 public String getName()  
	 {
		 return name;
	 }
	 public int getAge()
	 {
		 return age;
	 }
 }

2、TreeSet:

TreeSet要求往里面存的元素具备比较性，否则会报错。

TreeSet排序的第一种方式:

让元素自身具备比较性，定义对象类，实现Compareble接口,复写compareTo方法，此方式是元素的自然顺序

package day15;
/*
 需求：
 往TreeSet集合中存储自定义对象学生
 想按照学生的年龄进行排序。
 记住，排序时，当主要条件相同时，一定判断一下次要条件
*/
import java.util.*;
class TreeSetDemo 
{
	public static void main(String[] args) 
	{
		TreeSet ts=new TreeSet();
		
		ts.add(new Student("lisio2",22));
		ts.add(new Student("lisio3",20));
		ts.add(new Student("lisio4",24));
		ts.add(new Student("lisio5",19));
		ts.add(new Student("lisio9",20));
		//ts.add(new Student("lisio6",18));	
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Student stu=(Student)it.next();
			System.out.println(stu.getName()+"...."+stu.getAge());
		}
	}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
			Student s=(Student)obj;
			System.out.println(this.name+"....complareto.."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

3、TreeSet排序的第二种方式:

让集合具备比较性当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序),此时就需要让集合自身具备自定义的比较性。那如何让集合自身具备比较性呢？可在集合初始化时，就让集合具备比较方式。即定义一个类，实现Comparator接口，覆盖compare方法。

class StringLengthComparator implements Comparator
{
	public int compare(Object obj1,Object obj2)
	{
		String s1 = (String)obj1;
		String s2 = (String)obj2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
			return num;
			}
		 }
	class TreeSetTest
{
	public static void main(String[] args)
{
	TreeSet ts = new TreeSet(new StringLengthComparator());
	ts.add("addfg");
	ts.add("dfg");
	ts.add("agtuug");
	ts.add("vgjkg");
	sop(ts);
	}
 }
							 	
注意：基本数据类型或字符串对象均实现了Comparable接口，故同种类型基本数据间具备比较性，即自然顺序。

四、List集合：元素是有序的，元素是可以重复的，因为该集合体系有索引

(1)List:列表，元素是有序的(元素带角标索引)，可以有重复元素,可以有null 元素

1）ArrayList(JDK1.2):底层的数据结构是数组数据结构，特点是查询速度快(因为带角标)，但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变，线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。 2）LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个)，特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快，因为元素再多，增删一个，只要让其前后的元素重新相连即可，线程是不同步的。 3）Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都很慢。默认长度是10，当超过长度时,按100%延长集合长度。线程同步。(Vector功能跟ArrayList功能一模一样，已被ArrayList替代)。

特有方法：凡是可以操作角标的方法都是该体系特有的方法。

1、ArrayList:

package day14;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 将自定义对象作为元素存到ArrayList集合中，并去除重复元素，
 * 比如: 存人对象。同姓名同年龄，视为同一个人，为重复元素
 * 思路：
 * 1，对人描述，将数据封装进人对象。
 * 2，定义容器，将人存入
 * 3，取出
 * List集合判断元素是否相同，依据的是元素的equals方法。
 */
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		
		Person p=(Person)obj;
		
		System.out.println(this.name+"....."+p.name);
		return this.name.equals(p.name)&&this.age==p.age;
	}
	/**/
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class ArrayListTest2 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		ArrayList al=new ArrayList();
		al.add(new Person("lisi01",30));
		//al.add(new Person("lisi02",32));
		al.add(new Person("lisi03",33));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi02",32));
		//al.add(new Person("lisi03",33));
		
		//al=singleElement(al);//去除重复元素
		//contains、、remove用的全是equal进行比较的
		sop("remove 03:"+al.remove(new Person("lisi03",33)) );//删除（“lisi03”，33）这个对象
		
		Iterator it=al.iterator();
		while(it.hasNext())
		{
			Person p=(Person)it.next();
			sop(p.getName()+"...."+p.getAge());
		}

	}
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl=new ArrayList();
		Iterator it =al.iterator();	
		while(it.hasNext())
		{
			Object obj=it.next();
			
			if(!newAl.contains(obj))//调用一次contains则contains在内部调用一次equals比较一次  
				newAl.add(obj);
		}	
		return newAl;
	}
}

2、LinkedList

package day14;
/*
 LinkedList:特有方法：
 addFrist();
 addLast();
 
 getFrist();
 getLast();
 获取元素，但是不删除元素
 
 removeFrist();
 removeLast()；
 获取元素，但是元素被删除了,如果集合中没有元素会出现异常
 
 在TDK1.6出现了替代方法
 
 offerFirst()；
 offerLast();
 
 
 peekFrist();
 peekLast();
 获取元素，但不元素被删除了,如果集合中没有元素返回null
 
 pollFist();
 pollList();
 获取元素，但是元素被删除了,如果集合中没有元素返回null
*/
import java.util.LinkedList;
class LinkedListDemo 
{
	public static void main(String[] args) 
{
		LinkedList link=new LinkedList();	
		link.addLast("java01");
		link.addLast("java02");
		link.addLast("java03");
		link.addLast("java04");	
		//sop(link)
		//sop(link.getFirst());
		//sop(link.getFirst());
		//sop(link.getLast());  
		//sop(link.removeFirst());
		//sop(link.removeFirst());	
		//sop("size="+link.size());
		while(!link.isEmpty())
		{
			sop(link.removeLast());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

1）使用LinkedList模拟一个堆栈或者一个队列数据结构
堆栈：先进后出如同一个杯子
队列：先进先出 Fist in Fist out FIFo 如同一个水管。

class DuiLie
{
	private LinkedList link;
	DuiLie()
	{
		link=new LinkedList();
	}
	
	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}
	public Object myGet()
	{
		return link.removeFirst();
	}
	public boolean isNull()
	{
		return link.isEmpty();
	}
}

class LinkedListTest 
{

	public static void main(String[] args)
	{
		
		DuiLie dl=new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		
		while(!dl.isNull())
		{
			System.out.println(dl.myGet());
		}
	}
}

2、
|--Lise：元素是有序的，元素师可以重复的，因为该集合体系有索引
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快，但是增减稍慢。线程不同步
|--LinkedList:底层使用的是链表数据结构。特点：查询速度稍慢，增删速度很快。
|--Vector：底层是数组数据结构，线程时同步的。
|--Set：元素是无需的，元素不可以重复
List：
特有方法：凡是可以操作角标的方法都是该体系特有的方法
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(form,to);
ListIterator();
List集合特有的迭代器，ListIterator是Inerator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生异常，所以，在迭代式，只能用迭代器的方法错做元素，可是Interator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如，修改，添加就需要使用其子接口，ListIterator，该接口只能通过List集合listIterator方法获取

import java.util.*;
class ListDemo 
{
public static void sop(Object obj)
{
	System.out.println(obj);
}
public static void method()
{
	//创建一个集合容器，使用Collection接口的子类，ArrayList
			ArrayList al=new ArrayList();
			//添加元素
			al.add("java01");
			al.add("java02");
			al.add("java03");
			al.add("java04");		
			sop("原集合是："+al);
			//在指定位置添加元素。
			al.add(1,"java00");
			//删除指定位置的元素
			//al.remove(2);	
			//修改元素
			al.set(2, "java0_0");	
			//通过角标获取元素
			sop("get(1)"+al.get(1));
			sop(al);
			//获取所有元素
			for(int x=0;x<al.size();x++)
			{
				System.out.println("al("+x+")="+al.get(x));
				
			}
			
			Iterator it=al.iterator();
			while(it.hasNext())
			{
				sop("next:"+it.next());
			}	
			//通过indexof获取对象的位置
			sop("index=:"+al.indexOf("java0_0"));
			List sub=al.subList(1, 3);
			sop("sub="+sub);	
		}	
public static void main(String[] args)
{
		//演示列表迭代器。
	ArrayList al=new ArrayList();
	//添加元素
	al.add("java01");
	al.add("java02");
	al.add("java03");
	al.add("java04");
	sop(al);
	ListIterator li=al.listIterator();
	//sop("hasPrevious:"+li.hasPrevious());
	while(li.hasNext())
	{
		Object obj=li.next();
		if(obj.equals("java02"))
			//li.add("java009");
			li.set("java006");	
	}
	while(li.hasPrevious())
	{
		sop("prev::"+li.previous());
	}
	//sop("haeNext():"+li.hasNext());
	//sop("hasPrevious():"+li.hasPrevious());
	sop(al);
	/*
	//在迭代过程过中，准备添加或者删除元素
	Iterator it=al.iterator();
	while(it.hasNext())
	{
		Object obj=it.next();
		if(obj.equals("java02"))
			it.remove();//将java02的引用从集合中删除了
		sop("obj="+obj);	
	}
	sop(al);
	*/	
}
}

1）枚举就是Vector特有的取出方式

枚举就是Vector特有的取出方式。
发现枚举和迭代器很像，其实枚举和迭代式一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。

import java.util.Enumeration;
import java.util.Vector;
class VectorDemo 
{
	public static void main(String[] args)
	{
		Vector v=new Vector();	
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		Enumeration en=v.elements();
		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}
	}
}

五、 Map集合

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性
1，添加
put(K key,V value)
putAll(Map<？ extends k,? extends V>m)
2，删除
clear()
remove(Object key)
3，判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4，获取
get(Object key)
size()
values()

entrySet()
keySet()

Map
|--hashtable:底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。

|--hashMap：底层是哈希表数据结构的，允许使用null值和null键，该集合是不同步的。

|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序。

Map和Set很像
Set底层就是使用了Map集合。

import java.util.*;
class MapDemo {

	public static void main(String[] args) {
		Map<String,String>map=new HashMap<String,String>();
		//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键的对应值。
		System.out.println("put:"+map.put("01","zahngsan"));
		System.out.println("put:"+map.put("01","wangwu "));
		//添加元素
		map.put("01","lisi1");
		map.put("02","lisi2");
		map.put("03","lisi3");
		map.put("04","lisi4");
		
		System.out.println("containsKey:"+map.containsKey("090"));
		//System.out.println("remove:"+map.remove("02"));
		System.out.println("get:"+map.get("03"));
		
		//可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断
		map.put("06",null);
		System.out.println("get:"+map.get("06"));
		
		//获取Map集合中所有的值
		Collection<String> coll=map.values();
		System.out.println(coll);
		System.out.println(map);
	}
}

map集合的两种取出方式：
1，key<k>keySet：
将map中所有的键存入到Set集合，因为Set集合具备迭代器，
所以可以通过迭代方式取出所有的键在根据get方法获取每一个键对应的值。
Map集合的取出原理：将map集合转成Set集合，在通过迭代器取出
2，Set<Map.Entry<k,v>> entrySet：将Map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry

import java.util.*;
public class MapDemo2 {
	public static void main(String[] args) {
		Map<String,String>map=new HashMap<String,String>();	
		map.put("01","lisi01");
		map.put("02","lisi02");
		map.put("06","lisi06");
		map.put("04","lisi04");
		//将Map集合中的映射关系取出，存入到Set集合中
		Set<Map.Entry<String,String>>entrySet=map.entrySet();
		Iterator<Map.Entry<String,String>>it=entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String>me=it.next();
			String key=me.getKey();
			String value=me.getValue();
			
			System.out.println(key+"::"+value);
		}
		/*
		//先获取map集合中所有键的Set集合，keySet();
		Set<String>keySet=map.keySet();
		
		//有了Set集合，就可以获取其迭代器。
		Iterator<String>it=keySet.iterator();
		while(it.hasNext())
		{
			String key=it.next();
			//有了键可以通过map集合的get方法获取其对应的值。
			String value=map.get(key);
			System.out.println("key:"+key+"value:"+value);
		}
		*/
	}
}
/*  
 Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。 
 */
/*
interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}
class HashMap implements Map
{
	class Hahs implements Map.Entry
	{
		public abstract Object getKey(){}
		public abstract Object getValue(){}
	}	
}
*/

Map扩展知识。
Map集合被使用时因为具备映射关系。
“yureban” Student( “01” “zhangsan”)
“yureban” Student( “02” “lisi” )

“jiuye” “01” “wangwu”
“jiuye” “02” “zhaoliu”
一个学校有多个教室，每个教室都有名称。

import java.util.*;
class MapDemo3
{
	public static void main(String[] args) 
	{
		HashMap<String,HashMap<String,String>>czbk=new HashMap<String,HashMap<String,String>>();//先创建学校
		HashMap<String,String>yure=new HashMap<String,String>();//再创建教室
		HashMap<String,String>jiuye=new HashMap<String,String>();//再创建教室
		czbk.put("yureban",yure);
		czbk.put("jiuye",jiuye);
		
		yure.put("01","zhangsan");
		yure.put("02","lisi");	
		jiuye.put("01","zhaoliu");  
		jiuye.put("02","wangwu");		
		//遍历czbk集合，获取所有的教室。
		Iterator<String>it=czbk.keySet().iterator();
		while(it.hasNext())
		{
			String roomName=it.next();
			HashMap<String,String>room=czbk.get(roomName);
			System.out.println(roomName);
			getStudentInfo(room);
		}
		//getStudentInfo(jiuye);
	}
	public static void getStudentInfo(HashMap<String,String>roomMap)
	{
		Iterator<String>it=roomMap.keySet().iterator();
		while(it.hasNext())
		{
			String id=it.next();
			String name=roomMap.get(id);
			System.out.println(id+"::"+name);
		}
	}
}

需求：对学生对象的年龄进行升序排序
因为要使用可以排序的Map集合。 TreeMap

import java.util.*;
class StuNameComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int  num=s1.getName().compareTo(s2.getName());
		if(num==0)
		
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			return num;
		
	}
}

class MapTest1
{
	public static void main(String[] args) 
	{		
		TreeMap<Student,String>tm=new TreeMap<Student,String>(new StuNameComparator());
		tm.put(new Student("aisi1",21), "beijin");
		tm.put(new Student("disi6",26), "shanghai");
		tm.put(new Student("fisi3",23), "nanjing");
		tm.put(new Student("gisi2",22),"tianjin");
		tm.put(new Student("disi6",26), "shanghai");
		
		Set<Map.Entry<Student,String>>entrySet=tm.entrySet();
		Iterator<Map.Entry<Student,String>>it=entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Student,String> me=it.next();
			Student stu=me.getKey();
			String addr=me.getValue();
			System.out.println(stu+"--------"+addr);
			
		}
		
	}

}

package day16;
/*
 每一个学生都有对应的归属地
 学生属性：姓名，年龄
 注意：姓名和年龄相同的视为同一个学生
 保证学生的唯一性
 1，描述学生。
 2，定义Map容器，将学生作为键，地址作为值，存入
 3，保证学生的唯一性。
 */
import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public int compareTo(Student s)
	{
		int num=new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
		{
			return this.name.compareTo(s.name);
			return num;
		}
	}
	public int hashCode()
	{
		return name.hashCode()+age*43;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s=(Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
		
	}
	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+"::"+age;
	}
}
class MapTest 
{
	public static void main(String[] args)
	{
		HashMap<Student,String>hm=new HashMap<Student,String>();
		hm.put(new Student("lisi1",21), "beijin");
		hm.put(new Student("lisi2",22), "shanghai");
		hm.put(new Student("lisi3",23), "nanjing");
		hm.put(new Student("lisi4",24), "wuhan");	
		//第一种取出方式 keySet
		Set<Student>keySet=hm.keySet();
		Iterator<Student>it=hm.keySet().iterator();
		while(it.hasNext())
		{
			Student stu=it.next();
			String addr=hm.get(stu);
			System.out.println(stu+"::"+addr);
		}
		
		//第二种取出方式 entrySet
		Set<Map.Entry<Student,String>>entrySet=hm.entrySet();
		Iterator<Map.Entry<Student, String>>iter=entrySet.iterator(); 
		while(iter.hasNext())
		{
			Map.Entry<Student,String>me=iter.next();
			Student stu=me.getKey();
			String addr=me.getValue();
			System.out.println(stu+"........"+addr);										}
	}
}

集合变数组

package day17;
/*
 集合变数组。 
 */
import java.util.*;
class CollectionToArray 
{
	public static void main(String[] args) 
	{
		ArrayList<String>al=new ArrayList<String>();
		al.add("absc01");
		al.add("absc02");
		al.add("absc03");
		al.add("absc04");
		
		/*
		 1,指定类型的数组到底要定义多长呢？
		 当指定类型的数组长度小于集合的Size，那么该方法内部会创建一个新的数组。长度为集合的Size
		 当指定类型的数组长度大于了集合的size，就不会新创建数组了，而是使用传递进来的数组。
		 所以创建一个刚刚好的数组最优
		 
		 2,为什么要将集合变数组呢？
		 为了限定对元素的操作。不需要进行增删了。
		 */
		String[] arr=al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}

}

六、迭代器与迭代列表

1)迭代器：Iterator(Map集合没有迭代器)

(1)迭代器就是取出集合元素的方式

(2)迭代器的作用

因为每个集合中元素的取出方式都不一样，于是就把元素的取出方式进行抽取，并定义在集合内部，

这样取出方式就可以直接访问集合内部的元素；

而每个容器的数据结构不同，所以取出动作的细节也不一样，但是有共性内容：判断和取出。

那么就将共性内容进行抽取，从而形成了接口Iterater

(3)获取迭代器的方法：

Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。

(3)迭代器方法：

boolean hasNext() 如果仍有元素可以迭代,则返回 true。

E next() 返回迭代的下一个元素。

void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。

Iterator<Person> it = al.iterator();

while(it.hasNext())

{

Person p = it.next();

sop(p.getName()+"::"+p.getAge());

}

2)列表迭代器：（List集合特有的迭代器）ListIterator

(1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的

     方法操作集合中的元素，因为会发生ConcurrentModificationException(当方法检测到对象的并发修改，

      但不允许这种修改时，抛出此异常)

(2)Iterator方法有限，只能对元素进行判断、取出和删除的操作

       ListIterator可以对元素进行添加和修改动作等。

(3)获取列表迭代器方法：

ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。

ListIterator<E> listIterator(int index)

返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

(4)列表迭代器方法：

void add(E e) 将指定的元素插入列表（可选操作）。

boolean hasPrevious()  如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

int nextIndex() 返回对 next 的后续调用所返回元素的索引。

E previous() 返回列表中的前一个元素。

int previousIndex() 返回对 previous 的后续调用所返回元素的索引。

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

　　public static void listIterator()
　　{
　　ArrayList al = ArrayList();
　　al.add(“java01”);
　　al.add(“java04”);
　　
　　ListIterator it = al.ListIterator();
　　while(it.hasNext())//向前遍历
　　{
　　Object obj = it.next();
　　if(ibj.equals(“java02”))
　　it.add(“java03”);
　　}
　　while(it.hasPrevious())//向后遍历
　　{
　　System.out.println(“pre:”+it.previous());
　　}
　　
　　}

-------android培训、Java培训、期待与您交流！ ----------