黑马程序员_集合Collection

---------------------- ASP.Net+Android+IOS开发 、 .Net培训 、期待与您交流！ ----------------------

1.集合框架：

java中集合类的关系图

概述：

2.Collection接口有两个子接口：
List（列表），Set（集合）
（1）List：元素是有序的，可以重复 List集合判断元素是否相同运用的是equals方法。比如contains方法 remove方法

 |--ArrayList:底层的数据结构是数组结构。特点：查询修改速度很快 缺点：增加删除稍慢

 |--LinkedList:底层的数据结构是链表数据结构。线程不同步 特点：增删速度很快，查询稍慢。

 |--Vector ：底层是数组数据结构。线程同步。ArrayList是线程不同步的。

（2）Set：元素是无序(存入和取出的顺序不一定一致)的，不可以重复
 |--HashSet:底层数据结构是哈希表。线程时不同步的。
 HashSet是如何保证元素的唯一性的呢？
是通过元素的两个方法：hashCode和equals来完成

先判断hashCode，如果相同，再用equals比较。

 HashSet中的判断和删除依据的也是hashCode和equals方法。

 |--TreeSet:底层数据结构是二叉树。可以对Set集合中的元素进行排序。线程不同步
保证元素唯一性的依据：compareTo方法return 0；

3.List，Set的方法：

(1)ArrayList的方法：
添加：
boolean add(E e)： 将指定的元素添加到此列表的尾部。
void add(int index, E element)： 将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c):按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部 。
boolean addAll(int index, Collection<? extends E> c)： 从指定的位置开始，将指定 collection中的所有元素插入到此列表中。 

删除：

void clear(): 移除此列表中的所有元素。
E remove(int index): 移除此列表中指定位置上的元素。 
boolean remove(Object o): 移除此列表中首次出现的指定元素（如果存在）。
protected  void removeRange(int fromIndex, int toIndex): 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
boolean removeAll(Collection<?> c): 从列表中移除指定 collection 中包含的其所有元素 
获取：
E get(int index): 返回此列表中指定位置上的元素。
int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。   
public List<E> subList(int fromIndex,int toIndex): 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Iterator<E> iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。
ListIterator<E> listIterator(int index):返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。
修改：(特有方法！！)
E set(int index, E element): 用指定的元素替代此列表中指定位置上的元素。 
(2)LinkedList的方法：
方法摘要:(特有的)
添加
void addFirst(E e): 将指定元素插入此列表的开头。 
void addLast(E e): 将指定元素添加到此列表的结尾。 
获取元素，但不删除元素
E get(int index): 返回此列表中指定位置处的元素。           
E getFirst(): 返回此列表的第一个元素。          
E getLast(): 返回此列表的最后一个元素。
获取元素且删除元素
E remove()： 获取并移除此列表的头（第一个元素）。          
E remove(int index)： 移除此列表中指定位置处的元素。         
boolean remove(Object o)： 从此列表中移除首次出现的指定元素（如果存在）。         
E removeFirst()： 移除并返回此列表的第一个元素。 
E removeLast(): 移除并返回此列表的最后一个元素。
修改
E set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。 
(3)Vector
添加：
boolean add(E e): 将指定元素添加到此向量的末尾。
void add(int index, E element): 在此向量的指定位置插入指定的元素。         
boolean addAll(Collection<? extends E> c):将指定 Collection 中的所有元素添加到此向量的末尾， 按照指定 collection 的迭代器所返回的顺序添加这些元素。 
boolean addAll(int index, Collection<? extends E> c): 在指定位置将指定 Collection 中的所有元素插入到此向量中。
获取:
Enumeration<E> elements(): 返回此向量的组件的枚举。

 Vector特有的取出方式:
枚举和迭代器很像，其实枚举和迭代器是一样的，只是因为枚举的名称和方法的名称名字都过长，所以枚举被迭代器取代了。
(4)枚举Enumeration的方法摘要：
boolean hasMoreElements(): 测试此枚举是否包含更多的元素。 
E nextElement(): 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。 
(5)Set集合子类及其方法：

TreeSet:使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序.
添加：
boolean add(E e)  将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
boolean addAll(Collection<? extends E> c) 将指定 collection 中的所有元素添加到此 set 中。
删除：
void clear() 移除此 set 中的所有元素。 

boolean remove(Object o)  将指定的元素从 set 中移除（如果该元素存在于此 set 中）。

E pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 
E pollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 
获取：
Iterator<E> iterator()  返回在此 set 中的元素上按升序进行迭代的迭代器。
E first() 返回此 set 中当前第一个（最低）元素。
E last() 返回此 set 中当前最后一个（最高）元素。
int size()  返回 set 中的元素数（set 的容量）。
判断：
boolean isEmpty()  如果此 set 不包含任何元素，则返回 true。 
boolean contains(Object o) 如果此 set 包含指定的元素，则返回 true。

4.迭代：

迭代器:就是集合取出元素的一种方式。因为要取出的元素都在集合的内部，就把取出方式定义在集合的内部，定义成了内部类。
而每一个容器的数据结构不同，但是共性内容都有判断和取出，这样把共性抽取。而这些内部类都符合一个规则，这个规则就是Iterator。
再通过一个对外提供的方法iterator()来获取集合中的对象。
ArrayList al = new ArrayList();
for(Iterator it = al.iterator();it.hasNext();)
{
it.next();
}

5.模拟堆、栈的示例：

import java.util.*;  
class DuiZhan  
{  
    private LinkedList link;  
    DuiZhan()  
    {  
        link = new LinkedList();  
    }  
    public void MyAdd(Object obj)  
    {  
        link.addFirst(obj);  
    }  
    public Object MyGet()  
    {  
        return link.removeFirst();//如果是队列的话，只需要改成removeLast()  
    }  
    public boolean isNull()  
    {  
        return link.isEmpty();  
    }  
}  
  
  
class DuiZhanDemo  
{  
    public static void main(String[] args)  
    {  
        DuiZhan dz = new DuiZhan();  
    }  
}  

6.Hashset示例，需要重写hashcode和equals

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("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
//		hs.add(new Person("a2",12));
//		hs.add(new Person("a4",14));

		//sop("a1:"+hs.contains(new Person("a2",12)));
			
//		hs.remove(new Person("a4",13));
		

		Iterator it = hs.iterator();

		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37;
	}

	public boolean equals(Object obj)
	{

		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}

	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

7.TreeSet
TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Comparable接口，复写compareTo方法
也称为自然顺序。

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)//复写compareTo方法，让元素具备自然顺序  
    {  
        if(!(obj instanceof Student))  
            throw new ClassCastException();  
        Student stu = (Student)obj;  
        if(this.age>stu.age)  
            return 1;  
        if(this.age<stu.age)  
            return -1;  
        return this.name.compareTo(stu.name);  
    }  
  
  
    public String getName()  
    {  
        return name;  
    }  
    public int getAge()  
    {  
        return age;  
    }  
}  

TreeSet的第二种排序方式：当元素不具备自然顺序，或者自然顺序不是所需要的。
这时需要让集合自身具备比较性。实现Comparator接口，覆盖compare方法。覆盖方法时要考虑比较的主要条件和次要条件。

class MyCompare implements Comparator  
{  
    public int compare(Object o1,Object o2)  
    {  
        Student s1 = (Student)o1;  
        Student s2 = (Student)o2;  
  
  
        int num = s1.getName().compareTo(s2.getName());  
        if(num==0)  
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));//s1.getAge()-s2.getAge();  
        return num;  
    }  
}  

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------