黑马程序员_集合1

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

一 集合
1 概念：数据多用对象存储，而对象一多就用集合存储。集合就是容器，用来存储对象的（集合存储的是地址值）。
（1）存储对象有两种容器，一是数组，二是集合。
（2）为什么要用集合存呢。首先，数组是固定长度的，而集合是可变长度。其次，数组存储的是同一类型的对象，而集合只要是对象就可以存储。

2 因为数据结构不同，所以出现了集合划分体系。
（1）collection--->List--->ArrayList,Vector,LinketList
（2）collection--->Set--->HashSet,TreeSet
（3）其中collection这个体系的根接口，它里面定义的是这些集合的共性方法。List集合存储的元素是可重复的，有序的，下面有3个重要的子类。ArrayList,Vector,LinketList；Set集合存储的是元素是不可重复的，无序的，下面有2个重要的子类HashSet和TreeSet。

二 collection接口集合体系
1 collection中有一个比较重要的方法，iterator()。此方法可以获取迭代器，该迭代器是获取元素的方法。
 取出方式代码如下：

import java.util.*;//导包
class IteratorDemo 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();//创建集合对象
		//添加元素
		al.add("abc");
		al.add("def");
		al.add("ghi");
		//获取迭代器
		Iterator it=al.iterator();
		//利用迭代器特有方法取出元素
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

2 List:元素是有序的，可以重复。
（1）List中的特有迭代器，列表迭代器。listIterator()，因为collection中的iterator()方法只能删除，不能添加等其他操作，如果想在遍历的过程中操作元素，用此迭代器比较方便。
 取出方法如下：

import java.util.*;
class IteratorDemo 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();//创建集合对象
		//添加元素
		al.add("abc");
		al.add("def");
		al.add("ghi");
		//获取ListIterator迭代器
		ListIterator li=al.listIterator();
		//利用迭代器特有方法取出元素
		while(li.hasNext())
		{
			Object obj=li.next();
			if(obj.equals("abc"))
				li.add("abc1");//ListIterator的特有方法
			System.out.println(obj);
		}
		System.out.println(al);
	}
}

（2）List下面有三个常见的子类对象ArrayList,LinkedList，Vector。
     ArrayList,线程不同步。底层是数组数据结构，查询数据快，判断元素是否相同底层调用的是equals()方法。
     LinkedList，底层是链表数据结构，增删数据块
     Vector，跟ArrayList功能一致，唯一不同的是线程同步。底层是数组数据结构

3 Vector对象
（1）Vector中有个方法枚举elements(),它是Vector集合中的特有取出方法，跟迭代器很类似。
举例：

import java.util.*;
class EnumerationDemo 
{
	public static void main(String[] args) 
	{
		Vector v=new Vector();//创建集合对象
		//添加元素
		v.add("abc");
		v.add("def");
		v.add("ghi");
		//获取枚举
		Enumeration en=v.elements();
		//利用枚举特有方法取出元素
		while(en.hasMoreElements())
		{
			System.out.println(en.nextElements());
		}
	}
}

4 LinketList对象
（1）特有方法：
addFirst(Object obj)//在第一个添加元素
addLast(Object obj)//在最后面第一个添加元素
getFirst(Object obj)//获取第一个但不删除元素
getLast(Object obj)//获取最后一个但不删除元素

removeFirst(Object obj)//获取第一个并删除元素

removeLast(Object obj)//获取最后一个并删除最后元素

5 ArrayList集合
（1）此集合存储的元素是可重复的，而该集合判断元素是否重复的方法是底层调用equals(),而该方法是Object是覆盖Object()的比较的地址值的equals()。所以如果该集合想存储自己定义的对象元素，必须复写Object中的equals()方法，定义自己比较元素重复的方法。
（2）通过一个例子说明：

import java.util.*;
//定义人类
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//覆盖Object的equals()方法，定义自己的比较元素重复方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p=(Person)obj;
		//名字跟年龄一致视为同一个人
		return this.name.equals(p.name) && this.age==p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class  ArrayLiDemo
{
	public static void main(String[] args) 
	{
		//创建对象并存储元素
		ArrayList al=new ArrayList();
		al.add(new Person("zhangsan1",12));
		al.add(new Person("zhangsan1",12));
		al.add(new Person("zhangsan2",12));
		al.add(new Person("zhangsan3",12));
		al.add(new Person("zhangsan4",12));
		al.add(new Person("zhangsan3",12));
		//把重复元素去掉
		al=SingleElement(al);
		//用迭代器的方法取出元素
		Iterator it=al.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			Person p=(Person)obj;
			System.out.println(p.getName()+":::"+p.getAge());
		}
	}
	//定义个方法把集合中重复的元素去掉
	public static ArrayList SingleElement(ArrayList al)
	{
		ArrayList at=new ArrayList();//定义个临时容器存储元素
		//将集合中的元素遍历的过程中判断临时容器中是否有该元素，有就存进去
		Iterator it=al.iterator();

		while(it.hasNext())
		{
			Object obj=it.next();
			if(!at.contains(obj))//此方法判定的依据是调用底层equals（）方法
				at.add(obj);
		}
		return at;
	}
}

6 Set集合：Set集合存储的是元素是不可重复的，无序的。其定义的功能跟collection接口功能一致。下面有2个重要的子类HashSet和TreeSet。

7 HashSet集合：底层是哈希表数据结构。此集合存储的元素是不可重复的，而该集合判断元素是否重复的方法是底层先调用hashCode()方法，如果哈希值一致再调用equals()方法判断是否同个元素,而这两个方法是覆盖Object()的hashCode()方法和覆盖Object()的比较的地址值的equals()。所以如果该集合想存储自己定义的对象元素，必须复写Object中的hashCode()方法和equals()方法，定义自己比较元素重复的方法。
通过一个例子说明：

import java.util.*;
class Student
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//复写Object中的hashCode()方法
	public int hashCode()
	{
		return name.hashCode()+age*56;
	}
	//复写Object中的equals()方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			return false;
		Student s=(Student)obj;
		return this.name.equals(s.name) && this.age==s.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class HashDemo 
{
	public static void main(String[] args) 
	{
		//创建集合并添加元素
		HashSet hs=new HashSet();
		hs.add(new Student("lis1",11));
		hs.add(new Student("lis3",11));
		hs.add(new Student("lis1",11));
		hs.add(new Student("lis5",11));
		hs.add(new Student("lis3",11));
		//获取迭代器取出元素
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
			Student s=(Student)it.next();
			System.out.println(s.getName()+":::"+s.getAge());
		}
	}
}

8 TreeSet:底层是二叉树数据结构，保证元素的唯一性是实现Comparable接口调用compareTo()方法，可以对元素进行排序。有两种比较性：
（1）让元素自身具备比较性，方式是实现Comparable接口，复写compareTo()方法
（2）让集合具备比较性，方法是，定义一个比较器实现Comparator接口，覆盖compare()方法。

例子：

import java.util.*;
//定义人类并实现Comparable让其对象具备比较性
class Person implements Comparable
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//复写compareTo方法，定义自己比较元素大小的方式
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Person))
			throw new RuntimeException("列西部汽配");
		Person p=(Person) obj;
		int num=this.age-p.age;
		if(num==0)
			return this.name.compareTo(p.name);
		return num;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
//定义一个比较器实现Comparator接口
class Mycompare implements Comparator
{
	//复写Comparator接口中compare方法，定义自己比较大小的方式
	public int compare(Object o1,Object o2)
	{
		Person p1=(Person)o1;
		Person p2=(Person)o2;
		int num=p1.getName().compareTo(p2.getName());
		if(num==0)
			return p1.getAge()-p2.getAge();
		return num;
	}
}
class TreeDemo 
{
	public static void main(String[] args) 
	{
		//创建TreeSet集合，并将比较器对象传给集合的构造函数，让其按照比较器的比较方式给元素排序
		TreeSet ts=new TreeSet(new Mycompare());
		//添加人对象元素进集合
		ts.add(new Person("lisi1",11));
		ts.add(new Person("lisi7",17));
		ts.add(new Person("lisi01",19));
		ts.add(new Person("lisi3",11));
		ts.add(new Person("lisi5",15));
		ts.add(new Person("lisi1",11));
		//获取迭代器，取出元素
		Iterator it=ts.iterator();
		while(it.hasNext())
		{
			Person p=(Person)it.next();
			System.out.println(p.getName()+"::::"+p.getAge());
		}
	}
}