集合框架

创建和使用集合

• 定义：集合是一个可变数组

• List集合存储有序可重复序列

点击查看详细代码

import java.util.*;
 
public class List01 {
    public static void main(String[] args) {
        /**
         *创建List集合
         */
        List list = new ArrayList();
        List list1 = new LinkedList();
        List list2 = new Vector();
 
        /**
         *向集合中插入值，可插入Object类型的值
         */
        list.add(12345);
        list.add("狗剩");
        list.add(true);
        list.add(null);
        list.add("abcd");
 
        list1.add(12345);
        list1.add("狗剩");
        list1.add(true);
        list1.add(null);
        list1.add("abcd");
 
        /**
         *如何将集合中的值插入数组
         */
        int l1 = 0;
        int l2 = 0;
        String[] strings = new String[5];
        int[] ints  =  new int[5];
        for(Object c : list){
            if(c instanceof String){
                strings[l1++] = (String) c;
            }else if(c instanceof Integer){
                ints[l2++] = (int)c;
            }
        }
        System.out.println("String数组：" + Arrays.toString(strings));
        System.out.println("int数组：" + Arrays.toString(ints));
 
        /**
         *如何做到一边向数组插入值，一边删除集合中的值
         */
        System.out.println("遍历前："+list1.size());
        String[] strings1 = new String[5];
        int[] ints1  =  new int[5];
        Iterator iterator = list1.iterator();
        //遍历
        while (iterator.hasNext()){
            Object next = iterator.next();
            if(next instanceof String){
                //先将值添加到数组后赋值
                strings1[l1++] = (String)next;
                //System.out.println(next);
                //删除
                iterator.remove();
            }else if(next instanceof Integer){
                ints1[l2++] = (Integer)next;
                iterator.remove();
            }
        }
        System.out.println("遍历后："+list1.size());
        System.out.println("数组1："+Arrays.toString(strings1));
        System.out.println("数组2："+Arrays.toString(ints1));
    }
}

运行结果：

String数组：[狗剩, abcd, null, null, null]
int数组：[12345, 0, 0, 0, 0]
遍历前：5
遍历后：2
数组1：[null, null, 狗剩, abcd, null]
数组2：[0, 12345, 0, 0, 0]

基础扩展

• Set集合存储无序不可重复序列

点击查看详细代码

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
 
public class Set01 {
    public static void main(String[] args) {
        //创建集合
        Set set = new HashSet();
        Set set1 = new TreeSet();
 
        //向集合中添加值
        set.add("二狗");
        set.add("abcd");
        set.add(0123);
        set.add(true);
        set.add(0123);  // 重复的元素会覆盖
        set.add(null);
        System.out.println(set);
    }
}

运行结果：

[null, 二狗, 83, abcd, true]

• Map集合以键值对的形式存储，不可重复

点击查看详细代码

import java.util.*;
 
public class Map01 {
    public static void main(String[] args) {
        Map map =  new HashMap();
        Map map1 = new TreeMap();
 
        //添加键值对
        map.put(null, null);
        map.put("age", 23);
        map.put("sex", 0);
        map.put("sex", 0);  //重复的元素会覆盖
 
        /**
         * 遍历map集合中的键值对
         */
        Set entryset = map.entrySet();
        Iterator iterator = entryset.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println();
 
        /**
         * forEach遍历
         */
        map.forEach((key, value) -> {
            System.out.println("key:"+key+",value:"+value);
        });
   }
}
 

特性

• ArrayList集合查询快，增删慢；LinkedList集合查询慢，增删快；Vector集合线程安全，效率低

点击查看详细代码

import java.util.*;
 
public class List02 {
    /**
     *测试增删速度
     * 插入1000000个数的时间
     * 插入10000000个数的时间
     */
    public static void main(String[] args) {
        //获取当前时间戳
        long l1 = System.currentTimeMillis();
        //向集合中插入数值
        List list = new ArrayList();
        for(int i = 0; i<1000000; i++){
            list.add(i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("ArrayList:" + (l2 - l1));
        System.out.println();
 
        long l3 = System.currentTimeMillis();
        List list1 = new LinkedList();
        for(int i = 0; i<1000000; i++){
            list1.add(i);
        }
        long l4 = System.currentTimeMillis();
        System.out.println("LinkedList:" + (l4 - l3));
        System.out.println();
 
        long l5 = System.currentTimeMillis();
        List list2 = new Vector();
        for(int i = 0; i<1000000; i++){
            list2.add(i);
        }
        long l6 = System.currentTimeMillis();
        System.out.println("Vector:" + (l6 - l5));
        System.out.println();
        
    }
    
}

插入1000000个数运行结果：

ArrayList:32
 
LinkedList:198
 
Vector:20

插入10000000个数运行结果：

ArrayList:2821
 
LinkedList:5205
 
Vector:801

• Set集合的特性

点击查看详细代码

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
 
public class Set02 {
    /**
     *测试增删速度
     * 插入100000个数的时间
     * 插入10000000个数的时间
     */
    public static void main(String[] args) {
        long l1 = System.currentTimeMillis();
        Set Set = new HashSet();
        for(int i = 0; i < 1000000; i++){
            Set.add(i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("HashSet:" + (l2 - l1));
 
        long l3 = System.currentTimeMillis();
        Set set1 = new TreeSet();
        for(int i = 0; i < 1000000; i++){
            set1.add(i);
        }
        long l4 = System.currentTimeMillis();
        System.out.println("TreeSet:" + (l4 - l3));
 
    }
 
}

插入100000个数的运行结果

HashSet:70
TreeSet:112

插入10000000个数的运行结果

HashSet:2869
TreeSet:4992

• Map集合的特性

点击查看详细代码

public class Map02 {
    /**
     *测试增删速度
     * 插入100000个数的时间
     * 插入10000000个数的时间
     */
    public static void main(String[] args) {
        long l1 = System.currentTimeMillis();
        HashMap hashMap = new HashMap();
        for(int i = 0; i<100000; i++){
            hashMap.put(i,i);
        }
        long l2 = System.currentTimeMillis();
        System.out.println("HashMap:" + (l2 - l1));
 
        long l3 = System.currentTimeMillis();
        LinkedHashMap hashMap2 = new LinkedHashMap();
        for(int i = 0; i<100000; i++){
            hashMap2.put(i,i);
        }
        long l4 = System.currentTimeMillis();
        System.out.println("TreeMap:" + (l4 - l3));
    }
    
}

插入100000个数的运行结果：

HashMap:24
TreeMap:16

插入10000000个数的运行结果：

HashMap:5825
TreeMap:5106