备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

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

2022-10-29 53
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 黑马全套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教程集合进阶
游客dpjq4ou3oloby
目录
相关文章
布客飞龙
|
5天前
|
XML JavaScript Java
Java 中文官方教程 2022 版（四十）(4)
Java 中文官方教程 2022 版（四十）
布客飞龙
35 0
技能实验室
|
1天前
|
Java 编译器 API
Java基础教程(17)-Java8中的lambda表达式和Stream、Optional
【4月更文挑战第17天】Lambda表达式是Java 8引入的函数式编程特性，允许函数作为参数或返回值。它有简洁的语法：`(parameters) -> expression 或 (parameters) ->{ statements; }`。FunctionalInterface注解用于标记单方法接口，可以用Lambda替换。
技能实验室
10 1
北京宏哥
|
2天前
|
数据采集 前端开发 测试技术
《手把手教你》系列技巧篇（三十一）-java+ selenium自动化测试- Actions的相关操作-番外篇（详解教程）
【4月更文挑战第23天】本文介绍了网页中的滑动验证码的实现原理和自动化测试方法。作者首先提到了网站的反爬虫机制，并表示在本地创建一个没有该机制的网页，然后使用谷歌浏览器进行验证。接着，文章详细讲解了如何使用WebElement的click()方法以及Action类提供的API来模拟鼠标的各种操作，如右击、双击、悬停和拖动。
北京宏哥
6 2
程序员三木
|
3天前
|
Java API 调度
[AIGC] 深入理解Java并发编程：从入门到进阶
[AIGC] 深入理解Java并发编程：从入门到进阶
程序员三木
9 0
北京宏哥
|
3天前
|
Web App开发 数据采集 Java
《手把手教你》系列技巧篇（三十）-java+ selenium自动化测试- Actions的相关操作下篇（详解教程）
【4月更文挑战第22天】本文介绍了在测试过程中可能会用到的两个功能：Actions类中的拖拽操作和划取字段操作。拖拽操作包括基本讲解、项目实战、代码设计和参考代码，涉及到鼠标按住元素并将其拖动到另一个元素上或指定位置。划取字段操作则介绍了如何在一段文字中随机选取一部分，包括项目实战、代码设计和参考代码。此外，文章还提到了滑动验证的实现，并提供了相关的代码示例。
北京宏哥
32 2
技能实验室
|
3天前
|
安全 Java
Java基础教程(15)-多线程基础
【4月更文挑战第15天】Java内置多线程支持，通过Thread类或Runnable接口实现。线程状态包括New、Runnable、Blocked、Waiting、Timed Waiting和Terminated。启动线程调用start()，中断线程用interrupt()，同步用synchronized关键字。线程安全包如java.util.concurrent提供并发集合和原子操作。线程池如ExecutorService简化任务管理，Callable接口允许返回值，Future配合获取异步结果。Java 8引入CompletableFuture支持回调。
技能实验室
21 2
JavaBuild
|
3天前
|
存储 Java C++
Java集合篇之深度解析Queue，单端队列、双端队列、优先级队列、阻塞队列
Java集合篇之深度解析Queue，单端队列、双端队列、优先级队列、阻塞队列
JavaBuild
17 0
布客飞龙
|
5天前
|
XML 算法 搜索推荐
Java 中文官方教程 2022 版（四十九）(4)
Java 中文官方教程 2022 版（四十九）
布客飞龙
31 0
布客飞龙
|
5天前
|
XML 自然语言处理 安全
Java 中文官方教程 2022 版（四十九）(3)
Java 中文官方教程 2022 版（四十九）
布客飞龙
22 0
布客飞龙
|
5天前
|
XML Java 编译器
Java 中文官方教程 2022 版（四十九）(2)
Java 中文官方教程 2022 版（四十九）
布客飞龙
24 0

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Java中的集合框架：深入理解与应用
    19
  • 2
    Java并发编程：理解并使用Future和Callable接口
    17
  • 3
    性能工具之 Java 调试工具 JDB
    45
  • 4
    JAVA云HIS系统医院信息管理源码
    32
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    148
  • 6
    [Java基础]——JVM内存模型
    36
  • 7
    [Java基础]——类的生命周期
    13
  • 8
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    23
  • 9
    【java进阶】Java中线程的实现方式
    14
  • 10
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    17

    • 相关课程

    更多
  • 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程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）