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

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

集合框架（1）

    集合：
    1，用于存储对象的容器。
    2，该容器的长度是可变的。
  
   集合和数组的区别？
   1，
       集合长度是可变的。
       数组长度是固定的。
   2，
       集合中只能存储对象。
       数组中即可以存储对象，又可以存储基本类型数值。
   3，
       集合中存储的对象可以是任意类型的。
       数组中只能存储同一类型的对象。

集合框架的由来：
    
    容器很多，因为每个容器中的数据结构是不同的。
    数据结构：就是数据在容器中存储方式
 
    容器虽然因为结构有不同，但是都具备着共性，可以不断地向上抽取。
    就形成集合框架，该框架的顶层之一就是Collection接口。
    该接口中定义了集合框架中最共性的功能。
   
    最终使用的时候，其实使用的该框架最子类的对象。

Collection
            List：列表。
             特点：
              1，有序(存储元素的顺序和取出元素的顺序一致)
              2，该集合中的元素都有索引，所以可以通过索引(角标)来访问元素。
              3，它可以存储重复元素。 
   
         常见子类对象:记住：具体的子类对象，我们要学习应该是该对象的特有的数据结构，以及相关的特点。

         1，Vector:jdk1.0就存在了。底层是数组结构的。可变长度数组，
          原理：一旦原数组长度不够，会创建新数组，将原数组的元素复制到新数组中，并将新元素添加到新数组中。
           Vector是同步的。
         2，ArrayList:底层是数组结构，也是支持长度可变数组的。是不同步的。替代了Vector 查询效率高，但是增删的效率很低。
         3，LinkedList:底层是链接列表结构，简称链表结构。是不同步的。这个中结构的好处：对元素的增删非常效率很高。 查询的效率很低。
   
                Set：集：
                特点：
                1，不包含重复元素。(最大的特点)
                2，这个集合存入元素的顺序和取出元素的顺序不一定一致

              常见子类：

               1，HashSet：底层数据结构是哈希表，不保证顺序，是不同步的。
      
               特点：
                1，不关系元素的顺序。
                2，提高了查询效率。
                3，不可能出现重复元素，因为哈希值都不同。即使相同，会再次判断两个元素的equals，内容是否相同。
                      如果内容也相同，不存，如果内容不同，存储。
                      所以哈希表要保证元素的唯一性，必须要依赖于两个方法。
                     1,hashCode
                     2,equals 
        
              2，TreeSet：可以给Set集合中的元素进行指定顺序的排序。非同步的。 
      
               TreeSet排序的方式一：让元素自身具备比较性，需要实现Comparable接口，覆盖compareTo方法。
               这种比较方式成为自然顺序排序。
      
     
               这时只能用第二种方式 。
               TreeSet排序的方式二：让容器自身具备比较性。容器一初始化就具备了比较功能。
               因为容器时在对象构造时完成的。通过查阅，有一个构造方法TreeSet(Comparator).
               在容器初始化时可以指定一个比较器。
               需要实现Comparator接口，覆盖compare方法即可。
               所以这种方式成为比较器排序。

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

看一下collection中有哪些常用方法：

    Collection中常用方法
    1，添加方法。 
      boolean add(object e):一次添加一个元素。
      boolean addAll(Collection):将一个参数容器中的元素添加到当前容器中。
      
    2，删除方法。
      boolean remove(object):删除一个指定对象。 
      boolean removeAll(Collection):删除指定collection中和本Collection中相同的元素。 
      void clear():直接将集合中的元素清空。
    3，判断方法：
      boolean contains(object):是否包含指定元素。
      boolean containsAll(Collection):是否包含指定容器中的元素。 
      boolean isEmpty():是否有元素。
    4，获取元素个数：
      int size():获取元素有几个。
    5，取交集。
      boolean retainAll(collection):保留和指定collection集合中相同的元素，不相同的元素会被删除。
    6，将集合转成数组。
      Object[] toArray():
    7，取出元素的方法：
      Iterator iterator():

 迭代器：取出集合中元素的方式的一个对象。该对象本身就内置在容器中。
    
    如何获取到集合的迭代器呢？
    可以通过iterator()方法来完成。该方法返回一个Iterator类型对象。
    
    
    迭代器接口出现：将每一个容器中的取出方式进行了封装。并对外暴露。
    这样无论是什么容器或者数据结构，只要内部取出方式实现了Iterator接口，
    都可以通过该接口取出这些容器中的元素。
    
    它的出现，将容器的取出方式和容器的数据结构相分离，降低了耦合性。 
    而取出方式因为直接在访问容器中的元素，并依赖具体的数据结构，所以被定义在了容器中。
    通过内部类来实现Iterator接口。
    
  
    
    只要是Collection集合中的容器，迭代器是通用取出方式。

迭代器演示：

public class IteratorDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		 
		 * 
		 */
		
		//创建集合。 
		Collection coll = new ArrayList();
		//添加元素。
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		
		
		/*
		//获取该集合的迭代器对象。
		Iterator it = coll.iterator();
		
		//使用迭代器对象中的方法完成元素的获取。 
		while(it.hasNext()){
			System.out.println(it.next());
		}
		*/
		
		//将while改成for结构。开发的时候建议写for。
		for(Iterator it = coll.iterator(); it.hasNext(); ){
			System.out.println(it.next());
		}
		
//		System.out.println(it.next());
//		System.out.println(it.next());
//		System.out.println(it.next());//next()可以取出元素。而且自动往下取。
	}

}

 演示List子接口中的特有方法。
    因为该接口的特点是 对元素有索引标示。
    所以它的特有方法应该都是围绕着索引定义的。 
    
    1，添加：
     void add(index,element);
     boolean addAll(index,collection);
     
    2，删除：
     object remove(index):获取并删除。记住大家，增加或者删除方法的成功都会改变集合的长度。
    
    3，获取：
     获取元素：
     Object get(index):获取
     获取元素索引：
     int indexOf(object);
     int lastIndexOf(object);
     获取子列表：
     List subList(fromIndex,toIndex):获取列表中的一部分，包含fromIndex位置，不包含toIndex位置。
    
    4，修改。
     object set(index,element):替换指定位置的元素，并返回被替换掉的元素。
    
    我们发现，List接口是可以对元素进行增删改查的操作的。
    注意：只有这个集合具备着增删改查。具备的原因：因为有索引。

package cn.itcast.api.p1.list.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		
		
		listMethodDemo(list);
		getAllElements(list);
		
	}
	
	

	
	/*
	 * 需求：获取list集合中所有的元素。 
	 * 
	 */
	public static void getAllElements(List list){
		list.add("abc1");
		list.add("abc7");
		list.add("abc2");
		list.add("abc4");
		
		
		
		//迭代器。
//		Iterator it = list.iterator();		
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
		
		//遍历。通过索引完成。
		for(int x=0; x

treeset演示

package cn.itcast.api.p3.set.demo;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		TreeSet ts = new TreeSet();
		
		ts.add("haha");
		ts.add("xixi");
		ts.add("heihei");
		ts.add("hehe");
		ts.add("hohoh");
		ts.add("hiahia");
		
		Iterator it = ts.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}

}

 

HashSet

package cn.itcast.api.p3.set.demo;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		//创建容器。
		HashSet hs = new HashSet();
		
		hs.add("nba");
		hs.add("hahaha");
		hs.add("xixi");
		hs.add("abcd");
		
		Iterator it = hs.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}