java（14）：数据结构（1）--Collection

日期：2017/11/3

一、集合的意义：

        面向对象语言对事物的体现都是以 对象的形式，所以为了方便对多个对象的操作，用前面所学知识，我们只能采用对象数组实现，但对象数组的长度又是固定的，适应不了变化的需求，所以，java就提供了集合类供我们使用。

        上面的图展示了整个集合大家族的成员以及他们之间的关系。下面就上面的各个接口、基类做一些简单的介绍(主要介绍各个集合的特点。区别)。

一、Collection 接口

public interface Collection<E>
 
 
  
  extends 
  
  Iterable<E>
 
 

所有超级接口：

Iterable<E>

所有已知子接口：

BeanContext,  BeanContextServices,  BlockingDeque<E>,  BlockingQueue<E>,  Deque<E>,  List<E>,  NavigableSet<E>,  Queue<E>,  Set<E>,  SortedSet<E>

所有已知实现类：

AbstractCollection,  AbstractList,  AbstractQueue,  AbstractSequentialList,  AbstractSet,  ArrayBlockingQueue,  ArrayDeque,  ArrayList,  AttributeList,  BeanContextServicesSupport,  BeanContextSupport,  ConcurrentLinkedQueue,  ConcurrentSkipListSet,  CopyOnWriteArrayList,  CopyOnWriteArraySet,  DelayQueue,  EnumSet,  HashSet,  JobStateReasons,  LinkedBlockingDeque,  LinkedBlockingQueue,  LinkedHashSet,  LinkedList,  PriorityBlockingQueue,  PriorityQueue,  RoleList,  RoleUnresolvedList,  Stack,  SynchronousQueue,  TreeSet,  Vector

       Collection 接口是最基本的集合接口，它不提供直接的实现，Java SDK提供的类都是继承自 Collection 的“子接口”如 List 和 Set。Collection 所代表的是一种规则，它所包含的元素都必须遵循一条或者多条规则。如有些允许重复而有些则不能重复、有些必须要按照顺序插入而有些则是散列，有些支持排序但是有些则不支持。

      Collection 是层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

       在 Java 中所有实现了 Collection 接口的类都必须提供两套标准的构造函数，一个是无参，用于创建一个空的 Collection，一个是带有 Collection 参数的有参构造函数，用于创建一个新的 Collection，这个新的 Collection 与传入进来的 Collection 具备相同的元素。

Collection 小例子1.1，提供了元素（对象）增删改查/判断的方法：

package com.colection;
/*
 * 为什么出现集合类?
 * 		面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，用前面所学知识，我们只能采用对象数组实现。
 * 		但是，对象数组的长度又是固定的，适应不了变化的需求，所以，java就提供了集合类供我们使用。
 * 
 * 集合类的特点：
 * 		A:长度可变
 * 		B:只能存储对象
 * 		C:可以存储不同类型的对象
 * 
 * 面试题：数组和集合的区别?
 * 		A:集合长度可变；集合只能存储引用数据类型；集合可以存储不同数据类型的元素
 * 		B:数组长度固定；数组可以存储引用数据类型，也可以存储基本数据类型；数组存储的是同一种数据类型的元素
 * 
 * 由于我们的功能需求不太一样，所以，java就提供了多种集合类供我们使用。这些集合类的本质区别：其实是底层的数据结构不同。
 * 数据结构：数据的存储方式。
 * 
 * Collection的功能：
 * A:添加功能
 * 		boolean add(Object obj):往集合中添加一个元素
 * 		boolean addAll(Collection c):往集合中添加多个元素。
 * B:获取功能
 * 		Iterator iterator():迭代器
 * 		int size():集合的元素个数，长度
 * C:删除功能
 * 		void clear():清空集合的所有元素
 * 		boolean remove(Object obj):从集合中移除一个元素
 * 		boolean removeAll(Collection c):从集合中移除多个元素
 * D:判断功能
 * 		boolean contains(Object obj):判断集合中是否包含指定的元素
 * 		boolean containsAll(Collection c):判断集合中是否包含指定的多个元素
 * 		boolean isEmpty():判断集合是否为空
 * E:交集元素
 * 		boolean retainAll(Collection c)
 * F:转数组
 * 		Object[] toArray():把集合转成对象数组
 */
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

	public static void main(String[] args) {
//		不能实例化类型 Collection
//		Collection c = new Collection();
		Collection v = new ArrayList();
		
		// boolean add(Object obj):往集合中添加一个元素
		//warnning:类型安全：方法 add（Object）属于原始类型 Collection。
		//应该将对通用类型 Collection<E> 的引用参数化
		v.add("hello");
		v.add("world");
		v.add("java");
		
		System.out.println("size: "+v.size());
		System.out.println("v:"+v);
				
		// boolean remove(Object obj):从集合中移除一个元素
		v.remove("java");
		
		// boolean contains(Object obj):判断集合中是否包含指定的元素
		System.out.println("contains hello: " + v.contains("hello"));
		System.out.println("contains javaee: " + v.contains("javaee"));
		
		// void clear():清空集合的所有元素
		System.out.println("after clear..");
		v.clear();

		// boolean isEmpty():判断集合是否为空
		System.out.println("isEmpty : "+v.isEmpty());
		
		System.out.println("size: "+v.size());
		System.out.println("v:"+v);
	}

}

     集合之间亦能做比较，Collection提供了相关的方法，见例子1.2：

package com.colection;

import java.util.ArrayList;
import java.util.Collection;

/*
 * boolean addAll(Collection c)
 * boolean removeAll(Collection c):删除一个，就是删除，返回true
 * boolean containsAll(Collection c):全部包含，才是包含。
 * boolean retainAll(Collection c)
 */
public class CollectionDemo2 {

	public static void main(String[] args) {
		// 创建集合
		Collection<String> c1 = new ArrayList();
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");
		
		// 创建集合
		Collection c2 = new ArrayList();
		// c2.add("abc1");
		// c2.add("abc2");
		// c2.add("abc3");
		// c2.add("abc4");
		c2.add("abc5");
		c2.add("abc6");
		c2.add("abc7");
		
		// boolean addAll(Collection c)
		 System.out.println("addAll:" + c1.addAll(c2));
		 System.out.println("c1: "+c1);

		// boolean removeAll(Collection c)
		 System.out.println("removeAll:" + c1.removeAll(c2));
		 System.out.println("c1: "+c1);

		// boolean containsAll(Collection c)
		 System.out.println("containsAll:" + c1.containsAll(c2));
		 System.out.println("c1: "+c1);
		 
		// boolean retainAll(Collection c)
		System.out.println("retainAll:" + c1.retainAll(c2));
		/*
		 * 如果我有两个集合A，B。用A对B做交集 交集元素存储在A集合，B集合不发生改变。 返回值表达是A集合是否发生过改变。
		 */
		
		System.out.println("c1: "+c1);
		System.out.println("c2: "+c2);

	}

}

     利用迭代器进行元素的遍历，见例子1.3：

package com.colection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest2 {
	public static void main(String[] args){
		// 创建集合对象
		Collection c = new ArrayList();

		// 创建元素对象
		Student s1 = new Student("孙悟空", 30);
		Student s2 = new Student("紫霞仙子", 26);
		Student s3 = new Student("嫦娥", 22);

		// 把元素添加到集合
		c.add(s1);
		c.add(s2);
		c.add(s3);

		// 遍历集合
		// 通过集合对象调用iterator()方法获取迭代器对象
		Iterator it = c.iterator();
		// 通过迭代器对象的hasNext()方法进行判断是否有元素
		while (it.hasNext()) {
			// 通过迭代器对象的next()方法获取元素,并转换为你存储的元素类型
			Student s = (Student) it.next();
			// 直接输出对象的名称，输出的是地址值，没有什么意义。
			// 如何解决呢?A:重写对象所属类的toString()方法。B:通过对象调用getXxx()方法
			System.out.println(s.getName() + "---" + s.getAge());
		}
	
	}

}

     第四个例子，当Collection存放String和int对象时，迭代器取出的东西就麻烦大了，，见例子1.4：

package com.colection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Collection;
import java.util.Iterator;

/*
 * Iterator iterator()
 * 		boolean hasNext():是否有下一个元素
 * 		Object next():获取下一个元素,并自动移动到下一个位置等待
 * 
 * 		NoSuchElementException:没有这样的元素异常。
 * 		原因是：你已经获取到元素的末尾了，你还要获取元素，已经没有元素了，所以报错。
 */
public class IteratorDemo {

	public static void main(String[] args) {
		Collection c = new ArrayList();
		
		// 创建元素并添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add(100);

		// 集合中的方法：Iterator iterator()
		Iterator it  = c.iterator();// 右边其实是接口的实现类对象，这是多态的应用

//		System.out.println(it.next());
//		 System.out.println(it.next());
//		 System.out.println(it.next());
		 
/*	
    	 while(it.hasNext()){
			 System.out.println(it.next());
			 
//			 String s = (String) it.next();
//			 System.out.println(s);			 
//			 s = (String) it.next();
//			 System.out.println(s);			 
//			 s = (String) it.next();
//			 System.out.println(s);
//			 int i = (int) it.next();
//			 System.out.println(i);
 
		 }*/
//			 for循环改进
			 for (Iterator itt = c.iterator(); itt.hasNext();) {
			 String s = (String) itt.next();
			 System.out.println(s);
//			 System.out.println(itt.next());
			 }
	}

}

     PS：Collection的确解决了存储限度的问题，但这也暴露了一个问题 ---- 因为我们想要存储的数据，肯定不可能全部类型一样的，那怎么办呢？？ Tips： 泛型！