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

原创已于 2023-12-13 10:13:22 修改 · 412 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2023-06-19 10:15:58 首次发布

本文介绍了Java中的集合框架，包括ArrayList和LinkedList的特点与使用，Set集合如HashSet和TreeSet的差异，以及泛型的概念和应用。还讨论了集合的并发修改异常问题，如何避免在遍历过程中删除元素导致的问题。另外，提到了Map集合的遍历方式和不可变集合的创建。

集合是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("","🐅",21);
        Card xiao = new Card("","🃏",20);
        //所有的牌已经存入到集合中
        Collections.addAll(allCards,da,xiao);    //Collections的api

    }

    public static void main(String[] args) {
        //洗牌
        Collections.shuffle(allCards);
        //建立3个玩家，也就是三个集合
        List<Card> wang = new ArrayList<>();
        List<Card> zhang=new ArrayList<>();
        List<Card> li = new ArrayList<>();
        //54张牌，发51张，采用轮询方式，轮询用取余
        for (int i = 0; i < allCards.size() - 3; i++) {
            if (i % 3 ==0){
                wang.add(allCards.get(i));
            }else if (i % 3 ==1){
                zhang.add(allCards.get(i));
            }else if(i % 3 ==2){
                li.add(allCards.get(i));
            }
        }
        //把最后三张牌当作地主牌
        List<Card> cards = allCards.subList(allCards.size() - 3, allCards.size());
        sortCard(wang);
        sortCard(zhang);
        sortCard(li);
        System.out.println(cards);
    }
    //定义一个方法，用来排序
    private static void sortCard(List<Card> cards) {
        Collections.sort(cards, new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o2.getIndex()-o1.getIndex();
            }
        });
        System.out.println(cards);
    }

Map集合

Map集合的遍历方式

第一种：键找值，先拿到集合的全部键，遍历每个键，根据键取值

 Map<String,Integer> map=new HashMap<>();
        map.put("伽罗",20);
        map.put("刘备",23);
        map.put("关羽",27);
        map.put("伽罗",30);
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }

第二种：键值对

使用forEach遍历集合，发现Map集合的键值对元素直接是没有类型的。所以不可以直接forEach遍历集合。

 Map<String,Integer> map=new HashMap<>();
        map.put("伽罗",20);
        map.put("刘备",23);
        map.put("关羽",27);
        map.put("伽罗",30);
        //把map集合转换成set集合
        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);
        }

第三种：Lambda表达式

第三种，map.forEach(new BigConsumer)

 Map<String,Integer> map=new HashMap<>();
        map.put("伽罗",20);
        map.put("刘备",23);
        map.put("关羽",27);
        map.put("伽罗",30);
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"="+integer);
            }
        });

简化之后代码，简化为一行（推荐用这种，简单）

 public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("伽罗",20);
        map.put("刘备",23);
        map.put("关羽",27);
        map.put("伽罗",30);
        map.forEach(( s, integer) -> System.out.println(s+"="+integer));
    }

 public static void main(String[] args) {
       StringBuilder sb=new StringBuilder();
       String[] JingDian={"A","B","C","D"};
       Random r=new Random();
        //让80个人随机选择景点
        for (int i = 0; i < 80; i++) {
            sb.append(JingDian[r.nextInt(JingDian.length)]);
        }
        System.out.println(sb);
        Map<Character,Integer> map=new HashMap<>();
        for (int i = 0; i < sb.length(); i++) {
            char c = sb.charAt(i); //获取每一个景点
            //判断集合是否包含这个景点，如果有，取出值加1
           if (map.containsKey(c)){
               map.put(c, map.get(c)+1);
           }else{
               map.put(c,1);
           }
        }
        System.out.println(map);
    }

LinkedHashMap

集合嵌套

public static void main(String[] args) {
        Map<String, List<String>> map= new HashMap<>();
        List<String> list1=new ArrayList<>();
        Collections.addAll(list1,"A","B","C");
        List<String> list2=new ArrayList<>();
        Collections.addAll(list2,"A","D");
        List<String> list3=new ArrayList<>();
        Collections.addAll(list3,"C","D");
        map.put("伽罗",list1);
        map.put("刘备",list2);
        map.put("关羽",list3);
        System.out.println(map);
        //统计人数
        Map<String,Integer> people=new HashMap<>();
        //先得到集合map的所有的值，再遍历map
        Collection<List<String>> values = map.values();
        System.out.println(values);
        for (List<String> value : values) {
            for (String s : value) {
                if (people.containsKey(s)){
                    people.put(s,people.get(s)+1);
                }else{
                    people.put(s,1);
                }
            }
        }
        System.out.println(people);

    }

不可变集合

如何创建不可变集合

创建不可变集合

 List<Double> list=List.of(34.0,23.3,34.4,90.9);
       //list.add(34.2);
       //list.set(2,88.8);
       // System.out.println(list);
        Set<String> set=Set.of("伽罗","刘备","关羽","吕布");
       // set.add("张飞");
        Map<String,Integer> maps=Map.of("张飞",20,"关羽",21,"刘备",22);
        //maps.put("伽罗",23);

修改删除不可变集合之后，会报java.lang.UnsupportedOperationException