Java

Java - 集合

 

* 本节要点

1、Java 框架集合

2、Collection 接口API

3、Iterator 迭代器接口

4、Collection 子接口之一：Set接口

    > HashSet    LinkedHashSet  TreeSet

5、Collection 子接口之二：List接口

    > ArrayList    LinkedList    Vector

6、Map 接口

    > HashMap    TreeMap    Hashtable

7、Collections 工具类

---

一、Java 集合概述

    集合可以存储数量不等的多个对象，还可用于保存具有映像关系的关联数组，集合又被简称为容器

 

1、Java 集合分为两种体系：Collection 和 Map

    > Collection 接口

        > Set ：元素无序、不可重复的集合

        > List ：元素有序、可重复的集合

    > Map 接口 ：具有映射关系 "key - value对" 的集合，"key" 是唯一的

 

---

二、Collection 接口API

 

1、Collection 接口继承树

 

2、Collection 中的方法：

    > size()  -> 返回集合中的元素个数

    > add(Object obj)  -> 向集合中添加元素(任何类型的元素)

    > addAll(Collection coll)  -> 将coll中包含的所有元素添加到当前集合中

        Collection coll1 = Arrays.asList(1,2,3);

        coll.addAll(coll1);

    > isEmpty()  -> 判断这个集合是否为空，为空返回 True

    > clear()  -> 清空集合中的元素

    *  System.out.println(coll);  -> 查看集合中的元素

    > contains(Object obj)  -> 判断这个集合中是否包含指定的obj元素，如果包含返回 True

        如何存入集合中的元素是自定义类的对象，要求：自定义类重写 equals() 方法

    > containsAll(Collection coll)  -> 判断当前集合中是否包含coll中所有的元素

    > retainAll(Collection coll)  -> 保留当前集合与coll集合共同的元素，就是求当前集合和coll集合的交集，将结果返回给当前集合

    > remove(Object obj)  -> 删除集合中的某一个元素，删除成功返回True，如果返回False说明里面没有

    > removeAll(Collection coll)  -> 删除当前集合中包含coll集合的所有元素，返回Boolean值

    > equals(Object obj)  ->判断两个集合中的元素是否相同

    > hashCode()  -> 算一下集合中的hash值，返回一个整数，主要在Set中用的多点,到时候在具体了解这个方法

    > toArray()  -> 将集合转换成数组

        Object[] obj = coll.toArray(); 

    > iterator()  -> 用来遍历一个集合，返回一个Iterator接口实现类的对象

        Iterator iterator = coll.iterator();

        Iterator.hasNext();    // 判断是否有下一次元素

        iterator.next();    //     返回集合中的元素，调用几次，返回几个

 

---

四、Collection 子接口之一：Set接口

    HashSet(主要实现类)、LinkedHashSet、TreeSet

    > 存储无序的，Set中常用的方法都是Collection 下定义的 (无序 != 随机，添加的顺序和输出的顺序不一样，但是运行多少次得到的结果是有序的，

       真正的无序性指的是元素在底层存储的位置是无序的，底层实现如C语言的链表)

    > 不可重复的元素，当向Set中添加进相同的元素的时候，后面的这个不能添加进去

    > 说明：要求添加进Set中的元素所在类，一定要重写Object的equals() 方法和hashCode() 方法，进而保证Set中的元素的不可重复性

    > Set中添加元素时，采用 Hash算法，添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在

       Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals()方法比较这两个对象

       是否相同。如果相同，后一个对象就不能再添加进来

        > 要求：hashCode() 和 equals() 方法属性相同

 

1、HashSet() 中常用的方法都是Collection 中的方法

 

2、LinkedHashSet：使用链表维护了一个添加进集合中的顺序，导致当我们遍历LinkedHashSet 集合元素时，是按照添加进去的顺序遍历的

    > 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以 插入顺序保存的

    > 插入性能略低于 HashSet，但在迭代访问Set里的全部元素时，有很好的性能

    > 不允许集合元素重复

 

3、TreeSet

    > 只能添加同一类型的数据或对象

    > 无法插入相同的元素，并且插入的数据按照从小到大的顺序遍历

        当自定义类没有实现 Comparable 接口时，当向TreeSet 中添加对象时，会报 ClassCastException异常错误

    > 当向TreeSet 中添加自定义类的对象时，有两种排序方法：①自然排序、②定制排序

    > 自然排序：要求自定义类实现java.lang.Comparable 接口并重写其 compareTo(Object obj) 抽象方法，在此方法中，指明按照自定义类的那个属性进行排序

        > 向 TreeSet 中添加元素时，首先按照compareTo() 方法进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，但程序会认为这两个对象是相同的，进

           而后一个对象就不能添加进来

        > compareTo() & hashCode() & equals() 三者之间保持一致

    > 定制排序：要实现Comparator类

/*

  * TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！

  */

 @Test

 public void testTreeSet2() {

  // 1.创建一个实现了Comparator接口的类对象

  Comparator com = new Comparator() {

   // 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer

   // 的哪个属性排序的。

   @Override

   public int compare(Object o1, Object o2) {

    if (o1 instanceof Customer && o2 instanceof Customer) {

     Customer c1 = (Customer) o1;

     Customer c2 = (Customer) o2;

     int i = c1.getId().compareTo(c2.getId());

     if (i == 0) {

      return c1.getName().compareTo(c2.getName());

     }

     return i;

    }

    return 0;

   }

  };

  // 2.将此对象作为形参传递给TreeSet的构造器中

  TreeSet set = new TreeSet(com);

  // 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。

  set.add(new Customer("AA", 1003));

  set.add(new Customer("BB", 1002));

  set.add(new Customer("GG", 1004));

  set.add(new Customer("CC", 1001));

  set.add(new Customer("DD", 1001));

 

  for (Object str : set) {

   System.out.println(str);

  }

 }

 

---

五、Collection 子接口之二：List接口

 

1、List新增的方法;

List 的实现类：ArrayList、LinkedList、Verctor

    ArrayList : List的主要实现类，List中新增了很多方法：

   * 底层还是以数组实现

         > void add(int index, Object ele)

              在指定的索引位置添加元素 ，这种插入效率很低，如果在前面插入一个元素，后面的所有元素都要移位

         > boolean addAll(int index, Collection eles)

              在指定的索引位置添加一个eles集合

         > Object get(int index)

              获取指定索引位置的元素

         > int indexOf(Object obj)

              返回 obj 在集合中首次出现的位置，没有返回 -1

         > int lastIndexOf(Object obj)

              返回 obj 在集合中最后一次出现的位置，没有返回 -1

         > Object remove(int index)

              删除指定索引位置的元素，删除后，后面的数据依次往前挪

         > Object set(int index, Object ele)

              修改指定索引位置的元素为ele

         > List subList(int fromIndex, int toIndex)

              返回List中索引从 fromIndex 到 toIndex 的子集

    LinkedList 对于频繁的插入删除操作效率比ArrayList 高很多

    Verctor 已经被淘汰了

 

---

六、Map 接口

    > Map 与 Collection 并列存在，用于保存具有映射关系的数据：Key-Value

    > Map 中的 Key 和 Value 都可以是任何引用类型的数据

    > Map 中的 Key 用 Set 来存放，不允许重复，即同一个 Map 对象所对象的类，须重写 hashCode() 和 equals() 方法

    > 常用 String 类作为 Map 的 "Key"

    > Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value(Value 可以是重复的，Key是唯一的)。

    > 一个 Key-Value 被称为一个 Entry，所有的Entry 是用Set 存放的，是不可重复的

* HashSet 类是 HashMap 类的特殊实现

 

1、Map 接口继承树

        

    > TreeMap 按照添加进Map中的元素的 Key 的指定属性进行排序

    > HashMap (主要实现类)，Key 是用 Set 存放的，不可重复，Value 是用Collection 存放的，可以重复

        > 向HashMap 中添加元素时，会调用 Key 所在类的 equals(0 方法，判断两个 Key ***

    > Hashtable 已经几乎不用了，

        > Properties 比较常用，常用来处理属性文件，Key-Value都是String类型的

    > LinkedHashMap 使用链表维护添加进Map中的顺序，故遍历 Map 时是按添加的顺利遍历的

    

2、Map 方法：

    > Object put(Object key, Object value)  -> 向Map中添加一个元素

    > Object remove(Object key)  -> 按照指定的e Key 值删除此 Key-Value

    > void putAll(Map t)

    > void clear()  -> 清空

    > Object get(Object key)

    > boolean containsKey(Object key)

    > boolean containsValue(Object value)

    > int size()  -> 返回集合的长度

    > boolean isEmpty()  -> 判断集合是否为空

    > boolean equals(Object obj)

    > keySet()  -> 遍历 Key 集

        Set set = map.keySet();

        for (Object obj : set){

            Ssytem.out.println(obj);

        }

    > values()  -> 遍历 Value 集

        Collection values = map.values();

        Iterator i = values.iterator();

        while (i.hasNext()){

            System.out.println(i.next());

        }

    > entrySet()  -> 遍历 Key - Value 对

 

3、如何遍历 Key - Value 对：

    ① 方式一

    Set set1 = map.keySet();

    for (Object obj : set1){

        System.out.println("Key : " + obj + "<-->" + "Value: " + map.get(obj));

    }

    ② 方式二

    Set set2 = map.entrySet();

    for (Object obj : set2){

        Map.Entry entry = (Map.Entry) obj;

        System.out.println(entry);

    }

 

4、使用Properties处理属性文件

 @Test

 public void test6() throws FileNotFoundException, IOException{

  Properties pros = new Properties();

  pros.load(new FileInputStream(new File("jdbc.properties")));

  String user = pros.getProperty("user");

  System.out.println(user);

  String password = pros.getProperty("password");

  System.out.println(password);

 }

 

---

七、Collections 操作集合的工具类

 * Collection 和 Collections 是有区别的

    > Collections 可以操作 Collection 以及Map

   

1、常用方法：

    > reverse(List)，反转List中元素的顺序

    > shuffle(List)，对List 集合元素进行随机排序

    > sort(List)，根据元素的自然顺序对指定List 集合元素按升序排序

    > sort(List，Comparator)，根据指定的 Comparator 产生的顺序对List 集合元素进行排序

    > swap(List, int i, int j)，将指定List 集合中的 i 处元素和 j 处元素进行交换

    > Object max(Collection)，根据元素的自然顺序，返回给定集合中的最大元素

    > Object max(Collection, Comparator)，根据 Comparator 指定的顺序，返回给定集合中的最大元素

    > Object min(Collection)，根据元素的自然顺序，返回给定集合中的最小元素

    > Object min(Collection, Comparator)，根据 Comparator 指定的顺序，返回给定集合中的最小元素

    > int frequency(Collection, Object)，返回指定集合中指定元素的出现次数

    > void copy(List dest, List src)，将 src 中的内容复制到 dest 中

    > boolean replaceAll(List list, Object oldVal, Object newVal)，使用新值替换 List 中的旧值