day03-List、Set、数据结构、Collections

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

java集合体系结构

a.Collection（单列集合）：

​ list（接口–新增四个方法）：1.有序的。 2.可以存储重复元素

​ ArrayList(子类)：数组实现

​ LinkedList(子类—新增2个方法)：链表实现

​ set（接口）；1.无序的。 2.不能存储重复元素

​ HashSet(子类):哈希表实现

​ LinkedHashSet(子类):链表、哈希表实现

b.Map（双列集合）：

List集合—接口常用的方法

特点：

​ 1.有序的；

​ 2.可以储存重复元素；

常用方法：

1.增

​ public void add(int index, E ele);将元素ele添加到index位置

2.删

​ public E remove(int index):移除列表中指定位置的元素,返回的是被移除的元素

3.改

​ public E set(int index, E ele):用指定元素替换集合中指定位置的元素,返回值是更新前的元素

4.查

​ public E get(int index):返回集合中指定位置的元素

注意:上述四个方法都会用到一个index作为索引值,注意不要超出集合范围,否则抛异常
示例代码：
public static void main(String[] args) {
        ArrayList<String> strList = new ArrayList<>();
        strList.add("王宝强");
        strList.add("杰克");
        strList.add("汤姆");
        System.out.println(strList);
        System.out.println("---------------------");
        //增：在索引的位子添加一个元素，然后原先索引位置的元素依次往后移
        strList.add(1,"邦德");
        System.out.println(strList);
        //删：把索引位置的元素给删除，返回的移除的那个元素
        System.out.println(strList.remove(1));
        System.out.println(strList);
        System.out.println("=========================");
        //改：在指定索引的位置修改一个元素，返回值时修改前的元素
        System.out.println(strList.set(1,"Tom"));
        System.out.println(strList);
        //查：查询指定索引的元素
       String name = strList.get(0);
        System.out.println(name);
    }

数据结构

存储数据的方式就是数据结构

作用：不同的存储方式，会影响增，删，改，查的效率

数据结构__数组

ArrayList（内部就是数组来实现的）

“数组”特点：在内存中是“连续的”，可以通过索引访问里面的元素

​ 1.添加:可能涉及到”数组扩容”,影响效率

​ 2.删除:删除元素后,要将后续元素依次前移一位,影响效率

​ 3.查询:查询list.get(索引),内部将索引作为数组的索引,直接获取,效率快

总结：增删慢，查询快

这里写图片描述

LinkedList(链表实现)

特点:

​ 1.添加:只需赋值几个引用即可,效率快

​ 2.删除:只需要将自己的next赋值给前一个节点(node)的next即可,效率快

​ 3.查询:总是需要从一端开始,向另一端查找,效率慢
这里写图片描述

总结:

​ 1.链表是通过记录节点的地址来进行连接的（多个节点，通过地址连接）

​ 2.操作受限的一个线性表,查询慢,添加,删除快

栈

1).栈结构

这里写图片描述

特点:

​ 1.受限的线性表:添加，删除元素都在同一端（栈顶）

​ 2.先进后出

2).队列

这里写图片描述

特点:

​ 1.受限的线性表,添加，删除各占一端：

​ 2.先进先出

数据结构—红黑树

这里写图片描述

List的子类—ArrayList集合

1.ArrayList内部：数组实现_查询快，增删慢：

2.示例代码：
ArrayList<String> list = new ArrayList<>();
        list.add("黄磊");
        list.add("黄渤");
        list.add("黄晓明");
        //遍历方式：增强for(底层：迭代器)
        for(String s : list){
            System.out.println(s);
        }
        //遍历方式：size() + get()
        for(int i = 0;i < list.size(); i++){
            String s = list.get(i);
            System.out.println(s);
        }

List的子类—LinkedList集合

1.LinkedList：链表实现—查询慢，增删快：

2.特有方法:

​ a) push():模拟压栈

​ b) Poll():模拟弹栈

示例代码：
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.push("7.62");
        list.push("7.62");
        list.push("7.62");
        list.push("7.62");
        list.push("7.62");
        list.push("7.62");
        //因为LinkedList是list集合的子类，所以有list的接口特点：1.有序的  2.可以储存重复的元素

        //list.poll();
        //list.poll();
        //list.poll();
        //list.poll();
       // list.poll();
        //list.poll();
        //System.out.println(list.poll());
        //为了防止抛空的情况，可以用while循环进行判断
        while(list.size() >0){
            System.out.println(list.poll());
        }
    }

Set接口—HashSet存储字符串

Set集合的特点；

​ 1.无序的

​ 2.不能存储重复元素（可以用这个筛选一些重复的元素，编译通过，运行不报错，但是重复的自动筛选出来）

示例代码：
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("Tom");
        set.add("jarry");
        set.add("邦德");
        set.add("詹姆斯");
        set.add("科比");
        set.add("jarry");
        //筛选出重复的元素，编译通过，运行不报错，但是集合不储存这个重复的元素，
        //实际案例中让我们把重复的一些元素筛选出来，打印剩下的，最简便的 方法就是用Set

        //遍历集合
        for (String S:set) {
            System.out.println(S);
        }
    }

Set接口—HashSet存储自定义对象

1.定义Student类（注意：重写,hashCode()和equals()）

示例代码：

1.Student类

   private String name ;
   private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

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

2.测试类

    public static void main(String[] args) {
        HashSet<Student> set = new HashSet<>();
        set.add(new Student("邦德",10));
        set.add(new Student("Tom",3));
        set.add(new Student("Tom",3));
        //这里添加的两个相同的元素，Set会先判断hashCode()，相同，在判断equals(),要是再相同，不存储元素，不相同就存储进集合
        //                                                 不相同的话，就会存储进集合
        //遍历
        for (Student S:set) {
            System.out.println(S);
        }
        System.out.println("集合大小"+set.size());
    }

Set接口数据结构_哈希表

![](F:\黑马程序员 就业办 课件\photo\7.png)

特点：

​ 1.采用：数组 + 链表 + 红黑树实现

​ 2.验证元素的唯一性：

​ a)先判断元素的hashCode()

​ 不同:存到集合中

​ 相同:在判断元素的equals()

​ 不同:存到集合中

​ 相同:不存

Set接口-LinkedHashSet的特点及使用

1.LinkedHashSet:它是链表，哈希表的实现

​ 它是Set的特例，有序的哈希表

示例代码:
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();

        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("ccc");
        //Set接口自己会把重复的元素筛选出来
        //System.out.println(set);
        //遍历
        for (String S:set) {
            System.out.println(S);//有序的
        }
    }

Set接口—可变参数

    public static void main(String[] args) {
        //编译前
        sum();
        sum(10,20);
        sum(10,3,24,324,321,45,43,24,324,325,42,431);
        //Set接口的可变参数的作用就是方便添加元素

        //编译后
       /* sum(new int[0]);
        sum(new int[]{10,20});
        sum(new int[]{10,3,24,324,321,45,43,24,324,325,42,431);*/

    }
    //编译前
    public static int sum(int ... nums) {
        int sum = 0;
        for (int n : nums) {
            sum += n;
        }
        return sum;
    }
    //编译后
    /*public static int sum(int[] nums) {
        int sum = 0;
        for (int n : nums) {
            sum += n;
        }
        return sum;
    }*/
}
其它说明：

1).在一个方法中最多只能有一个“可变参数”，而且必须位于参数列表的末尾：
public static int sum(int a,String b,int … nums){//OK的
}
public static int sum(int…nums,int a,int b){//错误
}
public static int sum(String…s,int … nums){//错误
}

注意：前两个必须要传，后面一个可以不传

Collection-常用功能

1.java.util.Collections(工具类):里面包含了对Collection集合操作的一些工具性方法。

2.常用方法：
1).public static <T> boolean addAll(Collection<T> c, T. .elements) :往集合中添加一些元素。
2).public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
3).public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
4).public static <T> void sort(List<T> list,Comparator<? super T>):将集合中元素按照指定规则排序。

shuffle（list c）：打乱集合内元素顺序，实用例子洗牌

3.示例代码：
    public static void main(String[] args) {
        ArrayList<Integer> intList = new ArrayList<>();
        /*intList.add(10);
        intList.add(1);
        intList.add(2);
        intList.add(13);
        intList.add(1);
        intList.add(40);
        */
        //之前这种添加方式效率慢

        //1.addAll(Collection c , T ... nums):向集合中添加若干的T类型的数据
        Collections.<Integer>addAll(intList,10,1,2,13,1,4);
        System.out.println(intList);

        //2.shuffle(List c):打乱集合内元素的顺序
        Collections.shuffle(intList);
        System.out.println(intList);

        //3.sort(List c):对集合内的元素进行"排序（默认—升序）"
        Collections.sort(intList);
        System.out.println(intList);

        System.out.println("-------------------------");

        ArrayList<String> strList = new ArrayList<>();
        strList.add("abcdef");
        strList.add("abc");
        strList.add("bac");
        strList.add("bca");
        strList.add("cba");
        strList.add("cab");

        Collections.sort(strList);
        System.out.println(strList);

        System.out.println("======================");
        //对于自定义对象排序的前提：Student必须实现Comparable接口
        ArrayList<Student> stuList = new ArrayList<>();
        stuList.add(new Student("邦德",10));
        stuList.add(new Student("Tom",4));
        stuList.add(new Student("Jerry",3));
        stuList.add(new Student("詹姆斯",20));

        Collections.sort(stuList);
        System.out.println(stuList);

        //这时候是按年龄的从小到大，按升序排的。       int n = this.age - o.age;
        //要是想从大到小，按降序排。         int n = o.age - this.age;
    }

Student类：

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {

        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(Student o) {
        int n = o.age - this.age;
        return n;
    }

        //这时候是按年龄的从小到大，按升序排的。       int n = this.age - o.age;
        //要是想从大到小，按降序排。         int n = o.age - this.age;

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

Collection工具类—实现比较方式一 -为类添加比较功能—Comparble

3).public static void sort(List list) :将集合中元素按照默认规则排序。

示例代码：
public class Student implements Comparable<Student>{
    private String name;
    private int age;
     ......
    @Override
    public int compareTo(Student o) {
        int n = o.age - this.age;
        return n;
    }
}
测试代码：
ArrayList<Student> stuList = new ArrayList<>();
stuList.add(new Student("张三1", 18));
stuList.add(new Student("张三2", 19));
stuList.add(new Student("张三3", 17));
stuList.add(new Student("张三4", 10));

Collections.sort(stuList);//sort会去调用Student的compareTo()方法进行依次的比较

System.out.println(stuList);

Collection工具类—实现比较方式一 比较器—Comparator接口

4).public static void sort(List list,Comparator

示例代码：
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
测试类：
class MyCom implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() -o2.getAge();
    }
}
public class Deom {
    public static void main(String[] args) {
        ArrayList<Student> stuList = new ArrayList<>();
        stuList.add(new Student("邦德",10));
        stuList.add(new Student("Tom",3));
        stuList.add(new Student("Jarry",1));
        stuList.add(new Student("詹姆斯",20));

        Collections.sort(stuList,new MyCom());
        System.out.println(stuList);

    }
}
使用匿名内部类：
public class Demo01 {
    public static void main(String[] args) {
        ArrayList<Student> stuList = new ArrayList<>();
        stuList.add(new Student("邦德", 10));
        stuList.add(new Student("Tom", 3));
        stuList.add(new Student("Jarry", 1));
        stuList.add(new Student("詹姆斯", 20));

        //这个用了匿名内部类，简化代码，
        //new的不是Comparator 因为它是个接口，new的是括号内的子类对象
        /*new  Comparator<Student> (){
                    @Override
                   public int compare(Student o1, Student o2) {
                        return o1.getAge() -o2.getAge();
                   }*/
        //这个表达式做了两件事：1.定义了一个子类，并且即实现了Comparator接口，又重写了Compare方法
        //2.直接把这个子类new出一个对象，然后传到这个方法中
        Collections.sort(stuList, new  Comparator<Student> (){
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() -o2.getAge();
            }
    });
        System.out.println(stuList);
    }
}
I'M 吴一
关注
day05-迭代器，数据结构,List,Set ,TreeSet集合,Collections工具类 - 副本.md
07-20
这是为了方便大家了解集合类的相关知识所找的一个MarkDown文档,读者可以通过阅读了解各种子类集合的实现原理,红黑树的实现也会有所介绍.
day03 【List、Set、数据结构、Collections】.md
04-16
最详细的java 的Collection 和Map 集合知识点 ！
List、Set、数据结构、Collections-笔记
qq_28770419的博客
03-15 423
我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？在HashSet下面有一个子类，它是链表和哈希表组合的一个数据存储结构。
day11【List、Collections、set】
weixin_43525993的博客
06-22 1775
今日内容 List集合 Collections工具类 Set集合 教学目标 能够说出List集合特点 能够使用集合工具类 能够使用Comparator比较器进行排序 能够使用可变参数 能够说出Set集合的特点 能够说出哈希表的特点 使用HashSet集合存储自定义元素 第一章 List接口 我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？ 接下来，我们一起学习Collection中的常用几个子接口（java.uti
Java学习day03--Collection的子类之List和Set
Renatoly的博客
03-23 215
Java学习day03--Collection的子类之List和SetCollection的子类之List和SetList抽象类Set抽象类可变参数Collections类 Collection的子类之List和Set 该模块涉及抽象类List、Set。也涉及List的子类ArrayList和LinkedList，Set的子类HashSet、LinkedHashSet。最后还讲解了可变参数、Col...
【List、Set、数据结构、Collections】-Collections
qq_28770419的博客
03-16 504
强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。强行对某个对象进行整体排序。
JAVA进阶-set,Comparable排序,数据结构-树
qinqin__的博客
09-14 528
简单介绍set,Comparable排序,数据结构-树
数据结构-list集合-set集合
qq_28770419的博客
03-13 915
是变速箱的工作原理。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。**指定索引位置删除元素：**需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。
Day25-API基础Collection下的List接口及方法和Set接口,Collections工具类
aiheshuicxy的博客
10-28 604
Day25-API基础Collection下的List接口及方法和Set接口,Collections工具类
day32 泛型 List 数据结构概述
weixin_45939821的博客
09-03 680
JDK1.5同时推出了两个和集合相关的特性：增强for循环，泛型泛型可以修饰泛型类中的属性，方法返回值，方法参数， 构造函数的参数{}自定义的泛型方法list){
study_day03-Python程序设计基础
weixin_73895683的博客
09-18 1225
什么是可迭代对象 iterable：是指可以一个一个返回其成员的对象，所有的序列类型，list,str,tuple,和一些非序列对象，比如dict,__iter__()或者实现了__getitem__()方法的任何类对象。filter：接收一个函数，和一个可迭代对象，函数的作用是对可迭代对象的每一个元素进行判断，返回Ture或False，filter根据判断的结果过滤出那些不符合条件的元素。与位置参数不同的是，关键字参数不依赖参数的位置，而是，依赖参数的名字。函数的作用域：定义了函数中变量的可见性。
数据结构之Map和Set（下）
我要学编程的博客
08-09 1422
冲突-解决-闭散列、开散列/哈希桶 手动实现哈希表 哈希表和Java类的关系 有关Map和Set的相关练习：只出现一次的数字、随机链表的复制、宝石与石头、前k个高频单词
Java基础知识-day03【List、Set】.pdf
10-26
Java基础知识-day03【List、Set】 本节课程主要介绍了Java中的List集合和Set集合，並对数据结构和Collections进行了详细的讲解。通过本节课程，学生将掌握List集合的特点、Set集合的特点、数据结构的常见类型、...
day03_List、Set 每日作业卷答案1
08-08
- **Comparator**：Comparator接口提供了一种灵活的排序方式，可以在运行时动态指定排序规则，常用于Collections.sort()或Arrays.sort()方法，以及数据结构如有序集合和有序映射。 LinkedList作为List接口的一个...
景区民宿预约系统代码系统 Springboot景区民宿预约系统（程序，中文注释）
最新发布
09-26
景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统-景区民宿预约系统 1、资源说明：景区民宿预约系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：SpringBo
C语言期末题库.zip
09-26
C语言期末题库.zip
金融行业理财产品介绍汇报人：清XXX风XX时间：202XXXXXIntroduction to financial produc
09-26
金融行业理财产品介绍汇报人：清XXX风XX时间：202XXXXXIntroduction to financial products模板手动提交
20240926-H3CNE题库GB190含详细答案解析
09-26
20240926-H3CNE题库GB190含详细答案解析
Java SE Day3：List与Set操作详解与数据结构特点
在Java SE的第三天学习中，主要围绕List接口、Set集合、数据结构以及Comparable和Comparator接口展开。以下是详细的知识点总结： 1. List接口的特点： List是一种有序的、可变的集合，它的元素具有明确的索引。这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值