黑马程序员-集合

---------------------- android培训、java培训、期待与您交流！ ----------------------

1、 和数组的区别：

长度可变，只能存储对象。

2、  集合框架：

每种框架存储数据的方式不同，（即数据结构不同）

3、  内存中的存储：

存储的是对象的引用（地址）。

4、迭代器：

    集合的输出方式。迭代器被定义为集合中的一个私有类并实现了Iterator接口。容器的数据结构不同，集合中取出对象的方式细节就不同，所共性的是判断和取出，并定义在Iterator接口中。

hashCode()方法和以哈希算法为底层数据结构存取对象的集合(HashSet和HashMap)。

       这些集合内部采用对某个数字n进行取余的方式，对存储的对象进行分组和划分存储区域，当要查找某个对象时，java系统首先调用该对象的hashCode()方法取得该对象的哈希码，然后根据哈希码找到相应的存储区域。然后取出该区域内的每个元素与该对象进行比较。提高了查询的效率。

注意：

       1、 通常来说，一个类的两个实例对象调用equals()方法比较的结果相等时，他们的哈希码也必须相等，但反之则不成立。及equals()方法比较结果不相等的两个对象可以有相等的哈希码。或者说哈希码相同的两个对象的equals()方法比较的结果可以不等。

      2、当一个对象被存储进HashSet或HashMap中厚，就不能改变这个对象中参与hashCode()运算的字段的值。否则，对象修改后的哈希值与最初存储进集合中的对象的哈希值就不同了，在这种情况下，这个对象将不能被查询(contains(该对象的引用)方法)到，也不能被删除，从而造成内存溢出。

 List：

5、List：（判断删除的依据）(自定义类必须重写equals方法)

         判断元素是否相同，（contain（）等方法比较时调用的是equals方法）自定义类必须重写equals方法有序（存入和取出的顺序相同），元素可以重复。List接口特有方法：可以操作角标的方法

      |-ArrayList：底层的数据结构使用的是数组结构：查询快，增删稍慢，线程不同步（自定义类型重写：equalsf方法）

       |-LinkedList：底层的数据结构使用的是链表：查询慢，增删快，注意：jdk1.6开始对其中的remove，get方法进行了替换，防止发生异常。（自定义类型重写：equals方法）

       |-Vector：底层的数据结构使用的是数组结构：查询慢，增删也慢，线程同步被ArrayList取代。特有输出方式Eumeration枚举。

ArrayList应用：

package org.cc.collection;

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

class Person {//自定义Person类，从写父类的equals()方法
 private String name;
 private int age;

 public Person(String name, int age) {
  this.name = name;
  this.age = age;
 }

 public String toString() {
  return "name.." + this.name + "  age.." + this.age;
 }

 public boolean equals(Object obj) {
  if (!(obj instanceof Person))
   return false;
  Person p = (Person) obj;
  return this.name.equals(p.name) && this.age == p.age;//比较当姓名和年龄相等时为相同对象
 }
}

public class ArrayListDemo {
 public static void main(String[] str) {
  List<Person> arr = new ArrayList<Person>();
  arr.add(new Person("chenchao", 23));
  arr.add(new Person("chao", 24));
  arr.add(new Person("chen", 32));
  arr.add(new Person("chao", 24));
  arr.add(new Person("chen", 32));

  sop(arr);
  arr = SingalA(arr);
  sop(arr);

 }

 public static ArrayList<Person> SingalA(List<Person> a) {//去掉ArrayList集合中的重复元素
  ArrayList<Person> newa = new ArrayList<Person>();
  Iterator<Person> i = a.iterator();
  while (i.hasNext()) {
   Person p = i.next();
   if (!newa.contains(p))
    newa.add(p);
  }
  return newa;
 }

 public static void sop(List<Person> a) {//输出集合中的元素
  Iterator<Person> i = a.iterator();
  while (i.hasNext()) {
   System.out.println(i.next());
  }
 }
}
7、ListIterator:

ListIterator是Iterator的子接口，

在迭代时，不能用集合对象的方法对集合元素进行操作。会发生异常（集合和迭代器并发操作）。所以在迭代时只能用迭代器的方法操作集合元素，

ListIterator能提供比Iterator(判断、删除、取出)更多的操作集合元素的方法（增删改查）。通过List集合的ListIterator（）取得，a)        删除元素：

删除时是删除对对象的引用，对象本身还存在。

       Set：（判断删除以及唯一性的依据）(加入元素相同时，不能加入)

              无序，不包含重复元素。

1、 hashSet：判断删除以及唯一性的依据

     a)        底层使用的数据结构是哈希表，根据哈希值存储。

     b)       （判断删除以及唯一性的依据）实现Object中的hashCode（）和equals（）

     c)        加入自定义类型时,自定义类型要复写Object中的hashCode（）和equals（）方法。其中hashCode（）方法返回值尽量唯一，可提高存储效率，

因为：

hashSet在添加元素时，先判断hashCode值是否相等，不等则加入，相等再判断equals（）方法。（判断元素是否存在，以及删除等操作同理）

2、 treeSet：判断删除以及唯一性的依据（实现排序两种方式）

     a)        底层使用的数据结构是二叉树，

     b)       取出时先取小的。

     c)        （集合中元素自身具备比较性）自定义类实现Comparable接口的comparableTo（）方法。

     d)       当集合中元素自身不具备比较性，或者具备的比较性不是所需的比较性时，这时需要是容器自身具备比较性。

定义一个类实现Comparator接口中的compare（T  o1，T  o2）方法，将定义类的对象作为参数传递给容器的构造方法。

     e)        当两种排序都存在时以比较器为准。

TreeSet集合中存储自定义类时，按元素的自然顺序排序，自定义类要实现Comparable接口，复写父类中的equals方法

 @Override
 public boolean equals(Object obj) {
  if (!(obj instanceof SetPerson))
   return false;
  SetPerson sp = (SetPerson) obj;
  if (this.name.equals(sp.name) && this.age == sp.age)
   return true;
  else
   return false;
 }

 @Override
 public int compareTo(SetPerson sp) {
  int num = new Integer(this.age).compareTo(new Integer(sp.age));
  if (num == 0)
   return this.name.compareTo(sp.name);
  return num;
 }

  Map：（加入键值相同时，则覆盖value值，返回被覆盖的值）

1、 存储一对值，键值唯一。

2、hashTable:底层是哈希表数据结构，不可以存入null键null值，线程同步，效率低

3、hashMap：底层是哈希表数据结构，允许存入null键null值，线程不同步，效率高

4、treeMap。底层是二叉树数据结构，线程不同步，可用于对键值进行排序。

5、 输出方式：

       a) 通过keySet()获得Iterator实例然后获得每个键值。（取键值的Set集合）

       b) 通过entrySet（）获得装有Map集合中每对值的关系的Map.Entry的Set集合，然后通过迭代器Iterator遍历每个Map.entry实列entry.getKey(),entry.getValue()。（取Map.Entry关系的Set集合）

      c) foreach输出

说明：

Map.Entry：Entry是一个定义在Map中的static接口。Map的子类实现Map接口并在内部实现了Entry接口，将Entry这种关系存于Set集合中。

通过Map接口子类的entrySet()方法返回。

6、 表示一对多的映射关系。Map中嵌套Map，Map中嵌套List等。

集合工具类：

Collections：

      a) <T extendsComparable<? super T>> voidsort(List<T> list)

           i.根据元素的自然顺序对指定列表按升序进行排序

      b) <T> voidsort(List<T> list,Comparator<? super T> )

           i.根据指定比较器产生的顺序对指定列表进行排序          

      c)<T extendsObject &Comparable<? super T>> Tmax(Collection<? extends T> coll)

          i.根据元素的自然顺序，返回给定 collection的最大元素

      d)max(Collection<? extendsT> coll,Comparator<? super T> comp)

          i.根据指定比较器产生的顺序，返回给定 collection的最大元素

      e) binarySearch(List<? extendsComparable<? super T>> list, T key)

          i.使用二分搜索法搜索指定列表，以获得指定对象   

      f)static voidreverse(List<?> list)

         i. 反转指定列表中元素的顺序

      g)static <T>Comparator<T>reverseOrder()

          i.返回一个比较器，它强行逆转实现了Comparable接口的对象collection的自然顺序

      h)<T> Comparator<T>reverseOrder(Comparator<T> cmp)

          i.返回一个比较器，它强行逆转指定比较器的顺序

      i)集合同步：将不同步的集合框架变成同步的集合框架。

     j)集合转数组：限定对集合元素的操作，不需要增加删除。

 基于数组的APIß----------à基于集合的API：

       Arrays：

       a)数组转集合：好处是使用集合中的一些方法

          i.Arrays.asList()（转后不能调用集合增删方法）因为数组长度固定

         ii.当数组的元素为对象时直接转为集合元素。

         iii.当数组的元素为基本数据类型时，将数组作为集合元素。   

      b)集合转数组：限制对集合元素的操作：如：增删

           i.  Collection中的toArray方法

           ii.指定类型数组的长度多少？

当指定类型的数组长度小于集合的size时，那么该方法内部会创建一个新的数组，长度为集合的 size当指定类型的数组长度大于集合的size时，就不会创建新的数组，而是使用传递进来的数组所以传递一个长度刚刚好的的数组最佳。

 

---------------------- android培训、java培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net/heima