list / map / set 的区别

list / map / set 的区别

collection大致分为标题上的三类, 他们一般有其较为稳定的存储场景
如List的自动扩展
set无法存储重复元素
自动排序的组数--TreeSet,TreeList,Tree**
list 和 set 是collection的子类, map不是
Map集合和Collection集合的区别
Map集合是有Key和Value的，Collection集合是只有Value。
Collection集合底层也是有Key和Value，只是隐藏起来。

分类

list常用方法

package test;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class ListDemo {
    public static void main(String[] args) {
        // 创建一个新集合
        List list = new ArrayList<>();
 
        // 1. 向集合中追加元素
        list.add("cc");
 
        // 2. 往集合的指定位置追加元素
        list.add(0 , "bbb");
 
        // 3. 向集合追加一个collection，只可追加collection，由于java不提供collection的实现，由它的下级接口来实现
        list.addAll(list);
 
        // 4. 往集合的指定位置追加collection
        list.addAll( 4 ,list);
 
        // 5. 获取集合长度
        int size = list.size();
 
        // 6. 根据元素下标来取集合中的元素
        list.get(0);
 
        // 7. 根据元素下标来删除集合中的元素
        list.remove(2);
 
        // 8. 集合间做对比
        /*
         * 此方法是用来比较的，与equals比较相似，现在list的元素中有[a, b, a, b, a, b, a],来和"a,b,c"比较会返回false，
         * 但是注意再用来比较String字符串的时候会进行局部的比较，两组字符串部分相同的情况下会返回true
         */
        boolean contains = list.contains("a,b,c");
 
        // 9. List -> 数组
        // 为了将List转为数组，JDK提供了toArray
        // 9.1
        String [] array=(String[]) list.toArray(new String[list.size()]);
        for(String arrays: array) {
            System.out.println(arrays);
        }
        // 9.2
        String [] arr=new String [list.size()];
        list.toArray(arr);
        for(String arrs: arr) {
            System.out.println(arrs);
        }
 
        // 10. 在集合中判断是否为空
        // 在集合中判断是否为空 ，不空返回false，空会返回true，常常会与null！=list来共同判定集合是否为空，
        // null！=list和list.isempty最大的区别是：一个人要喝水，前者判断是否有水杯，后者判断的是水杯是否有水
        System.out.println(list.isEmpty()); //false
        System.out.println(null!=list);     //true
 
        // 11. 在集合中查找元素，如果有 ,返回所查找元素的下标,如果不存在则返回-1
        list.indexOf("a");
 
        // 12. 打印集合元素
        // 12.1：
        Iterator it=list.iterator();
        while(it.hasNext()) {
            String string=(String) it.next();
            System.out.println(string);
        }
        // 12.2：
        for (Object o:list) {
            System.out.println(o);
        }
        // 12.3：
        for(int s=0;s<list.size();s++) {
            System.out.println(list.get(s));
        }
        // 13. 将list释放，元素清空，且无返回值
        list.clear();
        System.out.println(list);
    }
}

map常用方法

package test;
 
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class MapTest {
    public static void main(String[] args) {
        // 创建一个新 map
        Map map = new HashMap<>();
        // 1. 添加元素
        /*
            V put(K key, V value)
            向map集合中添加Key为key，Value为value的元素，当集合中没有这个key时返回null，当集合中有这个key时返回前一个value。
            就是说Map集合中的Key是不能重复的，这就类似于Set集合中元素不能重复，但是Map集合中的Value是可以重复。
        */
        map.put("1" , "demo1");
        map.put("2" , "demo1");
        map.put("1" , "demo2");
        System.out.println(map);    // 输出 {1=demo2, 2=demo1}
 
        // 2. 添加集合的所有元素
        /*
            void putAll(Map<? extends K,? extends V> m)
            向map集合中添加指定集合的所有元素
        */
        Map map2 = new HashMap<>();
        map2.put("71" , "zuan");
        map2.putAll(map);
        System.out.println(map2);   // 输出 {1=demo2, 2=demo1, 71=zuan}
 
        // 3. 把map集合中所有的键值删除void clear()
        map2.clear();
        System.out.println(map);   // 输出 {1=demo2, 2=demo1}
        System.out.println(map2);   // 输出 {}
 
        // 4. 检出map集合中有没有包含Key为key的元素，
        // 如果有则返回true，否则返回false。boolean containsKey(Object key)
        boolean b1 = map.containsKey("1");       // true
        boolean b2 = map.containsKey("71");     // false
 
        // 5. boolean containsValue(Object value)
        // 检出map集合中有没有包含Value为value的元素，如果有则返回true，否则返回false。
        boolean b3 = map.containsValue("demo1");       // true
        boolean b4 = map.containsValue("zuan");     // false
 
        // 6. Set<Map.Entry<K,V>> entrySet()
        // 返回map到一个Set集合中，以map集合中的Key=Value的形式返回到set中。
        Set set = map.entrySet();
        System.out.println(set);        // 输出[1=demo2, 2=demo1]
 
        // 7. boolean equals(Object o)
        // 判断两个map集合的元素是否相同
        Map map3 = new HashMap<>();
        map3.put("1" , "demo1");
        map3.put("2" , "demo1");
        Map map4 = new HashMap<>();
        map4.put("1" , "demo1");
        map4.put("2" , "demo1");
        boolean equals = map3.equals(map4);
        System.out.println(equals);    // 输出true
 
        // 8. V get(Object key)
        // 根据map集合中元素的Key来获取相应元素的Value
        Object o = map.get("1");
        System.out.println(o);          // 输出demo2
 
        // 9. boolean isEmpty()
        // 检出map集合中是否有元素，如果没有则返回true，如果有元素则返回false
        boolean mapIsEmpty = map.isEmpty();
        System.out.println(mapIsEmpty);     // false
        Map map5 = new HashMap<>();
        boolean map5IsEmpty = map5.isEmpty();
        System.out.println(map5IsEmpty);    // true
 
        // 10. Set<K> keySet()
        // 返回map集合中所有Key
        Set keySet = map.keySet();
        System.out.println(keySet);         // [1, 2]
 
        // 11. V remove(Object key)
        // 删除Key为key值的元素
        map.remove("1");
        System.out.println(map);            // {2=demo1}
 
        // 12. int size()
        // 返回map集合中元素个数
        int size = map.size();
        System.out.println(size);           // 1
 
        // 13. Collection<V> values()
        // 返回map集合中所有的Value到一个Collection集合
        map.put("5" , "demo2");
        map.put("6" , "demo5");
        Collection collection = map.values();
        System.out.println(collection);     // [demo1, demo2, demo5]
    }
}

Set常用方法

package test;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class SetTest {
    public static void main(String[] args) {
        // 先创建一个set
        Set<String> ss = new HashSet<String>();
 
        // 1. 新增：重复新增的值会被覆盖
        ss.add("a");
        ss.add("a");
        ss.add("a");
        ss.add("a");
        ss.add("b");
        ss.add("b");
        ss.add("b");
        ss.add("b");
        ss.add("c");
        ss.add("d");
        ss.add("");
        ss.add("");
        ss.add(" ");
        ss.add(" ");
        for (String s : ss) {
            System.out.println("循环值为：" + s);
        }
        System.out.println("Set长度为：" + ss.size());
        /*
        打印结果：
        循环值为：
        循环值为：
        循环值为：a
        循环值为：b
        循环值为：c
        循环值为：d
        Set长度为：6
        */
 
        // 2. 删除：remove(Object) 和removeAll（Set）
        ss.remove("a");
        System.out.println(ss);     // [,  , b, c, d]
 
        // 先创建一个set
        Set<String> s2 = new HashSet<String>();
        s2.add("b");
        s2.add("c");
        ss.removeAll(s2);
        System.out.println(ss);     // [,  , d]
 
        // 3. 查询
        System.out.print("循环方法1：");
        for (String s : ss) {
            System.out.print(s + ",  ");
        }
        System.out.println();
 
        System.out.print("循环方法2：");
        Iterator<String> iterator = ss.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + ",  ");
        }
        System.out.println();
 
        System.out.print("循环方法3：");
        String[] strs = new String[ss.size()];
        ss.toArray(strs);
        for (String s : strs) {
            System.out.print(s + ",  ");
        }
    }
}