黑马程序员_集合框架

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

集合框架

面向对象的语言对事物的体现都是以对象的形式，为了更方便的对数据进行操作就对对象进行存储，集合就是用来存储对象的

数组和集合都可存储对象

二者有什么区别：

数组：可以存储对象也可以存储基本数据类型，数组的长度固定，数组类型确定后，只能存储一种类型的数据

集合：只能存储对象，集合的长度可变，可以存储不同类型的对象

Collection：

Collection 是一个接口，有两个常用的子接口：List 和Set

List 常用的子类有:ArrayList, LinkedList ,Vector

ArrayList ：底层数据结构是数组结构，特点：查询快，增删慢，线程不同步

LinkedList ：底层数据结构是链表数据结构，特点，增删快，查询慢

Vector：底层数据结构是数组结构，线程同步，已被ArrayList 代替

Set 常用子类有 ：HashSet ，TreeSet

HashSet：底层数据结构是哈希表，线程非同步

TreeSet：底层数据结构是二叉树

每个容器对数据的存储方式不同，这个存储方式称为数据结构

Collection 常用的共性方法：

以ArrayList 为例：

ArrayList  al = new ArrayList();

1，添加元素

al.add(“abcd”);

al.addAll();//添加一组元素

注意：（1）add 方法的参数类型是Object，以便接受任意类型的参数

 （2）集合中存储的是对象的引用

2，集合的长度 

al.size()

3，删除元素

al.remove(“abcd”);

al.clear()//清空集合

4，判断元素

al.contains(“java03”)//集合中是否存在元素”java03”，返回值为布尔型

al.isEmpty()//判断集合是否为空，返回值为布尔型
5，取交集

al1.retainAll(al2);//al1中只保存与al2中相同的元素，返回布尔型

Al1.removeAll(al2)//删除al1中与al2相同的元素

迭代器Iterator

集合中的元素用迭代器取出

集合的iterator() 方法，返回值类型是Iterator 。Iterator 是一个接口，这个接口的对象是用Iterator() 方法获取的

迭代器获取集合元素：

方法一:

while(it.hasNext())//如果集合中有下一个元素

	{

		System.out.println(it.next());//取出集合中的元素

	}

写法二：

for(Iterator it=al.iterator();it.hasNext(); )
	{

		System.out.println(it.next());//取出集合中的元素

	}//与方法一相比，方法二节省内存空间

List 接口

List 接口是Collection 的子接口，该体系集合的元素是有序的，元素可以重复，该集合内有索引

List 的特有方法：凡是有角标的方法都是List体系特有方法

List 的特有方法：

添加元素：

add(index element);
add(index collection);

代码示例：

//指定位置上添加元素
al.add(1,"java08");
//指定位置上添加集合
al.add(2,all);

删除元素

remove (index);

//删除角标3位置上的元素
al.remove(3);

修改元素

set(index element);

//修改角标2位置上元素改为"java008"
al.set(2,"java008");

查找元素

get(index);
subList(from,to);
listIterator();
indexOf();
lastIndexOf();

//获取指定位置上的元素
al.get(1);
//获取角标从1到3（不包括3）的集合
al.subList(1,3);
//从后往前获取某元素“java02”第一次出现的位置
al.lastIndexOf("java02");

ListIterator

列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置始终位于调用previous() 所返回的元素和调用next() 所返回的元素之间。

ListIterator 是List 的特有的迭代器，是Iterator 的子接口，在迭代过程中可以添加、删除或修改元素

public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		//1,添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//列表迭代器
		ListIterator li=al.listIterator();
		while(li.hasNext())
		{
			Object obj=li.next();
			if(obj.equals("java02"))
			//li.add("java0007");//迭代过程中添加元素
			li.set("java0009");//迭代过程中修改元素		
	}

Vector中 的枚举

Vector 的取出方式除了有迭代器，for循环，角标索引，还有枚举法，枚举法是Vector特有的取出方式，枚举和迭代器是一样的，由于枚举的名称和方法的名称都过长，所以被迭代器所取代了。

class  VectorDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	
	public static void main(String[] args) 
	{
		Vector  v=new Vector();
		
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		sop(v);
		Enumeration en=v.elements();//返回此向量组件的枚举
		while(en.hasMoreElements())//测试此枚举是否包含更多元素
		{
			sop(en.nextElement());//返回枚举的下一个元素
		}
	}
}

LinkedList 的特有方法
addFirst()//添加元素到第一项
addLast()//添加元素到最后一项
getFirst()//获取集合中第一个元素，元素不被删除
getLast()//获取集合中最后一个元素，元素不被删除
removeFirst()//获取第一个元素，元素被删除
removeLast()//获取最后一个元素，元素被删除

size()//获取集合大小

import java.util.*;
class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList ll=new LinkedList();
		ll.addFirst("java01");
		ll.addFirst("java02");
		ll.addFirst("java03");
		ll.addFirst("java04");//添加元素到第一项
		sop(ll.getFirst());//获取第一个元素
		
		ll.removeFirst();//获取第一个元素并删除
		ll.removeLast();//获取最后一个兵删除
		sop(ll.getLast());//获取最后一个元素
		sop(ll);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

当LinkedList 集合为空时，以上的get和remove方法会抛出NoSuchElementException，在JDK 1.6 以后，如果集合为空则返回null，
1.6以后以上方法用以下代替
offerFirst();
offerLast();
peekFirst();
peekLast();
poolFirst();

poolLast();

Set 接口

Set接口是Collection 接口的子接口，该体系集合的功能与Collection 是一致的，集合的元素是无序的（存入和取出的顺序不一致），元素不可以重复。

常见的子类有HashSet 和TreeSet

HashSet 集合

HashSet 集合底层的数据结构是哈希表，当把元素存入HashSet集合中，元素是按照哈希表存储的，取出元素时就是按照元素在集合中的哈希表的存储顺序取出，所以集合的存取是无序的，当两个元素的哈希值相同，那么会判断两个元素是否相同，如果不同，就会在原哈希值的位置顺延存储，如果相同，那么就认为两个元素是相同的，因此HashSet集合中的元素不重复。

元素的唯一性：

HashSet如何保证集合中的元素是唯一？

是通过hashCode() 和equals() 方法来完成，先调用hashCode()方法，判断元素的哈希值：如果元素的哈希值相同，在调用equals()方法判断元素是否相等，如果值为false 则元素不相等，如果值为true 则元素相等；如果哈希值不同，则不是同一元素，不调用equals方法。

在开发时，为了保证存入HashSet的对象的唯一性，一般复写hashCode() 和equals() 方法。

例如：

import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//复写hashCode方法，
	public int hashCode()
	{
		return name.hashCode()+age*16; 
	}
	//复写equals方法 
	public boolean  equals(Object obj)//当前对象和传过来的对象相比
	{
		if(!(obj instanceof Person))
			return false;
		//obj shi Object 类型 所以强转成person 类型
		Person p=(Person)obj;
		return this.name.equals(p.name)&&this.age==p.age;
	}
	
}
class  HashSetDemo2
{
	public static void main(String[] args) 
	{
		HashSet hs=new HashSet();
		hs.add(new Person("zhangsan1",26));
		hs.add(new Person("zhangsan2",25));
		hs.add(new Person("zhangsan3",28));
		hs.add(new Person("zhangsan3",28));
		hs.add(new Person("zhangsan4",21));
		sop(hs.remove(new Person("zhangsan2",25)));//返回布尔型
		sop(hs);//集合中存放的是对象的引用，打印结果为hash值
		sop(hs.contains(new Person("zhangsan3",28)));
		Iterator it=hs.iterator();
		while (it.hasNext())
		{
			Person p=(Person)it.next();
			sop(p.getName()+"....."+p.getAge());
		}


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

TreeSet 集合

TreeSet 集合底层的数据结构是二叉树，其特点是可以对集合中的元素进行排序，往TreeSet集合中存储的元素必须具有比较性

元素的唯一性：

TreeSet 集合保证元素唯一性的依据是compareTo 方法和return 0.

Comparable 接口

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

int	compareTo(T o)           比较此对象与指定对象的顺序

如果想按照自定义的顺序比较集合中的元素，就要复写该方法。

比较方法：

TreeSet 集合中的元素是按照自然顺序比较后存储的，在实际开发中，TreeSet 集合的比较顺序不一定需要按照自然顺序比较的，那么就要自定义比较规则比较集合中的元素，有两种方法

方法一：实现Comparable 接口复写compareTo 方法 

代码如下：

class Student implements Comparable//存入TreeSet对象实现Comparable接口 
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public int compareTo(Object obj)//复写compareTo方法在方法中定义比较规则，按年龄比较学生对象
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("对象类型不同 不具备可比性");
		Student s=(Student)obj;
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
			return this.name.compareTo(s.name);//如果年龄相同，那么按照姓名的自然顺序比较两个对象
		return -1;

	}

}

记住：排序时，如果元素的主要条件相同，要判断次要条件，复写compareTo方法，从方法中判定主次要条件

方法二：实现Comparator 方式排序

当元素不具备比较性或者具备的比较性不是需要的，这时让集合自身具备比较性，在集合初始化时就有比较方式。定义比较器，将比较器作为参数传递给TreeSet集合的构造函数。

代码示例：

class MyComparator implements Comparator//自定义比较器实现Comparator
{
	public int compare(Object o1,Object o2)//复写compare 方法，在方法中定义比较规则
	{
		Student s1=(Student)o1;
		Student s2=(Student)o2;
		int num= s1.getName().compareTo(s2.getName());//按照学生的姓名比较
		if(num==0)
			return new Integer(s1.getAge()).compareTo(s2.getAge());//当学生姓名相同，按照年龄的大小比较
		//return s1.getAge()-s2.getAge(); 
		return num;
	}
}

class TreeSetDemo3 
{
	public static void main(String[] args) 
	{
			TreeSet ts=new TreeSet(new MyComparator());//在集合初始化时，就具有比较性，就将比较器放到集合的构造函数中
		ts.add(new Student("lisi03",26));
		ts.add(new Student("lisi06",24));
		ts.add(new Student("lisi01",24));
		ts.add(new Student("lisi02",27));
		ts.add(new Student("lisi02",25));
		ts.add(new Student("lisi08",22));
		ts.add(new Student("lisi08",22));
		Iterator it =ts.iterator();
		while (it.hasNext())
		{
			Student s=(Student)it.next();
			sop(s.getName()+"....."+s.getAge());

		}

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

}

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