[Java]Collection集合

最新推荐文章于 2025-03-09 22:07:40 发布
最新推荐文章于 2025-03-09 22:07:40 发布
阅读量292 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_62245390/article/details/124843330
版权

List系列集合：

1.集合是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型

2.集合只支持引用数据类型，在集合中存储的元素都认为是对象

Collection常用API：

package wryyyyy;


import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        //1.在添加元素这里，有的集合不允许重复
        Collection<String> list = new ArrayList<>();

        list.add("我要吃鱼");
        list.add("wwwww");
        list.add("Java");
        System.out.println(list);

        //2.清空
        //list.clear();
        System.out.println(list);

        //3.判断集合是否为空，空则返回true
        System.out.println(list.isEmpty());

        //4.获取集合大小
        System.out.println(list.size());

        //5.判断集合有没有包含某个元素
        System.out.println(list.contains("wwwww"));

        //6.删除某个元素，如果有两个相同元素默认删前面的
        //如果要删除所有的相同元素应遍历
        //Collection不支持索引，只能通过元素值来删
        list.remove("wwwww");
        System.out.println(list);

        //7.把集合转换成数组
        Object[] arrs = list.toArray(new String[0]);//注意转成Object

        //8.合并两个集合的元素
        Collection<String> list1 = new ArrayList();
        list1.add("123");
        list1.add("abc");
        list.addAll(list1);//把list1中元素全部拷贝到list
        System.out.println(list);
    }
}

Collection集合的遍历：

1.迭代器（集合的专用遍历方式）

//得到当前集合的迭代器对象
Iterator<String> it = list.iterator();
//String ele = it.next();//取一个元素
//System.out.println(ele);//注意不要越界
while (it.hasNext())
{
    String ele = it.next();
    System.out.println(ele);
}

2.foreach遍历/增强for循环（集合数组都可以遍历）

for (String ele:list)//快捷方式：list.   for
{
     System.out.println(ele);//这里ele当做形参，修改无意义
}

Lambda表达式：

        list.forEach(new Consumer<String>()//Consumer是一个接口，不能有对象，只能new一个匿名形式
        {
            @Override
            public void accept(String s)
            {
                System.out.println(s);
            }
        });

        //简化
        list.forEach(s->{
            System.out.println(s);
        });

        list.forEach(s->System.out.println(s));

        list.forEach(System.out::println);

数据结构： 

栈：先进后出，后进先出

堆：先进先出 ，后进后出

数组：根据索引的查询速度快（元素在内存中是连续存储的）

链表：元素在内存中不连续存储，每个元素结点包含数据和下一个结点的地址；

查询慢，无论查询那个数据都要从头开始找；增删块（但找到这个元素慢）。

 

 二叉树：

检索数据快。（以后会具体学习）

List系列集合：

List集合独有方法：

package wryyyyy;

import java.util.ArrayList;
import java.util.List;

public class CollectionDemo1
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<>();
        list.add("Java1");
        list.add("Java2");
        list.add("Java3");
        list.add("Java4");

        list.add(2,"Java2.5");
        System.out.println(list);
        list.remove("Java2.5");//有返回值，返回被删除元素
        System.out.println(list.get(2));
        list.set(2,"modify");//有返回值，返回修改前的数据
    }
}

 ArrayList集合底层原理：

当插入元素超过10时要进行扩容

LinkedList集合：

底层数据结构是双链表，查询慢，首尾操作速度快。 

LinkedList可以完成队列结构和栈结构。

package wryyyyy;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class CollectionDemo1
{
    public static void main(String[] args)
    {
        LinkedList <String> stack = new LinkedList<>();//要用独有功能，所以不用多态写
        //压栈，入栈
        stack.addFirst("111");//专业的应写为push
        stack.addFirst("222");
        stack.addFirst("333");
        stack.addFirst("444");//每次加第一个位置把上一个压下去
        //出栈，弹栈
        System.out.println(stack.removeFirst());//取出并删除//专业的应写为pop
        System.out.println(stack);
        
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("111");//专业的应写为offerLast
        queue.addLast("222");
        queue.addLast("333");
        queue.addLast("444");
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
    }
}

 并发修改异常问题：

迭代器：

        Iterator<String> it = list.iterator();
        while (it.hasNext())
        {
            String ele = it.next();
            if ("Java2".equals(ele));
            {
//                list.remove("Java2");//错误的，删掉之后后面的元素会往前走
                it.remove();//用迭代器删除当前所在元素时，不会后移
            }
        }
        System.out.println(list);

 foreach，Lambda表达式：不能用于遍历删除。

解决删除某个元素之后后面元素前移导致跳位（fori）：

方法1：remove时i--（删除成功后退一步）

方法2：倒序循环

泛型：

 泛型可以在很多地方进行定义：

类后面 -> 泛型类

方法声明上 -> 泛型方法

接口后面 -> 泛型接口

自定义泛型类：

package wryyyyy;


public class CollectionDemo1
{
    public static void main(String[] args)
    {
        //模拟ArrayList定义一个MyArrayList
        MyArrayList<String> list = new MyArrayList<>();
        list.add("Java1");
        list.add("Java2");
        list.add("Java3");
        list.remove("Java1");
        System.out.println(list);
    }
}

 自定义泛型方法：

方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性 

泛型方法的原理：把出现泛型变量的地方全部替换成真实数据类型

package wryyyyy;


import java.io.InputStream;

public class CollectionDemo1
{
    public static void main(String[] args)
    {
        //需求：给一个任意类型的数组，都能返回它的内容
        String[] names = {"鱼","虾","蟹"};
        printArray(names);
        Integer[] ages = {10,20,30};
        printArray(ages);
    }
    public static <T> void printArray(T[] arr)//所有类型都可以接收
    {
        if (arr!=null)
        {
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++)
            {
                sb.append(arr[i]).append(i== arr.length-1?"":",");
            }
            sb.append("]");
            System.out.println(sb);
        }
        else
        {
            System.out.println(arr);
        }

    }
}

自定义泛型接口：

package wryyyyy;

public interface Data<E>
{
    void add(E e);
    void delete(int id);
    void update(E e);
    void queryById(int id);
}

public class TeacherData implements Data<Teacher>

泛型语法知识（泛型通配符，上下限）：

通配符：？，可以在使用泛型的时候代表一切类型

E D K V：在定义泛型时使用

package wryyyyy;


import java.awt.*;
import java.io.InputStream;
import java.util.ArrayList;

public class CollectionDemo1
{
    public static void main(String[] args) {
        //开发一个飞车游戏，让所有汽车都能参加比赛
    }
    public static void go(ArrayList<? extends Car> cars) {
        
    }
}

class BENZ extends Car {

}

class BMW extends Car {

}

class Car {

}

 Set系列集合：

（Set集合在功能上与Collection集合基本一致） 

（无序不是指每次启动都无序）

package wryyyyy;


import java.util.*;
import java.util.function.Consumer;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        Set<String> sets = new LinkedHashSet<>();
        sets.add("Java");
        sets.add("Java");
        sets.add("Mysql");
        sets.add("HTML");
        sets.add("HTML");
        sets.add("Java");
        sets.add("Java");
        System.out.println(sets);//[Java, Mysql, HTML]
    }
}

HashSet集合： 

如果希望Set集合认为两个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法 

package wryyyyy;


import java.util.*;
import java.util.function.Consumer;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        Set<Student> sets = new HashSet<>();
        Student s1 = new Student("小王",20,'男');
        Student s2 = new Student("小王",20,'男');
        Student s3 = new Student("小于",21,'男');
        sets.add(s1);
        sets.add(s2);
        sets.add(s3);
        System.out.println(sets);
        //Set集合重复的原因：先判断哈希值，再判断equals
        //使用equals and hashCode重写之后两个对象哈希值一样
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
    }
}

 LinkedHashSet集合：

TreeSet集合：

Set<Integer> sets = new TreeSet<>();
sets.add(23);
sets.add(46);
sets.add(12);
sets.add(23);
System.out.println(sets);//[12, 23, 46]
//自定义排序规则
//方法1：让自定义的类实现comparable接口重写里面的compareTo方法来定制比较规则

package wryyyyy;

public class Apple implements Comparable<Apple>
{
    private String name;
    private String color;
    private double price;
    private int weight;

    //省略

    @Override
    public int compareTo(Apple o) {
        //按照重量进行比较
        return this.weight-o.weight >= 0 ? 1: -1;
    }
}

//方法2：TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则

 //就近原则，优先用集合自带比较规则
    {
        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return o1.getWeight()- o2.getWeight();//升序
            }
        });
//就近原则，优先用集合自带比较规则
    {
        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return Double.compare(o2.getPrice(),o1.getPrice());//升序
            }
        });

简化：

Set<Apple> apples = new TreeSet<>((o1,o2)->Double.compare(o2.getPrice(), o1.getPrice()));

可变参数：

package wryyyyy;

import java.util.Arrays;

public class MethodDemo
{
    public static void main(String[] args)
    {
        sum();
        sum(10);
        sum(10,20,30);
        sum(new int[]{10,20,30,40,50});
    }
    public static void sum(int ... nums)
    {
        //可变参数在方法内部其实就是一个数组
        System.out.println("元素个数："+nums.length);
        System.out.println("元素内容："+Arrays.toString(nums));

    }
}

 Collections集合工具类：

Collections排序相关API（只能对于List集合排序）：

  

package wryyyyy;


import java.util.*;
import java.util.function.Consumer;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        //List names = new ArrayList<>();
        //Collections.addAll(names,"Java","Html","C",new int[]{1,2,3});

        List<String> names = new ArrayList<>();
        //批量添加
        Collections.addAll(names,"Java","Html","C","Python");
        System.out.println(names);

        //打乱list集合顺序
        Collections.shuffle(names);
        System.out.println(names);

        //排序
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,12,26,74,90,3);
        Collections.sort(list);
        System.out.println(list);
        //自定义排序方法2：
        List<Apple> apples = new ArrayList<>();
        Collections.sort(apples, new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return Double.compare(o1.getPrice(), o2.getPrice());//自定义比较器优先于自带比较规则
            }
        });
        //简化
        Collections.sort(apples,((o1, o2) -> Double.compare(o1.getPrice(),o2.getPrice())));
        System.out.println(list);
    }
}
Java集合——Collection
qq_51553982的博客
04-13 879
Java集合——CollectionCollection基本体系结构Collection的特点方法（基于源码）案例案例1案例2案例3user类实体类 Collection 基本体系结构 Collection的特点 代表一组任意类型的对象，无序，无下标，不能重复 方法（基于源码） boolean add(E e);向容器中添加一个对象 int size()；返回此集合中元素的个数 boolean remove(Object o);移除集合中的指定对象 boolean containsAll(Collect
Java核心知识：java集合之Collection集合
qq_43745578的博客
07-22 585
java集合之Collection集合
集合进阶——Collection
最新发布
2301_76662173的博客
03-09 177
tips：判定对象是否存在时候，需要重写equals方法。——>增强for遍历( 快捷键 coll.for )for遍历只适用于list系列，无序的set遍历不了。Collection的遍历方式。——> lambda 表达式。List和Set区别。
Java集合类之Collection接口实现
云扬的博客
11-15 514
Java集合类之Collection接口实现，包含： Collection、List、ArrayList、LinkedList、Deque、ArrayQueue、Set
Java中的Collection集合
feizuiku0116的博客
12-13 791
一、概述 Collection集合是单例集合的顶层接口，里面定义了所有单列集合都共有的内容 二、创建Collection对象 因为Collection是接口，所以不能直接通过new关键字来创建它的对象，可以通过多态的方式，创建其子类对象，从而实现创建Collection接口对象，代码如下： Collection<String> list = new ArrayList<String>(); 解释： - 集合后边的<数据类型>是泛型的意思，泛型是用来限定集合中存储元素的数
Java Collection集合
疯一样的码农
11-07 1597
Java 集合是一种预定义的架构，能够存储一组元素并像单个单元一样行为。集合可以存储和管理多个元素，并提供方法来添加、删除、搜索和排序元素。Java 集合框架提供了能力，使 Java 集合能够以类和接口的形式表示一组元素。集合框架使用户能够执行各种数据操作，如存储数据、搜索、排序、插入、删除和更新数据。Java 集合框架（Java Collections Framework）是 Java 标准库的一部分，提供了一系列接口和实现类，用于存储和操作一组对象。
Java Collection集合遍历运行代码实例
08-19
Java Collection 集合遍历运行代码实例 Java Collection 集合遍历是 Java 语言中最常用的数据结构之一。Collection 是 Java 集合框架中的一个接口，提供了基本的集合操作，例如添加、删除、遍历元素等。Collection ...
Java Collection集合iterator方法解析
08-25
Java Collection 集合 iterator 方法解析 Java Collection 集合 iterator 方法是一种非常重要的方法，通过该方法我们可以对集合进行遍历和操作。下面我们将详细介绍 Java Collection 集合 iterator 方法的实现原理...
JAVA collection集合之扑克牌游戏实例
09-01
根据给定的文件内容，以下是对“JAVA collection集合之扑克牌游戏实例”知识点的详细说明： ### 知识点概述 - **Java集合框架（Collection Framework）**：Java集合框架是提供一系列接口和类用于存储和操作对象的...
Java Collection集合的简单介绍与运用
12-21
集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map，这里主要记录一下Collection集合。 Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个...
Java之Collection集合
qq_48313380的博客
08-05 1196
集合层次结构中的根界面
JAVA Collection在java中的使用
yuzhentao123的博客
04-01 721
集合的体系结构： import java.util.ArrayList; /* * ArrayList * 集合的体系结构 * 由于不同的数据结构（数据的组织 存储方式），所以java为我们提供了不同的集合 * 但是不同的集合他们的功能都是相似的，不断地向上提取，将他们的共性提取出来，这就是集合体系结构形成的原因 * 体系结构 * 怎么学习？ 从最顶层开始学习，因为最顶层包含了所有的共性 * ...
Java基础之Collection
qq_45344586的博客
04-07 4502
Java基础之Collection
Java Collection的使用
HUAIJIUdada的博客
11-17 2246
注意：Collection 是一个接口不能直接创建对象，下面使用实现类的对象ArrayList来测试创建Collection对象。
JAVA集合Collection常用方法详解
weixin_65752158的博客
07-09 3372
提到集合就不得不提一下数组，好多集合底层都是依赖于数组的实现。数组一旦初始化后，长度就确定了，存储数据对象不能达到动态扩展，其次数组存储元素不便于对数组进行添加、修改、删除操作，而且数组可以存储重复元素。这个时候集合对作用显现出来了。集合分为Collection和Map两种体系。下面先介绍Collection的集合类的继承树如下图所示：单列集合只能一次添加一个数据双列集合可以一次添加2个数据。
java Collection常用方法
weixin_45966674的博客
08-16 435
这里我们输出了两个的结果 第一个 判断集合中 有没有 小猫猫 节点 是有的 所以返回了 true 条件真。这里我们添加了两个一样的值 有一些集合添加是不能重复的 但显然ArrayList没有做这方面的限制。这里因为我们加了两条内容 所以长度是2 不是空的 因此返回了 false 条件假。第二个 我们节点中显然没有叫 大猫猫 的 所以就返回了 false 条件假。这个方法就很简单粗暴了 直接把集合中的内容全干掉 但要慎用。...
【JavaSE】Java基础语法(二十六)：Collection集合
(⊙o⊙)？
05-27 3328
Collection集合概述是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现创建Collection集合的对象多态的方式具体的实现类ArrayListCollection集合常用方法。
Java基础——Collection集合概述及遍历
qq_48389943的博客
02-21 407
Collection集合概述集合概念集合与数组的区别Collection集合Collection：单例集合最顶层接口List extends Collection：子类：特点：Set extends Collection:子类：特点：Collection集合的常用功能 集合概念 集合是java中提供的一种容器，可以用来存储多个数据。 集合与数组的区别 ·数组的长度是固定的，集合的长度是可变的。 ·数组中存储的是同一类型的元素，可以存储基本类型数据。而集合存储的都是对象。 Collection集
javacollection集合
12-08
Java Collection集合是Java中非常重要的一部分，它提供了一种存储和操作对象的方式。Java Collection集合框架包括List、Set、Queue和Map等接口，每个接口都有不同的实现类。下面是Java Collection集合的一些常见用法和示例： 1. List集合：有序、可重复、有索引 ```java List<String> list = new ArrayList<>(); list.add("apple"); list.add("banana"); list.add("orange"); System.out.println(list.get(1)); // 输出：banana ``` 2. Set集合：无序、不重复、无索引 ```java Set<String> set = new HashSet<>(); set.add("apple"); set.add("banana"); set.add("orange"); System.out.println(set.contains("banana")); // 输出：true ``` 3. Queue集合：队列，先进先出 ```java Queue<String> queue = new LinkedList<>(); queue.offer("apple"); queue.offer("banana"); queue.offer("orange"); System.out.println(queue.poll()); // 输出：apple ``` 4. Map集合：键值对 ```java Map<String, Integer> map = new HashMap<>(); map.put("apple", 1); map.put("banana", 2); map.put("orange", 3); System.out.println(map.get("banana")); // 输出：2 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值