程序员

集合框架1-集合框架总述

2017-11-07  本文已影响32人  偏偏注定要落脚丶
I. 完整的容器分类法
集合框架分类.jpg

上图不包括Queue的内容，部分Map实现类未给出。

简单的表格分类.jpg
II. 容器各层次常用方法

  数组是保存一组对象的最有效的方式，如果要保存一组基本类型数据，也推荐使用这种方式(数组既可以存储基本类数据也可以存储引用类型数据)。但是数组具有固定尺寸，而在更一般的情况中，程序并不知道将需要多少个对象，或者是否需要更复杂的方式来存储对象，因此数组尺寸固定这一限制显得过于受限了。
 Java 提供了一套相当完整的容器类来解决这个问题，其中基本类型是 List、Set 、Queue和Map。 这些对象类型也称为集合类，但由于Java的类库中使用了Collection这个名字来指代该类库的一个特殊子集，所以我们使用范围更广的术语容器(Container)来称呼它们。

1. Collection

Collection 是容器的一个根接口。封装了Collection子接口(类)的共性方法。其常用方法有:

collection中的方法演示：

import java.util.ArrayList;
import java.util.Collection;

/**
 * @Author: 落脚丶
 * @Date: 2017/10/16
 * @Time: 上午9:38
 * @ClassName: CollectionDemo
 * @Description: 演示collection接口中的方法。
 */
public class CollectionDemo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        Collection collection1 = new ArrayList();
        Collection collection2 = new ArrayList();
        show(collection);
        show(collection1,collection2);

    }
    public static void show(Collection collection){
        // 1. 添加元素。add
        collection.add("abc1");
        collection.add("abc2");
        collection.add("abc3");
        System.out.println(collection);// 集合直接打印以字符串输出
        /**
         * 输出结果：[abc1, abc2, abc3]
         */

        // 2. 删除元素。remove
        collection.remove("abc2"); // 会改变集合长度
        System.out.println(collection);// 集合直接打印以字符串输出
        /**
         * 输出结果：[abc1, abc2, abc3]
         */

        // 清空
        // collection.clear();
        // System.out.println(collection);// 集合直接打印以字符串输出
        /**
         * 输出结果：[]
         */

        // 3. 包含
        System.out.println(collection.contains("abc3"));
        System.out.println(collection.contains("abc4"));
        /**
         * 输出结果：true  false
         */
    }

    public static void show(Collection collection1, Collection collection2){
        // 给collection1添加元素
        collection1.add("abc1");
        collection1.add("abc2");
        collection1.add("abc3");
        collection1.add("abc4");

        // 给collection2添加元素
        collection2.add("abc2");
        collection2.add("abc6");
        collection2.add("abc7");

        System.out.println("collection1:" + collection1);
        System.out.println("collection2:" + collection2);
        /**
         * Output:
         * collection1:[abc1, abc2, abc3, abc4]
         * collection2:[abc2, abc6, abc7]
         */

        // 演示addAll
        collection1.addAll(collection2); // 将collection2元素添加collection1中。
        System.out.println("collection1:" + collection1);
        /**
         * Output:
         * collection1:[abc1, abc2, abc3, abc4, abc2, abc6, abc7]
         */

        // 演示removeAll
        boolean b = collection1.removeAll(collection2); 
        // 将两个collection中相同元素从collection1中删除
        System.out.println("removeAll:" + b);
        System.out.println("collection1:" + collection1);
        /**
         * Output:
         * removeAll:true
         * collection1:[abc1, abc3, abc4]
         */

        // 演示retainAll
        boolean b = collection1.retainAll(collection2); 
        // 将两个collection中不相同元素从collection1中删除
        System.out.println("retainAll:" + b);
        System.out.println("collection1:" + collection1);
        /**
         * Output:
         * retainAll:true
         * collection1:[abc2]
         */

    }
}

collection迭代器演示：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @Author: 落脚丶
 * @Date: 2017/10/16
 * @Time: 上午10:15
 * @ClassName: IteratorDemo
 * @Description: 迭代器演示
 */
public class IteratorDemo {
    public static void main(String[] args){
        Collection collection = new ArrayList();
        collection.add("abc1");
        collection.add("abc2");
        collection.add("abc3");
        collection.add("abc4");

        // 使用Collection中的iterator()方法。调用集合迭代器方法，
        是为了获取集合中迭代器对象。
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) { // while循环后iterator对象依然存在
            System.out.println(iterator.next());
        }
        /**
         * Output:
         * abc1
         * abc2
         * abc3
         * abc4
         */

        for (Iterator iterator = collection.iterator(); iterator.hasNext(); ){
            System.out.println(iterator.next());
        }
        // for循环结束后iterator会被释放
    }
}

1.1 List
List特点：

List特有的常见方法：有一个共同特点是可以操作下标。

1.1.1 Vector
JDK1.0的时候只有Vector，JDK1.2以后才有 List。
内部是数组数据结构，长度可变(默认长度为 10，百分之百延长)，是同步的(同步会降低速度)。
可变长度的实现是重新创建新的数组。

Vector常见特有的方法:

1.1.2 ArrayList
内部是数组数据结构，长度可变(百分之五十延长)，是不同步的。替代了 Vector。查询元素的速度很快。

1.1.3 LinkedList
内部是链表数据结构，是不同步的。增删元素的速度很快。

LinkedList 特有的方法:

此处方法未全部列举。链表对头和尾的操作最明显。

1.2 Set

Set特点:

1.2.1 HashSet

1.2.2 TreeSet

2. Map

Map特点：

Map常用方法:

Map常用方法演示：

import java.util.*;

/**
 * @Author: 落脚丶
 * @Date: 2017/11/8
 * @Time: 下午6:57
 * @Description: Map方法演示
 */
public class MapDemo {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        // methods(map);
        // keySetDemo(map);
        entrySetDemo(map);
    }
    public static void methods(Map<Integer,String> map) { // 学号和姓名
        // 添加元素
        System.out.println(map.put(8, "wang"));
        System.out.println(map.put(8, "li"));
        map.put(2, "Sam");
        map.put(7, "Jean");
        System.out.println(map);


        /**
         * Output:
         * null
         * wang
         * {2=Sam, 7=Jean, 8=li}
         */

        // 删除
        System.out.println("remove:" + map.remove(2));
        System.out.println(map);

        /**
         * Output:
         * remove:Sam
         * {7=Jean, 8=li}
         */

        // 获取
        System.out.println("get:" + map.get(6));
        System.out.println("get:" + map.get(8));
        /**
         * Output:
         * get:null
         * get:li
         */
    }

    /**
    * @Date: 2017/11/8
    * @Time: 下午7:18
    * @Method: keySetDemo
    * @Description: 演示keySet()方法
    */
    public static void keySetDemo(Map<Integer,String> map) {
        map.put(2, "Sam");
        map.put(8, "Jane");
        map.put(6, "Sun");
        map.put(7, "Ben");
        /**
         * 取出map中的所有元素
         * 原理：通过keySet方法获取map中所有键的集合Set，再通过Set的迭代器取到每一个键
         * 通过每一个键可以获取其对应的值
         */
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            String value = map.get(key);
            System.out.println(key + ":" + value);
            /**
             * 2:Sam
             * 6:Sun
             * 7:Ben
             * 8:Jane
             */
        }
    }

    /**
    * @Date: 2017/11/8
    * @Time: 下午7:29
    * @Method: entrySetDemo()
    * @Description: 演示entrySet()方法
    */
    public static void entrySetDemo(Map<Integer,String> map) {
        map.put(2, "Sam");
        map.put(8, "Jane");
        map.put(6, "Sun");
        map.put(7, "Ben");
        /**
         * 通过Map转成Set就可以迭代
         * 使用方法entrySet()
         * 该方法返回映射关系对象到Set中，这个映射关系的类型就是Map.Entry类型
         * 通过Map.Entry中的getKey()、getValue()方法获取键和值
         */
        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer,String> me = iterator.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key + ":" + value);

            /**
             * 2:Sam
             * 6:Sun
             * 7:Ben
             * 8:Jane
             */
        }
    }
}

2.1 Hashtable

2.2 HashMap

2.3 TreeMap

上一篇 下一篇

猜你喜欢

热点阅读