java集合

本文介绍了Java集合框架,包括List、Set和Map集合的实现类,如ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap和TreeMap。详细讨论了它们的特点、底层结构、增删查改操作以及效率对比,并提到了Collections工具类的作用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

集合

list集合

Arraylist

add增加
set修改
get查询
remove移除

* 数组:只能存储单一数据类型
 * 优点:线性存储 查询速度快
 * 缺点:数组一旦声明长度不可修改
 * List:有序可重复
 * 泛型:限定数据类型
 * <>钻石操作符
 * ArrayList 新增、删除数据慢 查询快
 * LinkedList 新增、删除数快 查询慢
  
public class ArraylistTest {
    @Test
    public void test() {
        int[] array = new int[5];
        array[2] = 2;
        System.out.println(Arrays.toString(array));// [0, 0, 2, 0, 0]
    }
    @Test
    public void test01(){
        List list = new ArrayList();
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        String i ="桃李不言下自成蹊";
        Persion persion=new Persion();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        list.add(g);
        list.add(h);
        list.add(i);
        list.add(persion);
        System.out.println(list.size()); //10

    }
    @Test
    public void test02(){
        List list=new ArrayList();
        list.add("小王");
        list.add("小白");
        list.add("小王");
        System.out.println(list.get(0));//小王
        System.out.println(list.get(1));//小白
        System.out.println(list.get(2));//小王
    }
    @Test
    public void test03(){
        //3种写法
//        List<String> list= new ArrayList<String>();
//        List<String> list= new ArrayList<>();
//        List<String> list= new ArrayList();
        List<String> list =new ArrayList<>();
        list.add("王鹏飞");

    }
    @Test
    public void test04(){
        List<Integer> list01 =new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list01.add(i);
        }
        System.out.println(list01);//[0, 1, 2, 3, 4]

        List<Integer> list02 =new ArrayList<>(){
            {
                for (int i = 0; i < 5; i++) {
                    add(i);
                }
            }};
        System.out.println(list02);//[0, 1, 2, 3, 4]
    }
    @Test
    public void test05(){
        //不可变集合
        List<Integer> list =List.of(0,1,2,3,4);
        System.out.println(list);

    }
    @Test
    public void test06(){
        //不可变集合转为可变集合
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        System.out.println(list);//[0, 1, 2, 3, 4]
        list.add(6);              //add 增加
        System.out.println(list);//[0, 1, 2, 3, 4, 6]
        list.set(2,20);           //set 修改
        System.out.println(list);//[0, 1, 20, 3, 4, 6]
    }
    @Test
    public void test07(){
        List<String> list=new ArrayList<>(List.of("0","1","2","3","4"));
        System.out.println(list);
        //末尾追加
        list.add("6");
        System.out.println(list);
        //向指定位置添加
        list.add(5,"5");
        System.out.println(list);
        //将指定index位置上的元素从集合中删除
        list.remove(6);
        System.out.println(list);
        //在集合中删除指定元素
        list.remove("5");
        System.out.println(list);
        //删除指定的元素的时候,如果有相同的,就会删除一个
        //建议使用下标去删除
        list.add("王");
        list.add("王");
        System.out.println(list);
        list.remove("王");
        System.out.println(list);
        //更新指定index位置上的值
        list.set(3,"三");
        System.out.println(list);
        //查询指定index位置上元素的值
        System.out.println(list.get(3));
        //输出的结果
        //[0, 1, 2, 3, 4]
        //[0, 1, 2, 3, 4, 6]
        //[0, 1, 2, 3, 4, 5, 6]
        //[0, 1, 2, 3, 4, 5]
        //[0, 1, 2, 3, 4]
        //[0, 1, 2, 3, 4, 王, 王]
        //[0, 1, 2, 3, 4, 王]
        //[0, 1, 2, 三, 4, 王]
        //三
    }
    @Test
    public void test08(){
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        for (int i = 0; i < 5; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("元素个数"+list.size()); //元素个数5

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("++++++++++++++++++++++");
        //for(集合中的元素数据类型 集合中的每一个元素 :被遍历的集合)
        for (int num : list) {
            System.out.println(num);
        }
    }
    @Test
    public void test09(){
        //迭代的方式
        // 在List 上用迭代器遍历
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        Iterator<Integer> it =list.listIterator();
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);  //01234
        }
        System.out.println("第一次");   //第一次 第二次 第三次
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);
        }
        System.out.println("第二次");
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);
        }
        System.out.println("第三次");
        //
    }
    @Test
    public void test10(){
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        list.stream().forEach(System.out::println);
    }
}

泛型

泛型可以理解为参数的数据类型
List list=new ArrayList<>(List.of(0,1,2,3,4));

迭代器

Iterator<Integer> it =list.listIterator();
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);  //0,1,2,3
        }
  • List: 有序可重复 有序指的是下标有序 可重复指的是不同下标位置上可以存储相同值的元素
  • Set: 无序不可重复 录入的顺序和存储的顺序不一致 不可重复指的是相同值的元素不可重复存储
    在这里插入图片描述
    isEmpty
public void test01(){
        Collection c = new ArrayList();
        c.add(1);
        c.add(2);
        System.out.println(c);
        System.out.println(c.isEmpty()); //判断是否为空
    }

快速失败机制

    public void test06(){
        //快速失败机制
        Collection c = new ArrayList();
        c.add("tom");
        c.add("jack");
        c.add("rose");
        c.add("jerry");
        Iterator it = c.iterator();
        while (it.hasNext()){
            Object o = it.next();
            if ("jack".equals(o)){
//                c.remove(o); //集合的方法 会造成数据异常
                it.remove();//迭代器的方法
            }
        }
        System.out.println(c);
    }

遍历集合

    public void test01(){
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        //遍历方式一
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
//            Object next = it.next();
//            System.out.println(next);
        }
        //方式二 增强for
        for (Object o : list) {
            System.out.println(o);
        }
        //方式三 普通for循环
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }

Arrays.aslist
//Arrays.aslist 可以生成一个list集合,是一个不可变集合(不能修改)

LinkedList

特点:

  • 元素有序 可重复 可以通过所以访问元素
  • 底层双向链表
  • 增删快 查询慢
  • 线性安全 效率低
public class LinkedList{
    @Test
public void test01(){
        List list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
}

## ListIterator迭代器

List 集合额外提供了一个 listIterator() 方法,该方法返回一个 ListIterator 对象, ListIterator 接口继承了 Iterator 接口,提供了专门操作 List 的方法:

set集合

Set是一个Collection接口的典型子接口。
Set接口代表的集合特点:元素都是唯一的。通常元素都是无序的。

HashSet实现类

  • 元素唯一 无序
  • 底层结构 哈希表
  • 综合效率高
  • 特殊的 hashset 存储student 对象时,
  • hashset 判断两个元素相同的依据是:
    1.先比较元素的hashcode值
    2.元素哈希值相同,在进行equals判断。如果都相同 则元素相同
  public class HashSetTest {
    @Test
    public void test01(){
        HashSet<String> set = new HashSet<>();
        set.add("tom");
        set.add("jock");
        set.add("rose");
        set.add("jerry");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

linkedhashset

  • 元素唯一 有序
  • 底层结构 哈希表基础上 维护一个链表 用于保证元素的迭代顺序
  • 效率 略低于hashset

Treeset

  • 元素唯一 无序 但实现了 排序

  • 底层结构:红黑树 -一种相对平衡的二叉树

  • 效率 查询效率高于链表

  • 排序原理:

  • 存储元素过程:先存储根节点,其余元素小的放右边,大的放左边

  • 取出元素过程:采用中序遍历 ,即在左中右的遍历

  • TreeSet 集合要所有元素必须实现 comparde 接口 那么元素就可以比较大小了

  • 或者创建TreeSet 集合时通过构造器传入一个比较器,用于 比较元素大小

map集合

  • map 是一个顶层接口 表示一组键值对
  • 特定 key 是唯一 通过key 可以映射到value
  • map 的典型实现类
  • hashmap 、linkedhashmap 、treemap 、hashtable、 properties
public class MapTest {
    @Test
    public void test01(){
    //创建map集合
        HashMap<String, String> map = new HashMap<>();
        //key 是唯一的
        map.put("小白","小黑");
        map.put("小红","小绿");
        map.put("好好","学习");
        map.put("虚线","直线");
        System.out.println(map);
        System.out.println(map.isEmpty());
    }
    @Test
    public void test02(){
        Map<Integer,String> map =new HashMap<>();
        map.put(01,"tom");
        map.put(02,"jer");
        map.put(03,"ros");
        map.put(04,"tom");
        //遍历map集合
        Set<Integer> set =map.keySet();
        for (Integer key : set) {
            String value=map.get(key);
            System.out.println(key+"---"+value);
        }
    }
    @Test
    public void test03(){
        Map<Integer,String> map =new HashMap<>();
        map.put(01,"tom");
        map.put(02,"jerr");
        map.put(03,"rose");
        map.put(04,"tom");
        //遍历
        Set<Map.Entry<Integer,String>> set =map.entrySet();//把每对key-value 看成以恶搞entry封装到一个set集合
        for (Map.Entry<Integer, String> entry : set) {
            //通过entry 获取 key 和value
            Integer key= entry.getKey();
            String value= entry.getValue();
            System.out.println(key+"---"+value);
        }
    }
}

HashMap

  • 特点 key 唯一 无序
  • 底层结构:哈希表
  • 效率:综合效率高
  • key 去重原理, 先比较key 的哈希值 然后哈希值相同,在进行equals比较
 public class HashMapTest {
    @Test
    public void test01(){
        HashMap<String,Integer> map =new HashMap<>();
        map.put("tom",18);
        map.put("jerr",20);
        map.put("rose",19);
        map.put("tom",20);
        //遍历
        Set<String> keySet=map.keySet();
        for (String key : keySet) {
            Integer value=map.get(key);
            System.out.println(key +value);
            //去重了,因为字符串 hashcode 重写了
        }
    }

* linkedHashMap 实现类

  • 是hashmap 的子类
  • 特点:key 唯一 有序
  • 底层结构:哈希表基础维护一个链表 用于保证元素的迭代顺序
  • 效率:略低于hashmap
 * public class LinkedHashMapTest {
    @Test
    public void test01(){
        HashMap<String,Integer> map =new HashMap<>();
        map.put("tom",18);
        map.put("jerr",20);
        map.put("rose",19);
        map.put("tom",20);
        Set<Map.Entry<String,Integer>> entries=map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key =entry.getKey();
            Integer value=entry.getValue();
            System.out.println(key+value);
        }
    }
}

* TreeMap 实现类

  • 特点:key 唯一 无序 但实现了排序
  • 底层结构:红黑树
  • 效率:高于链表
  • TreeMap 集合实现了对象key的排序,所以要求key 必须可以比较大小,即要求key类型实现了comparable接口
  • 或者创建treemap 集合时 传入一个comparator 比较器来比较key 的大小
 public class TreeMapTest {
    @Test
    public void test01(){
        TreeMap<Integer,String> map=new TreeMap<>();
        map.put(110,"警察");
        map.put(120,"医生");
        map.put(119,"急救");
        map.put(114,"坦克");
        Set<Integer> keys =map.keySet();
        for (Integer key : keys) {
            String value=map.get(key);
            System.out.println(key+value);
        }
    }
}

Collections工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法:

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值