JavaSe基础2023年2月02日学习内容泛型、Map集合、Collections使用-CSDN博客

本文链接：https://blog.csdn.net/weixin_53214204/article/details/128854258

JavaSe-2023-2-02 泛型、Map集合、Collections使用

每日一句: 如果你不握紧拳头，你就不知道你力量到底有多大；如果你不咬紧牙关，你就不知道你的坚持到底有多狠；如果你不跺脚而起，你就不知道你的果决到底有多正确；如果你不瞪眼，你就不知道你的内心到底多强大。最强悍的竞争力只有两个字：行动。只有当你足够努力，你才会足够幸运。这世界不会辜负每一份努力和坚持。早安，共勉！

学习内容：泛型、Map集合的使用、Collections类的使用

泛型

泛型是JDK5的新特性，泛型机制，用泛型来指定集合中的存储的数据类型
好处：
- 泛型的好处，从集合中取出来的元素类型是泛型指定的类型，不需要进行大量的类型转换
- 集合中存储的元素类型统一的
坏处:
- 导致集合中存储的元素缺乏多样性
- 在大多数的时候，我们都是存储相同的类型

public class TestType {
    public static void main(String[] args) {
        //定义泛型,提高类型转换的安全性和稳定性
        List<String> list = new ArrayList<>();
        list.add("北京");
        list.add("长沙");
        list.add("武汉");
        //2让代码通用性更强
        Pointer<Integer> p1 = new Pointer<>(1,2);
        System.out.println(p1);
        Pointer<Double> p2 = new Pointer<>(1.1,1.2);
        System.out.println(p2);

    }
}
class Pointer<T>{
    T x;
    T y;

    public Pointer(T x, T y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Pointer{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

Map集合(重点)

无序、不可重复、Map集合的key和Set集合存储元素的特点相同
Map集合和Collection没有继承关系
Map集合是以key和value的方式存储数据的（键值对）
key和value都是引用数据类型、都是存储对象的内存地址
key起到了主导地位，value是key的一个附属品

HashMap接口

return type	Method	Brief Introduction
v	put(t,v)	添加一个键值对到map集合当中
int	size()	返回键值对的个数
v	get(k)	通过指定的key返回对于的value
v	remove(k)	根据指定的key删除对应的value
boolean	containsKey(Objectkey)	判断map是否包含指定key如果包含true否则false
boolean	containsValue(Object value)	判断Map中是否存在value
Set	keySet()	将map中所有的key以set集合的形式返回
Collection	values()	获取map中所有的Value
void	clear()	清空map
boolean	isEmpty()	判断键值对是否有值
Set <Map.Entry<K,V>>	entrySet()	将Map集合转换成Set集合

代码实现:

public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //1.v put(t,v); 添加一个键值对到map集合当中
//        如果k存在则修改v
        map.put("1","北京");
        map.put("1","上海");
        map.put("1","深圳");
        map.put("1","广州");
        map.put("2","长沙"); //修改

        //size(); 返回键值对的个数
        System.out.println(map.size());

        //3. v get(k); 通过指定的key返回对于的value

        //4.删除 v remove(k); 根据指定的key删除对应的value
        map.remove("3");
        System.out.println(map);

        //5.booelan containsKey(key); 判断map是否包含指定key如果包含true否则false
        System.out.println(map.containsKey("3"));

        //6.Set keySet(); 将map中所有的key以set集合的形式返回
        Set<String> set = map.keySet();
        System.out.println(set);

        //注意HashMap,key值不能重复，可以为null,但只能有一个values可以重复,也可以有多个null
        //Collection values(); 获取map中所有的Value
        Collection c = map.values();
        System.out.println(c);

        //8 clear(); 清空map
        map.clear();
        System.out.println(map);

        //Map的迭代
        map = new HashMap<String,String>();
        map.put("1","吕布");
        map.put("2","关羽");
        map.put("3","赵云");
//        1.使用增强for+keySet
        System.out.println(map);
        Set<String> set1=  map.keySet();
        for (String key:set1) {
            System.out.println(key+":"+map.get(key));
        }
//        2.使用迭代器
        Set<String> set2 = map.keySet();
        Iterator<String> it =  set2.iterator();
        while (it.hasNext()){
            String key = it.next();
            System.out.println(key+":"+map.get(key));
        }
//        3.使用entry 效率最高
        Set<Map.Entry<String,String>> set3 = map.entrySet();
        for (Map.Entry<String,String> entry:set3) {
            System.out.println(entry.getKey()+":"+ entry.getValue());
        }
        Map<Character,Integer> map1 = new HashMap<>();
        //定义一个字符串统计每个字符串出现的次数 如a:4 b:3等
        String str = "1hxdfdw6q3143rvrt";
        for (int i = 0; i < str.length(); i++) {
            char tmp =  str.charAt(i);
            if(map1.get(tmp) == null){
                map1.put(tmp,1);
            }else{
                map1.put(tmp,map1.get(tmp)+1);
            }
        }
        System.out.println(map);
    }

散列表/哈希表
- 哈希表HashMap使用不当时发挥性能
  - 假设所有的HashCode()方法返回值固定为某个值，那么会导致哈希表变成纯单向链表，这种情况我们称为，散列分布不均匀
  - 假设将所有的hashCode()方法返回值设定为不一样的值，可以吗？不行，因为这样的话会导致底层哈希表称为了一维数组没有了链表的概念
  - HashMap集合的默认初始化容量是16，默认加载因子是0.75这个默认加载因子是当HashMap集合底层数组的容量达到了75%的时候，数组开始扩容
  - HashMap集合的初始化容量必须是2的倍数，这也是官方推荐的，为了提高HashMap集合的存储效率
- 如果一个类的equals方法重写了，那么必须重写他的hashCode方法

Collections使用

Collection:集合接口，其子接口有List、Set
Collections：是一个操作Set、List、Map等集合的工具类

Method	Brief Introduction
sort(list)	排序
shuffle(list)	随机打乱
reverse(list)	翻转
copy (被复制,复制的集合)	复制
binarySearch(list,“小黑”)	二分查找(必须先排序) 没有该元素则返回负数
toArray(arr)	List和数组之间相互转换
Arrays.asList(arr1)	数组转集合

代码实现:

 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小六");
        list.add("大红");
        list.add("小黑");
        list.add("旺财");
        list.add("来福");
        list.add("黑慧慧");
        list.add("小甜甜");
        System.out.println(list);

        //1.排序 sort(list);
        Collections.sort(list);
        System.out.println("排序后"+list);

        //2.随机打乱 shuffle(list);随机打乱
        Collections.shuffle(list);
        System.out.println("打乱后"+list);

        //3翻转 reverse(list)
        Collections.reverse(list);
        System.out.println("翻转后"+list);

        //4.复制 copy (被复制,复制的集合)
        List<String> list1= new ArrayList<>();
        Collections.copy(list,list1);

        //5.二分查找(必须先排序) 没有该元素则返回负数
        Collections.sort(list);
        System.out.println(list);
        int index = Collections.binarySearch(list,"小黑");
        System.out.println(index);

        //List和数组之间相互转换
        List<Integer> list2 = new ArrayList<>();
        list2.add(2);
        list2.add(3);
        list2.add(23);
        list2.add(32);
        list2.add(7);
        Integer[] arr= {};
        Integer[] ints = list2.toArray(arr);
        System.out.println(Arrays.toString(ints));
        //数组转集合
        String[] arr1 = {"123","12312","352","412"};
        List<String> list3= Arrays.asList(arr1);
        System.out.println(list3);
    }

以上仅供参考,如有不对的地方，望指出！
gitee代码仓库地址:https://gitee.com/Zhengsenbing/java-se-basic