AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

黑马全套Java教程（八）：集合进阶（上）

2022-10-29 70
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 黑马全套Java教程（八）：集合进阶

31 集合进阶

集合类的特点：提供一个存储空间可变的存储模型，存储的数据容量可以随时发生改变


集合类体系结构如下：



31.1 Collection集合



package myCollection.Demo1;
import java.util.ArrayList;
import java.util.Collection;
/*
    创建Collection集合的对象
        多态的方式
        ArrayList()
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c =  new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);
    }
}



Collection集合常用方法


package myCollection.Demo1;
import java.util.ArrayList;
import java.util.Collection;
/*
    Collection集合常用方法：
        bololean add(E e)：添加元素
        boolean remove(Object 0)：从集合中移除指定的元素
        void clear()：清空集合中的元素
        boolean contains(Object o)：判断集合中是否存在指定的元素
        boolean isEmpty()：判断集合是否为空
        int size()：集合的长度，也就是集合中元素的个数
        alt+7：  打开一个窗口，能够看到类的所有信息
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //1.add()添加元素
        System.out.println("add()：" + c.add("hello")); //调用add方法永远返回true
        c.add("world");
        c.add("java");
        System.out.println(c);
        System.out.println("----------------------");
        //2.remove()移除元素
        System.out.println(c.remove("hello"));
        System.out.println(c.remove("javaee"));
        System.out.println(c);
        System.out.println("---------------------");
        //4.contains()判断是否有这个元素
        System.out.println(c.contains("world"));
        System.out.println(c);
        System.out.println("-----------------------");
        //6.size()计算长度
        System.out.println(c.size());
        System.out.println("_______________________");
        //3.clear()清空集合
        c.clear();
        System.out.println(c);
        System.out.println("--------------------");
        //5.isEmpty判断是否为空
        System.out.println(c.isEmpty());
    }
}



Iterator迭代器


Collection集合的遍历



package myCollection.Demo2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
    Iterator：迭代器，集合的专用遍历方式
        Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
    Iterator中的常用方法
        E next()：返回迭代器中的下一个元素
        boollean hasNext():如果迭代器具有更多元素，则返回true
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);   //实现遍历集合
        }
    }
}



集合使用步骤




案例：Collection集合存储学生对象并遍历



Studnet.java


package myCollection.Demo3;
public class Stduent {
    private String name;
    private int age;
    public Stduent() {
    }
    public Stduent(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 "Stduent{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


Demo1.java


package myCollection.Demo3;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo1 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Stduent> c = new ArrayList<Stduent>();
        //创建学生对象
        Stduent s1 = new Stduent("林青霞", 30);
        Stduent s2 = new Stduent("张曼玉", 33);
        Stduent s3 = new Stduent("风清扬", 35);
        //添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合：迭代器方式
        Iterator<Stduent> it = c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}



31.2 List集合


有序，可重复



package myList.Demo1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
    List集合特点
        有序：存储和取出的元素顺序一致
        可重复：存储的元素可以重复
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建对象
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");
        System.out.println(list);
        //遍历
        Iterator<String>  it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}



List集合特有方法



package myList.Demo1;
import java.util.ArrayList;
import java.util.List;
/*
    List集合特有方法：
        void add(int index, E element)：在此集合中的指定位置插入指定的元素
        E remove(int index):删除指定索引处的元素，返回被删除的元素
        E set(int index, E element):修改指定索引处的元素，返回被修饰的元素
        E get(int index):返回指定索引处的元素
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add(2, "java");
        //1.删除
        list.remove("hello");  //删除指定元素
        System.out.println(list);
        System.out.println("-----------------");
        list.remove(1);     //删除指定索引处的元素
        System.out.println(list);
        System.out.println("------------------");
        list.set(0, "hello");
        System.out.println(list);
        System.out.println("--------------");
        list.add(1,"world");
//        System.out.println(list.get(0));
        for(int i=0;i< list.size();i++){
            String s = list.get(i);
            System.out.println(s);
        }
    }
}



案例：List集合存储学生对象并遍历



学生类的代码上面有，这里便不再重复


package myList.Demo2;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        //集合添加学生
        list.add(s1);
        list.add(s2);
        list.add(0, s3);
        //遍历：迭代器和for遍历
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------------------");
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}



并发修改异常



package myList.Demo3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
    需求：
        我有一个集合：List<String> list = new ArrauList<String>();
        里面有三个元素：hello world java
        遍历集合，得到每一个元素，看有没有world这个元素；如果有就添加一个javaee
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //集合中添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //迭代器遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();   //ConcurrentModificationException
            //System.out.println(s);
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);
    }
}



但是for循环实现遍历便可行


package myList.Demo3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //集合中添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("world")) {
                list.add("javaee");
                break;
            }
        }
        System.out.println(list);
    }
}



1. ListIterator



package myList.Demo4;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*
    ListIterator：列表迭代器
        通过List集合的ListIterator()方法得到，所以说它是List集合特有的迭代器
        用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
    ListIterator中的常用方法
        E next():返回迭代中的下一个元素
        boolean hasNext():如果迭代具有更多元素，则返回true
        E previous():返回列表中的上一个元素
        boolean hsaPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
        void add(E e):将指定的元素插入列表
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //遍历
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if(s.equals("world")){
                lit.add("javaee");
            }
            System.out.println(s);
        }
        System.out.println("------------------------");
        System.out.println(list);
        System.out.println("------------------------");
        while (lit.hasPrevious()) {   //逆向遍历，从后到前
            String s = lit.previous();
            System.out.println(s);
        }
    }
}



2. 增强for循环



package myList.Demo5;
import java.util.ArrayList;
import java.util.List;
/*
    增强for：简化数组和collection集合的遍历
        实现Iterator接口的类允许其对象称为增强for语句的目标
        它是JDK5之后出现的，其内部原理是一个Iterator迭代器
    格式：
        for(元素数据类型 变量名：数组或者Collection集合){
            //在此处使用变量即可，该变量就是元素
        }
 */
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("---------------------");
        String[] strArr = {"hello", "world", "java"};
        for (String i : strArr) {
            System.out.println(i);
        }
        System.out.println("----------------------");
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        //有三种遍历方式：for，迭代器（这里迭代器也有两种），增强for
        for (String i : list) {
            System.out.println(i);
        }
        //内部原理是一个Iterator迭代器，下面代码会报错   ConcurrentModificationException
        for(String s : list){
            if(s.equals("world")){
                list.add("javaee");
            }
        }
    }
}



案例：List集合存储学生对象，用三种方式遍历



学生类对象代码这里便不再重复


package myList.Demo6;
import java.util.*;
public class Demo1 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("林青霞", 18);
        Student s2 = new Student("张曼玉", 19);
        Student s3 = new Student("王祖贤", 20);
        //集合添加学生
        list.add(s1);
        list.add(s2);
        list.add(1, s3);
        System.out.println(list);
        //遍历
        //1.for
        for (int i = 0; i < list.size(); i++) {
            Student s = list.get(i);
            System.out.println(s);
        }
        System.out.println("---------------------");
        //2.增强for
        for (Student s : list) {
            System.out.println(s);
        }
        System.out.println("------------------------");
        //3.迭代器
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------------------");
        //4.
        ListIterator<Student> lit = list.listIterator();
        while (lit.hasNext()) {
            Student s = lit.next();
            System.out.println(s);
        }
    }
}



31.3 数据结构


数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合


通常情况下，精心选中的数据结构可以的带来更高的运行或者存储效率


1. 栈



2. 队列



3. 数组


数组是一种查询快，增删慢的模型


查询数据通过索引定位，查询任意数据耗时相同，查询速度快



删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低



添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低



4. 链表


链表是一种增删快，查询慢的模型



添加元素：



删除元素：



查询元素



5. 哈希表


哈希表是一种常见的数据结构


文章标签：
Java
索引
存储
关键词：
Java集合
Java教程
Java进阶
Java黑马
Java教程集合
zdb呀
目录
相关文章
众所周知
|
10天前
|
Java
Java 8 引入的 Streams 功能强大，提供了一种简洁高效的处理数据集合的方式
Java 8 引入的 Streams 功能强大，提供了一种简洁高效的处理数据集合的方式。本文介绍了 Streams 的基本概念和使用方法，包括创建 Streams、中间操作和终端操作，并通过多个案例详细解析了过滤、映射、归并、排序、分组和并行处理等操作，帮助读者更好地理解和掌握这一重要特性。
众所周知
21 2
2G冲浪词条
|
10天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
23 1
大树营养快线
|
15天前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
15 7
大树营养快线
|
15天前
|
存储 Java 开发者
在 Java 中，如何遍历一个 Set 集合？
【10月更文挑战第30天】开发者可以根据具体的需求和代码风格选择合适的遍历方式。增强for循环简洁直观，适用于大多数简单的遍历场景；迭代器则更加灵活，可在遍历过程中进行更多复杂的操作；而Lambda表达式和`forEach`方法则提供了一种更简洁的函数式编程风格的遍历方式。
大树营养快线
29 1
大树营养快线
|
15天前
|
Java 开发者
从 Java 中的 Set 集合中删除元素
【10月更文挑战第30天】
大树营养快线
40 1
游客syv66y3m2ksnc
|
18天前
|
安全 Java 编译器
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
Kotlin教程笔记(27) -Kotlin 与 Java 共存(二)
游客syv66y3m2ksnc
30 3
游客syv66y3m2ksnc
|
18天前
|
Java 开发工具 Android开发
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
Kotlin教程笔记(26) -Kotlin 与 Java 共存(一)
游客syv66y3m2ksnc
43 2
shuj
|
14天前
|
存储 Java 开发者
Java中的集合框架深入解析
【10月更文挑战第32天】本文旨在为读者揭开Java集合框架的神秘面纱，通过深入浅出的方式介绍其内部结构与运作机制。我们将从集合框架的设计哲学出发，探讨其如何影响我们的编程实践，并配以代码示例，展示如何在真实场景中应用这些知识。无论你是Java新手还是资深开发者，这篇文章都将为你提供新的视角和实用技巧。
shuj
12 0
热爱技术的小郑
|
3月前
|
存储 安全 Java
【Java集合类面试二十五】、有哪些线程安全的List？
线程安全的List包括Vector、Collections.SynchronizedList和CopyOnWriteArrayList，其中CopyOnWriteArrayList通过复制底层数组实现写操作，提供了最优的线程安全性能。
热爱技术的小郑
152 4
热爱技术的小郑
|
3月前
|
Java
【Java集合类面试二十三】、List和Set有什么区别？
List和Set的主要区别在于List是一个有序且允许元素重复的集合，而Set是一个无序且元素不重复的集合。
热爱技术的小郑
36 2

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    来聊聊Java项目分层规范
  • 3
    超全面！阿里巴巴最新发布23年秋招200道Java面试题（含答案）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 6
    JDK6笔记（5）----JDBC4
  • 7
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 8
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 9
    （十三）java类的继承
  • 10
    How to programmatically new a java class which implements sepecified interface in eclipse plugin development
  • 1
    前端和Java验签以太坊钱包签名实现中心化登录
    1023
  • 2
    零基础轻松入门Java数据库连接（JDBC）
    61
  • 3
    04｜零基础玩转面向对象编程：Java OOP
    34
  • 4
    03｜Java基础语法：讲解标识符、关键字、变量、数据类型、运算符、控制语句（条件分支、循环）
    39
  • 5
    探索Java世界的奇妙工具——运算符与表达式运算符
    31
  • 6
    深入浅出Java基础语法：标识符、关键字、变量、数据类型、运算符与控制语句
    32
  • 7
    Java一分钟之-Java IO流：文件读写基础
    119
  • 8
    轻松理解Java中的数据类型和变量
    25
  • 9
    Java一分钟之-Map接口与HashMap详解
    40
  • 10
    01｜Java简介与历史
    37

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云OSS设置跨域访问