Collection&Map

Collection

list

有序可重复

arrayList

基层是数组，按照顺序存储，查询速度快
默认空间大小为10
每次扩容1.5倍

LinkedList

基层是双向链表，按照链式存储，删除和添加效率高

copyOnWriteArrayList

高并发环境下使用的类

arraylist与linkedlist区别

1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2. 对于随机访问get和set，ArrayList优于LinkedList，因为ArrayList可以随机定位，而LinkedList要移动指针一步一步的移动到节点处。（参考数组与链表来思考）
3. 对于新增和删除操作add和remove，LinedList比较占优势，只需要对指针进行修改即可，而ArrayList要移动数据来填补被删除的对象的空间。

方法

//添加元素
list.add()
//添加集合
list.addAll()
//修改元素
list.set()
//根据条件删除元素
list.removeIf(s -> s %2 ==0)
// 根据对象删除数据，返回一个 boolean
list.remove(Integer.valueOf(150));
// 根据索引删除数据,返回删除的元素list.remove(1);
//获取指定位置的元素
list.get(0)

 System.out.println("=============for i=============");
        // 遍历集合
        for(int i=0 ; i< list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("==============增强for循环============");
        // 增强for循环
        for(Integer s : list) {
            System.out.println(s);
        }
        // foreach 1.8
        System.out.println("==================JDK8 foreach遍历===================");

        list.forEach(System.out::println);

set

无序且不可重复

hashSet

实现原理链表，数组

1. 采用 hash 算法
2. 重写hashCode、以保证不同对象hash值尽可能不同
3. 重写 equals 、用来比较 相同 hash对象的内容是否一致
4. 去重的原理: hashCode 值相同 且 内容 或者 地址 相同

添加元素
set.add(“abc”)
删除 指定的元素
set.remove(“abc”);

修改元素 （无修改）

查长度
set.size()
判断是否为空
set.isEmpty();
判读是否包含
set.contains(“abc”)

建立一个只读集合
Set<integer> list=Set.Of(1,2,3);
只读集合转换普通集合
Set <integer> list1=new HashSet<>(list);
普通集合转换只读集合
Set <integer> list2=Set.copyOf(list1)

System.out.println("=========================");
        // 数据遍历
        for(String s : set) {
            System.out.println(s);
        }

        System.out.println("使用迭代器遍历=====================");

        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("JDK8进行数据的遍历==========");
        set.forEach(System.out::println);

无序性
添加的顺序和存储顺序不一定会一样
不可重复
向集合中，添加重复的元素, 会添加失败,发生覆盖

treeSet

去重原理：comparator()方法

Map

hashMap

1. hashMap中的 键 是 无序且 不可重复
2. 去重原理：根据键的 hashCode 值相同 且 内容 或者 地址 相同

treeMap

properties（键值对均为字符串、删除处理properties文件）

@Test
    public void testProperties(){
        // Property 属性
        // 创建一个 Properties对象
        Properties p = new Properties();

        p.setProperty("name", "张三");
        p.setProperty("sex", "男");

        // 获取某个值
        System.out.println(p.getProperty("name", "xxx"));
    }


    @Test
    public void testProperties2(){
        // 通过 System 快速构建一个 Properties 对象
        // 获取系统对应的环境变量
        Properties p = System.getProperties();

        //p.forEach((k, v)-> System.out.println(k + "=" + v));

        System.out.println(p.getProperty("java.home"));

    }

    @Test
    public void testProperties3() throws Exception{

        // Properties 类是专门用来 解析 properties 配置文件的
        // Java语言通常用 properties 文件作为 项目的 配置文件
        // 以 .properties结尾的文件，就是 properties配置文件
        // 配置文件中 每一行 定义的是 键=值 这样的格式

        // Java中的配置文件，通常放在 resources 资源目录下，和 java代码进行分离，便于管理
        // idea需要将 resources 目录 标记为 资源目录
        
        //  读取 test.properties 文件
        
        // 通过一个 从 classpath 下读取文件的流，负责读取 配置文件
        InputStream in = PropertiesTest.class.getResourceAsStream("/test.properties");

        // 将 流中的数据 读取到 Properties中
        Properties p = new Properties();
        p.load(in);

        // 获取 配置文件中的 name 值
        System.out.println(p.getProperty("name"));

    }

concurrentHashMap(支持并行的Map)

方法

// 添加数据
map.put(“name”, “张三”);
// 删除 Map集合中的数据, remove根据键删除数据，返回键对应的 值
// map.remove(“name”);
// 根据 键和 值 删除元素，返回 boolean
map.remove(“name”, “张三”);
// 修改数据，有这个键则修改，没有则添加
map.put(“sex”, “女”);
map.put(“page”, “10”);
// 获取 指定的键对应的数据
map.get(“name”);
// map中如果获取一个不存在的键，则返回 null
map.get(“age”);
// 获取 当前显示的 是 第几页数据，若有返回值，没有返回默认值
map.getOrDefault(“page”, “1”)
//是否包含某个key
map.containsKey(key)
//是否包含某个值
map.containsValue（val）
//合并集合
map.putAll(Map<? extends K,? extends V>)
//清空集合
clear()
//获取Map中所有的键
List list=map.keySet()
//获取Map中所有的值
List list=map.values()
//获取Map中的键值对
List<Map.Entry<key,vaules>> list=map.entrySet();
//在键值对中获取键和值
entry.getKey();
entry.getValue();

遍历输出

     // 构建一个只读的Map容器
    Map<String, Object> map = Map.of("name", "张三", "sex", "男", "age", 19);

    // 键遍历
    System.out.println("===================键遍历=================");

    // 获取Map集合中所有的键
    for(String key : map.keySet()) {
        // 通过 key 获取 value
        System.out.println(key + " = " + map.get(key));
    }

    // 值遍历
    System.out.println("================值遍历【不常用】==================");

    for(Object obj : map.values()) {
        System.out.println("value=" + obj);
    }

    // 键值对遍历
    //Set<Map.Entry<String, Object>> entries = map.entrySet();
    System.out.println("================键值对遍历==========================");
    for(Map.Entry<String, Object> entry :  map.entrySet()) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }

    //
    System.out.println("======================JDK8遍历方式===================");
    map.forEach((k, v) -> System.out.println(k +"=" + v) );