黑马程序员-集合框架（1）



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

1、集合类 

集合类：面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同的不同：数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储任意数据类型，集合只能存储对象。

集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合框架的构成及分类

 

 

两大接口：Collection

Set  ：不能存放重复对象

List  ：可存放重复对象，有序

Queue ：队列

SortedSet ：可对集合数据排序

Map 

SortedMap ：可对集合数据排序

2、Collection接口

方法：

boolean add(Object o):该方法用于向集合里面添加一个元素，若集合对象被添加操作改变了，返回true.

boolean addAll(Collection c):把集合c里面的所有元素添加到指定集合里面去，如果集合对象被添加操作改变了返回true.

void clear():清除集合里面的所有元素，将集合长度变为0。

boolean contains(Object o):返回集合里是否包含指定的元素。

boolean containsAll(Collection c):返回集合里是否包含集合c内所有的元素。

boolean isEmpty()：返回集合是否为空（长度是否为0）。

Iterator iterator():返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object o)：删除集合中指定元素o。

boolean removeAll(Collection c):从集合中删除集合c里面的元素。若删除一个或以上返回true。

boolean retainAll(Collection c):从集合中删除集合c里不包含的元素。

int size()：得到集合元素的个数。

Object[] toArray():把集合转成一个数组，所有集合元素变成数组元素。

3、Iterator接口 

 

主要方法：boolean hasNext()：若被迭代的集合元素还没有被遍历，返回true.

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

void remove():删除集合上一次next()方法返回的元素。(若集合中有多个相同的元素，都可以删掉)

iterator对于集合才能用，for不同，只要是循环都可用。

 

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。

模板代码：

Iterator iter = l.iterator();

while(iter.hasNext()){

    System.out.println(iter.next());

}

 

4、Set接口（元素不可以重复）

Set是Collection子接口；Set和Collection基本上一样，一点除外：Set无法记住添加的顺序，不允许包含重复的元素。

当试图添加两个相同元素进Set集合，添加操作失败，add()方法返回false。

Set判断两个对象是否相等用equals,而不是使用==。也就是说两个对象equals比较返回true，Set集合是不会接受这个两个对象的。

常用子类：HashSet:散列存放；TreeSet:有序存放

HashSet元素添加：

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,判断已经存储在集合中的对象的hashCode值是否与添加的对象的hashCode值一致:若不一致:直接添加进去;若一致,再进行equals方法比较,equals方法如果返回true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去;

如果我们重写了equals方法,也要重写hashCode方法,反之亦然;。

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode方法返回值也相等。

如果需要某个类的对象保存到HashSet集合中，覆写该类的equals()和hashCode()方法，应该尽量保证两个对象通过equals比较返回true时,他们的hashCode返回也相等。

 

总结：往hashset集合存数据，要先调用两个方法：equals()和hashCode()方法。 

示例代码：

//hashset方法和equals方法判断输入的对象是否重复！
import java.util.HashSet;
import java.util.Set;
class PersonDemo{
	private String name;
	public PersonDemo(String name) {
		super();
		this.name = name;
	}
	public String toString() {
		return "name= " + name ;
	}
	//没有覆写hashcode和equals方法前，显示三次（一样的）。覆写后，只剩下一个了！说明覆写后方法起作用了，重复的输入不进去！
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		PersonDemo other = (PersonDemo) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}
public class Demo12 {
	public static void main(String[] args) {
		Set s = new HashSet();
		
		s.add(new PersonDemo("黑马"));
		s.add(new PersonDemo("黑马"));
		s.add(new PersonDemo("黑马"));
		System.out.println(s);
	}
}	

5、TreeSet

TreeSet是SortedSet接口唯一的实现，与HashSet相比额外的方法有：

Comparator comparator():返回当前Set使用的Comparator,若返回null,表示以自然顺序排序。

Object first() 返回此 set 中当前第一个(最低)元素。 

Object last() 返回此 set 中当前最后一个(最高)元素。 

SortedSet subSet(Object  fromElement, E toElement) 返回此 set 的部子集，其元素从 fromElement（包括）到 toElement（不包括）。 

SortedSet headSet(Object  toElement)返回此 set 的部分子集，其元素严格小于 toElement。 

SortedSet tailSet(Object  fromElement) 返回此 set 的部分子集，其元素大于等于 fromElement。 

TreeSet的排序之自然排序

TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Object o)方法;

该方法用于比较对象,若:obj1,compareTo(obj2),返回0,表示两个对象相等,若返回一个正整数,表示obj1大于obj2,若返回一个负整数,表示obj1小于obj2;

对于TreeSet集合而言,判断两个对象相等的标准是:compareTo()方法比较返回 0;

示例代码：

//TreeSet的自然排序，升序
import java.util.Set;
import java.util.TreeSet;
class Student implements Comparable{//必须实现接口
	private Integer age;
	public Student(Integer age) {
		super();
		this.age = age;
	}
	public int compareTo(Object o) {//比较的规则，运用泛型可以消除强转！
		if(o instanceof Student){
			Student s = (Student)o;
			return this.age.compareTo(s.age);
		}
		return 0;
	}
	public String toString() {
		return age+"" ;
	}
}
public class Demo14 {
	public static void main(String[] args) {		
		Set<Student> s = new TreeSet();
		s.add(new Student(140));
		s.add(new Student(15));
		s.add(new Student(11));
		s.add(new Student(63));
		s.add(new Student(96));
		System.out.println(s);//[11, 15, 63, 96, 140]
	}
}

TreeSet的排序之定制排序

TreeSet的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就可以使用Comparator接口了:

该接口包含int compare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和compareTo方法一致;

要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,该对象里负责集合元素的排序逻辑;

TreeSet(Comparator comparator) 

//定制排序的话，必须在创建TreeSet集合对象的时候提供一个Comparator方法
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
class Student1{
	private Integer age;	
	public Student1(Integer age) {
		super();
		this.age = age;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String toString() {
		return age + "";
	}
}
class MyComparator implements Comparator{
	public int compare(Object o1, Object o2) {
		if(o1 instanceof Student1 & o2 instanceof Student1){
			Student1 s1 = (Student1)o1;
			Student1 s2 = (Student1)o2;
			if(s1.getAge() > s2.getAge()){
				return -1;
			}else if(s1.getAge() < s2.getAge()){
				return 1;
			}
		}
		return 0;
	}
}
public class Demo15 {
	public static void main(String[] args) {
		Set<Student1> s = new TreeSet(new MyComparator());
		/**
		 * 要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,
		 * 该对象里负责集合元素的排序逻辑;
		 */
		s.add(new Student1(140));
		s.add(new Student1(15));
		s.add(new Student1(11));
		s.add(new Student1(63));
		s.add(new Student1(96));	
		System.out.println(s);
	}
}

6、List接口

List是有序的集合，集合中每个元素都有对应的顺序序列。List集合可使用重复元素，可以通过索引来访问指定位置的集合元素（顺序索引从0开始）,List集合默认按元素的添加顺序设置元素的索引,比如第一个元素的索引就是0,好似数组。

List接口常用类：Vector：线程安全，但速度慢，已被ArrayList替代。ArrayList：线程不安全，查询速度快。LinkedList：链表结构，增删速度快。

取出List集合中元素的方式：get(int  index)：通过脚标获取元素。iterator()：通过迭代方法获取迭代器对象。

ArrayList和Vector类都是基于数组实现的List类,Vector比较古老,被ArrayList取代了;

ArrayList是线程不安全的,而Vector是线程安全的,但是即使这样,也不推荐使用Vector,因为Collections有方法可以得到线程安全的ArrayList对象;

Collections类: static  List synchronizedList(List list) 返回指定列表支持的同步（线程安全的）列表。 

List作为Collection子接口当然拥有其所有方法，同时也有自己的方法：

void add(int index,Object e):将元素e添加到List集合中的index处；

boolean addAll(int index,Collection c):将集合c所包含的所有元素都插入在List集合的index处；

Object get(int index):返回集合index索引处的元素；

int indexOf(Object o):返回对象o在List集合中第一次出现位置的索引；

int lastIndexOf(object o):返回对象o在List集合中最后一次出现的位置索引；

Object remove(int index)：删除并返回index索引处的元素；

Object set(int index,Object e):把集合index处的元素替换为e对象，返回以前在指定位置的元素；

List subList(int fromIndex,int toIndex):返回从所有fromIndex(包括)到toIndex(不包括)处所有集合元素的子集合。

ListIterator：Iterator的子接口，专门用于操作List集合的输出；

List自己还有一个listIterator()方法，该方法返回ListIterator对象，ListIterator继承了Iterator接口，提供了专门操作List的方法。在Iterator上额外增加的方法：

支持双向输出：

boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素；

Object previous():返回该迭代器的上一个元素；

示例代码：

<pre class="java" name="code">import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo16 {
	public static void main(String[] args) {
		List<Integer> l = new ArrayList<Integer>();
		l.add(12);
		l.add(24);
		l.add(36);
		l.add(23);
		l.add(37);		
		System.out.println(l);		
		ListIterator<Integer> it = l.listIterator();
		while(it.hasNext()){
			System.out.println("正序："+it.next());
		}
		System.out.println("==================================");
		//使用向前迭代前必须将游标（指针）移动到后边！
		while(it.hasPrevious()){
			System.out.println("逆序："+it.previous());
		}
	}
}

 

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

黑马训练营：http://edu.csdn.net/