JAVASE基础模块二十二（Collection集合类）

最新推荐文章于 2024-09-09 14:40:58 发布
最新推荐文章于 2024-09-09 14:40:58 发布
阅读量196 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx9977/article/details/107782549
版权

JAVASE基础模块二十二（Collection集合类）

list 集合

  • 为什么会用集合
    1. 数组作为容器的不好之处 就是对容器中的元素 进行操作时 不够方便
    2. 比如增删数组元素 就不方便
    3. 因为数组定义后 长度就不能改变了
import java.util.Arrays;

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

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

    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;
    }

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

class Test {
    public static void main(String[] args) {
        Student x1 = new Student("x1", 21);
        Student x2 = new Student("x2", 22);
        Student x3 = new Student("x3", 23);
        Student x4 = new Student("x4", 24);
        Student[] s = new Student[]{x1, x2, x3};
        for (int i = 0; i < s.length; i++) {
            Student d = s[i];
            System.out.println(d.getName() + "---" + d.getAge());
        }
        Student[] aa=new Student[4];
        aa= Arrays.copyOf(s,s.length+1);
        aa[aa.length-1]=x4;
        System.out.println(Arrays.toString(aa));
    }
}
运行结果：
x1---21
x2---22
x3---23
[Student{name='x1', age=21}, Student{name='x2', age=22}, Student{name='x3', age=23}, Student{name='x4', age=24}]

Process finished with exit code 0

  • java为了我们更加方便的去操作容器中的元素 提供了Collectiont 集合这个新的容器

  • 集合与数组的区别

    1. 数组的长度 一单定义就固定了 集合的长度是可变的
    2. 数组既可以存储基本数据类型元素 也可以存储引用数据类型元素 集合只能存储引用数据类型元素
    3. 数组只能存储同种数据类型元素 集合可以存储不同数据类型元素

  • Collection 集合的顶层接口

    1. 接口 List
      • ArrayList 底层数据结构是数组 查询快 增删慢 线程不安全 效率高
      • LinkedList 底层数据结构是链表 查询慢 增删快 线程不安全 效率高
      • Vector 底层数据结构是数组 查询快 增删慢 线程安全 效率低
    2. 接口 Set
      • HashSet
      • TreeSet
      • LinkedHashSet

Collection方法

  • 添加元素 add

    1. 添加普通元素

      import java.util.ArrayList;
import java.util.Collection;
public class Coll {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //添加元素
        c.add("zz");
        c.add("zz");
        c.add("zz");
        c.add("zz");
        c.add("zz");
        c.add("zz");
        System.out.println(c);
    }
}
运行结果：
[zz, zz, zz, zz, zz, zz]

Process finished with exit code 0

    2. 添加数值 （可以直接添加 会进行自动装箱）

      import java.util.ArrayList;
import java.util.Collection;
public class Cv {
    public static void main(String[] args) {
        int num=333;
        Collection c = new ArrayList();
        //添加元素
        c.add("zz");
        c.add("zz");
        c.add(num);//自动装箱
        System.out.println(c);
    }
}
运行结果：
[zz, zz, 333]

Process finished with exit code 0

    3. 添加对象

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

public class Df {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Student x1 = new Student("x1", 21);
        Student x2 = new Student("x2", 22);
        Student x3 = new Student("x3", 23);
        Student x4 = new Student("x4", 24);
        //添加元素
        c.add(x1);
        c.add(x2);
        c.add(x3);
        c.add(x4);
        System.out.println(c);

    }
}

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

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
[Student{name='x1', age=21}, Student{name='x2', age=22}, Student{name='x3', age=23}, Student{name='x4', age=24}]

Process finished with exit code 0

    4. addAll()方法 将一个collection添加到另一个collection

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

public class Ff {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //添加元素
        c.add(100);
        c.add(200);
        Collection cc = new ArrayList();
        //添加元素
        cc.add(333);
        cc.add(333);
        boolean d=c.addAll(cc);
        System.out.println(d);
        System.out.println(c);
        System.out.println(cc);

    }
}
运行结果：
true
[100, 200, 333, 333]
[333, 333]

Process finished with exit code 0

  • 清空 clear 清空此集合中的所有元素

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

public class QuanBu {
    public static void main(String[] args) {
        Collection cc = new ArrayList();

        cc.add(333);
        cc.add(333);
        System.out.println(cc);
        //清空
        cc.clear();
        System.out.println(cc);
    }
}
运行结果：
[333, 333]
[]

Process finished with exit code 0

  • 删除 remove

    1. remove() 删除指定元素

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

public class QuanBu {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(100);
        c.add(200);
        c.add(333);
        c.add(777);
        c.add(999);
        System.out.println(c);
        //删除
      c.remove(333);
        System.out.println(c);
    }
}
运行结果：
[100, 200, 333, 777, 999]
[100, 200, 777, 999]

Process finished with exit code 0

    2. removeAll() 删除与另外一个集合内的重复元素

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

public class Removall {
    public static void main(String[] args) {
        Collection cc = new ArrayList();
        //添加元素
        cc.add(333);
        cc.add(123);
        cc.add(777);
        cc.add(999);
        Collection c = new ArrayList();
        //添加元素
        c.add(123);
        c.add(200);
        c.add(777);
        c.add(999);
        System.out.println(c);
        System.out.println(cc);
        c.removeAll(cc);
        System.out.println(c);
        System.out.println(cc);
    }
}
运行结果：
[123, 200, 777, 999]
[333, 123, 777, 999]
[200]
[333, 123, 777, 999]

Process finished with exit code 0

  • 包含 contain

    1. contain() 查看某个元素是否在集合内

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

public class Cont {


    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(123);
        c.add(200);
        c.add(777);
        c.add(999);
        System.out.println(c.contains(999));
        System.out.println(c.contains(9995));
        c.clear();
        System.out.println(c.isEmpty());
    }
}
运行结果：
true
false
true

Process finished with exit code 0

    2. containAll() 查看一个集合是否完全包含在另一个集合内

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

public class Contall {
    public static void main(String[] args) {
        Collection cc = new ArrayList();
        cc.add(333);
        cc.add(123);
        cc.add(777);
        cc.add(999);
        cc.add(200);
        Collection c = new ArrayList();
        //添加元素
        c.add(123);
        c.add(777);
        c.add(999);   System.out.println(c.containsAll(cc));     System.out.println(cc.containsAll(c));
    }
}
运行结果：
false
true

Process finished with exit code 0

  • size() 集合长度

  • retainAll() 取交集

    import java.util.ArrayList;
import java.util.Collection;
public class JiaoJi {
    public static void main(String[] args) {
        Collection cc = new ArrayList();
        //添加元素
        cc.add(3336);
        cc.add(123);
        cc.add(777);
        cc.add(9995);
        Collection c = new ArrayList();
        //添加元素
        c.add(123);
        c.add(200);
        c.add(777);
        c.add(999);
        System.out.println(c);
        System.out.println(cc);
        boolean i = c.retainAll(cc);
        System.out.println(i);
        System.out.println(c);
        System.out.println(cc);
    }
}
运行结果：
[123, 200, 777, 999]
[3336, 123, 777, 9995]
true
[123, 777]
[3336, 123, 777, 9995]

Process finished with exit code 0

  • import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class ShuZu {
    public static void main(String[] args) {
        Collection cc = new ArrayList();
        cc.add(3336);
        cc.add(123);
        cc.add(777);
        cc.add(9995);
        Object[] ccc=new Object[cc.size()];
        Iterator s=cc.iterator();
        int r=0;
        while(s.hasNext()){
            Object u=s.next();
            ccc[r]=u;
            r++;
        }
        System.out.println(Arrays.toString(ccc));
        Object[] jj=cc.toArray();
        System.out.println(Arrays.toString(jj));
   
   
    }
}
运行结果：
[3336, 123, 777, 9995]
[3336, 123, 777, 9995]

Process finished with exit code 0

List

  • List常用方法
    1. 根据索引插入
    2. 通过索引获取元素
    3. 根据索引来删除元素
    4. 根据元素值删除数值 包装一下 一次只删除一个
    5. 替换集合中的元素 返回的是被替换的旧元素
    6. 查找数值索引
import java.util.ArrayList;

public class List {
    public static void main(String[] args) {
        ArrayList v = new ArrayList();
        v.add(1001);
        v.add(1002);
        v.add(1003);
        v.add(1004);
        v.add(1005);
        v.add(1006);
        //根据索引插入
        v.add(6,5555);
        System.out.println(v);
        //通过索引获取元素
        System.out.println(v.get(v.size() - 1));
        //根据索引来删除元素
        v.remove(4);
        System.out.println(v);
        //根据元素值删除数值 包装一下 一次只删除一个
        v.remove(Integer.valueOf(1002));
        System.out.println(v);
        //替换集合中的元素 返回的是被替换的旧元素
        Object u=v.set(v.size()-1,7777);
        System.out.println(u);
        System.out.println(v);
        //查找数值索引
        int y=v.indexOf(1003);
        System.out.println(y);
    }
}
运行结果：
[1001, 1002, 1003, 1004, 1005, 1006, 5555]
5555
[1001, 1002, 1003, 1004, 1006, 5555]
[1001, 1003, 1004, 1006, 5555]
5555
[1001, 1003, 1004, 1006, 7777]
1

Process finished with exit code 0
  • 迭代
    1. 正向迭代
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class BianLi {
    public static void main(String[] args) {
        ArrayList v = new ArrayList();
        v.add(1001);
        v.add(1002);
        v.add(1003);
        v.add(1004);
        v.add(1005);
        v.add(1006);
        for (int i = 0; i < v.size(); i++) {
            Object u = v.get(i);
            System.out.print(u + " ");
        }
        System.out.println("--------->");
        Iterator ff = v.iterator();
        while (ff.hasNext()) {
            Object kk = ff.next();
            System.out.print(kk + " ");
        }
        System.out.println("--------->");
        //java.util.ArrayList$ListItr@10f87f48  内部类
        ListIterator yy = v.listIterator();
        System.out.println(yy);
        while (yy.hasNext()) {
            Object kkk = yy.next();
            System.out.print(kkk + " ");
        }
    }
}
运行结果：
1001 1002 1003 1004 1005 1006 --------->
1001 1002 1003 1004 1005 1006 --------->
java.util.ArrayList$ListItr@7291c18f
1001 1002 1003 1004 1005 1006 
Process finished with exit code 0
  1. 反向迭代 （前提是必须进行正向迭代）
import java.util.ArrayList;
import java.util.ListIterator;

public class gg {
    public static void main(String[] args) {
        ArrayList v = new ArrayList();
        v.add(1001);
        v.add(1002);
        v.add(1003);
        v.add(1004);
        v.add(1005);
        v.add(1006);
        ListIterator yy = v.listIterator();
        System.out.println(yy);
        while (yy.hasNext()) {
            Object kkk = yy.next();
            System.out.print(kkk + " ");
        }
        System.out.println();
        while (yy.hasPrevious()) {
            Object kkk = yy.previous();
            System.out.print(kkk + " ");
        }
    }
}
运行结果：
java.util.ArrayList$ListItr@10f87f48
1001 1002 1003 1004 1005 1006 
1006 1005 1004 1003 1002 1001 
Process finished with exit code 0
  • ConcurrentModificationException 异常分析
import java.util.ArrayList;
import java.util.ListIterator;
public class LianXi {
    public static void main(String[] args) {
        ArrayList v = new ArrayList();
        v.add("world");
        v.add("333333");
        v.add("333333");
        v.add("333333");
        v.add("333333");
        ListIterator yy = v.listIterator();
        System.out.println(yy);
        while (yy.hasNext()) {
            if (yy.next().equals("world")) {
                v.add("Javaee");
            }
        }
        System.out.println(v);
    }
    }
迭代器预先拿到了集合的长度 在迭代过程中再加入 会打乱迭代器取到的集合长度就会出现并发修改异常
解决方案一：yy.add("Javaee"); 使用list自己的迭代器
[world, Javaee, 333333, 333333, 333333, 333333]

Process finished with exit code 0
解决方案二：    if (v.contains("world")) {
            System.out.println("222");
            v.add(v.size(),"JAVAEE");}
[world, 333333, 333333, 333333, 333333, JAVAEE]

Process finished with exit code 0
  • sublist() 含头不含尾
public class iiii {
    public static void main(String[] args) {
        ArrayList v = new ArrayList();
        v.add("world");
        v.add("335633");
        v.add("334533");
        v.add("333133");
        v.add("333883");
        System.out.println(v.subList(1, 3));
    }
}
运行结果：
[335633, 334533]

Process finished with exit code 0

待续…

弎屲
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA基础(四十二)——集合之Collection
qq_37466661的博客
09-17 449
集合 Collection
（十四）java中集合类collection
qq_43070500的博客
08-16 121
（十四）java中集合类collection 1. 集合定义collection       集合相当于一个容器，里面可以存放对象，每个对象作为集合的一个元素，每个对象的数据类型可以不同。但是，对象必须是引用类型的。 2. 常用的集合set map list set无序，没有重复的元素的集合，有hashset，treeset lis...
JavaSE模块
weixin_50845073的博客
07-18 132
学习笔记
JAVASE基础知识模块一
cx9977的博客
07-12 324
JAVA 基础知识模块一 计算机基础知识 语言 自然语言：交流工具（人 人） 机器语言/计算机语言：交流工具（人 计算机）< 机器码 汇编 c/c++ JAVA Phython> c：面向过程 JAVA：面向对象 封装过程 人机交互的方式： 图形界面化（适用 普通用户） ​ 命令行方式： 特定指令 Linux终端 计算机常用的快捷键 Ctrl+C 复制 Ctrl+V 粘贴 Ctrl+X 剪切 Ctrl+A 全选 Ctrl+Z 撤销 Ctrl+S 保存
JavaSe模块一笔记
weixin_43185034的博客
04-30 150
变量：程序中要记录数据内容时,在内存中开启一个存储单元,这个存储单元中的内容会发生改变,所以称作变量 如：int num = 10; 数据类型 变量名 = 初始值; 变量声明注意事项： 声明变量时必须指定数据类型 变量使用之前必须初始化 变量不能重复声明 标识符命名规则 由字母、数字、下划线和$组成,不能以数字开头 不能使用 java中的关键字 3.区分大小写,变量长度不宜过长 4....
java面向对象(学生练习)
qq_44739966的博客
03-02 738
创建一个学生类（姓名、年龄、性别） ​ 创建5个学生对象 ​ 将5个学生对象存放到学生数组 ​ 设计一个方法，从键盘随机录入学生姓名，查找对应学生是否存在 ​ 设计一个方法，按照学生年龄从大到小，对数组中所有学生进行排序 ​ 设计一个方法，根据性别，统计男生和女生人数 public class Student { private String name; private int age; private String sex; public Student() { super(); } pu
Java基础总结篇--JavaSE你必须要知道的基础
热门推荐
风离紫竹zhangqiang的博客
07-12 3万+
01.Java概述与语法 作者： 风离紫竹 java发展概述 一、 Java由SUN公司研发，SUN 被 Oracle 收购 Java 由1995年发布，正式版本由1996年1月发布（jdk1.0） Java之父： James Gosling 二、 面向对象 分布式 多线程 简单化 安全 跨平台移植  -
【JavaSE-07】：集合（1）：Collection接口（含源码分析）
m0_49167443的博客
04-11 176
【JavaSE-9】：集合一、概述二、Collection接口和常用方法1. Collection常用方法2. Collection接口遍历元素的方式1——使用Iterator（迭代器）3. Collection接口遍历元素的方式2——增强型循环for三、 Collection子接口之一：List接口1. List接口方法2. List实现类之一：ArrayList 一、概述 ● 数组在内存存储方面的特点： 1.数组一旦初始化以后，长度就确定了。 2.数组声明的类型，就决定了进行元素初始化时的类型，保存和操
史上最全 javaSE基础和高级面试题整理
陈先生
02-14 2664
javaSE基础和高级 一.面向对象基础 1.面向对象的特征有哪些方面？ 面向对象的编程语言有封装、继承 、多态、抽象等4个主要的特征。 封装： ​ 面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，把握一个原则：把对同一事...
java面试宝典书籍-JavaSE基础
qq_28400629的博客
08-08 408
知识：java面试宝典 JavaSE基础注：知识都来源于Java面试宝典书籍，此处只为学习 一、Java面向对象 Standard Edition 1. 面向对象的特性以及理解 封装：将对象进行封装，封装后可以通过调用对象的方式调用对象的属性，使一切变得有序 继承：父类、子类，继承方法 多态：方法重写(修改方法里的内容)、方法重载(方式所携带的参数不同) 、对象造...
JavaSEstudy:JavaSE
05-15
JavaSE（Java Standard Edition）是Java编程语言的核心部分，它为开发桌面应用程序、服务器端应用程序以及嵌入式系统提供了基础平台。本资料包"JavaSEstudy:JavaSE"旨在帮助学习者深入理解JavaSE的基本概念、语法和...
javase学习总结
06-20
#### 二十、垃圾回收机制 - **GC**：Garbage Collection，垃圾回收机制，自动管理内存，回收不再使用的对象所占用的内存空间。 - **触发时机**：当系统内存不足时，GC 会被自动触发。 - **手动触发**：可以通过 `...
spring事务详细讲解-深入浅出
小电玩
09-08 351
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1341
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1328
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 671
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 525
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
最新发布
Tony_yitao的博客
09-09 479
MyBatis面试
SpringBoot总结
2302_77073236的博客
09-06 198
都做成图了，方便理解和掌握全局关系。
Java SE入门：Collection类详解与集合框架
在Java SE编程中，Collection类扮演着核心角色，它是所有集合类的基类，为Java集合框架提供了基础接口。对于Java初学者而言，理解Collection类及其相关概念至关重要，因为它奠定了后续学习集合框架的基础。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值