javase复习day22集合进阶

最新推荐文章于 2024-10-11 17:30:36 发布
最新推荐文章于 2024-10-11 17:30:36 发布
阅读量762 收藏 9
点赞数 14
分类专栏： javase复习 文章标签： java apache windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72625929/article/details/142080714
版权

集合体系结构

Collection单列集合



import java.util.ArrayList;
import java.util.Collection;

public class A01_CollectionDemo1 {
    public static void main(String[] args) {
/*
        public boolean add(E e)             添加
        public void clear()                 清空
        public boolean remove(E e)          删除
        public boolean contains(Object obj) 判断是否包含
        public boolean isEmpty()            判断是否为空
        public int size()                   集合长度


       注意点：
        Collection是一个接口,我们不能直接创建他的对象。
        所以，现在我们学习他的方法时，只能创建他实现类的对象。
        实现类：ArrayList
*/
        //目的：为了学习Collection接口里面的方法
        //自己在做一些练习的时候，还是按照之前的方式去创建对象。
        Collection<String> coll = new ArrayList<>();


        //1.添加元素
        //细节1：如果我们要往List系列集合中添加数据，那么方法永远返回true，因为List系列的是允许元素重复的。
        //细节2：如果我们要往Set系列集合中添加数据，如果当前要添加元素不存在，方法返回true，表示添加成功。
        //                                       如果当前要添加的元素已经存在，方法返回false，表示添加失败。
        //                                       因为Set系列的集合不允许重复。
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);

        //2.清空
        //coll.clear();

        //3.删除
        //细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
        //细节2：方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false
        //如果要删除的元素不存在，就会删除失败。
        System.out.println(coll.remove("aaa"));
        System.out.println(coll);


        //4.判断元素是否包含
        //细节：底层是依赖equals方法进行判断是否存在的。
        //所以，如果集合中存储的是自定义对象，也想通过contains方法来判断是否包含，那么在javabean类中，一定要重写equals方法。
        boolean result1 = coll.contains("bbb");
        System.out.println(result1);



        //5.判断集合是否为空
        boolean result2 = coll.isEmpty();
        System.out.println(result2);//false


        //6.获取集合的长度
        coll.add("ddd");
        int size = coll.size();
        System.out.println(size);//3

    }
}

package Collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo1 {
    public static void main(String[] args) {
        //由于callection为接口，无法直接创建对象
        //所以可以使用多态来创建对象
        Collection<String> coll = new ArrayList<>();

        //添加,
        /**
         * 由于Collection被全部单例集合继承，add的返回值在ArrayList下都为true
         * 在set中由于其不重复的特性，当set中没有时返回true，当已经存在时返回fales
         */
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");

        System.out.println(coll);//[aaa, bbb, ccc]

        //清空
//        coll.clear();

        System.out.println(coll);//[aaa, bbb, ccc]

        //删除
        /**
         * set中无索引只能使用对象删除
         */
        System.out.println(coll.remove("aaa"));//true

        //判断是否存在
        /*
        底层实现为调用对象的equse方法来判断，所以对象需要重写equse方法，让方法判断内容是否正确，
        而不是内存地址是否一致
         */
        System.out.println(coll.contains("bbb"));//true

        //判空
        System.out.println(coll.isEmpty());//false

        //长度
        System.out.println(coll.size());//2

    }
}

Collection的遍历方式

没有for循环的原因：

        for循环通过访问索引的方式进行遍历，但是set没有索引因此无法使用for循环遍历。

迭代器遍历

特点：不依赖索引。

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo3 {
    public static void main(String[] args) {
        //创建一个集合
        Collection<String> coll = new ArrayList<>();

        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        //集合对象获取迭代器对象
        Iterator<String> it = coll.iterator();
        //进行循环遍历
        //判断当前位置是否存在对象
        while (it.hasNext()){
            String next = it.next();//获取对象并将指针下移一位
            System.out.println(next);
        }
    }
}

迭代器细节：

  1.  当指针指向集合外时，依然强制获取对象则报错，NoSuchElementException错误。
  2. 迭代器遍历完毕，指针不会复位。
  3. 循环中只能用一次next方法。
  4. 迭代器遍历时，不能使用集合的方法进行增加和删除。会出现并发修改异常。如果要删除可以使用迭代器提供的方法进行删除。
package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo4 {
    public static void main(String[] args) {
        //创建一个集合
        Collection<String> coll = new ArrayList<>();

        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        //集合对象获取迭代器对象
        Iterator<String> it = coll.iterator();
        //进行循环遍历
        //判断当前位置是否存在对象
        while (it.hasNext()){
            String next = it.next();//获取对象并将指针下移一位
            System.out.println(next);
        }
        //强制获取对象
//        System.out.println(it.next());//NoSuchElementException异常
        //指针不复位
        System.out.println(it.hasNext());//false,没有获取到对象，即指针没有复位

        //想要再次遍历则需要再次获取迭代器
        //集合对象获取迭代器对象
        Iterator<String> it2 = coll.iterator();
        //进行循环遍历
        //判断当前位置是否存在对象
        while (it2.hasNext()){
            String next = it2.next();//获取对象并将指针下移一位
            System.out.println(next);
        }


    }
}

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo5 {
    public static void main(String[] args) {
        //创建一个集合
        Collection<String> coll = new ArrayList<>();

        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        coll.add("eee");
        //集合对象获取迭代器对象
        Iterator<String> it = coll.iterator();
        //进行循环遍历
        //判断当前位置是否存在对象
        while (it.hasNext()){
            //在循环中对集合进行增加和删除操作，出现异常：ConcurrentModificationException
            if("bbb".equals(it.next())){
//                coll.remove("bbb");
                //如果必须要进行删除操作，可以使用迭代器的方法,进行删除
                it.remove();
            }
            //一次获取两个对象,异常:NoSuchElementException
            //由于next方法获取对象后指针后移一位如果不判断对象是否存在就会出现对象不存在异常
//            System.out.println(it.next());
//            System.out.println(it.next());

        }
        //想要再次遍历则需要再次获取迭代器
        //集合对象获取迭代器对象
        Iterator<String> it2 = coll.iterator();
        //进行循环遍历
        //判断当前位置是否存在对象
        while (it2.hasNext()){
            String next = it2.next();//获取对象并将指针下移一位
            System.out.println(next);
        }

    }
}

迭代器小结：

增强for遍历

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collectiondemo6 {
    public static void main(String[] args) {
        //创建一个集合
        Collection<String> coll = new ArrayList<>();

        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        //使用增强for循环
        /*
        集合名+for快捷生成增强for循环
         */
        for (String s : coll) {
            System.out.println(s);
        }
        //增强for循环中的数据改变不影响集合中的数据
        for (String s : coll) {
            s = "qqq";
        }
        for (String s : coll) {

            System.out.println(s);
        }
    }
}

Lambda表达式遍历

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;

public class CollectionDemo7 {
    public static void main(String[] args) {
        //创建一个集合
        Collection<String> coll = new ArrayList<>();

        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
       //lambda表达式遍历
        //先使用匿名内部类进行遍历
        /*
        forEach方法底层为for循环，将每次遍历到的对象都交给accept方法
            string 就是获取的对象
         */
//        coll.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String string) {
//                System.out.println(string);
//            }
//        });
        //lambda表达式
        coll.forEach( string-> System.out.println(string));
    }
}

Collection小结

List集合

特点

List的特有方法

package MyArrayList;

import java.util.ArrayList;
import java.util.List;

public class ArraylistDemo1 {
    public static void main(String[] args) {
        //List集合
        List<String> list = new ArrayList<>();

        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        //根据索引在指定位置插入元素
        /*
        被占据位置的元素，会向后退一位
         */
        list.add(1,"QQQ");
        System.out.println(list);

        //删除元素
        /*
        通过索引来删除元素，并返回被删除的元素
        详细解释见下一段代码
         */
        System.out.println(list.remove(0));

        //根据索引修改元素,并返回被修改的元素
        System.out.println(list.set(0, "qqq"));

        //获取元素
        System.out.println(list.get(0));

        System.out.println(list);

    }
}

关于删除的解释代码：

package MyArrayList;

import java.util.ArrayList;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        //删除的情况
        List<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println(list);

        /*
        由于删除方法有两个,直接输入数字，调用的是根据索引删除，
        原因：重载的方法调用会根据输入的值的类型来判断使用哪个方法，
            输入数字，因为数字是int 类型所以调用了根据索引删除的方法
            如果想要调用根据对象删除则可以将数字装箱为一个引用类型再调用。
         */
        //直接调用为根据索引删除
        System.out.println(list.remove(1));
        //装箱后调用为根据对象删除，因为对象时Integer类型就近调用
        //可看做该方法不会自动装箱
        Integer i = 1;
        System.out.println(list.remove(i));

        System.out.println(list);

    }
}

List集合的遍历方式

package MyArrayList;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Consumer;

public class ArrayListDemo3 {
    public static void main(String[] args) {
        //List的遍历方式
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //迭代器遍历
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()){
//            String str = it.next();
//            System.out.println(str);
//        }
        //增强for循环
//        for (String s : list) {
//            System.out.println(s);
//        }
        //lambda表达式
//        list.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String string) {
//                System.out.println(string);
//            }
//        });
        //化简为Lambda表达式
//        list.forEach(s-> System.out.println(s));

        //普通for循环
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }

        //列表迭代器遍历
        /*
        列表迭代器实现了迭代器的接口，添加了增加的方法，和指针从后向前的方法
         */
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){

            String s = listIterator.next();
            System.out.println(s);
            //遍历中添加元素
            if ("bbb".equals(s)){
                listIterator.add("QQQ");
            }
        }
        System.out.println(list);

    }
}
遍历方式的对比

数据结构

数据结构是计算机存储、组织数据的方式。

数据结构概述

常见的数据结构

栈、队列、数组、链表、二叉树、二叉查找树、平衡二叉树、红黑树。

栈

应用：栈内存。

队列

数组

链表

总结

Arraylist 的底层原理

添加数据时会有一个size指针，表示当前集合的数量又指定先一个元素的位置。

Arrayslist集合添加第一个元素时的源码解析：

Arrayslist集合添加100个元素时需要扩容的源码解析：

LinkedList集合

大多使用Conllection中的方法。

迭代器的源码

未命名冀
关注
专栏目录
javase_day01
11-06
Java是一种由SUN公司在1995年推出的高级编程语言，最初命名为Oak。它以其在Web应用程序中的广泛应用而著名，特别适合互联网编程，具备安全、可靠和面向对象的特性。Java的重要特点是其跨平台性，这得益于Java虚拟机...
JavaSE复习.md
12-23
JavaSE复习
javase复习day13_面对对象进阶_static
m0_72625929的博客
09-03 652
System.out.println("父类的无参构造");System.out.println("调用父类的有参构造");super();System.out.println("调用子类无参构造");System.out.println("调用子类有参构造");ziClass z1 = new ziClass("小李",20);System.out.println("员工正在工作");System.out.println("员工正在吃饭");
JavaSE进阶（day05，复习自用）
Singularity_233的博客
05-14 112
}// 1.：定义一个电影类，定义一个集合存储电影对象。// 2.：创建3个电影对象，封装相关数据，把3个对象存入到集合中去。movies . add(new Movie("《肖生克的救赎》" , 9.7 , "罗宾斯"));movies . add(new Movie("《霸王别姬》" , 9.6 , "张国荣、张丰毅"));movies . add(new Movie("《阿甘正传》" , 9.5 , "汤姆.汉克斯"));
JavaSE进阶（day06，复习自用）
Singularity_233的博客
05-16 303
Set集合的底层原理是什么样的？JDK8之前的，哈希表：底层使用数组+链表组成JDK8开始后，哈希表：底层采用数组+链表+红黑树组成哈希表的详细流程创建一个默认长度16，默认加载因为0.75的数组，数组名table根据元素的哈希值跟数组的长度计算出应存入的位置判断当前位置是否为null，如果是null直接存入，如果位置不为null，表示有元素， 则调用equals方法比较属性值，如果一样，则不存，如果不一样，则存入数组。
JavaSE进阶（day10，复习自用）
Singularity_233的博客
05-23 124
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。缓冲流的作用？缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能缓冲流有几种？字节缓冲流字节缓冲输入流： BufferedInputStream字节缓冲输出流：BufferedOutputStream。
JavaSE进阶（day07，复习自用）
Singularity_233的博客
05-18 424
/初步体验Stream流的方便与快捷 public class StreamTest {Collections . addAll(names , "张三丰" , "张无忌" , "周芷若" , "赵敏" , "张强");// //1.从集合中找出姓张的放到新集合 // List<String> zhangList = new ArrayList<>();
JavaSE进阶（day04，复习自用）
Singularity_233的博客
05-12 130
1、包装类是什么，作用是什么？基本数据类型对应的引用类型，实现了一切皆对象。后期集合和泛型不支持基本类型，只能使用包装类。2、包装类有哪些特殊功能？可以把基本类型的数据转换成字符串类型(用处不大)可以把字符串类型的数值转换成真实的数据类型（真的很有用）/*** 目标：明白包装类的概念，并使用。int a = 10;//自动装箱 System . out . println(a);//自动拆箱 System . out . println(it1);
JavaSE进阶（day14，复习自用）
Singularity_233的博客
05-29 517
XML是什么?XML的全称为（EXtensible Markup Language），是一种可扩展的标记语言。它是是一种数据表示格式，可以用于自定义数据格式。XML的作用是什么?用于进行存储数据和传输数据作为软件的配置文件使用程序读取XML中的数据两种解析方式SAX解析DOM解析。
JavaSE进阶（day13，复习自用）
Singularity_233的博客
05-29 572
Junit单元测试是做什么的？测试类中方法的正确性的。Junit单元测试的优点是什么？JUnit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。JUnit可以生测试报告，如果测试良好则是绿色；如果测试失败，则是红色。单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。反射的第一步是什么？获取Class类对象，如此才可以解析类的全部成分获取Class类的对象的三种方式方式一：Class c1 = Class.forName(“全类名”);
JavaSE进阶（day09，复习自用）
Singularity_233的博客
05-22 118
字符集（Character Set）是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集有：ASCII字符集GBK字符集Unicode（UTF-8）字符集等。常见字符集底层字符的编码是什么样的？英文和数字等在任何国家的字符集中都占1个字节GBK字符中一个中文字符占2个字节UTF-8编码中一个中文1般占3个字节编码前的字符集和解码时的字符集有什么要求？必须一致，否则会出现字符乱码英文和数字不会乱码每次读取一个字节存在什么问题？性能较慢。
JavaSE进阶每日复习与笔记.zip
11-03
本压缩包包含的笔记涵盖了JavaSE的一些重要进阶主题，包括抽象类与接口、集合、数组、线程以及异常处理和注解。以下是这些主题的详细讲解： 1. **抽象类与接口** - **抽象类**：在Java中，抽象类是一种不能被实例...
JavaSE专题-Set集合.doc
06-03
JavaSE专题-Set集合 Set集合是JavaSE中的一种重要数据结构，主要包括HashSet、TreeSet和LinkedHashSet三个子类。下面我们将对Set集合的原理、特点、使用场景等进行详细的探索和分析。 HashSet HashSet是Set集合中...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1395
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
JDK1.0主要特性
FoolRabbit的专栏
10-06 760
JDK1.0主要特性。
Backend - Java 基础
最新发布
是萝卜干呀的博客
10-11 443
知识量决定了未来能走多远
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1644
2024最新Java面试题，针对一些小厂，中厂
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值