集合框架

集合框架

简介

集合的由来
　　数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

定义：

　　java提供了一种可以存数一组数据的数据结构，其提供了丰富的方法，在实际开发中往往比数组使用的广泛。这种数据结构成为集合:Collection。

　　Collection是一个接口，其定义了集合的相关功能方法。

数组和集合的区别

• 区别1 :
  • 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  • 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
• 区别2:
  • 数组长度是固定的,不能自动增长
  • 集合的长度的是可变的,可以根据元素的增加而增长

数组和集合什么时候用

• 如果元素个数是固定的推荐用数组
• 如果元素个数不是固定的推荐用集合

集合框架图

Collection （集合的最大接口）继承关系

　　——List　可以存放重复的内容
　　——Set　　不能存放重复的内容，所以的重复内容靠hashCode()和equals()两个方法区分
　　——Queue　　队列接口
　　——SortedSet　　可以对集合中的数据进行排序

关于list,set,map的我的博客链接java集合（list,set,map)

Collection定义了集合框架的共性功能。

Collection接口常见的方法

（1）单元素添加、删除操作。

方法	描述
boolean add(Object o)	将对象添加给集合。
boolean remove(Object o)	如果集合中有与o相匹配的对象，则删除对象o。

（2）查询操作。

方法	描述
int size()	返回当前集合中元素的数量。
boolean isEmpty()	判断结合中是否有任何元素。
boolean contains(Object o)	查找集合中是否含有元素o。
Iterator iterator()	返回一个迭代器，用来访问集合中的各个元素。

（3）组操作：作用于元素或整个结合。

方法	描述
boolean containsAll(Collection c)	查找集合中是否含有集合c中的所有元素。
boolean addAll(Collectiion c)	将集合c中的所有元素添加给该集合。
void clear()	删除集合中所有的元素。
void removeAll(Collection c)	从集合中删除集合c中的所有元素。
void retainAll(Collection c)	从集合中删除集合c中不包含的元素。

（4）Collection转换为Object数组。

方法	描述
Object[] toArray()	返回一个内含集合所有元素的数组。
Object[] toArray(Object[] a)	返回一个内含集合所有元素的数组。运行期返回的数组和参数a的类型相同。

注：集合中存储的都是对象的引用(地址)

Iterator 迭代器

Collection提供了一个遍历集合的通用方式，迭代器(Iterator)。
获取迭代器的方式是使用Collection定义的方法:

Iterator iterator():迭代器Iterator是一个接口，集合在覆盖Collection的iterator()方法时提供了迭代器的实现。Iterator提供了统一的遍历集合元素的方式。

迭代器原理

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二：
　　第一规定了整个集合体系的遍历方式都是hasNext()和next()方法；
　　第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

hasNext与next方法

迭代器用于遍历集合的两个主要方法:

• boolean hasNext():判断集合是否还有元素可以遍历。

• E next():返回迭代的下一个元素

  遍历集合应遵循“先问后取”的方式，也就是说，应当在确定hasNext()方法的返回值为true的情况下再通过next()方法取元素。

  由此可以看出，使用迭代器遍历集合是通过boolean值驱动的，所以它更适合使用while循环来遍历。

	Collection<String> c = new HashSet<String>();
	c.add("java");        
	c.add("cpp");        
	c.add("php");
	c.add("c#");        
	c.add("objective-c");
	Iterator<String> it = c.iterator();
	while (it.hasNext()) {
		String str = it.next();
		System.out.println(str);
	} 

remove方法

　　迭代器还提供了一个方法:

　　void remove()该方法用于删除迭代器当次从集合中获取的元素。若我们在迭代过程中想删除集合元素时，我们就需要通过该方法来进行。这里需要注意，在使用迭代器遍历集合时是不能通过集合自身提供的remove方法删除元素的，否则迭代器在迭代时会抛出异常。

	Collection<String> c = new HashSet<String>();
	c.add("java");        
	c.add("cpp");        
	c.add("php");
	c.add("c#");        
	c.add("objective-c"); 
	System.out.println(c); // [cpp, php, c#, java, objective-c] 
	Iterator<String> it = c.iterator();
	while (it.hasNext()) {
	    String str = it.next();
	    if (str.indexOf("c") != -1) {
	        it.remove();
	    } 
	} 
	System.out.println(c); // [php, java]  

增强for循环

Java5.0之后推出了一个新的特性，增强for循环,也称为新循环。该循环不通用于传统循环的工作，其只用于便利集合或数组。 语法:

	for(元素类型 e : 集合或数组){
	    循环体 
	}

　　新循环并非新的语法，而是在编译过程中，编译器会将新循环转换为迭代器模式。所以新循环本质上是迭代器。
例如:

	Collection<String> c = new HashSet<String>();
	c.add("java");
	c.add("cpp");
	c.add("php");
	c.add("c#");
	c.add("objective-c");
	for (String str : c) {
	    System.out.print(str.toUpperCase() + " ");
	} 
	// CPP PHP C# JAVA OBJECTIVE-C

泛型机制

泛型在集合中的应用

　　泛型是Java SE 5.0引入的特性，泛型的本质是参数化类型。在类、接口和方法的定义过程中，所操作的数据类型被传入的参数指定。

　　Java泛型机制广泛的应用在集合框架中。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。Java编译器可以据此进行类型检查，这样可以减少代码在运行时出现错误的可能性。

我们来举个例子，比如ArrayList，其在定义时是这样的:

	public class ArrayList<E> {
	    … … …                
	    public boolean add(E e) {…};
	    public E get(int index) {…};
	} 

由此我们可以看出，再声明ArrayList时，类名的右侧有一个。"<>"表示泛型，而其中可以使用数字字母下划线(数字不能的第一个字符)来表示泛型的名字。(通常我们使用一个大写字母来表示，当然这个不是规定。)这时，在类中声明的方法的参数，返回值类型可以被定义为泛型。这样在创建对象时可以将类型作为参数传递，此时，类定义所有的E将被替换成传入的参数。
例如:

	ArrayList<String> list = new ArrayList<String>();//泛型E在这里被指定为String类型
	list.add("One");//那么add方法的参数就被替换为String类型
	list.add(100);//这里就会出现编译错误，因为这里的参数应为String类型。

集合工具类

　Collections:集合框架的工具类。里面定义的都是静态方法。

　　Collections和Collection有什么区别？
　　　　Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
　　　　　　它有两个常用的子接口，
　　　　　　List：对元素都有定义索引。有序的。可以重复元素。
　　　　　　Set：不可以重复元素。无序。

　　　　Collections是集合框架中的一个工具类。该类中的方法都是静态的。
　　　　　　提供的方法中有可以对list集合进行排序，二分查找等方法。
　　　　　　通常常用的集合都是线程不安全的。因为要提高效率。
　　　　　　如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

常用的方法

排序操作（主要针对List接口相关）

方法	描述
reverse(List list)	反转指定List集合中元素的顺序
shuffle(List list)	对List中的元素进行随机排序（洗牌）
sort(List list)	对List里的元素根据自然升序排序
sort(List list, Comparator c)	自定义比较器进行排序
swap(List list, int i, int j)	将指定List集合中i处元素和j出元素进行交换
rotate(List list, int distance)	将所有元素向右移位指定长度，如果distance等于size那么结果不变

例子

	public void testSort() {
        System.out.println("原始顺序：" + list);
        
        Collections.reverse(list);
        System.out.println("reverse后顺序：" + list);

        Collections.shuffle(list);
        System.out.println("shuffle后顺序：" + list);
        
        Collections.swap(list, 1, 3);
        System.out.println("swap后顺序：" + list);

        Collections.sort(list);
        System.out.println("sort后顺序：" + list);

        Collections.rotate(list, 1);
        System.out.println("rotate后顺序：" + list);
    }

输出

原始顺序：[b张三, d孙六, a李四, e钱七, c赵五]
reverse后顺序：[c赵五, e钱七, a李四, d孙六, b张三]
shuffle后顺序：[b张三, c赵五, d孙六, e钱七, a李四]
swap后顺序：[b张三, e钱七, d孙六, c赵五, a李四]
sort后顺序：[a李四, b张三, c赵五, d孙六, e钱七]
rotate后顺序：[e钱七, a李四, b张三, c赵五, d孙六]

查找和替换（主要针对Collection接口相关）

方法	描述
binarySearch(List list, Object key)	使用二分搜索法，以获得指定对象在List中的索引，前提是集合已经排序
max(Collection coll)	返回最大元素
max(Collection coll, Comparator comp)	根据自定义比较器，返回最大元素
min(Collection coll)	返回最小元素
min(Collection coll, Comparator comp)	根据自定义比较器，返回最小元素
fill(List list, Object obj)	使用指定对象填充
frequency(Collection Object o)	返回指定集合中指定对象出现的次数
replaceAll(List list, Object old, Object new)	替换

例子

		public void testSearch() {
        System.out.println("给定的list：" + list);
        System.out.println("max：" + Collections.max(list));
        System.out.println("min：" + Collections.min(list));
        System.out.println("frequency：" + Collections.frequency(list, "a李四"));
        Collections.replaceAll(list, "a李四", "aa李四");
        System.out.println("replaceAll之后：" + list);
        
        // 如果binarySearch的对象没有排序的话，搜索结果是不确定的
        System.out.println("binarySearch在sort之前：" + Collections.binarySearch(list, "c赵五"));
        Collections.sort(list);
        // sort之后，结果出来了
        System.out.println("binarySearch在sort之后：" + Collections.binarySearch(list, "c赵五"));

        Collections.fill(list, "A");
        System.out.println("fill：" + list);
    }

输出

给定的list：[b张三, d孙六, a李四, e钱七, c赵五]
max：e钱七
min：a李四
frequency：1
replaceAll之后：[b张三, d孙六, aa李四, e钱七, c赵五]
binarySearch在sort之前：-4
binarySearch在sort之后：2
fill：[A, A, A, A, A]

同步控制

　　Collections工具类中提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题。HashSet、ArrayList、HashMap都是线程不安全的，如果需要考虑同步，则使用这些方法。这些方法主要有：synchronizedSet、synchronizedSortedSet、synchronizedList、synchronizedMap、synchronizedSortedMap。

　　特别需要指出的是，在使用迭代方法遍历集合时需要手工同步返回的集合。

Map m = Collections.synchronizedMap(new HashMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
 	}

总结

　List：add/remove/get/set。

　　　　1，ArrayList：其实就是数组，容量一大，频繁增删就是噩梦，适合随机查找；

　　　　2，LinkedList：增加了push/[pop|remove|pull]，其实都是removeFirst；

　　　　3，Vector：历史遗留产物，同步版的ArrayList，代码和ArrayList太像；

　　　　4，Stack：继承自Vector。Java里其实没有纯粹的Stack，可以自己实现，用组合的方式，封装一下LinkedList即可；

　　　　5，Queue：本来是单独的一类，不过在SUN的JDK里就是用LinkedList来提供这个功能的，主要方法是offer/pull/peek，因此归到这里呢。

　　Set：add/remove。可以用迭代器或者转换成list。

　　　　1，HashSet：内部采用HashMap实现的；

　　　　2，LinkedHashSet：采用LinkedHashMap实现；

　　　　3，TreeSet：TreeMap。

　　Map：put/get/remove。

　　　　1，HashMap/HashTable：散列表，和ArrayList一样采用数组实现，超过初始容量会对性能有损耗；

　　　　2，LinkedHashMap：继承自HashMap，但通过重写嵌套类HashMap.Entry实现了链表结构，同样有容量的问题；

　　　　3，Properties：是继承的HashTable。

　　　　顺便说一下Arrays.asList，这个方法的实现依赖一个嵌套类，这个嵌套类也叫ArrayList！