黑马程序员--集合

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

1：集合
 (1)java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。
    而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能
    满足变化的要求。所以，java就提供了集合供我们使用。
 (2)集合的特点：
  A:长度可以发生改变
  B:只能存储对象
  C:可以存储多种类型对象(一般存储的还是同一种)
 (3)集合和数组的区别
  A:长度问题：数组固定；集合可变。
  B:存储元素问题：数组可以是基本类型，也可以是引用类型；集合只能是引用类型。
  C:是否同一类型：数组元素类型一致；集合元素类型可以不一致。
 (4)集合体系的由来
  集合是存储多个元素的容器，但是，由于数据结构不同，java就提供了多种集合类。
  而这多种集合类有共性的功能，所以，通过不断的向上抽取，最终形成了集合体系
  结构。

  数据结构：简单说就是数据存储的方式。

  集合体系：
  Collection(单列)
      List(有序,可重复)
         |--ArrayList底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
         |--Vector底层数据结构是数组，查询快，增删慢。线程安全，效率低。
         |--LinkedList底层数据结构是链表，查询慢，增删快。线程不安全，效率高。
   Set(无序,唯一)
         |--HashSet底层数据结构是哈希表。线程不安全，效率高。
         |--TreeSet底层数据结构是二叉树。线程不安全，效率高。
  Map(双列 底层结构是针对键有效，跟值无关)
         |--HashMap：底层数据结构是哈希表。线程不安全，效率高。允许null键和值。 
         |--Hashtable：底层数据结构是哈希表。线程安全，效率低。不允许null键和值。
         |--TreeMap：底层数据结构是二叉树。线程不安全，效率高。
  注：(1)HashSet、HashMap、Hashtable是如何保证元素的唯一性?
         它要重写两个方法：hashCode()和equals()。
         首先判断hashCode()值是否相同？
         相同：继续走equals()，看返回值
                    如果true：就不添加到集合。
                    如果false：就添加到集合。
         不同：就添加到集合。
 代码体现： 
  public int hashCode() {
  return this.name.hashCode() + this.age*13;//最大保证哈希值唯一
 }

public boolean equals(Object obj) {
  if (this == obj) {
   return true;
  }

  if (!(obj instanceof Student)) {
   return false;
  }

  Student s = (Student) obj;
  return this.name.equals(s.name) && this.age == s.age;
 }

        (2)TreeSet、TreeMap是通过比较方法的返回时是否是0来保证元素的唯一性。
       通过以下两种方法对元素排序。
       1，自然排序（元素具备比较性），实现Comparable接口。TreeSet无惨构造，要求对象所属的类实现Comparable接口。
  代码体现：
  @Override
  public int compareTo(Student s) {
  // 需求是比较年龄
  int num = this.age - s.age;
  // 由于对象有多个成员变量，不能根据其中的某一个决定其他的。
  // 当某一个相同的时候，还需要判断其他的是不是也是相同的。
  int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;
  return num2;
  }
       2，比较器排序（容器自身具备比较性），实现Comparator接口。TreeSet带参构造，要求构造方法接受一个实现类。
 代码体现<1>自定义一个类继承Comparator：
 public class MyComparator implements Comparator<Student> {
 @Override
 public int compare(Student s1, Student s2) {
  // 按年龄排序，从小到大
  int num = s1.getAge() - s2.getAge();
  // 次要条件
  int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
  return num2;
 }
}
 代码体现<2>采用匿名内部类：
 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
   @Override
   public int compare(Student s1, Student s2) {
    // 按年龄排序，从小到大
    int num = s1.getAge() - s2.getAge();
    // 次要条件
    int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
    return num2;
   }
  });

2：Collection的功能
  A:添加功能
   boolean add(Object obj):向集合中添加元素
   boolean addAll(Collection c):将一个集合中的元素添加到另一个集合中
  B:删除功能
   void clear():清除集合中的所有元素
   boolean remove(Object obj):清除集合中指定的元素
   boolean removeAll(Collection c):
  C:判断功能
   boolean isEmpty():判断集合石否为空
   boolean contains(Object obj):判断集合是否包含指定的元素
   boolean containsAll(Collection c):
  D:遍历功能
   Iterator iterator():迭代器
  E:长度功能
   int size():返回元素的个数
3：迭代器Iterator:所有Collection集合共性的取出方式，用来获取集合中的每一个元素。
  A:成员方法
    Object next():获取元素,并自动移动到下一个位置等待获取。
    boolean hasNext():判断迭代器中是否还有元素。
  B:迭代器原理
   由于多种集合的数据结构不同，所以存储方式不同，所以，取出方式也不同。
   这个时候，我们就把判断和获取功能定义在了一个接口中，将来，遍历哪种
   集合的时候，只要该集合内部实现这个接口即可。
  C:迭代器源码
   public interface Iterator
   {
    public abstract boolean hasNext();
    public abstract Object next();
   }

   public interface Collection
   {
    public abstract Iterator iterator();
   }

   public interface List extends Collection
   {
    ...
   }
   
   public class ArrayList implements List
   {
    public Iterator iterator()
    {
     return new Itr();
    }

    private class Itr implements Iterator
    {
     public boolean hasNext(){...}
     public Object next(){...}
    }
   }
   
4：应用。(添加功能，判断功能，删除功能，获取功能，长度功能)
 Collection
  A:添加功能(掌握)
   boolean add(Object obj):向集合中添加元素
   boolean addAll(Collection c):将一个集合中的元素添加到另一个集合中
  B:删除功能(掌握)
   void clear():清除集合中的所有元素
   boolean remove(Object obj):清除集合中指定的元素
   boolean removeAll(Collection c):
  C:判断功能(掌握)
   boolean isEmpty():判断集合石否为空
   boolean contains(Object obj):判断集合是否包含指定的元素
   boolean containsAll(Collection c):
  D:遍历功能(掌握)
   Iterator iterator():迭代器
  E:长度功能(掌握)
   int size():返回元素的个数
  
  |--List的特有功能
  A:添加功能
   void add(int index,Object obj):
  B:删除功能
   Object remove(int index):
  C:修改功能
   Object set(int index,Object obj):
  D:获取功能
   Object get(int index):
   int indexOf(Object obj):
   ListIterator listIterator():
  (2)ListIterator迭代器
   A:是Iterator的子接口。
   B:有自己的特有功能，可以逆向遍历数据，但是需要先正向遍历。一般不用。
  (3)注意问题：并发修改异常ConcurrentModificationException
   A:并发修改异常的产生原因
    用迭代器遍历集合时，用集合去操作集合。
   B:解决方案：
    a:使用集合操作。
    b:使用列表迭代器操作。 
  |--Set没有自己特有的方法，直接继承Collection

 Map接口功能(Map集合中的具体实现类的数据结构，是针对键有效。)
  A:增加功能
     V put(K key,V value):当key在集合中不存在时，添加元素；当key在集合存在时候，替换元素。
  B:删除功能
    void clear():清除所有键值对数据。
     V remove(Object key)：根据指定的键删除键值对。
  C:判断功能
     boolean containsKey(Object key):判断指定的键是否在集合中存在
    boolean containsValue(Object vlaue):判断指定的值是否在集合中存在
    boolean isEmpty():判断集合是否为空
  D:获取功能
     Set<Map.Entry<K,V>> entrySet():键值对对象的集合。
     Object get(Object key):根据键获取值
     Set<K> keySet():所有键的集合
     Collection<V> values()：所有值的集合
   E:长度功能
      int size()

5：遍历方式
 List:迭代器、增强for(开发中看到,JDK5以后用)、普通for。
  如果仅仅为了遍历，用任意一种即可。一般选择前两种的任意一种。
  如果要做修改，或者删除指定位置的元素，或者在指定位置添加元素。用普通for。
 Set:迭代器、增强for(是JDK1.5以后出现的)。
 Map:键找值。

6：遍历代码体现举例：
 A:
  ArrayList<String> array = new ArrayList<>();//采用泛型，此种写法符合JDK1.7新特性。
  ArrayList<String> array = new ArrayList<String>();//与上面的写法都可以，只不过上面的写法是JDK1.7新特性。

  方式1：
  Iterator<String> it = array.iterator();
  while(it.hasNext()){
   String s = it.next();
   System.out.println(s);
  }

  方式2：
  for(String s : array){
   System.out.println(s);
  }

  方式3：
  for(int x=0; x<array.size(); x++){
   String s = array.get(x);
   System.out.println(s);
  }

 B:
  HashSet<String> hs = new HashSet<String>();
 
  方式1：
  Iterator<String> it = hs.iterator();//根据上面迭代器源码这里是多态的体现。
  while(it.hasNext()){
   String s = it.next();
   System.out.println(s);
  }

  方式2：
  for(String s : hs)
  {
   System.out.println(s);
  }

 C:
  HashMap<String,Strting> hm = new HashMap<String,String>(); 
  Set<String> set = hm.keySet();
  for(String key : set)
  {
   String value = hm.get(key);
   System.out.println(key+"***"+value);
  }

7：什么时候用谁?
 是否键值对?
    是：Map
         是否对键排序?
               是：TreeMap
               否：HashMap

   否：Collection
       是否唯一
           是：Set
       是否对元素进行排序?
                   是：TreeSet
                   否：HashSet
          否：List
                  是否要安全：
                         是：Vector(真正开发中也不用)
                                List list = Collections.synchronizedList(new ArrayList());

                         否：ArrayList，LinkedList
                                查询多：ArrayList
                                增删多：LinkedList
8：Collections:
   是一个类，定义了针对Collection集合操作的功能。该类中的方法都是静态的，有排序，查找，反转等。
   Collections的功能：
   排序：public static void sort(List list)
   二分查找：public static <T> int binarySearch(List list,T key)
   反转：public static void reverse(List list)
   最大值：public static  T max(Collection coll)
   随机置换：public static void shuffle(List list)

9：在集合中的数据结构问题
 ArrayXxx:底层数据结构是数组。查询快，增删慢。
 LinkedXxx:底层数据结构是链表。查询慢，增删快。
 HashXxx:底层数据结构是哈希表。跟两个有关。hashCode()和equals()
 TreeXxx:底层数据结构是二叉树。两种排序方式。Comparable接口和Comparator接口

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