JAVA自学笔记（集合）

最新推荐文章于 2024-11-15 18:38:47 发布
最新推荐文章于 2024-11-15 18:38:47 发布
阅读量205 收藏 1
点赞数 2
文章标签： java 集合 链表 数组 hashtable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lol666111/article/details/118398538
版权

集合

1、集合

  • 概念：对象的容器，实现类对对象常用的操作，类似数组功能。

  • 和数组的区别：

    • 数组长度固定，集合长度不固定。

    • 数组可以存储基本类型和引用类型，集合只能存储引用类型。

  • 位置：java.util*

2、collection父接口

  • 注意事项：1.在迭代器中，不能连续调用it.next() 2.在迭代过程中不能使用collection.remove()，可以使用迭代器的删除，it.remove（）

  • 特点：代表一组任意类型的对象，无序、无下标、不能重复

  • 迭代器迭代过程中，不能使用collection的删除方法，可以使用iterator（迭代器）的删除方法

  • 方法：

    • public static void main(String[] args) {
    //创建集合
    Collection collection = new ArrayList();
    //添加元素   add
    collection.add("苹果");
    collection.add("xigua");
    collection.add(3306);
    collection.add('a');
    //获取集合元素个数  collection.size
    System.out.println("删除前元素个数："+collection.size());   //删除前元素个数：4
    //遍历元素
    //通过加强for进行便利
    System.out.println("----------通过加强for进行便利-----------");
    for (Object o:collection) {
        System.out.println(o);  //苹果   xigua   3306   a
    }
    //通过迭代器遍历  iterator   
    System.out.println("----------通过加强Iterator进行便利-----------");
    Iterator iterator = collection.iterator();
    while (iterator.hasNext()){
        Object o = iterator.next();
        System.out.println(o);    //苹果  xigua  3306  a
    }
​
    //删除元素  remove    iterator.remove
    collection.remove("苹果");
    System.out.println("删除后元素个数："+collection.size());   //删除后元素个数：3
    //判断元素是否存在   collection.contains
    System.out.println(collection.contains("xigua"));   //true
     //清除数据
        collection.clear();
        System.out.println(collection.size());   //0
}
​

3、List子接口

  • 特点：有序（添加的顺序和便利的顺序一样）、有下标、元素可以重复

  • 方法：

    • public static void main(String[] args) {
    List list = new ArrayList();
    //添加元素
    list.add("孙二");
    list.add("张三");
    list.add("李四");
    //通过下标向集合添加元素
    list.add(0,"赵大");
    System.out.println(list.toString());   //[赵大, 孙二, 张三, 李四]
​
    //获取下标为2的元素
    Object o = list.get(2);
    System.out.println(o);  //张三  下标为2，第三个元素
​
    //将下标为2的 张三 改为  王三
    list.set(2,"王三");
    System.out.println(list.get(2));   //王三
​
    //遍历数组
    //使用for循环遍历集合,因为List集合有下标
    System.out.println("------使用for循环遍历集合,因为List集合有下标------");
    for(int i = 0;i<list.size();i++){
        System.out.print(list.get(i)+"\t"); //赵大  孙二   王三 李四
    }
    System.out.println();
    //使用增强for遍历List集合
    System.out.println("-----使用增强for遍历List集合--------");
    for (Object o1: list) {
        System.out.print(o1+"\t");   //赵大  孙二 王三 李四
    }
    System.out.println();
    //使用迭代器listiterator遍历集合
    ListIterator iterator = list.listIterator();
    //顺序遍历数组
    System.out.println("-------顺序遍历数组-------");
    while (iterator.hasNext()){
        System.out.print(iterator.nextIndex()+":"+iterator.next());  //0:赵大1:孙二2:王三3:李四
    }
    System.out.println();
    System.out.println("-------逆序遍历数组-------");
    while (iterator.hasPrevious()){
        System.out.print(iterator.previousIndex()+":"+iterator.previous());  //3:李四2:王三1:孙二0:赵大
    }
    System.out.println();
    //判断元素是否存在
    System.out.println(list.contains("张三"));   //false
​
    //判断集合是否为空
    System.out.println(list.isEmpty());   //false
    list.add("小莲花");
    list.add("小翠");
    System.out.println(list.toString());   //[赵大, 孙二, 王三, 李四, 小莲花, 小翠]
    //subList获取一个子集合  含头不含尾
    List list1 = list.subList(list.size()-2,list.size());
    System.out.println(list1.toString());   //[小莲花, 小翠]
​
}

ArrayList源码分析（查询快，增删慢，数组结构）

  • 默认容量大小DEFAULT_CAPACITY：10

  • 初始化调用无参构造ArrayList集合，数组长度是0

  • 如果没有向集合中添加任何元素，默认容量是：0

  • 添加第一个元素之后，数组容量扩容为10

  • 存放元素的数组：elementData

  • size：实际元素个数

  • 扩容原理：扩容为原来的1.5倍，原大小使用二进制表示，然后右移，最后相加

  • 使用System.arraycopy实现复制方法，将原集合的数据拷贝到扩容后的集合

  • add（） 添加元素

    public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
​
private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }
​
​

ArrayList常用方法

  • ArrayList.remove(Object o)，只会删除第一个遇到的相同元素，并且返回true

public static void main(String[] args) {
    Student s1 = new Student("小翠",15,"女");
    Student s2 = new Student("小莲花",17,"女");
    Student s3 = new Student("小月",19,"女");
    Student s4 = new Student("厚本",29,"女");
    ArrayList arrayList = new ArrayList();
    //添加元素
    arrayList.add(s4);
    arrayList.add(s1);
    arrayList.add(s2);
    arrayList.add(s3);
    System.out.println(arrayList.toString());  //[Student{name='厚本', age=29}, Student{name='小翠', age=15},
                                       // Student{name='小莲花', age=17},Student{name='小月', age=19}]
    //删除元素
    arrayList.remove(new Student("厚本",29,"女"));
    System.out.println(arrayList.toString());      //[Student{name='小翠', age=15}, Student{name='小莲花', age=17},
                                           // Student{name='小月', age=19}]
​
    //查找位置
    System.out.println(arrayList.indexOf(new Student("小翠",15,"女")));   //0
}

LinkedList集合方法

LinkedList linkedList = new LinkedList();
Student s1 = new Student("小翠",15,"女");
Student s2 = new Student("小莲花",17,"女");
Student s3 = new Student("小月",19,"女");
Student s4 = new Student("厚本",29,"女");
//添加元素
linkedList.add(s1);
linkedList.add(s2);
linkedList.addFirst(s3);//将元素添加到第一个
linkedList.add(s4);
System.out.println(linkedList.toString());
//删除元素
linkedList.remove(s4);  //使用equals
System.out.println(linkedList.toString());
//迭代器遍历元素
System.out.println("--------迭代器遍历元素--------");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next().toString());
}
​
//列表迭代器
System.out.println("--------列表迭代器遍历元素--------");
ListIterator listIterator = linkedList.listIterator();
System.out.println("   -----列表迭代器先序遍历元素----");
while (listIterator.hasNext()){
    System.out.println(listIterator.previousIndex()+":"+listIterator.next().toString());
}
System.out.println("   -----列表迭代器后序遍历元素----  ");
while (listIterator.hasPrevious()){
    System.out.println(listIterator.previousIndex()+":"+listIterator.previous().toString());
}
//判断
System.out.println(linkedList.contains(s1));
System.out.println(linkedList.isEmpty());
​
//查找位置
System.out.println(linkedList.indexOf(s1));

队列

**
 * 队列：先进先出，数据结构的一种
 * Queue：队列的接口，LinkedList实现
 * 核心操作
 *     入队：offer()
 *     出队：poll()
 */
public class DemoQueue {
    public static void main(String[] args) {
        //创建队列
        Queue queue = new LinkedList();
        //入队（添加元素）
        queue.offer("北京1");
        queue.offer("上海2");
        queue.offer("深圳3");
        System.out.println("元素个数："+ queue.size());   //元素个数：3
        System.out.println("直接打印："+queue.toString());   //直接打印：[北京1, 上海2, 深圳3]
        //出队（删除元素）
        System.out.println("-----出队-----");
        int size = queue.size();
        for (int i =0;i<size;i++){
            System.out.println(queue.poll());   //北京1   上海2   深圳3
        }
        System.out.println("出队后的个数："+queue.size());  //出队后的个数：0
    }
}

栈

/**
 * 栈：先进后出的一种数据结构
 * 可以使用LinkedList代替，LinkedList也实现了栈结构
 * Stack类：继承Vector
 * 出栈必须使用一个变量来获取栈的长度，因为出栈的过程中，栈的元素个数一直在减少
 * 核心操作
 *    push（）；进栈
 *    pop（）；出栈
 */
public class DemoStack {
    public static void main(String[] args) {
        //创建一个栈
        Stack stack = new Stack();
        //进栈  (添加元素)
        stack.push("北京1");
        stack.push("上海2");
        stack.push("深圳3");
        System.out.println("元素个数:"+stack.size());   //元素个数:3
        System.out.println("直接打印："+stack.toString());   //直接打印：[北京1, 上海2, 深圳3]
        //出栈（删除元素）
        System.out.println("-----出栈-----");
        int size = stack.size();
        for(int i = 0;i<size;i++){
            String s = (String)stack.pop();
            System.out.println(s);    //深圳3   上海2   北京1
        }
        System.out.println("出栈之后的元素个数："+stack.size());  //出栈之后的元素个数：0
    }
}

泛型

概念：

  • 参数化类型、类型安全的集合，强制集合元素的类型必须一致

特点：

  • 编译时即可检查，而非运行时抛出异常

  • 访问时，不必类型转化（拆箱）

  • 不同泛型之间引用不能相互赋值

优点

  • 提高代码的重用性

  • 防止类型转换异常，增加代码安全性

泛型的使用：泛型类

  • 泛型类：在类名的后面添加<T,E,K,V.....>type，value,key，element

  • <T>表示类型占位符，代表一种引用类型。多个占位符之间使用逗号隔开

  • 静态方法不能使用泛型，泛型只有在创建对象是才确定类型，静态方法通过类名.访问。

泛型方法：

  • 在方法返回值的前面添加<T,....>

  • 调用方法时确定类型

泛型接口：在接口名后面添加<T,....>

  • <T,...>表示类型占位符，代表一种引用类型。多个占位符之间使用逗号隔开

  • 泛型接口不能创建泛型常量，常量必须进行赋值，创建接口时，才能确定泛型类型，

注意

  • 泛型不能在类中声明静态属性

    • static修饰的属性是静态属性，先于对象，泛型类型取决于创建对象是传入的实际类型

  • 泛型不能再类中初始化对象或者数组，但是可以声明引用或者数组

    • 实例化对象需要分配空间，没有确定类型不能开辟空间

    • 初始化数组时需要给元素进行分配空间，泛型类型不确定，无法分配空间

  • 在类中不能使用泛型声明参数相同的个数重载

  • 使用不同实际类型创建出的泛型类对象的引用不可以互相赋值

  • 泛型的类型不能作为重载的依据

    • 泛型的限制：

      • 泛型上限：？ extends Student ?代表Student类型或者Student类型的子类

      • 泛型下限： ？ supper Student ?代表Student类型或者Student类型的父类

      • public static void main(String[] args) {
    ArrayList<String> name = new ArrayList<>();
    name.add("张三");
    name.add("张si");
    name.add("张wu");
    show(name);
    ArrayList<Integer> num = new ArrayList<>();
    num.add(100);
    num.add(200);
    num.add(300);
    show(num);
}
public static void show(ArrayList<?>  list){  //?  表示任意类型
    for(int i =0;i<list.size();i++){
        System.out.println(list.get(i));
    }
}

Collections工具类

//创建集合
ArrayList<Integer> nums = new ArrayList<>();
nums.add(16);
nums.add(17);
nums.add(14);
nums.add(11);
nums.add(20);
//sort排序
System.out.println("排序之前："+nums.toString());   //排序之前：[16, 17, 14, 11, 20]
Collections.sort(nums);
System.out.println("排序之后："+nums.toString());   //排序之后：[11, 14, 16, 17, 20]

//二分查找
int pos = Collections.binarySearch(nums,20);
if(pos>=0){
    System.out.println("找到了"+pos);   //找到了4
}else {
    System.out.println("没找到");
}
//copy复制
ArrayList<Integer> dest = new ArrayList<>();
for(int i=0;i<nums.size();i++){
    dest.add(0);
}
Collections.copy(dest,nums);
System.out.println("dest:" + dest.toString());    //dest:[11, 14, 16, 17, 20]

//reverse  反转
Collections.reverse(nums);
System.out.println("反转之后："+ nums);   //反转之后：[20, 17, 16, 14, 11]

//shuffle随机打乱
Collections.shuffle(nums);
System.out.println("打乱之后："+nums);  //打乱之后：[16, 14, 20, 17, 11]

Set 接口

特点

  • 无序（取出元素的顺序和存入的顺序不一样）、无下标、元素不可重复

方法

  • 全部继承自Collection中的方法

    public static void main(String[] args) {
    //创建集合
    Set<String> set = new HashSet<>();
    //添加元素
    set.add("北京");
    set.add("深圳");
    set.add("北京");
    set.add("上海");
    set.add("北京");
    System.out.println("元素个数："+set.size());
    System.out.println("直接打印："+set.toString());

    //删除
     set.remove("北京");
    //遍历
    //3.1增强for
    for (String s:set) {
        System.out.println(s);
    }
    //3.2迭代器
    Iterator iterator =set.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
    //判断是否存在和判断是否为空
    System.out.println(set.contains("北京"));
    System.out.println(set.isEmpty());

HashSet

  • 存储结构 ：哈希表（数组+链表）

  • 基于hashCode、equals实现元素不重复：当输入元素的哈希值相同时，会调用equals进行确认，结果为true，拒绝后者进入。

public static void main(String[] args) {
    //创建集合
    HashSet<Student> hashSet = new HashSet<>();
    Student s1 = new Student("张三",15,"男");
    Student s2 = new Student("李四",15,"男");
    Student s3 = new Student("王五",15,"男");
    //添加元素
    hashSet.add(s1);
    hashSet.add(s2);
    hashSet.add(s3);
    hashSet.add(new Student("王五",15,"男"));
    System.out.println("元素个数："+hashSet.size());
    System.out.println("直接打印："+ hashSet.toString());
    //删除
    hashSet.remove(new Student("李四",15,"男"));
    System.out.println("删除之后元素个数："+hashSet.size());
    System.out.println("删除之后直接打印："+ hashSet.toString());
    //遍历
    //3.1增强for
    for (Student s : hashSet) {
        System.out.println(s.toString());
    }
    //3.2迭代器
    Iterator<Student> iterator = hashSet.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
    //判断
    System.out.println(hashSet.contains(s1));
    System.out.println(hashSet.isEmpty());

TreeSet

  • 基于排序顺序实现元素不重复

  • 实现了SortedSet接口，对集合元素自动排序

  • 元素对象的类型必须实现Comparable接口，指定排序规则。

  • 通过CompareTo方法确定是否为重复元素。左边比根小，右边比根小

  • 需求：元素必须实现comparable接口，compareTo（）返回零代表重复元素

Tom with Jerry
关注
Java学习笔记
VanMonday的博客
05-12 1157
兰智数加Java学习笔记
韩顺平Java自学笔记 集合
m0_67946241的博客
09-06 1109
笔记有很多缺陷，还有再完善
java基础笔记
m0_46393861的博客
01-19 406
命名规范 类名：类名的首字母应该大写。 方法名：首字母应该小写。 标识符： 所有的标识符都应该以字母、美元符（$）、下划线（_）开头。 首字符之后可以是字母，美元符，下划线和数字。 修饰符： 访问控制修饰符：default、public、protected、private 非访问控制修饰符：final、abstract、static、synchronized 数据类型 内置数据类型 有8中基本数据类型。其中六种数字类型（四个整数型，两个浮点型），一种字符型，还有一种布尔型。 byte # 8
Python自定义模块
ccc369639963的博客
04-03 6720
Python自定义模块 到目前为止，读者已经掌握了导入 Python 标准库并使用其成员（主要是函数）的方法，接下来要解决的问题是，怎样自定义一个模块呢？ 前面章节中讲过，Python 模块就是 Python 程序，换句话说，只要是 Python 程序，都可以作为模块导入。例如，下面定义了一个简单的模块（编写在 demo.py 文件中）： name = "张三" add = "zhangsan" print(name,add) def say(): print("人生苦短，我学Python！") c
Java自学笔记 集合和泛型
Lucas的博客
08-08 116
黑马程序员 java自学笔记 集合
dymx2008的专栏
04-07 588
------- android培训、java培训、期待与您交流！ ---------- 在编写程序的时候，我们不知道所需对象的数量，甚至不知道确切的类型，为了解决这样的问题，推出了集合（对象的引用），例如前面学的数组，数组只是一种能固定大小固定类型的对象引用，如果明确知道自己要保存的是一组基本数据类型，应该使用数组，否则就应该使用集合。 集合的基本类型有 list set map list
Java集合 自学笔记
weixin_42337048的博客
11-19 318
Java集合自学笔记 全网最全笔记合集。 【韩顺平讲Java】Java集合专题 视频地址https://www.bilibili.com/video/BV1YA411T76k?p=1&vd_source=ec630b32d5e9f303c00412d68ab19afc
韩顺平 Java集合 自学笔记(Java30天基础)
心向阳光的天域的博客
10-18 3712
Java集合 韩顺平老师 Java基础学习笔记
黑马程序员Java笔记
m0_68735537的博客
03-14 2455
输出打印、参与运算、修改记录的值。
JAVA自学笔记，集合类。
Lxxx_H的博客
08-03 165
java.util包中提供了一些集合类，这些集合类又被称为容器。提到容器不难想象到数组，集合类与数组的不同之处，数组的长度是固定的，集合的长度是可变的。数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合类有List集合，Set集合和Map集合，其中List与Set继承了Collection接口，各接口还体统了不同的实现类，上述集合类的继承关系如下图。 ...
JAVA基础笔记
星沅的博客
01-24 5501
第一章
马士兵java自学笔记.pdf
10-04
从提供的文件内容中，可以提取出与Java编程语言相关的...综合以上内容，这份自学笔记详细涵盖了Java的基础语法、面向对象编程、异常处理、标准库的使用等多个核心知识点，适合初学者通过学习和练习来提高Java编程能力。
计算机-java-自学笔记
05-28
自学Java的过程中，你需要掌握这些基础知识，并通过实践项目来加深理解。可以先从编写简单的控制台应用程序开始，逐渐过渡到图形用户界面（GUI）编程，再深入学习网络编程和数据库连接。同时，了解和掌握设计模式，...
Java基础自学笔记,全部的基础和心得
03-30
这份“Java基础自学笔记”包含了初学者在学习Java时需要掌握的关键知识点，旨在帮助你快速理解并掌握Java编程基础。 一、Java语言简介 Java是由Sun Microsystems（现已被Oracle收购）开发的，其设计目标是“一次...
java自学笔记
04-16
Java自学笔记概述 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。这份“java自学笔记”涵盖了从基础到进阶的多个Java知识点，旨在帮助初学者系统地学习并掌握...
Servlet的生命周期
wyk的博客
11-13 1327
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
Mybatis
最新发布
庸不易的博客
11-15 650
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 446
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
java加锁问题详解
qq_74056922的博客
11-14 752
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
Java自学笔记精要整理
本自学笔记将覆盖Java基础、面向对象编程、异常处理、集合框架、IO流、多线程编程、网络编程以及Java的新特性等内容。 知识点一：Java基础 Java基础包括Java语言的基本语法、数据类型、运算符、控制流程语句等。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值