JAVASE进阶day08（Map双列集合，注解）

HashMap

1.HashMap基本使用

package com.lu.day08.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDome {
    public static void main(String[] args) {
        HashMap<String , String> map = new HashMap<>();
        //添加后者修改->如果key不存在则是添加，如果key已经存在就是修改
        map.put("曹雪芹","红楼梦");
        map.put("施耐庵","水浒传");
        map.put("吴承恩","西游记");
        map.put("杜甫","登高");
        System.out.println(map);
        //通过key获取值，如果key不存在则，获取到的值为null
        System.out.println(map.get("吴承恩"));
        System.out.println(map.get("李白"));
        map.remove("吴承恩");
        System.out.println("--------------");
        map.put("杜甫","琵琶行");
        System.out.println(map);

        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1,"one");
        map1.put(2,"two");
        map1.put(3,"three");
        map1.put(4,"four");
        System.out.println(map1.containsKey(7));
        System.out.println(map1.containsValue("one"));

        System.out.println(map1.isEmpty());
        System.out.println(map.size());
        //获取键集合
        Set<String> strings = map.keySet();
        for (String key : strings) {
            System.out.println(key+"-->"+map.get(key));
        }
        System.out.println("-----------------");
        //entrySet 返回一个存放键值对set集合
        //entry是一个map接口中的内部类->通过put（k，v）放置的键值对，实际上存到了entry对象中->对象由HashMap中的内部类中的node实现
        //实现其中有两个属性（key,value）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"-->"+entry.getValue());
        }
        System.out.println("-----------------");
        //函数式的遍历方法forEach
        map.forEach((k,v)->{
            System.out.println(k+"-->"+v);
        });//只能key取value不能反过来
    }


}

TreeMap基本使用

1.TreeMap基本使用

package com.lu.day08.map;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {//TreeMap只能对key排序
        Comparator<Integer> c = (o1,o2)->o2-o1;
        TreeMap<Integer, String> map = new TreeMap<>(c);
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);

    }
}

LinkedHashMap

package com.lu.day08.map;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        //保证存取有序
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        map.put(4, "赵六");
        map.forEach((k, v) -> {
            System.out.println(k + ":" + v);
        });
        LinkedHashSet<Integer> set = new LinkedHashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.forEach(System.out::println);

    }
}

 集合嵌套

package com.lu.day08.map;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
    public static void main(String[] args) {
        HashMap<String, List<String>> map = new HashMap<>();
        ArrayList<String> xiaomi = new ArrayList<>();
        xiaomi.add("小米1");
        xiaomi.add("小米2");
        xiaomi.add("小米3");
        map.put("小米", xiaomi);

        ArrayList<Map<String,Double>> list = new ArrayList<>();
        HashMap<String, Double> clothMap = new HashMap<>();
        clothMap.put("耐克",2300.0);
        clothMap.put("贵人鸟",7800.0);
        clothMap.put("凡客",50.0);
    }
}

Collections

1.集合辅助工具类

package com.lu.day08.collections;

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(5);
        list.add(2);
        list.add(4);
        list.add(3);
        System.out.println(list);
        // 反转
        Collections.reverse(list);
        System.out.println(list);
        // 排序
        Collections.sort(list);
        System.out.println(list);
        // 随机
        Collections.shuffle(list);
        System.out.println(list);

    }
}

可变参数

package com.lu.day08.collections;

/**
 * 可变参数
 */
public class VaryParam {
    public static void main(String[] args) {
        print(1,2,3,4,5,6,7,8,9);
    }
    public static void print(int... a){
        for (int j : a) {
            System.out.println(j);
        }
    }
}

不可变集合

package com.lu.day08.collections;


import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * jdk9新增不可变集合
 */
public class Test {
    public static void main(String[] args) {
        //创建list不可变集合
        List<Integer> integers = List.of(1, 2, 3);
        integers.forEach(System.out::println);
        //创建set不可变集合
        Set<Integer> integers1 = Set.of(1, 2, 3);
        System.out.println(integers1);
        //创建map不可变集合
        Map<String, Integer> a = Map.of("A", 1, "B", 2, "C", 3);
        System.out.println(a);
    }
}

HashMap底层

注解 

1.什么是注解

对程序进行标注和解释

2.注解和注释的区别

3.回顾之前见到的注解

4.自定义注解

package com.lu.day14.note;

/**
 * 自定义注解
 * 使用@interface关键字来定义
 * 属性后要加（）
 * 属性赋值使用default关键字跟上值来赋值
 * 如果没有赋值，在使用时要指定属性值
 *数组属性default赋值如果只写一个值大括号可以省略，如果有多个不可以
 * value是jdk内置的一个特殊属性名
 */
@User(username = "lu",password = "123",arr = {123,456,789})
public class TestUser {
}

package com.lu.day14.note;

/**
 * 自定义用户注解类
 */
public @interface User {
    String name() default "lu";
    int age() default 18;
    String username();
    String password();

    String[] gender() default {"男","女"};

    int[] arr();
}

4.元注解 

 面试题

1.所有集合的底层分别是什么

在Java中，集合框架（Java Collections Framework，简称JCF）提供了一组接口和类来存储和操作对象集合。每种集合的具体实现方式不同，但它们都是基于一些基本的数据结构。以下是一些主要集合及其底层数据结构：

1. List 接口的实现类：

   • ArrayList：
     • 底层是一个可动态调整大小的数组。
     • 访问元素速度快（O(1)），但插入和删除操作，特别是在数组中间进行操作时，速度较慢（O(n)）。
   • LinkedList：
     • 底层是一个双向链表。
     • 插入和删除操作速度快（O(1)，前提是已定位到操作位置），但访问元素速度较慢（O(n)）。
   • Vector：
     • 底层也是一个可动态调整大小的数组，类似于 ArrayList。
     • 线程安全，但因此效率相对较低。

2. Set 接口的实现类：

   • HashSet：
     • 底层是一个哈希表（实际上是 HashMap 实例）。
     • 允许 null 元素，存取速度快（O(1)），但不保证元素顺序。
   • LinkedHashSet：
     • 底层是一个哈希表和一个链表（维护插入顺序）。
     • 访问速度较快（O(1)），并维护元素插入顺序。
   • TreeSet：
     • 底层是一个红黑树（自平衡二叉搜索树）。
     • 保证元素的排序顺序（根据自然顺序或 Comparator 提供的顺序），但存取速度相对较慢（O(log n)）。

3. Map 接口的实现类：

   • HashMap：
     • 底层是一个哈希表（数组 + 链表/红黑树，当链表长度超过阈值时转化为红黑树）。
     • 存取速度快（O(1)），但不保证键的顺序。
   • LinkedHashMap：
     • 底层是一个哈希表和一个双向链表（维护插入顺序或访问顺序）。
     • 访问速度较快（O(1)），并维护键的插入顺序或访问顺序。
   • TreeMap：
     • 底层是一个红黑树。
     • 保证键的排序顺序（根据自然顺序或 Comparator 提供的顺序），存取速度相对较慢（O(log n)）。

4. Queue 接口的实现类：

   • PriorityQueue：
     • 底层是一个基于数组的二叉堆。
     • 保证元素按照自然顺序或 Comparator 提供的顺序出队。
   • LinkedList：
     • 底层是一个双向链表。
     • 同时实现了 Queue 接口，作为队列使用时，提供 FIFO（先进先出）顺序。
     • 

2.HashMap有没有用过构造函数给集合初始化指定大小

 用过，为什么要用因为初始化指定大小省去了HashMap扩容的时间

• 无参构造函数：HashMap()，它使用默认的初始容量（通常是 16）和默认的加载因子（0.75f）。

• 指定初始容量的构造函数：HashMap(int initialCapacity)，你可以通过这个构造函数指定一个初始容量，而加载因子将保持默认值 0.75f。

• 指定初始容量和加载因子的构造函数：HashMap(int initialCapacity, float loadFactor)，这个构造函数允许你同时指定初始容量和加载因子。