集合框架

AlanHand

于 2014-08-27 18:43:33 发布

阅读量799

点赞数

分类专栏： JavaSE 文章标签： java 实例框架

本文链接：https://blog.csdn.net/AlanHand/article/details/38874393

版权

JavaSE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一.集合概述

1.集合的由来：

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定就使用集合容器进行存储。

2.集合特点：

(1)用于存储对象的容器。
(2)集合的长度是可变的。
(3)集合中不可以存储基本数据类型值。

3.集合容器因为内部的数据不同，有多种容器，不断的向上抽取就形成了集合框架。如图：

框架的顶层Collection接口：

(1)Collection的常见方法：

添加：boolean add(Object obi)；
boolean addAll(Collection coll)；

删除：boolean remove(Object obj)；
boolean removeAll(Collection coll)；
void clear()；

判断：boolean contains(Object obj)；
boolean containAll(Collection coll)；
boolean isEmpty()；

获取：int size()
Iterator iterator()取出元素的方法：迭代器，该对象必须依赖于具体容器，因为每一个容器的数据结构都不同,所以迭代器对象是在容器中进行内部实现的，对于使用容器而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就iterator() 方法。

其它：boolean retainAll(Collection coll);取交集

Object[] toArray();将集合转成数组。

二.集合Collection子类

1.List:有序，存入和取出顺序一致，元素都有索引，可放入重复元素。

1.1 List:特有常见方法：有一个共性特点就是可以操作角标

添加：void add(index,element)
void add(index,collection)

删除：Object remove(index)底层是根据equals方法判断是否有相同元素,contains()方法一样

修改：Object set(index,element)

获取：Object get(index)
int indexOf(object)
int lastIndexOf(object)
List subList(from,to)
注意：在对列表进行迭代操作时，如果对列表里的元素进行增加和删除时会出现ConcurrentModificationException异常,这个异常是当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。由于在对列表迭代时列表的长度是一定的，因此迭代取到的长度也是一定，当对列表进行增加删除是列表的长度改变，此时迭代的长度不变，所以就报ConcurrentModificationException异常,实例如下：

public class ListDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		Iterator it = list.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			if(obj.equals("abc2")){
				list.add("abc4");
			}
			System.out.println(list);
		}
}

结果如图：

ConcurrentModificationException异常解决办法：
List中有一个方法是listIterator()返回列表中元素的列表迭代器（以正确的顺序），若要进行上面的操作就用该方法就行，但是该方法只有List集合有，实例如下：

public class ListDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		ListIterator it = list.listIterator();
		while(it.hasNext()){
			Object obj = it.next();
			if(obj.equals("abc2")){
				it.add("abc4");
			}
		}
		System.out.println(list);
	}
}

结果如图：

1.2 常用子类：

Vector:内部是数组数据结构，是同步的，增删查都慢
ArrayList:内部是数组数据结构,初始容量为10,是不同步的，替代了Vector，查询效好。
LinkedList:内部是链表数据结构，初始容量为 0，不同步，增删元素效率好。

--------------------------------------------------------------------------------------------

2.Set: 元素不能重复，无序,Set接口中的方法和Collection一致，子类HashSet，TreeSet

2.1 HashSet:内部数据结构是哈希表，是不同步的,存放无序不重复的元素,哈希表确定元素是否相同

2.1.1.判断的是两个元素的哈希表值是否相同，如果相同在判断两个对象的内容是否相同。
2.1.2.判断哈希值相同其实判断的是对象的hashCode的方法。
2.1.3.contains方法和remove方法判断都是根据是否有相同的哈希值和内容
注意：如果哈希值不同，是不需要判断内容的。

LinkedHashSet:和HashSet的不同之处在于存放有序不重复的元素

示例如下，哈希算法图如下：

/**
 * 重写了hashCode方法和equals方法
 */
public class Person{
	private String name;
	private int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int hashCode() {//重写hashCode方法，根据属性name的hashCode和age的组合返回哈希值
		System.out.println("hashCode....");
		return this.name.hashCode()+this.age*39;
	}
	@Override
	public boolean equals(Object obj) {//重写equals方法，比较的是name和age的值
		if(obj instanceof Person){
			throw new ClassCastException("类型不匹配");
		}
		System.out.println("equals....");
		Person p = (Person)obj;
		return this.name.equals(p.getName()) && this.age==p.getAge();
	}
	@Override
	public String toString() {//重写toString方法，返回的是name和age
		return name+":"+age;
	}	
}
public class HashSetTest {

	public static void main(String[] args) {
		HashSet hastSet = new HashSet();
		/**
		 * 由于重写了Person的hashCode方法和equals方法
		 * 每添加一个对象都会调用Person的hashCode方法
		 * 每当添加一个name和age相同的Person对象时，该对象的哈希值相同，会在调用equals方法，
		 * 因为HashSet是先比较哈希值在比较内容
		 * 
		 */
		hastSet.add(new Person("lishi1", 20));
		hastSet.add(new Person("lishi1", 22));
		hastSet.add(new Person("lishi1", 25));
		hastSet.add(new Person("lishi1", 21));
		
		Iterator it = hastSet.iterator();
	    while(it.hasNext()){
	    	System.out.println(it.next());
	    }
	}
}<span style="color: rgb(255, 0, 0); font-family: KaiTi_GB2312; ">          </span>

2.2 TreeSet:可以对Set集合中的元素进行排序，是不同步的，可以按照自己定义的比较器存放，存放方式是二叉树排序，取数据时按照先序方式取。

2.2.1.对元素进行排序的方式一：

若存放元素是存放String对象不用实现Comparable接口，按照字符自然顺序排序，因为String类本身就
实现了Comparable接口
否则要实现Comparable接口，重写comparaTo函数，返回值负数（小于）,0（等于）,正数（大于）；

2.2.2对元素进行排序的方式二：(解决对象中不具备自然顺序的问题)

自定义一个比较器Comparator，覆盖conparaTo方法

在创建TreeSet对象时将传递一个 Comparator对象

示例代码如下：

/**
 * 重写了hashCode方法和equals方法，
 * @author lenovo
 *
 */
public class Person implements Comparable{
	private String name;
	private int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	
	@Override
	public String toString() {//重写toString方法，返回的是name和age
		return name+":"+age;
	}
	@Override
	public int compareTo(Object obj) {
		System.out.println("comparTo....");
		int temp = this.age-((Person)obj).age;
		return temp==0?this.name.compareTo(((Person)obj).getName()):temp;
	}	
}
/**
 * 根据Person的name进行比较的比较器
 */
public class ComparatorByName implements Comparator {
	@Override
	public int compare(Object o1, Object o2) {
		return ((Person)o1).getName().compareTo(((Person)o2).getName());
	}

}
public class TreeSetTest {
	public static void main(String[] str){
		TreeSet ts = new TreeSet();//根据Person实现的Comparable接口的TreeSet集合
		//TreeSet ts = new TreeSet(new ComparatorByName());//根据自定义的ComparatorByName比较器的集合
	        ts.add(new Person("lishi1", 20));
	        ts.add(new Person("lishi1", 21));
	        ts.add(new Person("lishi1", 22));
	        ts.add(new Person("lishi1", 20));
	        Iterator it = ts.iterator();
	        while(it.hasNext()){
	    	    System.out.println(it.next());
	        }
	}
}

结果图：

三：Map集合

1.概述

Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

2.方法

2.1.添加。

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

void putAll(Map);

2.2.删除。

void clear()：清空

value remove(key)：删除指定键。

2.3.判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value)：是否包含value

2.4.取出。

int size()：返回长度

value get(key)：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection values()：获取map集合中的所有的值。

3.把Map集合转成Set的方法 :

3.1.

Set keySet();

Set entrySet();//取的是键和值的映射关系。

Entry就是Map接口中的内部接口；

为什么要定义在map内部呢？

因为entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

3.2.取出map集合中所有元素的方式一：keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。

代码如下：

                Set keySet = map.keySet();
		Iterator it = keySet.iterator();
		while(it.hasNext()) {
			Object key = it.next();
			Object value = map.get(key);
			System.out.println(key+":"+value);
		}

3.3.取出map集合中所有元素的方式二：entrySet()方法。

代码如下：

                Set entrySet = map.entrySet();
		Iterator it = entrySet.iterator();
		while(it.hasNext()) {
			Map.Entry  me = (Map.Entry)it.next();
			System.out.println(me.getKey()+"::::"+me.getValue());
		}

四：Collections：

1.它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

静态方法：

Collections.sort(list);//list集合进行元素的自然顺序排序。

Collections.sort(list,newComparatorByLen());//按指定的比较器方法排序。

代码如下：

classComparatorByLen implements Comparator<String>{
  public int compare(String s1,String s2){
      int temp = s1.length()-s2.length();
      return temp==0?s1.compareTo(s2):temp;
  }
}

Collections.max(list);//返回list中字典顺序最大的元素。

int index =Collections.binarySearch(list,"zz");//二分查找，返回角标。

Collections.reverseOrder();//逆向反转排序。

Collections.shuffle(list);//随机对list中的元素进行位置的置换。