3.1集合-Set+集合-list

这篇具有很好参考价值的文章主要介绍了3.1集合-Set+集合-list。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、数据结构

1.1什么是数据结构

数据结构就是用来装数据以及数据与之间关系的一种集合,如何把相关联的数据存储到计算机,为后续的分析提供有效的数据源,是数据结构产生的由来。数据结构就是计算机存储、组织数据的方式。好的数据结构,让我们做起事来事半功倍。精心选择的数据结构可以带来更高的计算速度和存储效率。

1.2常见的数据结构

数组:操作数组利用下标,查询快,但是增删慢

链表:不依赖下标每个链表环环相扣,增删慢,查询快

队列:        3.1集合-Set+集合-list,list,数据结构

树形结构3.1集合-Set+集合-list,list,数据结构

二、ArrayList

2.1ArrayList的介绍

内部基于数组的集合类

ArrayList中有哪些方法:增加,删除,修改,查询,插入...

ArrayList的线程是不同步的。

 2.2ArrayList的使用

对它进行基本的增删改查插入。

 public static void main(String[] args) {
        ArrayList list = new ArrayList();
        ArrayList list01 = new ArrayList(list);
        ArrayList list02 = new ArrayList(14);

        list.add(1);
        list.add("a");
        list.add(true);
        list.add(new Date());
        list.add(1);
        list.add(null);
        //向指定下标插入元素。
        list.add(1,"xxx");
        System.out.println(list);

        list.remove(1);//删除指定元素

//修改指定元素
        list.set(0,9);

        //查询get
        System.out.println(list.get(2));

        System.out.println(list.size());
        //集合有效长度。
    }

 2.3遍历方式

1普通for循环

2增强for循环

3使用迭代器进行遍历

Iterator 就是一个迭代器(也是一个接口)其中的方法如下:

boolean hasNext() 判断是否有下一个元素,如果返回true表示有下一个;

Object next() 调用一次获得一个元素(每调用一次指针会向后移动一个);

void remove() 会从迭代器指向的结合容器中删除一个元素

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.ListIterator;

public class LoopText {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(1);
        list.add("a");
        list.add(true);
        list.add(new Date());
        list.add(1);
        list.add(null);
        //向指定下标插入元素。
        list.add(1,"xxx");

        //for遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-------增强for------");
        for (Object o : list) {
            System.out.println(o);
        }

        System.out.println("---------第一次单项迭代器----------");
        Iterator iterator = list.iterator();
        //获取迭代器
        while (iterator.hasNext()){//判断迭代器后面是否还有数据
            System.out.println(iterator.next());//有数据就打印
        }
        System.out.println("------第二次迭代----------");
        while (iterator.hasNext()){//判断迭代器后面是否还有数据
            System.out.println(iterator.next());
            //第二次迭代没有数据输出因为迭代器的指针指向最后一位,后面没有数据了
        }
        System.out.println("----------双向迭代--------");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        System.out.println("----------------");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }

    }
}

双向迭代器:单向迭代器有的功能双向迭代器也有。不过它可以从数据的最后一位数往前迭代,原理与单项迭代器差不多,就是判断前一个 元素,然后获取上一个元素。

三、LinkedList

1、 内部是基于链表结构实现的。插入和删除比较快,查询相对ArrayList比较慢

2、 内部相对于ArrayList而言多了一些操作头和尾的方法

3、 可以充当队列,堆栈

4、 不是线程安全的(同步的)

四、HashSet

4.1HashSet的介绍

无序不可重复,可存放null值
去重机制equals+hashcode
线程不安全
快速将一个集合元素去重

4.2验证上面原则

打印上面示例中的元素的hashCode和equals的结果

2.尝试自定义类,覆写hashCode 和 equals 这两个方法中的代码随便写

(1) 尝试修改两个方法的值来测试容器中添加了几个对象

创建一个user类
package org.lzh.set;

import java.util.Objects;

public class User implements Comparable{
    private String name;
    private Integer age;
    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

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

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


    @Override
    public int compareTo(Object o) {
        User a = (User)o;
        if(this.age>a.age){
            return 1;
        }else if(this.age < a.age){
            return -1;
        }else {
           return this.name.compareTo(a.name);
        }


    }
}



//测试代码
public class HashSetText {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        ArrayList arrayList = new ArrayList();
        HashSet hashSet1 = new HashSet(arrayList);

        hashSet.add(1);
        hashSet.add("c");
        hashSet.add(new Date());
        hashSet.add(true);
        hashSet.add(1);
        hashSet.add(null);
        hashSet.add(new User("za",14));
        hashSet.add(new User("za",1));
        System.out.println(hashSet);

        //不能用普通for迭代
        for (Object o : hashSet) {
            System.out.println(o);
        }
        //迭代器,只能用单向迭代器
        System.out.println("-------------------");
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

五、TreeSet

5.1TreeSet的介绍

无序:不保证(不记录)我们的添加顺序;但是排序了

2.不重复:不能够添加重复元素(多个心眼)如何判断重复的呢?

3.感觉内部存储有一定的顺序

**注意:TreeSet一旦添加了第一个元素后就不能添加其它数据类型的元素了,只能添加相同数据类型的元素,除非将容器中所有的元素全部清空,才能添加新的数据类型的元素

 5.2简单体验

*体验1*:**不重复及不保证添加顺序和打印顺序一致

TreeSet ts = new TreeSet();
ts.add("B");
ts.add("A");
ts.add("C");
ts.add("C");
System.out.println(ts.size());
System.out.println(ts);

1.结果: 虽然打印结果的顺序和添加顺序可能不一致,但是**感觉结果是有某种规则排序的

2.说明String类也实现了Comparable接口,String对象可以调用compareTo方法

*体验2*:**添加了一种类型不能在添加其他类型

TreeSet ts = new TreeSet();
ts.add("B");
ts.add("A");
ts.add("C");
ts.add("C");
ts.add(10);
System.out.println(ts.size());
System.out.println(ts);
---------------------------------------------
    Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at java.lang.Integer.compareTo(Unknown Source)
    at java.util.TreeMap.put(Unknown Source)
    at java.util.TreeSet.add(Unknown Source)
    at cn.itsource._07TreeSet.TestTreeSet.main(TestTreeSet.java:12)

1.结果:居然不能够放不同的类型,但是编译没有错

**体验3: 添加自定义的类的对象 Student对象

TreeSet ts = new TreeSet();
Student stu1 = new Student("王者",18);
ts.add(stu1);
System.out.println(ts.size());
System.out.println(ts);
-----------------------------------------
    Exception in thread "main" java.lang.ClassCastException: cn.itsource._07TreeSet.Student cannot be cast to java.lang.Comparable
    at java.util.TreeMap.compare(Unknown Source)
    at java.util.TreeMap.put(Unknown Source)
    at java.util.TreeSet.add(Unknown Source)
    at cn.itsource._07TreeSet.TestTreeSet.main(TestTreeSet.java:9)

1.结果:

2.疑问1:上面的代码添加的都是同种类型的数据,为什么还报错;

3.疑问2:为什么提示要把Student转成Comparable

4.正常情况 ----> TreeSet 或者 Comparable的文档

5.3 TreeSet的结构(存储原理)分析

1.TreeSet内部是按照大小进行排序的,大小有对象与对象之间比较进行决定的

2.设计TreeSet之前:Java设计了一个接口Comparable接口,其中提供了对象之间比较的方法CompareTo

3.TreeSet会调用对象的CompareTo方法,比较对象,所以我们放入的对象需实现Comparable

5.4 自然排序与定制排序(比较器)

5.4.1 自然排序 Comparable

**什么是自然排序

1.例如:大家排队,按照高矮个排队,那么同学们自己相互之间就能进行对比,每个对象具备自我比较判断的能力,称之为自然排序

*Comparable*中API**文档中的描述:

2.此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序,类的 compareTo 方法被称为它的自然比较方法

**理解:

3.如果一个类实现了Comparable接口,可以认为这个类的对象具有自然排序的能力(本质就是这个对象可以调用比较的方法compareTo),这种比较和排序的规则就是自然排序

@Override
public int compareTo(Object o) {
    if(o==null){
        return 0;
    }
    Student stu = (Student)o;
    if(this.age>stu.age){//如果大于的时候返回负数表示降序,返回负数表示升序
        return -1;
    }else if(this.age<stu.age){//如果大于的时候返回负数表示降序,返回负数表示升序
        return 1;
    }else{//如果年龄不大于也不小于说明等于,那么有名字来决定对象是否相同String已经写好排序规则
        return this.name.compareTo(stu.name);
    }
}

测试代码

TreeSet ts = new TreeSet();
Student stu1 = new Student("XXX",20);
Student stu2 = new Student("XXX",20);
ts.add(stu1);
ts.add(stu2);
System.out.println(ts.size());
System.out.println(ts);
-------------------------------------
    1
[Student [name=XXX, age=20]]

**自然排序小结

5.4.2 定制排序(比较器)Comparator

1、什么是定制排序

定制排序,相当于给容器提供了一个裁判:例如操场就是一个容器,那么体育老师就是这个裁判,每个同学进入操场同学们相互之间可以比较谁比较帅,或者不可以比较谁帅都可以,有了老师这个裁判,老师可以负责比较每一位同学

2、为什么需要定制排序

(1) 原来的比较规则不符合所有人的使用需求

(2) 不存在比较规则的对象,无法放入容器,我可以给容器提供定制比较器

3、定制排序如何实现

(1) Comparator 是一个比较器的接口(标准),必须得有进行比较的方法 :compare(Object o1,Object o2);

(2) 自定义一个类实现Comparator接口,其中写比较规则 ---> 比较器的模板,我们现在需要的是一个具体的比较器对象

public class MyComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        if(o1==null||o2==null){//判断,若两个有一个为null都直接返回
            return 0;
        }
        if(o1 instanceof Student && o2 instanceof Student){//如果类型匹配才转换
            Student stu1 = (Student)o1;
            Student stu2 = (Student)o2;
            if(stu1.age>stu2.age){//先判断年龄后判断姓名
                return 1;
            }else if(stu1.age<stu2.age){
                return -1;
            }else{
                return stu1.name.compareTo(stu2.name);
            }
        }
        return 0;
    }
}

测试代码

MyComparator mc = new MyComparator();
TreeSet ts = new TreeSet(mc);
Student stu1 = new Student("XXX",19);
Student stu2 = new Student("OOO",18);
Student stu3 = new Student("YYY",18);
Student stu4 = new Student("ZZZ",18);
Student stu5 = new Student("QQQ",18);
ts.add(stu1);
ts.add(stu2);
ts.add(stu3);
ts.add(stu4);
ts.add(stu5);
System.out.println(ts.size());
System.out.println(ts);
---------------------------------------
     5
[OOO-18, QQQ-18, YYY-18, ZZZ-18, XXX-19]

7.5 TreeSet判断重复的标准小结

1、如果采用的是自然排序调用对象的compareTo方法,如果返回0 表示相等;

大于且返回正数,升序排列 => 小于且返回负数,升序排列 对应

大于且返回负数,降序排列 => 小于且返回正数,降序排列 对应文章来源地址https://www.toymoban.com/news/detail-818231.html

2、如果使用的定制排序(比较器),调用比较器的方法compare 返回0 表示相等;

大于且返回正数,升序排列 => 小于且返回负数,升序排列 对应

大于且返回负数,降序排列 => 小于且返回正数,降序排列 对应

到了这里,关于3.1集合-Set+集合-list的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JAVA数据结构篇--13线程安全的Set 集合

    前言:java 中用于存放不重复元素的set 集合,其中无序的HashSet,以及有序的LinkedHashSet和TreeSet 都是非线程安全的,那么多线程环境下,我们要存放不重复的元素,需要使用哪种集合进行数据存取; 1 使用: 2 过程: 2.1 放入获取元素: Collections.synchronizedSet:通过使用synchron

    2024年02月16日
    浏览(40)
  • 【数据结构】搜索树 与 Java集合框架中的Set,Map

    作者主页:paper jie_博客 本文作者:大家好,我是paper jie,感谢你阅读本文,欢迎一建三连哦。 本文录入于《JAVA数据结构》专栏,本专栏是针对于大学生,编程小白精心打造的。笔者用重金(时间和精力)打造,将javaSE基础知识一网打尽,希望可以帮到读者们哦。 其他专栏:《

    2024年02月08日
    浏览(37)
  • Redis追本溯源(二)数据结构:String、List、Hash、Set、Zset底层数据结构原理

    Redis 并没有直接用 C 语言的字符串,而是自己搞了一个 sds 的结构体来表示字符串,这个 sds 的全称是 Simple Dynamic String,翻译过来就是“简单的动态字符串”。 安全的二进制存储 资源。关于sds的扩容和缩容下面会进行详细的介绍,这里先不赘述了。 在一些情况中,我们需要

    2024年02月16日
    浏览(51)
  • Java02-迭代器,数据结构,List,Set ,Map,Collections工具类

    目录 什么是遍历? 一、Collection集合的遍历方式 1.迭代器遍历 方法 流程 案例 2. foreach(增强for循环)遍历 案例 3.Lamdba表达式遍历 案例 二、数据结构 数据结构介绍 常见数据结构 栈(Stack) 队列(Queue) 链表(Link) 散列表(Hash Table) 树(Tree) List接口 ArraysList集合 Linked

    2024年02月14日
    浏览(50)
  • 【数据结构与算法】C++的STL模板(迭代器iterator、容器vector、队列queue、集合set、映射map)以及算法例题

    更多算法例题链接: 【数据结构与算法】递推法和递归法解题(递归递推算法典型例题) 什么是迭代器(iterator) 迭代器(iterator)的定义: 迭代器是一种检查容器内元素并遍历元素的数据类型。 迭代器提供对一个容器中的对象的访问方法,并且定义了容器中对象的范围。 容器

    2024年04月14日
    浏览(48)
  • Java学数据结构(3)——树Tree & B树 & 红黑树 & Java标准库中的集合Set与映射Map & 使用多个映射Map的案例

    1.B树,阶M,数据树叶上,根的儿子数在2和M之间,除根外,非树叶节点儿子为M/2和M之间; 2.B树的插入引起分裂,B树的删除,引起合并和领养; 3.红黑树,根是黑的,红色节点的儿子必须是黑的,所有路径的黑色节点数相同; 4.红黑树的插入,颜色翻转,单旋转,插入节点定

    2024年02月11日
    浏览(68)
  • 【3.1数据库系统】数据库体系结构

    ①.外模式: 外模式面向具体的应用程序,定义在逻辑模式之上,但独立于存储模式和存储设备。 ②.概念模式(模式): 用于描述数据库的逻辑结构。 ③.内模式: 也称为存储模式或物理模式,是数据库内部的一种表示方式,用于描述数据物理结构和存储结构。 ①. 基本关

    2024年01月23日
    浏览(52)
  • Python数据容器(列表list、元组tuple、字符串str、字典dict、集合set)详解

    相关介绍: 一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素。每一个元素,可以是任意类型的数据 分为五类: 列表[list]、元组(tuple)、字符串(str)、集合{set}、字典{dict} 相应区别: 列表 元祖 字符串 集合 字典 元素数量 多个 多个 多个 多个 多个 元素类

    2024年02月11日
    浏览(82)
  • 数据密集型应用系统设计--3.1 数据库核心:数据结构

    3.1 数据库核心:数据结构 数据库只需做两件事情:向它插入数据肘,它就保存数据:之后查询时,它应该返回那些数据。 本章我们主要从数据库的角度再来探讨同样的问题,即如何存储输入的数据,井在收到查询请求时,怎样重新找到数据. 了解存储引擎的底层机制。 存储

    2024年01月24日
    浏览(47)
  • List集合和Set集合的区别

    在进行Java开发的时候经常会用到集合,而集合又主要分为两种:Collection单列集合和Map集合。这里主要介绍一下Collection的一些常用子接口的区别。 Collection集合 😮 指单列集合,存储的一组对象。 List: Collection的子接口,特点:元素可重复,有序(存取顺序一致),可以通过

    2023年04月22日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包