java中的集合

集合类的由来：

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

集合特点： 

    1.用于存储对象的容器。

    2. 集合的长度是可变的。

    3. 集合中间不可以存储基本数据类型。

 各个集合不断向上抽取，就形成了最顶端的collection(java.util中) ，集合体系中所有的共性内容都在这里。

集合容器因为内部的数据结构的不同，有多种具体容器，不断向上抽取，就形成了集合框架。

框架的顶层： collection接口：

    常见方法：

     1.添加

        boolean add(Object e)    增加一个 

        boolean addAll(Collection coll) 增加一堆

       2.删除

        boolean remove(Object e)  删除一个

        boolean removeAll(Collection cott) 删除一堆

        void clear()    清空全部内容，集合还存在

       3. 判断

        boolean contains(Object o) 

        boolean contailsAll(Collection coll)

        boolean isEmpty()  判断集合是否为空,比较的是集合的长度。

     4 . 获取

        int size()   获取长度。

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

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

  5. 其它

    boolean retainAll(Collection coll)   取交集。

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

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

Collection 中的几个子接口。

    List接口：有序 ，存入和取出的顺序一致，元素都有索引(角标)，元素可以重复。

    Set 接口 ： 无序，元素不可以重复

   List特有的常见方法: （不提继承collection的方法），特有方法的共同特性是可以操作角标

     1.添加    

            void add(int index,Object o)  指定位置插入元素

     2. 删除  

            Object remove (int index)  指定位置删除元素，并返回该元素。

    3. 修改

        Object set(int index,Object o)  修改指定位置元素，返回的是改之前的位置的元素。

    4. 获取

        Object get(int index)  

        int indexOf(Object o)

        int lastindexOf(Object o)

        List subList(int start,int end) 获取部分元素的list集合

 List中三个常用对象：

    1 --Vector 内部是数组结构，是同步的(线程安全)，已经不常用了，增删改查都很慢。

    2. --ArrayList  内部是数组结构，是不同步的(效率高)，替代了Vector。查询速度快，推荐在单线程中使用

    3. --LinkedList 内部是链表结构，不同步，增删改查速度很快。

         jdk1.6以后，LinkedList中的这些方法有了另一种同样功能的方法，只不过返回值不同。

               void addFirst() ;        jdk1.6以后，boolean offerFirst()

                void addLast() ;                           boolean offerLast()

                E  getFirst()

                E  getLast() 获取但不移除，若链表为空，抛出NoSuchElementException

             jdk1.6以后，  E peekFirst()  

                                   E peekLast() 获取但不移除，若链表为空，返回Null

            removeFirst()

            removeLast()  获取并移除，若链表为空，抛出NoSuchElementException

          jdk1.6以后，pollFirst()

                               pollLast() 获取并移除，若链表为空，返回Null

  Set：元素不可以重复，是无序的

       Set接口中的方法和Collection中一致。

    常用的实现类：

      1 -- HashSet： 内部数据结构是哈希表，是不同步的    

            请注意:add()存入的元素是如何实现并保障元素不重复的？

                --- 哈希算法。 先判断哈希值(由hashcode() 算出)，若相同，在调用Object中的equals()方法比较

                哈希表确定元素是否相同：

                    1) 判断的是两个元素的哈希值是否相同，如果相同，在判断两个对象的内容是否相同。

                    2）判断哈希值是否相同，调用的是对象的hashcode()方法，判断内容相同用的是equals()方法，用的是Object中的equals(比较的是地址)。 注意：如果哈希值不同，则不需要判断equals的，直接就返回false了。

    1 --- TreeSet ：  可以对set集合中的元素进行排序，是不同步的。

                 判断元素唯一性的方式，就是根据 比较方法的返回值是否为0，若是0，就表明是相同元素，不存。

    TreeSet对元素进行排序的两种方式：

        1）让元素自身具备比较功能 

                这就需要实现Comparable接口，覆盖compareTo方法，如下所示：

class Person implements Comparable
{

	private String name;
	private int  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;
	}
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	
	//覆盖Comparable中的compareTo方法
	
	public int compareTo(Object o) {
	   return accordAge(o);
	}
	
	public int accordAge(Object o) {
		Person p =(Person_1)o;
		int temp = this.age-p.age;//根据年龄排序?
		return temp == 0?this.name.compareTo(p.name):temp;
	}   }

  如果不想按照对象中具备的自然顺序进行排序，又或对象中不具备自然顺序，怎么办？

        使用第二种方式

        2) 使 集合自身具备比较功能。

            自定义一个类，实现Comparator接口，覆盖compare()方法，将该类对象作为参数传递给TreeSet集合的构造方法

     

class ComparatoByName implements Comparator//此类实现Comparator
{
	public int compare(Object o1, Object o2) {
		Person_1 p1 = (Person_1)o1;
		Person_1 p2 = (Person_1)o2;
		
		int temp = p1.getName().compareTo(p2.getName());
		return temp == 0?p1.getAge()-p2.getAge():temp;
	}
}

------------------ ---- Map集合  ------------- ----

 了解Map前， 有必要先了解下  泛型，如不了解，请看下面的文章：java中的泛型

 Map：一次添加一对元素，Collection一次添加一个元素。Map也称为双列集合，Collection集合称为单列集合，其实map集合中存储的就是键值对。  map集合必须保证键的唯一性。

 常用方法： 

    1. 添加：   value   put(key,value)   返回前一个可key关联的值，如果没有，就返回Null

    2. 删除    void clear() 

                   value remove(key) 根据指定的key删除这个键值对。

    3. 判断

        boolean containsKey(key)  // 是否包含键

        boolean containsValue(value) //是否包含键值

        boolean isEmpty()     比较的是长度。

    4. 获取

        value get(key)   通过键获取值，如果没有返回null。可以通过返回空判断是否包含指定键

        int size()  获取键值对的个数。 

 Map常用的子类：

        1 -- Hashtable ：内部是哈希表，是同步的，不允许null。

               -- Properties 用来存储键值对类型的配置文件的信息，通常和IO技术配合。

        1 -- HashMap： 内部是哈希表，是不同步的，允许null

        1 -- TreeMap 内部是二叉树，不是同步的，可以对Map集合进行排序。

 使用集合的一些技巧：

    需要唯一吗？

        需要 ：Set

                需要指定顺序吗

                    需要： TreeSet

                    不需要： HashSet

                       需要一个和存储一致的顺序(有序) LinkedHashSet

            不需要：List

                需要频繁增删吗？

                        需要：   LinkedList

                        不需要 ： ArrayList

    如何记住每个容器的结构和所属的体系呢？
看名字？
List
1--ArrayList
1--LinkedList
Set
1--HashSet
1--TreeSet
后缀名就是该集合所属的体系。
前缀名就是该集合的数据结构。
看到Array就要想到数组，就要想到查询数据快、有角标。
看到link；就要想到链表，就要想道增删快，就要想道add，get，remove+ first，last的方法。
看到Hash就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖Hashcode和euqals方法。
看到tree就要想到二叉树，就要想到排序，就要想到两个接口，Comparable和Comparator。

而且通常这些常用的集合容器都是不同步的，eg Vector

--工具类的使用--

    List集合中提供了一个方法：

/** 指定者（）方法需要传入一个指定类型的数组。
		*数组长度应如何定义呢？
		*如果长度小于集合的大小，那么该方法创造一个同类型并集合相同大小的数组。
		*如果长度大于集合的大小，那么该方法就会使用指定的数据，存储集合的元素，其他位置
		*默认为null;
		*所以建议使用集合的大小
		* */
		
		public <T> T [] toArray（T [] a）//：将集合变成数组

阵列中提供的一个与集合有关的方法：

/** 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为
		*集合中的元素进行集合存储。
		*如果数组中的元素是基本类型数值，那么会将该数组作为集合的元素进行存储。

**/
		int [] arr = {31,11,61,51};
		List list = Arrays.asList(arr);

java中也提供了一个Collections的类，封装了一些已经实现好的方法：

    -- 是集合框架的工具类，里面的方法都是静态的。

常用方法如下：

//  根据指定的比较器，取出集合中最大值
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)		
// 将集合中的元素打乱，随机安放 。
 public static void shuffle(List<?> list)
//反转集合
public static <T> Comparator<T> reverseOrder()
 // 根据指定比较器反转集合
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

// 将 集合变成一个枚举类型 
public static <T> Enumeration<T> enumeration(final Collection<T> c)