第十二章 集合框架(二)

已于 2022-07-11 08:38:44 修改
阅读量138 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-07-10 17:00:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71674778/article/details/125705663
版权

1.练习回顾

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List list = new LinkedList();
        String name;
        String sex;
        while(true){
            System.out.print("请输入姓名:");
            name = scanner.next();
            System.out.print("请输入性别:");
            sex = scanner.next();
            Perple perple = new Perple(name,sex);
            if(list.contains(perple)){
                System.out.println("这位同志已存在，请重新输入!");
                continue;
            }
            list.add(perple);
            System.out.println("是否继续(y/n)?");
            if(scanner.next().equals("n")){
                break;
            }
        }
        //System.out.println("录入的学生信息是:\n"+list);
        for (Object obj: list) {
            System.out.println(obj);
        }
    }
}
public class Perple {
    String name;
    String sex;

    public Perple(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Perple perple = (Perple) o;
        return Objects.equals(name, perple.name) && Objects.equals(sex, perple.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, sex);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Perple[" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ']';
    }
}

2.Arraylist使用

2.1遍历集合

for+索引遍历

for (int i = 0; i < arrayList.size(); i++) {
            //默认存储的数据都是Object类型的
            Object obj = arrayList.get(i);
            System.out.println(obj);
        }

for Each遍历

 for (Object obj:arrayList) {
            System.out.println(obj);
        }

注:

        不要在遍历ArrayList 过程中使用remove()方法。

①for+索引遍历来的方式：

//错误使用①        
for (int i = 0; i < arrayList.size(); i++) {
            arrayList.remove(i);
        }

使用remove方式移除元素之后arrayList会进行重排，导致元素的索引改变，从而漏掉一些元素。

②for Each 遍历：

//错误使用②
for (Object obj: arrayList) {
            arrayList.remove(obj);
        }

该方式则是直接会产生异常：ConcurrentModificationException(并发修改异常)。

③解决方式：

倒序遍历

        for (int i = arrayList.size()-1; i>=0; i--) {
            arrayList.remove(i);
        }

使用迭代器(Iterator)

        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            if(it.next()=="aaa"){
                it.remove();
            }
        }

2.2 ArrayList底层源码

        对于ArrayList而言，它实现List接口、底层使用数组保存所有元素，其操作上基本是对数组的操作。

2.2.1 ArrayList无参构造：ArrayList()

    public ArrayList() {
        //elementData 是 ArrayList 底层实际存储数据的对象数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    transient Object[] elementData; // non-private to simplify nested class access

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //所以new ArrayList的本质就是创建了一个空的Object类型的数组

2.2.2 ArrayList有参构造：ArrayList(int initialCapacity)

//initialCapacity:初始容量
public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            //初始容量大于0，则按初始容量创建数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            //等于0，则直接赋给一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //小于0，则抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

2.2.3 添加元素：add(E e)扩容原理

    public boolean add(E e) {
        //扩容数组
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        将数据存储到数组中，并且元素个数+1
        elementData[size++] = e;
        return true;
    }
    //扩容的具体实现
    private void ensureCapacityInternal(int minCapacity) {
        //判断当前ArrayList是否是空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //private static final int DEFAULT_CAPACITY = 10
            //取二者中的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    private void ensureExplicitCapacity(int minCapacity) {
        //记录该list在结构上被修改的次数
        modCount++;

        // overflow-conscious code
        //当前数组长度小于扩容长度时，执行grow()
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        
        // overflow-conscious code
        //原始容量
        int oldCapacity = elementData.length;
        //新的容量 >>移位运算符 >>1 二进制数右移一位  相当于原数 /2 
        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //Array.copyOf:扩容的具体实现
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

2.2.4 删除元素：remove(Object o)

    public boolean remove(Object o) {
        //判断数据是否为空
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            //通过系统进行错位复制的方式，删除元素
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

2.2.5 清空集合:clear()

//将每一个元素设置为空，并长度设置为0
public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

2.2.6 查找集合中某个元素的位置：indexOf(Object o)

//所以indexOf找不到的时候返回值是 -1
public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

2.2.7 返回集合元素长度：size()

//size 记录着元素的个数  
public int size() {
        return size;
    }

3.Set接口及其实现类

3.1 Set接口特点

①Set接口是无序的；

②Set接口中的数据不允许重复；

③Set接口无法通过下标访问数据；

④查找慢，插入删除快(底层数据结构是哈希表、链表和红黑树)；

⑤Set集合使用equals()和hashCode()方法实现元素去重。

3.2 HashSet实现类

HashSet特点： 

①HashSet是Set接口的实现类；

②线程不安全。

    public static void main(String[] args) {
        //Set:1.无序 2.不重复 3.没有下标
        Set set = new HashSet();
        set.add("bbb");
        set.add("bbb");
        set.add(true);
        set.add(12.234);
        set.add("aaa");
        set.add("aaa");
        set.add(100);
        set.add(200);
        set.add(new Student("张三",20));
        //打印集合内容
        //System.out.println(set);
        //打印长度
        //System.out.println(set.size());
        //set无法按照索引获取数据，因为set是无序的没有下标
        //删除
        //set.remove("aaa");
        //System.out.println(set);
        //包含某个数据
        //System.out.println(set.contains("bbb"));
        //是否为空
        //System.out.println(set.isEmpty());
        //System.out.println("================================");
        //遍历set集合
        //方式1：for Each
        for (Object obj : set){
            System.out.println(obj);
        }
        System.out.println("============================");
        //方式2: Iterator迭代器
        //通过集合对象的iterator()方法，返回一个Iterator对象，通过这个对象可以遍历集合元素
        Iterator it =  set.iterator();
        //it.hasNext():判断集合是否有数据,返回true/false
        //it.next():读取集合中的一个数据
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }

HashSet避免对象重复的规则：

①如果对象的hashCde值不同,则不需要用equals方法判断，直接存到HashSet中；

②如果对象的hashCode值相同，需要用equals方法进行比较，如果结果为true，则视为相同元素，不存储；如果结果为false，则视为不同元素进行存储。

 

         如果对象元素要存储到HashSet中，必须覆盖hashCode方法和equals方法，才能从对象内容的角度确保唯一性。

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

    public Student(){
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写equals
    @Override
    public boolean equals(Object o) {
        if(this==o){
            return true;
        }
        if(!(o instanceof Student)){
            return false;
        }

        Student student = (Student) o;
        if(Objects.equals(this.name,student.getName()) &&
                Objects.equals(this.age,student.age)){
            return true;
        }
        return false;
    }

    //重写hashCode,返回hash值，通过hash值得到要存储到数组的下标
    //hash值一样的数据存储到同一个数组空间，后再用equals进行内容比较

    @Override
    public int hashCode() {
        return Objects.hash(name, 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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public static void main(String[] args) {
    Student s1 = new Student("张三","男",20);
    Student s2 = new Student("张三","男",20);
    Student s3 = new Student("李四","男",20);
    // Object中的HashCode默认返回的是对象的内存地址
    //System.out.println(s1.hashCode());
    //System.out.println(s2.hashCode());
    Set s = new HashSet();
    s.add(s1);
    s.add(s2);
    s.add(s3);
    System.out.println(s);
    // hash运算(默认调用数据的hashCode()方法实现)结果是相同的前提下，才会进行相
    // hash运算结果不同，是无法去重的
    /*String s = "sdf";
    String ss = "sdf";
    System.out.println(s.hashCode());
    System.out.println(ss.hashCode());
    */
}

3.3 迭代器Iterator

        

        HashSet类中没有提供根据集合索引获取索引对应的值的⽅法， 因此遍历HashSet时需要使⽤Iterator迭代器。

Iterator的主要方法
返回类型方法描述
booleanhasNext()如果有元素可迭代
Objectnext()返回迭代的下一个元素
public static void main(String[] args) {
    // LinkedHashSet:链表结构的Set集合
    // 1.不重复 2.能保证添加的次序(添加和输出次序一致)
    Set set = new LinkedHashSet();
    set.add("c");
    set.add("a");
    set.add("d");
    set.add("b");
    //System.out.println(set);
    // 迭代器遍历集合
    Iterator it = set.iterator();
    while (it.hasNext()){
        System.out.println(it.next());
    }
}

百密一疏^^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十四章第二节1：Java集合框架之链表及其实现
快乐江湖的博客
09-24 361
假设有一个数组，用这些数据以尾插建立单链表。假设有一个数组，用这些数据以头插建立单链表。第一个结点位置的指针叫做头指针。
第十四章第二节2：Java集合框架之LinkedList
快乐江湖的博客
09-25 321
双链表在单链表的基础上再增加一个指针域，用于指向它的前驱结点LinkedList：Java集合框架中，LinkedList就是双链表，它也实现了List接口。
Java - 集合
坚决不做秃头少女
11-05 326
Java集合框架位于java.util包中，提供了一套性能优良、使用方便的接口和类。Java集合框架共有三大类接口: List、Set、Map： 虚线框：接口，实线框：实现类  List接口： 概念：一组对象的集合，容器，用来存储对象的，他解决了数组一旦声明长度就固定的这种局限。List 接口存储一组不唯一，有序（插入顺序）的对象。 分类：集合分为两大类，用接口来体现 两大接口Coll...
第二章 MyBatis源码骨架分析笔记
hankin的博客
09-03 584
一、MyBatis 源码概述 1、怎么下载MyBatis源码？ MyBatis 源码下载地址：https://github.com/MyBatis/MyBatis-3建议直接用网盘里的源码包 源码包导入过程： 下载MyBatis的源码 检查 maven 的版本，必须是3.25以上，建议使用maven的最新版本 MyBatis 的工程是maven工程，在开发工具中导入，工程必须使用 jd...
关于equals和hashCode，看这一篇真的就够了
CringKong的博客
04-21 4567
这几天在尝试手撸一个类似Lombok的注解式代码生成工具，用过Lombok的小伙伴知道，Lombok可以通过注解自动帮我们生产equals()和hashCode()方法，因此我也想实现这个功能，但是随着工作的深入，我发现其实自己对于equals()和hashCode()的理解，也处在一个很低级的阶段。 因此痛定思痛，进行了一番深入学习，才敢来写这篇博客。 文章目录1、equals在Java中含义2...
铂西学习日记---克隆对象
qq_31671169的博客
01-26 65
对象克隆的应用场景是创建一组细粒度重复使用的对象时，效率会比直接创建对象高。比如：在飞机大战游戏中，飞机的子弹，如果要创建对象会消耗大量的资源和时间，对于飞出来的子弹到飞出屏幕外就使对象消失的情况，克隆的优势就是不需要多次计算这个对象在内存的大小，直接填充数据，在JVM处理的时候会比大量多次创建对象省去很多步骤。 如果某个类的对象想要被克隆，这个类就需要实现Cloneable接口。（这个接口没有定义任意方法，就是一个标记接口。），然后实现Object中的clone方法。 import java.uti
java 反射机制笔记
qq_42572322的博客
07-08 137
使用反射操作类的成员的前提条件是：要获得该类的字节码文件对象，就是Class对象。Class对象获取的方式 Class类常用方法 反射之构造方法 /** * 反射之构造方法 * ConStructor类的概述： * 作用：获得到ConStructor对象来创建类的对象 * 可以通过反射获取类的构造方法 * 可以通过反射执行类的构造方法 * 【可以通过反射获取类的构造方法】 * Class对象中，与Constructor有关的方法 * Constructor
第十二章 集合框架
qq_29145405的博客
01-15 218
1.Java 集合框架关系图 2.集合概述 Java集合框架标准化了Java处理对象组的方式。Java集合框架在JDK1.2版本提出，在JDK1.5版本进行了修改(引入了泛型、自动装箱/拆箱以及for-each格式循环)。 集合框架再设计之初有几个目标： 框架是高性能的，基本集合(动态数组、链表、树、哈希表等)的实现是高效的。 框架必须允许不同类型的集合以类似的方式进行工作，并且有很高的互操作...
【Java基础系列教程】第十九章 Java集合框架详解
波哩个波的博客
03-15 1994
一、Java集合框架概述 二、集合框架层次结构 三、Collection接口方法 四、Iterator迭代器接口 五、Collection子接口之一：List接口 六、Collection子接口之二： Set接口 七、Map接口 八、集合总结 九、线程安全集合类 十、Comparable 和 Comparator 十一、Collections工具类 十二、面试题
第12章 集合1
08-08
本章我们将深入探讨集合的概念，从基础的数组开始，逐渐过渡到更为复杂的集合框架。 12.1 集合概述 集合的本质是一个容器，用于存储对象。设计集合时，我们需要关注两个核心问题：如何存储和存储特点。数组是最...
完整版大数据课件集合12-大数据导论-第十二章-Spark（共22页）.ppt
08-21
Spark的运行架构基于弹性分布式数据集（Resilient Distributed Dataset, RDD），这是一种不可变、分区的数据集合，可在集群中的不同节点之间透明地分布。Spark的计算过程由一系列转换（Transformation）和动作...
完整版大数据课件集合12-大数据导论-第十二章-Spark（共22页）.rar
09-29
《Spark大数据导论》课程是理解大数据处理领域中Spark框架的关键。Spark作为当前最流行的大数据处理工具之一，因其高效、易用和灵活性备受青睐。本课件集合共计22页，深入浅出地介绍了Spark的基本概念、核心功能以及...
Object类和Objects类
wardo_l的博客
02-20 465
java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用，在对象实例化的时候，最终找的父类就是Object类。 所有对象（包括数组）都实现这个类的方法。 根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个，今天我们主要学习其中的2个： 1.public String toString():返回该对象的字符串表示。 2.public boolean equals(String obj):指示其他某个对象是否与此对象“相等
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3239
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1138
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1244
浅析synchronized锁升级的原理与实现
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
最新发布
央顺科技官方博客
09-05 417
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 801
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
数据访问：JPA
hhgh_的博客
09-02 1005
其二，Sun希望整合ORM 技术，实现统一的 API调用接口。@Table（name=“”,catalog=“”,schema=“”）可选，用来标注一个数据库对应的实体类，数据库中创建的表明默认和类名一致，通常和@Entity配合使用，只能标注在实体的class定义处，表示实体对应的数据库表的信息。@Entity(name=“EntityName”)必须，用来标注一个数据库表对应的实体，数据库中创建的表明默认和类名一致，其中，name可选，对应数据库中的一个表，使用此注解标记Pojo是一个JPA实体。
《疯狂Java讲义》第二版精华：第四章与第十七章详解
然而，由于版本是不完整的，仅包含第四章和第十七章内容，对于想要快速入门或浅尝辄止的读者来说，可能需要结合其他资源。 《疯狂Java讲义 第二版》具有很高的实用价值，适合在大学教育和培训中作为教材使用，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值