学习笔记 java学习（十）-CSDN博客

本文链接：https://blog.csdn.net/weixin_43482476/article/details/118958142

ArrayList–底层是数组-连续的内存空间–查询快，增删慢（扩容&缩容）
LinkedList–底层是链表–不连续的内存空间–查询满，增删快
注意：LinkedList还提供了很多针对首尾进行操作的API
Arraylist测试：

package cn.tedu.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**本类用于ArrayList相关测试*/
public class TestArrayList {
    public static void main(String[] args) {
        //1.出昂见对应的集合对象
        /**底层会自动帮我们创建数组来存放对象，并且数组的初始容量是10*/
        ArrayList<Integer> list =new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        list.add(400);
        list.add(400);
        list.add(300);
        list.add(600);
        System.out.println(list);
        //list.clear();//清空集合
        //System.out.println(list);//[]
        System.out.println(list.contains(100));//true 是否包含指定元素
        System.out.println(list.isEmpty());//false,判断集合是否为空
        System.out.println(list.get(0));//100,根据下标获取元素
        System.out.println(list.indexOf(400));//判断指定元素第一次出现的位置
        System.out.println(list.lastIndexOf(400));//判断指定元素最后一次出现的位置
        System.out.println(list.remove(1));//移除指定位置的元素
        //数组月结异常，主要是因为List中有两个重载的remove()，如果传入的是300，会认为是int类型的index索引，所以如果想之地那个元素删除数据，需要把int类型手动装箱成Integer类型
        //System.out.println(list.remove(300));
        System.out.println(list.remove(Integer.valueOf(300)));
        System.out.println(list.size());//集合长度,元素个数
        System.out.println(list.subList(1,3));//截取子段，左闭右开
        //进行集合的迭代
        //1.for循环
        System.out.println("方式一");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("方式二");
        //高效for循环
        for(Integer i:list){
            System.out.println(i);
        }
        System.out.println("方式三");
        Iterator<Integer> l=list.listIterator();
        while(l.hasNext()){
            System.out.println(l.next());
        }
        System.out.println("方式四");
        ListIterator<Integer> t=list.listIterator();
        while(t.hasNext()){
            System.out.println(t.next());
        }

    }

    }

LinkedList测试

package cn.tedu.list;

import java.util.LinkedList;

//本类用于LinkedList的相关测试
public class TestLinkedList {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> list=new LinkedList<>();
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("唐三藏");
        list.add("沙师弟");
        list.add("白龙马");
        System.out.println(list);
        //自行测试继承自Collection与List的方法
        //3.2测试LinkeedList自己的方法
        //1.添加首尾元素
        list.addFirst("玉兔");
        list.addLast("孔雀");
        System.out.println(list);
        //2.获取首尾元素
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        //3.移除首尾元素
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println(list);
        //4.其他测试
        //4.1创建集合对象
        LinkedList<String> list2=new LinkedList<>();
        list2.add("水浒传");
        list2.add("西游记");
        list2.add("三国演义");
        list2.add("红楼梦");
        System.out.println(list2);
        System.out.println(list2.element());//水浒传,获取但不移除集合中的首元素
        System.out.println(list2.peek());//功能同上
        System.out.println(list2.peekFirst());
        System.out.println(list2.peekLast());
        /**新增系列*/
        System.out.println(list2.offer("聊斋逸致"));//首位添加
        System.out.println(list2.offerFirst("斗破苍穹"));
        System.out.println(list2.offerLast("斗罗大陆"));
        System.out.println(list2);
        /**别名 移除系列*/
        System.out.println(list2.poll());//移除首字母
        System.out.println(list2.pollFirst());//移除首字母
        System.out.println(list2.pollLast());//移除末位字母

    }
}

set
1.set中的数据是无序的
2.set不允许存重复的数据，允许有null,但也最多一个
3.如果自定义对象想去重，需要重写equals()与hashCode()
set测试

package cn.tedu.list;

import java.util.HashSet;
import java.util.Set;

/**本类用于测试Set接口*/
public class TestSet {
    public static void main(String[] args) {
        //Set s=new Set();父接口不可直接创建对象
        Set<String> set=new HashSet<String>();
        set.add("牛气冲天");
        set.add("鼠气冲天");
        set.add("虎气冲天");
        set.add("虎气冲天");
        set.add(null);
        System.out.println(set);
        /**总结一：set集合中的元素都是无序的
         * 总结二：set集合中的元素不能重复
         * 总结三：se集合中可以存放null，也只允许最多存放一个null
         * 总结四：自定义对象如果想要去重
         * 需要添加重写的hashcode（）与equals（）*/
        Set<Student> stu=new HashSet<>();
        Student s1=new Student(3,"张三");
        Student s3=new Student(4,"李四");
        Student s2=new Student(3,"张三");
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);
        System.out.println(stu);
    }
}

Map
1.map的结构是<k,v>,表示的是一对键值对(映射关系)
2.Entry<k,v>–Map底层就是Entry[]
3.hashMap数据存储过程
1)会拿到当前entry中的key做运算
得出当前这个entry应该放在entry[]的哪个位置
2)如果两个entry的key值经过运算，余数相等
表示这两个entry的数组下标一致，这个现象就是哈希冲突/哈希碰撞
3）如果存在冲突的情况，可以把新entry链接到旧entry之后，形成链表
4）当链表长度大于8时会转成红黑树，小于6时会恢复成链表
结论：HashMap底层结构：数组+链表或者数组+红黑树
4. 拓展：树的数据结构研究的思路：树->二叉树->平衡二叉树->红黑树
5.我们有两个指标会影响hashMap的查询效率
容量：会约等于2倍的方式扩容–初始容量16
加载因子：存到什么程度就扩容–0.75f
注意：不管怎么设置，要避免频繁的rehash,Entry[]数组扩容的情况
Map测试1：

package cn.tedu.map;

import java.util.*;

//本类用于测试mao接口
public class TestMap {
    public static void main(String[] args) {
        //1.创建map对象
        /**Map中的数据要符合映射规则，一定注意要同时指定K和V的数据类型
         * 至于这个K和V具体要指定什么类型，取决于具体的业务需求*/
        Map<Integer,String> map=new HashMap();
        //2.向map集合存入数据，注意方法是put（），并且要存入一对kv的值
        map.put(9527,"白骨精");
        map.put(9528,"骨精");
        map.put(9529,"白骨");
        map.put(9529,"骨");//覆盖上一个
        map.put(9530,"白精");
        map.put(9531,"白精");//value可以重复
        /**map中存放的都是无序的数据
         * 2.map中的value可以重复
         * 3.map中的key不允许重复，如果重复，后面的value会把前面的value覆盖掉*/
        System.out.println(map);
        //3.进行方法测试
        //map.clear();
        System.out.println(map.hashCode());
        System.out.println(map.equals("黄毛怪"));
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println(map.containsKey(9527));//判断当前map集合中是否包含指定的键
        System.out.println(map.containsValue("白骨精"));//判断当前map集合中是否包含指定的value
        System.out.println(map.get(9530));//获取指定key值对应的value的值
        System.out.println(map.remove(9529));//删除了所有的此key值对应的键值对
        System.out.println(map);
       Collection<String> values= map.values();
        System.out.println(values);//将map集合中所有的value取出，放入collecion集合中
        //4.map集合迭代的方式
        /**方式一
         * 遍历map中的数据，但是map本身没有迭代器，所以需要先转换成set集合
         * Set《key》：把map中的所有key值存入到set集合当中--keyset（）*/
        //4.1将map集合中的key值取出存入set集合中，集合的泛型就是key的类型Integer
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> it= keySet.iterator();
        while(it.hasNext()){
            Integer key=it.next();
            System.out.println(map.get(key));
        }
        /**方式二：
         * 遍历map集合需要把map集合先转成set集合
         * 是把map中的一对键值对key&value作为一个Entry《k,V>整体放入set
         * 一对K，V就是一个Entry*/
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> next = iterator.next();
            System.out.println(next);
            Integer key=next.getKey();
            String value=next.getValue();
        }
    }
}

Map测试2：

package cn.tedu.list;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

//本类用于字符串中字符个数统计案例
public class TestMap2 {
    public static void main(String[] args) {
        System.out.println("输入");
        String input=new Scanner(System.in).nextLine();
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0;i<input.length();i++){
            char key=input.charAt(i);
            Integer value=map.get(key);
            if(value==null){
                map.put(key,1);
            }else{
                map.put(key,value+1);
            }

        }
        System.out.println(map);
    }
}