小惠珠哦

这个屌丝很懒，什么也没留下！

热门标签

Java基础知识点集合（学习集合这一篇就够了）_java集合知识点

作者：小惠珠哦 | 2024-08-13 08:22:28

踩

java集合知识点

集合是java中存储对象的容器，不能存储基本类型。大小不固定，可以动态变化，非常适合做元素的增删操作。只能存储引用类型非要存储基本类型，选择包装类。

1.数组和集合的元素存储的个数问题。

数组定义后类型确定，长度固定

集合类型可以不固定，大小是可变的

2.数组和集合存储元素的类型问题

数组可以存储基本类型和引用类型的数据

集合只能存储引用类型的数据

3.数组和集合适用的场景

数组适合做数据个数和类型确定的场景（存储东南西北，存储男女）

集合适合做数据个数不确定，且要做增删元素的场景

集合的体系结构

先学单列集合

List系列集合：有序、可重复、有索引

ArrayList、LinkedList：有序、可重复、有索引

Set集合：添加的元素无序、不重复、无索引

HashSet 无序、不重复、无索引

LinkedSet有序、不重复、无索引

TreeSet按着大小默认升序、不重复、无索引

如何约定集合存储的数据类型（集合支持泛型）

学习Collection的api，Collection是单列集合的祖宗，所有的单列集合都继承Collection的方法


        Collection<String> list = new ArrayList<>();
        //1.集合中添加元素,添加成功返回true，失败返回false
        list.add("java");
        list.add("Java");
        list.add("html");
        list.add("html");
        //2.清空元素
        list.clear();
        //3.判断是否为空
        list.isEmpty();
        //4.获取集合的大小
        list.size();
        //5.判断集合是否包含某元素
        list.contains("java");
        //6.删除集合的元素
        list.remove("java");
        // list.remove(2);不支持索引删除，只支持值删除
        //将集合转换成数组
        Object[] arr=list.toArray();

将集合转成数组，必须用Object来接收。

集合合并集合1.addAll(集合2)


        Collection<String> c1 = new ArrayList<>();
        c1.add("java");
        c1.add("html");
        Collection<String> c2= new ArrayList<>();
        c2.add("spring");
        c2.add("ssm");
        //把集合2中的元素合并到集合1，集合2中的元素也存在
        c1.addAll(c2);

Collection集合的遍历方式

1.第一种迭代器，取元素的时候c1.next() ,如果越界报异常NoSuchElementException


        Collection<String> c1 = new ArrayList<>();
        c1.add("java");
        c1.add("html");
        c1.add("css");
        //迭代器  
        Iterator<String> iterator = c1.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

2.第二种，foreach或者增强for循环，既可以遍历数组，也可以遍历集合。其内部原理是iterator迭代器

for(数据类型变量名：数组或collection集合){

//在此处使用变量

}

快捷键：数组名或集合名.for


        Collection<String> c1 = new ArrayList<>();
        c1.add("java");
        c1.add("html");
        c1.add("css");
        //增强for
        for (String s : c1) {
            System.out.println(s);
        }

3.第三种 lambda表达式，通过调用forEach()方法，在方法中new Consumer


        Collection<String> c1 = new ArrayList<>();
        c1.add("java");
        c1.add("html");
        c1.add("css");
        //lambda表达式，通过调用forEach()方法来遍历
        c1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //上面代码简化成下面格式
        c1.forEach(s-> System.out.println(s));

Collection集合不支持for循环遍历，集合不能通过索引查找对象

集合中存储的是元素的地址

List集合因为支持索引，所以多了很多索引的api，其他Collection的功能也都继承。


        //list集合特点  有序 重复 有索引
        List<String> list=new ArrayList<>();
        list.add("java");
        list.add("java");
        list.add("html");
        list.add("spring");
        //1.在某个位置插入元素
        list.add(2,"ssm");
        //2.根据索引删除元素，返回被删除元素
        System.out.println(list.remove(1));
        //3.根据索引获取元素
        System.out.println(list.get(2));
        //4.修改索引位置的元素，返回被修改的元素
        System.out.println(list.set(2, "mybatis"));

List实现类的底层原理

ArrayList底层是基于数组实现的，查询速度快，增删慢。

LinkedList底层是基于双链表实现的，查询元素慢，增删首尾元素快。

List集合的遍历方式有四种

iterator、增强for、lambda表达式、for循环

写一下for循环就行，通过list.get(索引) 来遍历


        List<String> list=new ArrayList<>();
        list.add("java");
        list.add("java");
        list.add("html");
        list.add("spring");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

ArrayList集合底层原理

List集合存储的元素超过容量后会扩容，扩容到原来的1.5倍。

一些常用api


         //栈
       LinkedList<String> stack=new LinkedList<>();
        //压栈，入栈
        stack.addFirst("第一颗子弹");
        stack.push("第二颗子弹");     //用push代替addFirst，作用一样
        stack.push("第三颗子弹");
        System.out.println(stack);
        stack.removeFirst();
        stack.pop(); //用stack.pop代替removeFirst，作用一样
        System.out.println(stack);
        //队列
        LinkedList<String> queue=new LinkedList<>();
        //入队
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        System.out.println(queue);
        //出队
        queue.removeFirst();
        queue.removeFirst();
        System.out.println(queue);

集合的并发修改异常问题

必须用迭代器自带的remove，如果用集合的remove方法，会报错(并发修改异常)，会漏删


       List<String> list = new ArrayList<>();
       list.add("java");
       list.add("java");
       list.add("html");
       list.add("ssm");
       Iterator<String> iterator = list.iterator();
       while(iterator.hasNext()){
           String next = iterator.next();
           if ("java".equals(next)){
               //list.remove("java") 会报错
               iterator.remove();  //保证不后移，会遍历到全部元素
           }
       }
        System.out.println(list);

不能用forEach遍历删除，Bug解决不了。

lambda也不能遍历删除，底层源码就是forEach

for循环正向着删除，也会漏删，但是不会报错。


       List<String> list = new ArrayList<>();
       list.add("html");
       list.add("ssm");
        list.add("java");
        list.add("java");
        for (int i = 0; i < list.size()-1; i++) {
            if("java".equals(list.get(i))){
                list.remove("java");
            }
        }
        System.out.println(list);

会漏删

for循环倒着遍历删除，不会出错


       List<String> list = new ArrayList<>();
       list.add("html");
       list.add("ssm");
        list.add("java");
        list.add("java");
        //倒着遍历不会出错
        for (int i = list.size()-1; i >=0; i--) {
            if("java".equals(list.get(i))){
                list.remove("java");
            }
        }
        System.out.println(list);

for循环如果非要正向删除，在下面加上 i-- 就可以


  List<String> list = new ArrayList<>();
       list.add("html");
       list.add("ssm");
        list.add("java");
        list.add("java");
        for (int i = 0; i < list.size()-1; i++) {
            if("java".equals(list.get(i))){
                list.remove("java");
            }
            i--;
        }
        System.out.println(list);

泛型

任意类型 + " " 都变成字符串类型


      double a= 1.0;
      String s=a+"";
      System.out.println(s);

泛型类、泛型接口、泛型方法

泛型方法

泛型方法用<T>修饰，定义的数组必须是引用类型。


 public static void main(String[] args) {
        Integer[] arr={2,4,6,3,1};
        printArray(arr);
    }
    public static <T> void printArray(T[] arr){
        if (arr !=null){
            StringBuilder sb=new StringBuilder("[");
            for (int i = 0; i <= arr.length - 1; i++) {
                sb.append(arr[i]).append(i == arr.length - 1 ? "" : ",");
 
            }
            sb.append("]");
            System.out.println(sb);
        }else{
            System.out.println(arr);
        }
    }

泛型接口

泛型接口的作用，可以让实现类选择当前功能需要操作的数据类型。

有Teacher类、Student类、Data接口、TeacherData实现类

Data接口种的代码如下

泛型通配符

？在使用泛型的时候代表一切类型。泛型的上下限 ? extends Car 必须是Car或其子类

? super Car 必须是父类或Car

Set集合

因为根据哈希值，可以快速的实现增删改查。

先根据哈希值取余，找到位置，再看位置是否为null，如果为null直接存入。不为null，用equals()方法比较内容是否一样。

Set集合去重复原因，先判断哈希值，在判断equals。Set集合里面存对象，如果对象中内容一样，set想要去掉重复的，必须在对象类中，重写hashcode()和equals()方法。

在没有在Student类中，重写equals()和


        Set<Student> set=new HashSet<>();
        Student s1=new Student("伽罗",20,170.0);
        Student s2=new Student("伽罗",20,170.0);
        Student s3=new Student("刘备",23,180.0);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        set.add(s1);
        set.add(s2);
        set.add(s3);
        System.out.println(set);

输出台中，hashcode值不一样，而且集合中存储两个伽罗信息

LinkedHashSet

TreeSet

要想使用TreeSet存储自定义类型，需要指定排序规则。

在对象类实现Comparable接口，重写compareTo方法时，要注意下面规则

写一个Student类


public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private double height;
 
    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
 
    public Student() {
    }
 
    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 double getHeight() {
        return height;
    }
 
    public void setHeight(double height) {
        this.height = height;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
 
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}

在重写的方法中，return this.age - o.age; 如果有两个对象的年龄相等，会被TreeSet判定为两个相同的对象，就会去掉一个。

输出结果会这样显示

重写的方法可以这样写，就只会返回两个值


 @Override
    public int compareTo(Student o) {
        return this.age-o.age >=0 ? 1:-1;
    }

第二种自定义规则的方法，用集合自带的比较器比较。


 public static void main(String[] args) {
        Set<Student> set=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge() >=0 ? 1:-1;
            }
        });
        Student s1=new Student("关羽",20,170.0);
        Student s2=new Student("伽罗",20,170.0);
        Student s3=new Student("刘备",23,180.0);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        System.out.println(set);
 
    }

如果想通过身高去比较，用Double的api，Double.compare(o2.getHeigth(),o1.getHeight()) 这是降序


 Set<Student> set=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o2.getHeight(),o1.getHeight());
            }
        });

用Double.compare()比较，当两个数值大小一样时，应该怎么办？


import java.util.Arrays;
 
public class Main {
    public static void main(String[] args) {
        double[] values = { 3.5, 2.0, 5.1, 3.5, 1.8 };
 
        Arrays.sort(values, (a, b) -> {
            int compareResult = Double.compare(a, b);
            if (compareResult != 0) {
                return compareResult;
            } else {
                // 在比较结果为0时，在这里添加其他排序条件
                // 例如，按照原始顺序保持相等值的相对顺序
                return 0; // 或者可以返回其他值进行排序
            }
        });
 
        // 输出排序结果
        for (double value : values) {
            System.out.println(value);
        }
    }
}

可变参数


 public static void main(String[] args) {
        MethodSum(); //可以不传入参数
        MethodSum(1); //可以传1个参数
        MethodSum(2,3,4,5,6); //可以传多个参数
    } 
    //一个方法只能传入一个可变参数
    //传入可变参数，必须放在其他参数后面
    //public static void MethodSum(int a,int...arr)
    public static void MethodSum(int...arr){
        //可变参数在方法本质就是一个数组
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
    }

Collections集合工具类

快捷键 Shift+F6 选中一个名字后，可以一下全部改所有的名字

Collections几个常用的api

public static<T> boolean addAll(Collection<? super T>)给集合对象批量添加元素。

addAll中添加T类和他的子类都可以。

1.批量添加数据（给所有的Collection集合添加数据）


  public static void main(String[] args) {
      List<Integer> list=new ArrayList<>();
      list.add(2);
      list.add(89);
      list.add(34);
      list.add(6);
      Collections.addAll(list,2,3,4,5,11,6,100,0);  //一行代码就搞定
 
    }

2.打乱List集合顺序

public static void shuffle (List<?> list) :打乱list集合顺序

Collections.shuffle();

3.对List集合排序

public static<T> void sort(List<T> list);

Collections.sort()；默认排有值特性的List，比如int类型


  List<Integer> list=new ArrayList<>();
      Collections.addAll(list,7,56,87,4,0,1);
      Collections.sort(list);
        System.out.println(list);

如果对自定义对象排序，除非有两种情况，第一种：对象类实现了Comparable接口，并重写了CompareTo方法，自定义了比较规则。

第二种：如下代码


 public static void main(String[] args) {
      List<People> list=new ArrayList<>();
      People p1=new People("伽罗",20,false);
      People p2=new People("刘备",23,true);
      People p3=new People("关羽",32,true);
      Collections.addAll(list,p1,p2,p3);
      Collections.sort(list, new Comparator<People>() {   //自定义规则
          @Override
          public int compare(People o1, People o2) {
              return o1.getAge()-o2.getAge();
          }
      });
        System.out.println(list);
    }

斗地主案例

先定义一个Card类（index的作用是给每个牌赋值，每张牌的真正大小）


public class Card {
    private String size;
    private String color;
    private int index;
 
    public Card() {
    }
 
    public Card(String size, String color,int index) {
        this.size = size;
        this.color = color;
        this.index = index;
    }
 
    public String getSize() {
        return size;
    }
 
    public void setSize(String size) {
        this.size = size;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
 
    public int getIndex() {
        return index;
    }
 
    public void setIndex(int index) {
        this.index = index;
    }
 
    @Override
    public String toString() {
        return color+size;
    }


 public static ArrayList<Card> allCards=new ArrayList<>();
    static {
        String[] size = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        String[] color = {"♥","♣","♠","♦"};
 
        for (String s : color) {
            int index=0;
            for (String s1 : size) {
                ++index;  //每张牌都有索引值的大小
                Card c=new Card(s1,s,index);
                allCards.add(c);
            }
        }
        Card da = new Card("","声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/973982
推荐阅读
articleMac搭建Java环境【环境搭建】_mac java...
Mac搭建Java环境【环境搭建】_mac javamac java                          ...
                                    赞
踩
articleJava 日志性能优化...
1. 选择合理的日志级别、合理控制日志内容2. 控制日志的输出内容和格式logger.debug("Entry numb...
                                    赞
踩
articlejava 异步 日志_异步打印日志的一点事...
一、前言最近刚刚结束转岗以来的第一次双11压测，收获颇多，难言言表， 本文就先谈谈异步日志吧，在高并发高流量响应延迟要求...
                                    赞
踩
articlejava 异步记录日志,异步非阻塞远程日志记录在Java中？...
Is there a lightweight logging framework/server I can use to...
                                    赞
踩
articlejava 多线程 异步日志_精彩技巧（1）-- 异步打印日志的一点事...
本文探讨了在高并发、低延迟需求的系统中，同步日志打印存在的问题以及如何通过异步日志解决。详细介绍了同步日志模型和异步日志...
                                    赞
踩
articlejava 异步写文件_java异步写日志到文件中实现代码...
这篇博客详细介绍了如何在Java中实现异步写日志到文件，包括使用`LogWriter`类进行初始化、写入日志信息以及异常...
                                    赞
踩
articlejava 多线程 异步日志_log4j2日志异步打印(实例讲解)...
log4j2支持日志的异步打印，日志异步输出的好处在于，使用单独的进程来执行日志打印的功能，可以提高日志执行效率，减少日...
                                    赞
踩
articleJava---数组...
无论c语言还是java数组都是重中之重，今天我们来学习java数组，看他与C语言中有几分不同。Java---数组    ...
                                    赞
踩
article【Java】SpringBoot实现异步任务（案例实现）_springboot异步执行任务...
SpringBoot实现异步任务（案例实现）_springboot异步执行任务springboot异步执行任务     ...
                                    赞
踩
articleJava实现用户画像活动推荐系统 JAVA+Vue+SpringBoot+MySQL_用户画像 ja...
基于JAVA+Vue+SpringBoot+MySQL的用户画像活动推荐系统，使用了协同推荐算法，包含了标签管理、活动档...
                                    赞
踩
article（java）websocket服务的两种实现方式_java websocket 服务端...
用java注解来监听连接@ServerEndpoint、连接成功@OnOpen、连接失败@OnClose、收到消息等状态...
                                    赞
踩
article【Java】：洗牌功能和杨辉三角的实现...
本篇文章详细介绍了如何用链表完成洗牌算法，和杨辉三角的实现【Java】：洗牌功能和杨辉三角的实现            ...
                                    赞
踩
article03弱引用内存泄露和hash冲突-ThreadLocal详解-并发编程(Java)_threadlo...
03弱引用内存泄露和hash冲突-ThreadLocal详解-并发编程(Java)_threadlocal hash冲突...
                                    赞
踩
article[独有源码]java-jsp爱心之家——流浪动物救助平台的设计与实现53860规划与实现适合自己的毕...
选题背景：在现代社会中，流浪动物问题已经成为一个严重的社会问题。随着城市化进程的加快和人口的增长，越来越多的流浪动物出现...
                                    赞
踩
article微信小程序流浪动物救助平台+后台管理系统SSM-JAVA【数据库设计、论文、源码、开题报告】_流浪动...
本流浪动物救助微信小程序的内容包括管理员和用户两方面。管理员的功能为个人资料管理、用户信息管理、信息发布管理、动物小圈管...
                                    赞
踩
article【毕业设计/课程设计】基于Springboot的流浪动物救助系统设计与实现（源码+文章） Java ...
该系统使用Java语言，SpringBoot框架和MySQL数据库设计实现，包括用户注册管理、密码管理、流浪动物管理、领...
                                    赞
踩
article如何在 Java 中实现自定义的排序算法？...
这里使用的是Java集合框架中的排序方法和接口，如果你需要实现自定义的排序算法（如快速排序、归并排序等），则需要自己编写...
                                    赞
踩
article2024年华为OD机试真题-游戏分组-Java-OD统一考试（C卷）_华为od机试 游戏分组 csd...
这篇博客介绍了2024年华为在线开发者（OD）考试中的一道真题，涉及游戏爱好者分组问题。10名参赛者需按评分分为两队，每...
                                    赞
踩
article2024华为OD机试真题-游戏分组、王者荣耀-(C++/Java/Python)-C卷D卷-100分...
华为OD机试题，10名王者荣耀爱好者需分为两队，每队5人，评分总和代表实力。目标是使两队实力差最小。给定10个评分，求最...
                                    赞
踩
article【华为OD机试】2024年真题C卷&D卷（java）-王者荣耀游戏分组_王者荣耀游戏分组绝对值...
这篇博客介绍了华为2024年机试真题中关于王者荣耀游戏分组的问题，目标是将10名评分不同的参赛者分成两队，使实力差最小。...
                                    赞
踩
相关标签
macos
开发语言
教程
环境搭建
Java
Maven
java
java 异步 日志
java 异步记录日志
java 多线程 异步日志
java 异步写文件
spring boot
spring
vue.js
mysql
websocket
maven
数据结构
链表