三个小任务掌握List、Set、Map

任务一：

ArrayList、Vector 和 LinkedList 都实现了 List 接口，对它们分别进行如下操作后比较它们的不同，然后形成初步耗时报告（三种不同 List 的耗时）：

追加元素（追加一万次）；

添加元素到任意位置（添加一万次）；

分别使用 for 循环、forEach 循环、迭代器进行遍历；

删除任意位置的元素（删除一万次）。

public class ListDemo {

    //add 追加

    public void addArrayList(){

        //追加元素一万次耗时

        ArrayList<Integer> a1 = new ArrayList<Integer>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

            a1.add(i);

            //在同一位置追加

            // a1.add(1);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("ArrayList追加一万次记录耗时："+(endTime-startTime)+"毫秒");

    }

    public void addVector(){

        //Vector追加一万次耗时

        Vector<Integer> v1 = new Vector<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

           v1.add(i);

            //在同一位置追加

           // v1.add(1);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("Vector追加一万次记录耗时："+(endTime-startTime)+"毫秒");

    }

    public void addLinkedList(){

        //LinkedList追加一万次记录耗时

        LinkedList<Integer> link1 = new LinkedList<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10000; i++) {

           link1.add(i);

            //在同一位置追加

           // link1.add(1);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("LinkedList追加一万次记录耗时："+(endTime-startTime)+"毫秒");

    }

    //traverse 遍历

    public void traverseArrayList(){

        System.out.println("ArrayList的三种遍历方式：");

        //创建ArrayList集合

        ArrayList<String> a1 = new ArrayList<>();

        //添加元素

        a1.add("从前有座山");

        a1.add("山上有座庙");

        a1.add("庙里有个小和尚在敲代码");

        //for 循环遍历

        System.out.println("for循环遍历：");

        for (int i = 0; i < a1.size(); i++) {

            System.out.println(a1.get(i));

        }

        //foreach 遍历

        System.out.println("foreach 遍历：");

        for (String s:a1) {

            System.out.println(s);

        }

        //iterator(迭代器遍历)

        System.out.println("iterator 遍历：");

        Iterator<String> iterator = a1.iterator();

        while (iterator.hasNext()){

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

        }

    }

    public void traverseVector(){

        System.out.println("Vector的三种遍历方式：");

        //创建Vector集合

        Vector<String> v1 = new Vector<>();

        //添加元素

        v1.add("从前有座山");

        v1.add("山上有座庙");

        v1.add("庙里有个小和尚在敲代码");

        //for 循环遍历

        System.out.println("for循环遍历：");

        for (int i = 0; i < v1.size(); i++) {

            System.out.println(v1.get(i));

        }

        //foreach 遍历

        System.out.println("foreach 遍历：");

        for (String s:v1) {

            System.out.println(s);

        }

        //iterator(迭代器遍历)

        System.out.println("iterator 遍历：");

        Iterator<String> iterator = v1.iterator();

        while (iterator.hasNext()){

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

        }

    }

    public void traverseLinkedList(){

        System.out.println("LinkedList的三种遍历方式：");

        //创建LinkedList集合

        LinkedList<String> link = new LinkedList<>();

        //添加元素

        link.add("从前有座山");

        link.add("山上有座庙");

        link.add("庙里有个小和尚在敲代码");

        //for 循环遍历

        System.out.println("for循环遍历：");

        for (int i = 0; i < link.size(); i++) {

            System.out.println(link.get(i));

        }

        //foreach 遍历

        System.out.println("foreach 遍历：");

        for (String s:link) {

            System.out.println(s);

        }

        //iterator(迭代器遍历)

        System.out.println("iterator 遍历：");

        Iterator<String> iterator = link.iterator();

        while (iterator.hasNext()){

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

        }

    }

    //remove 删除

    public void removeArrayList(){

        //创建集合

        ArrayList<Integer> a1 = new ArrayList<>();

        //添加一万个记录

        for (int i = 0; i < 10000; i++) {

            a1.add(i);

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除操作

        for (int i = 0; i < a1.size(); i++) {

            a1.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("ArrayList删除一万记录耗时："+(endTime -startTime)+"毫秒");

    }

    public void removeVector(){

        //创建集合

        Vector<Integer> v1 = new Vector<>();

        //添加一万个记录

        for (int i = 0; i < 10000; i++) {

            v1.add(i);

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除操作

        for (int i = 0; i < v1.size(); i++) {

            v1.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("Vector删除一万记录耗时："+(endTime -startTime)+"毫秒");

    }

    public void removeLinkedList(){

        //创建集合

        LinkedList<Integer> link = new LinkedList<>();

        //添加一万个记录

        for (int i = 0; i < 10000; i++) {

            link.add(i);

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除操作

        for (int i = 0; i < link.size(); i++) {

            link.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("LinkedList删除一万记录耗时："+(endTime -startTime)+"毫秒");

    }

    @Test

    public void test(){

        addArrayList();

        addVector();

        addLinkedList();

        traverseArrayList();

        traverseVector();

        traverseLinkedList();

        removeArrayList();

        removeVector();

        removeLinkedList();

    }

}

任务二：

HashSet 和 TreeSet 都实现了 Set 接口，对它们分别进行如下操作后比较它们的不同，然后形成初步耗时报告（两种不同 Set 的耗时）：

添加元素（添加一万次）；

分别使用 forEach 循环、迭代器进行遍历；

删除任意位置的元素（删除一万次）

public class SetDemo {

    //追加

    public void addHashSet(){

        //创建 HashSet集合

        HashSet<Integer> hashset = new HashSet<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            hashset.add(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("HashSet追加一万条记录耗时："+(endTime-startTime)+"毫秒");

    }

    public void addTreeSet(){

        //创建 TreeSet集合

        TreeSet<Integer> treeSet = new TreeSet<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            treeSet.add(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("TreeSett追加一万条记录耗时："+(endTime-startTime)+"毫秒");

    }

    //遍历 traverse

    public void traverseHashSet(){

        System.out.println("HashSet遍历方式：");

        //创建集合

        HashSet<String> hashSet = new HashSet<>();

        //添加元素

        hashSet.add("从前有座山");

        hashSet.add("山上有座庙");

        hashSet.add("庙有个小和尚在敲代码");

        //foreach 遍历

        System.out.println("foreach遍历：");

        for (String s:hashSet) {

            System.out.println(s.toString());

        }

        //iterator 遍历

        System.out.println("iterator遍历：");

        Iterator<String> iterator = hashSet.iterator();

        while (iterator.hasNext()){

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

        }

    }

    public void traverseTreeSet(){

        System.out.println("TreeSett遍历方式：");

        //创建集合

        TreeSet<String> treeSet = new TreeSet<>();

        //添加元素

        treeSet.add("从前有座山");

        treeSet.add("山上有座庙");

        treeSet.add("庙有个小和尚在敲代码");

        //foreach 遍历

        System.out.println("foreach遍历：");

        for (String s:treeSet) {

            System.out.println(s.toString());

        }

        //iterator 遍历

        System.out.println("iterator遍历：");

        Iterator<String> iterator = treeSet.iterator();

        while (iterator.hasNext()){

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

        }

    }

    //删除 remove

    public void removeHashSet(){

        //创建集合

        HashSet<Integer> hashSet = new HashSet<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            hashSet.add(i);

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < hashSet.size(); i++) {

            hashSet.remove(i);

        }

        //结束的时间

        long  endTime = System.currentTimeMillis();

        System.out.println("删除一万条元素HashSet耗时为："+(endTime-startTime)+"毫秒");

    }

    public void removeTreeSet(){

        //创建集合

        TreeSet<Integer> treeSet = new TreeSet<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            treeSet.add(i);

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < treeSet.size(); i++) {

            treeSet.remove(i);

        }

        //结束的时间

        long  endTime = System.currentTimeMillis();

        System.out.println("删除一万条元素TreeSet耗时为："+(endTime-startTime)+"毫秒");

    }

    @Test

    public void test(){

        addHashSet();

        addTreeSet();

        traverseHashSet();

        traverseTreeSet();

        removeHashSet();

        removeTreeSet();

    }

}

任务三：

HashMap、TreeMap、LinkedHashMap 和 Hashtable 都实现了 Map 接口，对它们分别进行如下操作后比较它们的不同，然后形成初步耗时报告（两种不同 Map 的耗时）：

追加键值对（追加一万次）；

替换键值对（替换一万次）；

分别使用 entrySet、keySet/values、迭代器进行遍历；

删除键值对（删除一万次）

public class MapDemo {

    //追加

    public void addHashMap(){

        //创建集合

        HashMap<Integer, String> hashMap = new HashMap<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加记录

        for (int i = 0; i < 10000; i++) {

            hashMap.put(i,"hello,word");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("HashMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void addTreeMap(){

        //创建集合

        TreeMap<Integer, String> treeMap = new TreeMap<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加记录

        for (int i = 0; i < 10000; i++) {

            treeMap.put(i,"hello,word");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("TreeMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void addLinkedHashMap(){

        //创建集合

        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加记录

        for (int i = 0; i < 10000; i++) {

            linkedHashMap.put(i,"hello,word");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("LinkedHashMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void addHashtable(){

        //创建集合

        Hashtable<Integer, String> hashtable = new Hashtable<>();

        //开始的时间

        long startTime = System.currentTimeMillis();

        //追加记录

        for (int i = 0; i < 10000; i++) {

            hashtable.put(i,"hello,word");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("Hashtable追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    //replace 替换

    public void replaceHashMap(){

        //创建集合

        HashMap<Integer, String> hashMap = new HashMap<>();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            hashMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //替换元素

        for (int i = 0; i < hashMap.size(); i++) {

            hashMap.replace(i,"你好，世界");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("HashMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");

    }

    public void replaceTreeMap(){

        //创建集合

        TreeMap<Integer, String> treeMap = new TreeMap<>();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            treeMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //替换元素

        for (int i = 0; i < treeMap.size(); i++) {

            treeMap.replace(i,"你好，世界");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("TreeMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");

    }

    public void replaceLinkedHashMap(){

        //创建集合

        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            linkedHashMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //替换元素

        for (int i = 0; i < linkedHashMap.size(); i++) {

            linkedHashMap.replace(i,"你好，世界");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("LinkedHashMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");

    }

    public void replaceHashtable(){

        //创建集合

        Hashtable<Integer, String> hashtable = new Hashtable<>();

        //追加元素

        for (int i = 0; i < 10000; i++) {

            hashtable.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //替换元素

        for (int i = 0; i < hashtable.size(); i++) {

            hashtable.replace(i,"你好，世界");

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("Hashtable替换一万次元素耗时为："+(endTime-startTime)+"毫秒");

    }

    //遍历

    public void traverseHashMap() {

        //创建集合

        HashMap<Integer, String> hashMap = new HashMap<>();

        //添加元素

        hashMap.put(1, "赵云");

        hashMap.put(2, "张飞");

        hashMap.put(3, "马超");

        System.out.println("HashMap遍历方式：");

        //entrySet 迭代器遍历

        System.out.println("entrySet 迭代器遍历：");

        Iterator<Map.Entry<Integer, String>> iterator01 = hashMap.entrySet().iterator();

        while (iterator01.hasNext()){

            Map.Entry<Integer, String> entry = iterator01.next();

            System.out.print("key:"+entry.getKey());

            System.out.println("  value:"+entry.getValue());

        }

        //keySet 迭代器遍历

        System.out.println("keySet 迭代器遍历");

        Iterator<Integer> iterator02 = hashMap.keySet().iterator();

        while (iterator02.hasNext()){

            Integer key = iterator02.next();

            System.out.println("key:"+key+"  value:"+hashMap.get(key));

        }

    }

    public void traverseTreeMap() {

        //创建集合

        TreeMap<Integer, String> treeMap = new TreeMap<>();

        //添加元素

        treeMap.put(1, "赵云");

        treeMap.put(2, "张飞");

        treeMap.put(3, "马超");

        System.out.println("treeMap遍历方式：");

        //entrySet 迭代器遍历

        System.out.println("entrySet 迭代器遍历：");

        Iterator<Map.Entry<Integer, String>> iterator01 = treeMap.entrySet().iterator();

        while (iterator01.hasNext()){

            Map.Entry<Integer, String> entry = iterator01.next();

            System.out.print("key:"+entry.getKey());

            System.out.println("  value:"+entry.getValue());

        }

        //keySet 迭代器遍历

        System.out.println("keySet 迭代器遍历");

        Iterator<Integer> iterator02 = treeMap.keySet().iterator();

        while (iterator02.hasNext()){

            Integer key = iterator02.next();

            System.out.println("key:"+key+"  value:"+treeMap.get(key));

        }

    }

    public void traverseLinkedHashMap() {

        //创建集合

        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        //添加元素

        linkedHashMap.put(1, "赵云");

        linkedHashMap.put(2, "张飞");

        linkedHashMap.put(3, "马超");

        System.out.println("linkedHashMap遍历方式：");

        //entrySet 迭代器遍历

        System.out.println("entrySet 迭代器遍历：");

        Iterator<Map.Entry<Integer, String>> iterator01 = linkedHashMap.entrySet().iterator();

        while (iterator01.hasNext()){

            Map.Entry<Integer, String> entry = iterator01.next();

            System.out.print("key:"+entry.getKey());

            System.out.println("  value:"+entry.getValue());

        }

        //keySet 迭代器遍历

        System.out.println("keySet 迭代器遍历");

        Iterator<Integer> iterator02 = linkedHashMap.keySet().iterator();

        while (iterator02.hasNext()){

            Integer key = iterator02.next();

            System.out.println("key:"+key+"  value:"+linkedHashMap.get(key));

        }

    }

    public void traverseHashtable() {

        //创建集合

        Hashtable<Integer, String> hashtable = new Hashtable<>();

        //添加元素

        hashtable.put(1, "赵云");

        hashtable.put(2, "张飞");

        hashtable.put(3, "马超");

        System.out.println("hashtable遍历方式：");

        //entrySet 迭代器遍历

        System.out.println("entrySet 迭代器遍历：");

        Iterator<Map.Entry<Integer, String>> iterator01 = hashtable.entrySet().iterator();

        while (iterator01.hasNext()){

            Map.Entry<Integer, String> entry = iterator01.next();

            System.out.print("key:"+entry.getKey());

            System.out.println("  value:"+entry.getValue());

        }

        //keySet 迭代器遍历

        System.out.println("keySet 迭代器遍历");

        Iterator<Integer> iterator02 = hashtable.keySet().iterator();

        while (iterator02.hasNext()){

            Integer key = iterator02.next();

            System.out.println("key:"+key+"  value:"+hashtable.get(key));

        }

    }

    //remove 删除

    public void removeHashMap(){

        //创建集合

        HashMap<Integer, String> hashMap = new HashMap<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            hashMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < hashMap.size(); i++) {

            hashMap.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("hashMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void removeTreeMap(){

        //创建集合

        TreeMap<Integer, String> treeMap = new TreeMap<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            treeMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < treeMap.size(); i++) {

            treeMap.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("treeMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void removeLinkedHashMap(){

        //创建集合

        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            linkedHashMap.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < linkedHashMap.size(); i++) {

            linkedHashMap.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("linkedHashMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    public void removeHashtable(){

        //创建集合

        Hashtable<Integer, String> hashtable = new Hashtable<>();

        //添加元素

        for (int i = 0; i < 10000; i++) {

            hashtable.put(i,"hello,word");

        }

        //开始的时间

        long startTime = System.currentTimeMillis();

        //删除元素

        for (int i = 0; i < hashtable.size(); i++) {

            hashtable.remove(i);

        }

        //结束的时间

        long endTime = System.currentTimeMillis();

        System.out.println("hashtable删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");

    }

    @Test

    public void test(){

        addHashMap();

        addTreeMap();

        addLinkedHashMap();

        addHashtable();

        replaceHashMap();

        replaceTreeMap();

        replaceLinkedHashMap();

        replaceHashtable();

        traverseHashMap();

        traverseTreeMap();

        traverseLinkedHashMap();

        traverseHashtable();

        removeHashMap();

        removeTreeMap();

        removeLinkedHashMap();

        removeHashtable();

    }

}

巴特西

三个小任务掌握List、Set、Map

任务一：

任务二：

任务三：

最新文章

热门文章