Java - 集合

已于 2022-07-22 17:44:10 修改
阅读量244 收藏
点赞数 1
分类专栏： JAVA # j 文章标签： java 开发语言 后端
于 2022-01-09 11:43:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHHX666/article/details/122286020
版权

文章目录

1. 集合

在这里插入图片描述

2. 集合体系结构

在这里插入图片描述

3. 单列集合

在这里插入图片描述

3.1 ArrayList集合

在这里插入图片描述

3.1.1 ArrayList特点

1.有序: 保证存入和取出元素的顺序是一致的
2.有索引: 可以通过索引的方式获取元素
3.可重复: 可以存储相同的内容

1.底层数据结构:数组
2.查询快: 元素有索引,元素内存空间连续
3.增删慢:
    数组长度不可改变
    需要频繁创建新数组,拷贝元素,销毁老数组
4.线程不同步,不安全,效率高

-------------JDK 1.0 Vector集合--------------
和ArrayList 唯一不同是:
	有synchronized 修饰，线程同步,安全,效率低

3.1.2 构造方法

在这里插入图片描述

3.1.3 方法

  • 删除方法
E	remove(int index)
Removes the element at the specified position in this list.
* 删除指定索引的元素
* 底层用 ``System.arraycopy(elementData, index+1, elementData, index, numMoved);`` 将索引后面的元素整体向前移动一位，最后空出来的设为null,元素个数减一。
  • toArray()
Object[]	toArray()
Returns an array containing all of the elements in this list in proper sequence (from first to last element).
* 将集合返回数组
* 底层用System.arraycopy() ,都是数组拷贝。

3.1.4 ArrayList底层原理

  • 底层基于Object[] 数组实现，增删需要做元素的移位操作。

3.1.5 遍历ArrayList删除特定元素，出现删不干净的现象

package com.arraylist_test;
import java.util.ArrayList;
public class Test01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("d");
        list.add("e");
        System.out.println(list);//[a, b, b, d, e]

        //遍历删除所有元素 "b"
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("b")) {
                list.remove(i);
            }
        }
        System.out.println(list);//[a, b, d, e] 发现漏删除
    }
}
  • 原因：
    • 删除操作，会将后面的元素整体向前移位。
    • 删除第一个"b" 索引是1，后面的元素整体向前移动一位。
    • 此时 第二个"b" 索引有原来的2 变为了 1 。
    • 但for循环 i 已经为2了，漏过了第二个"b"。
  • 解决方法:
  • 1 倒叙删除
        for (int i = list.size() - 1; i >= 0; i--) {
                if (list.get(i).equals("b")) {
                    list.remove(i);
                }
        }
  • 2 删除操作后 i–
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("b")) {
                list.remove(i);
                i--;
            }
        }

3.2 LinkedList集合

3.2.1 LinkedList特点

特点:
    1.底层数据结构:双向链表
    2.增删快: 元素分配不连续的,添加/删除元素,只需要找到位置,再修改对应节点保存地址的地方
    3.查询慢:
        要么从前向后查,要么从后向前查
    4.线程不同步,不安全,效率高

3.2.2 方法

public void addFirst(E e) :	将指定元素插入此列表的开头。
public void addLast(E e) :	将指定元素添加到此列表的结尾。
public E getFirst() :		返回此列表的第一个元素。
public E getLast() :		返回此列表的最后一个元素。
public E removeFirst() :	移除并返回此列表的第一个元素。
public E removeLast() :		移除并返回此列表的最后一个元素。
public void push(E e) :     底层调: addFirst
public E pop() :            底层调: removeFirst

3.3 HashSet

在这里插入图片描述

package set;

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

public class SetDemo01 {

    public static void main(String[] args) {

        Set<String> sets = new HashSet<>(); //无序 不重复 无索引
        //Set<String> sets = new HashSet<>(); //有序 不重复 无索引
        sets.add("Java");
        sets.add("hhh");
        sets.add("a");
        sets.add("b");
        sets.add("c");

        System.out.println(sets);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package set;

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    private String gender;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name) && Objects.equals(gender, student.gender);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, gender);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

package set;

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

public class SetDemo03 {

    public static void main(String[] args) {
        Set<Student> students = new HashSet<>();

        students.add(new Student("zhx",20,"male"));
        students.add(new Student("zhx",20,"male"));
        students.add(new Student("libai",2077,"male"));

        System.out.println(students);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package set;

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

public class SetDemo05 {

    public static void main(String[] args) {

        Set<Integer> sets = new TreeSet<>();
        sets.add(12);
        sets.add(23);
        sets.add(21);
        sets.add(88);
        System.out.println(sets);//[12, 21, 23, 88]

        Set<String> sets2 = new TreeSet<>();
        sets2.add("d");
        sets2.add("a");
        sets2.add("C");
        sets2.add("B");
        sets2.add("A");
        System.out.println(sets2);//[A, B, C, a, d]

    }
}


package set;

public class Apple implements Comparable<Apple>{

    private String name;
    private int weight;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public Apple(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public Apple() {
    }

    @Override
    public int compareTo(Apple o) {
        return this.weight - o.weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
}

package set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo05 {
    public static void main(String[] args) {
        Set<Apple> sets3 = new TreeSet<>();
        sets3.add(new Apple("a",10));
        sets3.add(new Apple("b",10));
        System.out.println(sets3); //[Apple{name='a', weight=10}]

        Set<Apple> sets4 = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                //return o1.getWeight()-o2.getWeight();//升序
                return o1.getWeight()-o2.getWeight(); //降序
            }
        });
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.4 Map

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package map;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapDemo01 {

    public static void main(String[] args) {

        Map<String,Integer> maps = new HashMap<>();

        maps.put("李宁",10);
        maps.put("那可",-10);
        maps.put("羊毛",1200);
        maps.put(null,null);

        System.out.println(maps);
    }
}

在这里插入图片描述

package map;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapDemo01 {

    public static void main(String[] args) {

        Map<String,Integer> maps = new LinkedHashMap<>();

        maps.put("李宁",10);
        maps.put("那可",-10);
        maps.put("羊毛",1200);
        maps.put(null,null);

        System.out.println(maps);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package map;

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

public class MapDemo02 {

    public static void main(String[] args) {

        Map<String,Integer> maps = new HashMap<>();

        maps.put("1",100);
        maps.put("2",200);
        maps.put("3",300);
        maps.put("4",200);
        maps.put("5",100);

        System.out.println(maps);//{1=100, 2=200, 3=300, 4=200, 5=100}

        //清空集合
//        maps.clear();
//        System.out.println(maps);

        //判断集合是否为空
        System.out.println(maps.isEmpty()); //false

        //根据键获取值
        Integer integer = maps.get("1");
        System.out.println(integer ); //100

        Integer integer1 = maps.get("");
        System.out.println(integer1); //null

        //根据键删除元素
        maps.remove("5");
        System.out.println(maps);//{1=100, 2=200, 3=300, 4=200}

        //是否包含某个键
        System.out.println(maps.containsKey("4"));//true
        //是否包含某个值
        System.out.println(maps.containsValue(200));//ture

        //获取键的集合
        Set<String> strings = maps.keySet();
        System.out.println(strings);//[1, 2, 3, 4]

        //获取值的集合
        Collection<Integer> values = maps.values();
        System.out.println(values);//[100, 200, 300, 200]

        System.out.println(maps.size());

        Map<String,Integer> maps2 = new HashMap<>();
        maps2.put("a",100);
        maps2.put("b",100);
        maps2.put("c",100);

        //将maps2 添加到maps
        maps.putAll(maps2);
        System.out.println(maps);//{1=100, a=100, 2=200, b=100, 3=300, c=100, 4=200}
        System.out.println(maps2 );//{a=98, b=100, c=100}


    }
}

Map集合的遍历

在这里插入图片描述
在这里插入图片描述

package map;

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

public class MapDemo03 {

   public static void main(String[] args) {
       Map<String, Integer> maps = new HashMap<>();

       maps.put("a", 100);
       maps.put("b", 200);
       maps.put("aaa", 300);
       maps.put("c", 400);
       maps.put("d", 200);

//方式一
       Set<String> keys = maps.keySet();
       for (String key : keys) {
           System.out.println(key + ":" + maps.get(key));
       }

//方式二
       Set<Map.Entry<String, Integer>> entries = maps.entrySet();
       for (Map.Entry<String, Integer> entry : entries) {
           String key = entry.getKey();
           Integer value = entry.getValue();
           System.out.println(key + " : " + value);
       }

   }
}

在这里插入图片描述

        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+" : "+integer);
            }
        });

        maps.forEach((k,v)->System.out.println(k+" : "+v));

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

参考资料

B站黑马视频

从零开始的JAVA世界
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList(JDK1
m0_61364397的博客
11-06 114
注：既然是源码，为什么要这样设计类，有这样的继承关系。这就要说到设计模式的问题了。所以我们要了解常用的设计模式，才能更深刻的去理解这个类。 文章目录 简介 继承关系图 成员变量 构造方法 内部类 核心方法 add()方法（有四个） 对数组的容量进行调整 大数据插入问题 remove()方法 get()方法 set()方法 indexOf()方法 contains()方法 toArray()方法 System.arraycopy()和 A
Java-集合
qq_42913378的博客
04-17 220
集合 使用Array存储对象方面具有一些弊端，而java集合就像一种容器，可以动态德把多个对象的引入放入容器中 1 集合框架的概述 1.集合、数组都是对多个数据进行存储操作的结构，简称java容器 说明：此时的存储，主要指内存层面的存储，不涉及到持久化的存储（.txt,.jpg) 2.1数组在存储多个数据方面的特点 一旦初始化以后，其长度就确定了。 数据一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如String[]，arr,int[] 2.2 数组 在存储多个数据
java list集合删除元素要倒着删除
Mr_tie的博客
05-20 1309
public class Demo { public static void main(String[] args) { List list = new ArrayList(); list.add("a"); list.add("b"); list.add("c"); list.add("b"); list.add("b"); for(int i = list....
java数组删除：删除数组中元素5对应位置上的元素，并将后面的元素前移，输出新的数组
Jungleforward的博客
05-12 2599
删除数组 /删除数组 1 int[] arr={1,2,3,4,5,6,7,8,9,10,0,0,0,0}; 2 删除元素5对应的位置上的元素，并将所有的元素前移 3 先找出要删除的位置用p进行标记赋值，然后从p点开始移动元素，判断元素为0时候停止调换 4.循环打印出新的数组 public class IncreaseArrays { public static void main(String[] args) { int[] arr={1,2,3,4,5,6,7,8,9,10,0,0,0,0};
Java中ArrayList如何删除指定位置的元素
m0_71777195的博客
01-08 4482
总结：使用迭代器遍历时ArrayList会用lastRet和cursor两个变量来维护当前遍历的元素索引和下一次需要遍历元素的索引，通过这两个变量就可以实现迭代中正确的删除某个位置的元素。我们通过list.iterator()拿到的就是这个内部类的对象实例，这个类中有两个字段cursor和lastRet，这两个字段就是我们能在迭代器中正确删除对应位置的元素的关键。首先当我们删除第10位元素时，List会将后面的元素向前补位，之后再查第10位元素就会输出第11位元素。
Java循环语句练习-删除指定的下标的元素，要求从删除的位置开始，之后的元素前移一位
一名资深Java工程师的技术分享
01-04 1061
删除指定的下标的元素，要求从删除的位置开始，之后的元素前移一位。 要求：删除指定的下标的元素，从删除的位置开始，之后的元素前移一位 对应的Java代码参考如下： public class Demo { public static void main(String[] args) { int[] arr = {1,3,5,7,9,11,13,15,17,19}; boolean remove = remove(arr, 0); System.out.pr
Java--集合
追求灵魂代码
10-06 607
目录实验目标正文截图总结 实验目标 编写程序练习List集合及泛型的基本使用： 1、 创建一个只能容纳String对象名为names的ArrayList集合； 2、按顺序往集合中添加5个字符串对象：“张三”、“李四”、“王五”、“马六”、“赵七”； 3、对集合进行遍历，分别打印集合中的每个元素的位置与内容； 4、首先打印集合的大小，然后删除集合中的第3个元素，并显示删除元素的内容，然后再打印目前集...
test java-集合
06-11
test java-集合
后端开发JAVA-集合
09-13
后端开发JAVA-集合
java-集合-知识点汇总
09-05
"Java集合知识点汇总" Java集合是Java语言中的一种数据结构，用于存储和操作数据。Java集合的知识点汇总将会涵盖Java集合的基本概念、类型、实现、操作和注意事项等方面。 Java集合的基本概念 Java集合是Java语言...
Java数组中的元素删除并实现向前移的代码
09-02
主要介绍了Java数组中的元素删除并实现向前移的代码的相关资料,需要的朋友可以参考下
JAVA-集合-基础部分
11-12
提供给正在学习java的同学，本资源属于个人学习所总结，有帮助的麻烦给个三连！一起学习！ 一起进步！！！ 后续会持续更新！
Java-集合中如何过滤出拥有相同属性的对象并返回.html
07-01
java郑
java数组中删除元素或一个数组元素
m0_61466807的博客
08-04 4万+
最后将中间的temp数组通过copy再返回，原因是 删除元素后的数组长度是需要测量出来的，即为代码中的index。找到需要删除的元素，（这只限于删除第一个找到err元素，如果需要删除数列中全部的err元素，看代码中注释）将原数组写入新数组的同时对写入的元素进行判断是否在需要删除的数组中。运用flag进行标记是否需要写入（即该元素是否在需要删除的数组中）后面所有的元素向前一个位置覆盖之前的元素，达到删除元素的效果。将原数组中值写入新数组时进行判断是否为要删除的元素，通过fiag的标识，在新的数组中写入元素，.
java数组：去重，增加，删除元素
evilcry2012的专栏
12-06 6883
java数组：去重，增加，删除元素 import java.util.List; import java.util.ArrayList; import java.util.Set; import java.util.HashSet; public class Code { public static void main(String [] args) { test...
java 中数组中删除元素_java数组中删除元素的操作
weixin_39818550的博客
02-25 6945
我们在学习数组的开始，就明确过初始的长度是不可变化的。但是在实际的使用中，难免会涉及到对数组的改动。本篇我们带来的是在数组中删除元素的方法：remove和索引。相信这两种概念大家都不陌生，那么结合了数组的改动后，需要在使用时注意一些事项了。下面就具体用法展开讲解。1.使用remove()方法将内部类的list类型转换为工具类的list类型，因为工具类的list类型重新定义了list的一些add，r...
Java 数组元素的删除
热门推荐
Janebook的博客
05-28 6万+
Java数组的长度固定，因此无法直接删除数组中的元素。 通过创建新的数组，将保留的原数组中的元素赋值到新数组来实现原数组元素的删除。同理，可以实现数组添加元素。 package package1; import java.util.Arrays; public class ArrayTest1 { public static void main(String[] args) { ...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 277
1.导入hutool的maven依赖。2.复制一下代码执行。
JAVA-SE入门：集合详解与应用
"这篇教程主要介绍了JAVA-SE入门学习中的集合相关知识，包括集合与数组的区别、集合类体系结构、Collection接口以及集合的遍历方法，重点讲解了迭代器的使用。" 在Java编程中，集合是用于存储多个对象的数据结构。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值