黑马程序员__集合

黑马程序员——集合

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

1.集合类

   集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。

  Java的集合类主要由两个接口派生而出：Collection和Map.这两个接口是Java集合框架的根接口。

  Java集合框架：

 

  注意：Collection接口是在整个Java类集中保存单列值的最大的操作父接口，此集合里每次操作的时候都只能保存一个对象的数据；

             Map是真个Java类中保存双列值（具有映射关系的数据）的最大操作父接口，此集合里每次操作的都是一对对象并且都是以键值对的形式存在的。

             Iterator接口也是Java集合框架的成员，但它与Collection和Map系列的集合不一样：Collection和Map系列的集合用于盛装其他对象；而Iterator 则主要用于迭代Collection集合中的元素，被称为迭代器。

2.Collection:

  

   Collection接口是List和Set接口的父接口，该接口里定义的方法既可以用于操作List集合，也可以操作Set集合。

   代码示例：

  

<span style="font-family:FangSong_GB2312;font-size:14px;">import java.util.*;
//集合中的共性方法
class CollectionMethodDemo 
{
	public static void main(String[] args) 
	{
		//创建集合对象
		ArrayList al1=new ArrayList();
		ArrayList al2=new ArrayList();
		ArrayList al3=new ArrayList();
		//向集合中添加元素
		al1.add("A");
		al1.add("B");
		al1.add("C");
		al1.add("D");
		al1.add("E");
		//将集合中的元素添加到指定的集合中
		al2.addAll(al1);
		al3.addAll(al1);
		//打印集合
		pri("集合1中的元素为："+al1);
		pri("集合2中的元素为："+al2);
		pri("集合3中的元素为："+al3);
		//清空集合里的所有元素
		al2.clear();
		pri("集合2中的元素为："+al2);
		//判断集合中是否包含指定元素
		pri("集合1中是否包含C："+al1.contains("C"));
		//判断集合中是否包含指定集合中的所有元素
		pri("集合1中是否包含集合3中的所有元素："+al1.containsAll(al3));
		//判断集合是否为空
		pri("集合2是否为空："+al2.isEmpty());
		//删除集合中的指定元素
		al3.remove("A");
		pri("删除集合3中的A："+al3);
		//从集合中删除指定集合中的所有元素
		al1.removeAll(al3);
		pri("从集合1中删除集合3中的所有元素："+al1);
		//获取两个集合的交集
		al1.retainAll(al3);
		pri("集合1与集合3的交集："+al1);
		//获取集合中的元素个数
		pri("集合3中的元素个数为："+al3.size());
		//将集合转换为数组
		Object[] obj=al3.toArray();
		pri("转换之后的数组的长度为："+obj.length);
		//用迭代器迭代集合
		Iterator iterator=al3.iterator();
		while(iterator.hasNext())
		{
			pri(iterator.next());
		}

	}
	private static void pri(Object obj)
	{
		System.out.println(obj);
	}
}
</span>

  2.1 List ：

      List集合代表一个元素有序并且可重复的集合，集合中的每个元素都有其对应的顺序索引。List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按照元素的添加顺序设置元素的索引。

      List的相关操作代码示例：

      

<span style="font-family:FangSong_GB2312;font-size:14px;">import java.util.*;
class ListMethodDemo 
{
	public static void main(String[] args) 
	{
		//创建List集合对象
		List list=new ArrayList();
		//向集合中添加元素
		list.add("A1");
		list.add("B2");
		list.add("C3");
		list.add("D4");
		list.add("E5");
		list.add("F6");
		//method(list);
		//用for循环来访问集合中的元素
		//formethod(list);
		//用foreach来访问集合中的元素
		//foreach(list);
		//用迭代器来迭代集合中的元素
		iterator(list);
		
		
	}
	//此方法中是List集合的特有操作方法
	private static void method(List list)
	{
		//原集合
		pri("原集合中的元素为："+list);
		//将元素插入到集合中的指定位置处
		list.add(3,"G7");
		pri("插入元素之后的结果为："+list);
		//将集合插入到指定集合的指定位置处
		ArrayList lt=new ArrayList();
		lt.add("a1");
		lt.add("b2");
		lt.add("c3");
		list.addAll(5,lt);
		pri("插入集合之后的结果为："+list);
		//获取指定索引处的集合元素
		pri("集合中1处的元素是："+list.get(1));
		//获取指定元素在集合中第一次出现的位置
		pri("G7的位置是："+list.indexOf("G7"));
		//获取指定元素在集合中最后一次出现的位置
		pri("a1在集合中最后一次出现的位置："+list.lastIndexOf("a1"));
		//删除并返回指定位置处的元素
		pri("删除5处的元素："+list.remove(5));
		pri("删除之后的集合是："+list);
		//将指定位置处的元素替换
		list.set(6,"H8");
		pri("替换之后的集合是："+list);
		//获取子集合
		List L=list.subList(3,7);
		pri("获取的子集合是："+L);
	}
	private static void formethod(List list)
	{
		for(int i=0;i<list.size();i++)
		{
			pri("list<"+i+">="+list.get(i));
		}
	}
	private static void foreach(List list)
	{
		for(Object obj:list)
		{
			pri(obj);
		}

	}
	private static void iterator(List list)
	{
		//获取迭代器对象
		ListIterator it=list.listIterator();
		//从前迭代
		while(it.hasNext())
		{
			pri(it.next());
		}
		pri("--------------------------");
		//从后迭代
		while(it.hasPrevious())
		{
			pri(it.previous());
		}
	}
	private static void pri(Object obj)
	{
		System.out.println(obj);
	}
}
</span>

 2.1.1 ArrayList：

   （1）底层数据结构使用的数组数据结构；

   （2）默认构造方法初始容量为10；

   （3）扩充算法：原来长度+原来长度>>1;

   （4）优点：元素的有序存储，利于遍历；

            缺点：删除和插入速度慢。

   （5）ArrayList是线程不安全的，性能较高。

   实例代码：

   

<span style="font-family:FangSong_GB2312;font-size:14px;">/*将自定义对象作为元素存入到ArrayList集合中，并去除重复元素
  比如：存入人对象，同姓名同年龄视为同一个人，为重复元素。
  思路：
  (1)定义人类，将信息封装到对象中。
  (2)创建集合对象，将数据存储到集合中。
  (3)从集合中获取元素。
*/
import java.util.*;
class ArrayListDemo2 
{
	public static void main(String[] args) 
	{
		//创建集合对象
		ArrayList list=new ArrayList();
		list.add(new Person("Apple",18));
		list.add(new Person("Lily",20));
		list.add(new Person("Joe",19));
		list.add(new Person("Apple",18));
		list.add(new Person("Eama",18));
		System.out.println("原集合为：");
		iterator_method(list);
		list=cancleSame(list);
		System.out.println("去除重复值为：");
		iterator_method(list);
		

	}
	private static void iterator_method(List list)
	{
		//迭代集合
		Iterator it=list.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	private static ArrayList cancleSame(ArrayList list)
	{
		//创建一个新的集合
		ArrayList al=new ArrayList();
		//迭代指定集合
		Iterator it=list.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(!al.contains(obj))
				al.add(obj);
		}
		return al;
	}
}
//人类
class Person
{
	private String name;
	private int age;
	public Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	//覆写equals方法
	public boolean equals(Object obj)
	{
		if(obj instanceof Person)
		{
			//类型转换
			Person p=(Person)obj;
			return this.getName().equals(p.getName()) && this.getAge()==p.getAge();
		}
		else
			return false;

	}
	//覆写toString 方法
	public String toString()
	{
		return "name"+name+",age"+age;
	}
}
</span>

 

2.2.2 Vector：

   （1）与ArrayList实现基本一致，初始容量为10；

   （2）扩充算法：原来长度+原来长度（或者指定长度）；

   （3）Vector是线程安全的，性能较低。

   （4）除了支持Iterator .ListIterator 迭代输出之外，还支持Enumeration输出。

2.2.3 LinkedList:

   (1)底层数据结构使用的是链表数据结构；

  （2）优点：适合插入和删除操作；

          缺点：查询的速度慢；

  （3）LinkedList可以作为链表、队列和堆栈来使用。

  （4）LinkedList是线程不安全的。

   代码示例：

  

<span style="font-family:FangSong_GB2312;font-size:14px;">//用LinkedList的来模拟队列（先进先出）和堆栈（先进后出）
import java.util.*;
class LinkedListDemo
{
	public static void main(String[] args) 
	{
		//创建链表对象
		LinkedList link=new LinkedList();
		//队列
		Quenue q=new Quenue(link);
		q.Add("A01");
		q.Add("B02");
		q.Add("C03");
		q.Add("D04");
		q.Add("E05");
		//遍历
		while(!q.isNull())
		{
			//q.Get();
			System.out.println(q.Get());
		}
		//堆栈
		DuiZhan d=new DuiZhan(link);
		d.Add("A01");
		d.Add("B02");
		d.Add("C03");
		d.Add("D04");
		d.Add("E05");
		//遍历
		while(!d.isNull())
		{
			//q.Get();
			System.out.println(d.Get());
		}
	}
}
//队列
class Quenue
{
	//内部封装了一个链表的数据结构
	private LinkedList link;
	public Quenue(LinkedList link)
	{
		this.link=link;
	}
	//添加元素的方法
	public void Add(Object obj)
	{
		//内部调用的是链表的添加方法
		link.addFirst(obj);
	}
	//获取元素的方法
	public Object Get()
	{
		//内部调用的是链表的获取方法
		return link.removeLast();
	}
	//判断队列是否为空
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
//堆栈
class DuiZhan
{
//内部封装了一个链表的数据结构
	private LinkedList link;
	public DuiZhan(LinkedList link)
	{
		this.link=link;
	}
	//添加元素的方法
	public void Add(Object obj)
	{
		//内部调用的是链表的添加方法
		link.addFirst(obj);
	}
	//获取元素的方法
	public Object Get()
	{
		//内部调用的是链表的获取方法
		return link.removeFirst();
	}
	//判断队列是否为空
	public boolean isNull()
	{
		return link.isEmpty();
	}
}</span>

 2.2 Set：

   Set接口也是Collection的子接口，与List接口最大的不同在于：Set不允许有重复元素，允许存在Null值。Set接口并没有对Collection接口进行扩充，基本上还是与Collection接口保持一致。

  2.2.1 HashSet：

   HashSet是Set的实现子类，属于散列的存放类集，里面的内容是无序存放的。HashSet 按哈希算法来存储集合中的元素，因此具体很好的存取和查找性能。

   （1）HashSet底层使用的哈希表数据结构；

   （2）默认初始容量为16，默认的加载因子为0.75（表示容量存满75%，就要重新散列）；

   （3）在哈希表中存储对象时，判断两个对象是同一个对象的方法：先比较两个对象的hashCode值是否相同，如果不同，就认为不是同一个对象；如果相同，在调用equals()方法判断。

   （4）当向HashSet集合中存入一个元素时，HashSet 会调用该对象的hashCode()来得到该对象的hashCode 值，然后根据该hashCode值决定该对象在HashSet中的存储位置。

   特点：

    a. 不能保证元素的排列顺序；

    b. HashSet 是线程不同步的；

    c. 集合元素可以是null。

  实例代码：

  

<span style="font-family:FangSong_GB2312;font-size:14px;">/*将自定义对象作为元素存入到HashSet集合中
  比如：存入人对象，同姓名同年龄视为同一个人，为重复元素。
  思路：
  (1)定义人类，将信息封装到对象中。
  (2)创建集合对象，将数据存储到集合中。
  (3)从集合中获取元素。
*/
import java.util.*;
class HashSetDemo
{
	public static void main(String[] args) 
	{
		HashSet set=new HashSet();
		set.add(new Person("Apple",19));
		set.add(new Person("Eama",10));
		set.add(new Person("Joe",19));
		set.add(new Person("Nuna",22));
		set.add(new Person("Eama",10));
		set.add(new Person("Apple",19));
		iterator_method(set);
	}
	private static void iterator_method(Set set)
	{
		//迭代集合
		Iterator it=set.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
//人类
class Person
{
	private String name;
	private int age;
	public Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	//覆写hashCode()方法
	public int hashCode()
	{
		return name.hashCode()+age*39;
	}
	//覆写equals方法
	public boolean equals(Object obj)
	{
		if(obj instanceof Person)
		{
			//类型转换
			Person p=(Person)obj;
			//返回比较结果
			return this.getName().equals(p.getName()) && this.getAge()==p.getAge();
		}
		else
			return false;

	}
	//覆写toString 方法
	public String toString()
	{
		return name+":"+age;
	}
}
</span>

 2.2.2 TreeSet：

    TreeSet可以确保集合元素处于排序状态，其本身属于排序的子类。

   （1）TreeSet底层数据结构是二叉树；

   （2）如果想TreeSet集合中添加自定义对象时，则该对象所属的自定义类必须实现Comparable接口，覆写compareTo方法。如果两个对象通过compareTo方法比较相等时，新对象将无法添加到TreeSet集合中。

  注意：对于TreeSet集合而言，它判断两个对象是否相等的唯一标准就是：两个对象通过compareTo方法比较是否返回0.如果返回0，TreeSet集合会认为它们相等；否则就认为它们不相等。

  实例代码：

  

<span style="font-family:FangSong_GB2312;font-size:14px;">//用TreeSet存储学生对象，并按照年龄进行排序。
import java.util.*;
class TreeSetDemo
{
	public static void main(String[] args) 
	{
		//创建集合对象
		TreeSet<Student> set=new TreeSet<Student>();
		set.add(new Student("Apple",12));
		set.add(new Student("Joe",24));
		set.add(new Student("Apple",24));
		set.add(new Student("Apple",12));
		iterator_method(set);
	}
	private static void iterator_method(Set set)
	{
		//迭代集合
		Iterator<Student> it=set.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
//学生类:要进行自然排序，必须实现Comparable接口
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	//覆写compareTo方法，让元素能按照自然顺序输出
	public int compareTo(Student s )
	{
		//比较年龄，返回比较结果
		if(this.getAge()>s.getAge())
				return 1;
		if(this.getAge()==s.getAge())
		{
			return this.getName().compareTo(s.getName());
		}
		return -1;
		
	}
		public String toString()
	{
		return name+":"+age;
	}

}</span>

  比较器：

  

<span style="font-family:FangSong_GB2312;font-size:14px;">//用比较器实现TreeSet存储学生对象，并按照姓名进行排序。
import java.util.*;
class TreeSetDemo2
{
	public static void main(String[] args) 
	{
		//将自定义的比较器对象作为构造函数的参数
		TreeSet set=new TreeSet(new MyComparator());
		set.add(new Student("Apple",24));
		set.add(new Student("Joe",20));
		set.add(new Student("Lily",24));
		set.add(new Student("Eama",30));
		set.add(new Student("Apple",12));
		iterator_method(set);
	}
	private static void iterator_method(Set set)
	{
		//迭代集合
		Iterator it=set.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
//学生类
class Student 
{
	private String name;
	private int age;
	public Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	
	public String toString()
	{
		return name+":"+age;
	}

}
//定义比较器
class MyComparator implements Comparator
{ 
	//覆写compare方法
	public int compare(Object obj1,Object obj2)
	{
		if(!((obj1 instanceof Student) && (obj2 instanceof Student)))
			throw new RuntimeException("参数类型错误！");
		//类型转换
		Student s1=(Student)obj1;
		Student s2=(Student)obj2;
		//定义变量用来记录姓名的比较结果
		int result=s1.getName().compareTo(s2.getName());
		//姓名相同时比较年龄
		if(result==0)
			return s1.getAge()-s2.getAge();
		return result;
	
	}
}</span>

3.  Iterator接口

   Iterator 接口也是Java集合框架中的成员，主要用于迭代Collection集合中的元素。Iterator的对象也被称为迭代器。

   Iterator接口里定义了如下三个方法：

         boolean HasNext():是否有下一个元素；

        Object next():返回集合里的下一个元素；

        void remove():删除当前元素。

  Iterator仅用于遍历集合，其本身并不提供盛装对象的能力。如果要创建Iterator对象，则必然有一个与之关联的Collection对象。

  注意：在使用Iterator迭代集合的时候，如果在进行迭代输出的时候要想删除当前元素，则只能使用Iterator接口中的remove（）方法，而不能使用集合中的remove（）方法，否则将出现ConcurrentModificationException。

  3.1 ListIterator接口

     ListIterator表示列表迭代器，只有List接口有。ListIterator提供了专门操作List集合的方法。

     此接口中定义了以下操作方法：

     void add(E e):增加元素；

     boolean hasPrevious():判断是否有前一个元素；

     E previous():取出前一个元素；

     void set(E e):修改元素的内容；

     int previousIndex():返回前一个索引；

     int nextIndex();返回下一个索引。

    注意：如果要想使用ListIterator接口，则必须依靠List接口进行实例化，通过List接口中定义的listIterator()方法。

   代码示例：

   

//获取迭代器对象
		ListIterator it=list.listIterator();
		//从前迭代
		while(it.hasNext())
		{
			pri(it.next());
		}
		pri("--------------------------");
		//从后迭代
		while(it.hasPrevious())
		{
			pri(it.previous());
		}

  3.2 Enumeration接口

    Enumeration是古老的输出接口，专门为Vector进行迭代输出。如果要想使用Enumeration输出的话，则必须使用Vector类，通过其elements()方法来完成。

      代码示例：

   

<span style="font-family:FangSong_GB2312;font-size:18px;">Vector v=new Vector();
		Enumeration e=v.elements();
		while(e.hasMoreElements())
		{
			Object obj=e.nextElement();
		}</span>

  4.  Map接口

  

   Map用于保存具有映射关系的数据，因此，Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value,key和value都可以是任何引用类型的数据。

   Map的key不允许重复，key和value之间存在单向一对一关系，即通过指定的key，总能找到唯一的、确定的value。

   Map的相关操作实例代码：

   

<span style="font-family:FangSong_GB2312;font-size:14px;">import java.util.*;
class MapDemo 
{
	public static void main(String[] args) 
	{
		//创建Map集合对象，并指定泛型
		Map<Integer,String> map=new HashMap<Integer,String>();
		//向集合中添加元素
		map.put(1,"Apple");
		map.put(2,"Joe");
		map.put(3,"Nuna");
		map.put(4,"Eama");
		//判断集合中是否包含指定的键
		print(map.containsKey(2));
		//判断集合中是否包含一个或者多个值
		print(map.containsValue("Joe"));
		//判断集合是否为空
		print(map.isEmpty());
		//删除指定键所对应的键值对
		print(map.remove(3));
		print(map);
		//获取集合中的键值对的个数
		print(map.size());
		//获取集合中所有值组成的集合
		Collection<String> col=map.values();
		print(col);
		//通过keySet()方法来获取集合中的每一个元素
		//获取所有键组成的set集合
		Set<Integer> set=map.keySet();
		//获取迭代器
		Iterator<Integer> it1=set.iterator();
		//获取元素
		while(it1.hasNext())
		{
			Integer key=it1.next();
			print("key="+key+",vaule="+map.get(key));
		}
		print("-------------------------");
		//通过entrySet()方法来获取集合中的每一个元素
		//获取映射关系
		Set<Map.Entry<Integer,String>> entry=map.entrySet();
		//获取迭代器
		Iterator<Map.Entry<Integer,String>> it2=entry.iterator();
		//获取元素
		while(it2.hasNext())
		{
			Map.Entry me=it2.next();
			print("key="+me.getKey()+",vaule="+me.getValue());
		}

	}
	private static <T> void print(T t)
	{
		System.out.println(t);
	}
}
</span>

  4.1  HashMap

  HashMap是Map的子类，本身是属于无序存放的。

  （1）HashMap底层的数据结构是哈希表；

  （2）默认初始容量为16，默认加载因子为0.75；

   （3）不同步，线程不安全；

    （4）性能较高。

 4.2  Hashtable

  Hashtable是一个古老的Map实现子类，与HashMap是类似的。与HashMap的不同：

   （1）默认初始容量为11，默认加载因子为0.75；

   （2）从JDK1.0开始；

   （3）同步，线程安全的；

   （4）性能较低；

    （5）Hashtable中是不能插入null值的。

  注意：

      A：HashMap和Hashtable都是无序的；

      B：HashMap和Hashtable判断两个key相对的标准是：两个key通过equals()方法比较返回true,两个key的hashCode值也相等；

      C：HashMap和Hashtable判断两个value相对的标准是：只有两个对象通过equals()方法比较返回true即可；

      D：要在HashMap和Hashtable中存储对象，用作key的对象所属类必须实现hashCode()和equals()。

  4.3  TreeMap

   （1）TreeMap的底层数据结构是红黑树；

  （2）TreeMap子类其本身在操作的时候将按照key进行排序，key中的内容可以为任意的对象，但是要求对象所在的类必须实现Comparable接口，覆写compare方法；

  （3）TreeMap中判断两个key相等的标准是：两个key通过compareTo()方法返回0，TreeMap即认为这两个key是相等的。

  实例代码：

     

 <span style="font-family:FangSong_GB2312;font-size:14px;"> /*
每一个学生都有一个对应的归属地。
学生Student,地址String
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
*/
import java.util.*;
class MapDemo2 
{
 public static void main(String[] args) 
 {
  Map<Student,String> map=new TreeMap<Student,String>(
   new Comparator<Student>()
   {
    //实现compare()
    public int compare(Student s1,Student s2)
    {
     int num=s1.getName().compareTo(s2.getName());
     if(num==0)
      return s1.getAge()-s2.getAge();
     return num;
    }
   });
  //添加元素
  map.put(new Student("Apple",18),"NewYork");
  map.put(new Student("Joe",20),"BeiJing");
  map.put(new Student("Eama",19),"LongDou");
  map.put(new Student("Paul",24),"Pairs");
  map.put(new Student("Nuna",18),"Shouer");
  //第一种方法获取元素
  Iterator<Student> it1=map.keySet().iterator();
  while(it1.hasNext())
  {
   Student s=it1.next();
   System.out.println("name:"+s.getName()+",age:"+s.getAge()+",contry:"+map.get(s));
  }
  //第二种方法获取元素
  Iterator<Map.Entry<Student,String>> it2=map.entrySet().iterator();;
  while(it2.hasNext())
  {
   Map.Entry<Student,String> me=it2.next();
   System.out.println("name---"+me.getKey().getName()+",age---"+me.getKey().getAge()+",contry---"+me.getValue());
  }
 }
}
//学生类
class Student implements Comparable<Student>
{
 private String name;
 private int age;
 public Student(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public void setName(String name)
 {
  this.name=name;
 }
 public String getName()
 {
  return name;
 }
 public void setAge(int age)
 {
  this.age=age;
 }
 public int getAge()
 {
  return age;
 }
 //覆写hashCode()和equals(),compareTo()
 public int hashCode()
 {
  return name.hashCode()+age;
 }
 public boolean equals(Object obj)
 {
  if(!(obj instanceof Student))
   throw new ClassCastException("类型不匹配！");
  //类型转换
  Student s=(Student)obj;
  return this.getName().equals(s.getName())&&this.getAge()==s.getAge();
 }
 public int compareTo(Student s)
 {
  int num=this.getAge()-s.getAge();
  if(num==0)
   return this.getName().compareTo(s.getName());
  return num;
 }
 
}</span>

        5. Collections：

            Collections是操作集合的工具类，其所有方法都是静态方法。该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。

 以下是一些常用方法：            
 addAll(Collection c, T... elements):将所有指定元素添加到指定 collection 中。 
 binarySearch(Listlist, T key) :使用二分搜索法搜索指定列表，以获得指定对象。
 binarySearch(List list, T key, Comparatorc) :使用二分搜索法搜索指定列表，以获得指定对象。
 copy(List dest, List src) :将所有元素从一个列表复制到另一个列表。
 fill(Listlist, T obj) :使用指定元素替换指定列表中的所有元素。 
 ArrayListlist(Enumeration e) :返回一个数组列表，它按返回顺序包含指定枚举返回的元素。
 max(Collection coll) :根据元素的自然顺序，返回给定 collection 的最大元素。
 max(Collection coll, Comparatorcomp) : 根据指定比较器产生的顺序，返回给定 collection 的最大元素。
 min(Collection coll) :根据元素的自然顺序 返回给定 collection 的最小元素。
 min(Collectioncoll, Comparator comp) :根据指定比较器产生的顺序，返回给定 collection 的最小元素。 
 replaceAll(Listlist, T oldVal, T newVal):使用另一个值替换列表中出现的所有某一指定值。
 reverse(List list) :反转指定列表中元素的顺序。
 reverseOrder() :返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
 reverseOrder(Comparator cmp) :返回一个比较器，它强行逆转指定比较器的顺序。 
 shuffle(List list) :使用默认随机源对指定列表进行置换。 
 sort(List list) :根据元素的自然顺序 对指定列表按升序进行排序。
 sort(List list, Comparator c) :根据指定比较器产生的顺序对指定列表进行排序。
 swap(List list, int i, int j) :在指定列表的指定位置处交换元素。
 synchronizedCollection(Collection c) : 返回指定 collection 支持的同步（线程安全的）collection。

 

总结：

<1> List的遍历方法

<span style="font-family:FangSong_GB2312;font-size:14px;">//第一种：
	for(int i=0;i<list.size();i++)
	{
		System.out.println(list.get(i));
	}
	//第二种：
	for(Object obj:list)
	{
		System.out.println(obj);
	}
	//第三种
	Iterator iter=list.iterator();
	while(iter.hasNext())
	{
		System.out.println(iter.next());
	}
	//第四种
	ListIterator lister=list.listIterator();
	//从前迭代
		while(lister.hasNext())
		{
			System.out.println(lister.next());
		}
		pri("--------------------------");
		//从后迭代
		while(lister.hasPrevious())
		{
			System.out.println(lister.previous());
		}
	//第五种
	Vector v=(Vector)list;
	Enumeration e=v.elements();
	while(e.hasMoreElements())
	{
		Object obj=e.nextElements();
		System.out.println(obj);
	}
</span>	

 

<2>Set集合的遍历方法

<span style="font-family:FangSong_GB2312;font-size:14px;">//第一种
	for(Object obj:set)
	{
		System.out.println(obj);
	}
	//第二种
	Iterator iter=set.iterator();
	while(iter.hasNext())
	{
		System.out.println(iter.next());
	}</span>

 

<3>Map集合的遍历方法

<span style="font-family:FangSong_GB2312;font-size:14px;">//第一种
	Set<Map.Entry<K,V>> set=map.entrySet();
	Iterator<Map.Entry<K,V>> iter=set.iterator();
	while(iter.hasNext())
	{
		Map.Entry<K,V> entry=iter.next();
		System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
	}
	//第二种
	Set<K> keys=map.keySet();
	Iterator<K> iter=keys.iterator();
	while(iter.hasNext())
	{
		K key=iter.next();
		System.out.println("key:"+key+",vaule:"+map.get(key));
	}</span>

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