1.1 Java集合框架

最新推荐文章于 2024-08-04 17:16:44 发布
最新推荐文章于 2024-08-04 17:16:44 发布
阅读量42 收藏
点赞数
分类专栏： Java基础 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53879048/article/details/123061448
版权

1、集合

集合 ： 对象的容器，定义了多个对象进行操作的常用方法。可实现数组功能。

和数组的区别 ；

  1. 数组长度固定，集合长度不固定。

  2. 数组可以存储基本类型和引用类型，集合只能存储引用类型。（装箱操作）

2、Collection体系集合

（1、1.1 ）

 

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

方法 ： boolean add(Object obj) // 添加一个对象

boolean add All(Collection c) // 将一个集合的所有对象添加到此集合中。

void clear() // 清空此集合中所有的对象。

boolean contains(Object o) // 检查此集合中是否包含o对象

boolean equals(Object o) // 比较此集合是否与指定对象相等

boolean isEmpty() // 判断刺激和是否为空

boolean remove(Object o) // 在此集合中移除o对象

int size() // 返回此集合中的个数

Object [] toArray() // 将此集合转换为数组

package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
/**
 Collection接口的使用
 1.添加与删除元素
 2.遍历元素
 3.判断元素是否存在
 */
​
public class Test01 {
    public static void main(String[] args) {
         //创建集合
         Collection collection = new ArrayList();
​
         //添加元素
         collection.add("苹果");
         collection.add("西瓜");
         collection.add("草莓");
        System.out.println("元素个数" + collection.size());
        System.out.println(collection);
​
        //删除元素
        collection.remove("苹果");
        System.out.println(collection);
​
        //遍历元素
        //1.增强for循环
        for (Object object:collection) {
            System.out.println(object);
        }
​
        //2.使用迭代器,迭代器专门用来遍历集合的一种方式
        Iterator it = collection.iterator();
​
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
        }
​
        //判断
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.isEmpty());//判断是否为空
​
    }
}
​

package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
/**
 * Collection 保存学生信息
 *
 */
public class Test02 {
    public static void main(String[] args) {
​
        Collection collection = new ArrayList();
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",15);
        Student s3 = new Student("王五",15);
​
        //1.添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
​
        System.out.println(collection.size());
        System.out.println(collection);
​
        //2.删除
        collection.remove(s1);
        System.out.println(collection.size());
​
        //3.遍历
        //1.增强for循环
        for (Object object :collection) {
            Student s = (Student) object;
            System.out.println(s);
        }
​
        //2.迭代器
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s);
        }
​
        //4.判断
        System.out.println(collection.contains(s1));
        
    }
}
​

Student 类

package Collection;
​
//学生类
public class Student {
    private String name;
    private int age;
​
    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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
​

3、List集合

特点 ：有序，有下标、元素可重复。

方法 ： void add(int index,Object o) // 在index位置插入o

boolean addAll(int index,Collection c) // 将一个集合中的元素添加到此集合中Index位置中。

Object get(int index) // 返回集合中指定位置的元素

List subList(int fromIndex,int toIndex) // 返回fromIndex和toIndex之间的集合元素。

package Collection;
​
import java.util.*;
​
public class Test03 {
    public static void main(String[] args) {
        
        //先创建集合对象
        List list = new ArrayList<>();
        
        //添加元素
        list.add("苹果");
        list.add("小米");
        list.add("华为");
        list.add(1, "一加");
        System.out.println(list.toString());
​
        //删除元素
        list.remove("苹果");
        System.out.println(list.toString());
​
        //遍历循环
        //1.for循环
        for (int i = 0; i < list.size(); i++) {
​
            System.out.println(list.get(i));
​
        }
​
        //2.增强for循环
        for (Object object : list) {
            System.out.println(object);
        }
​
        //3.迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
​
        //4.使用列表迭代器，和Iterator的区别，ListIterator可以向前或向后遍历、添加、删除、修改元素
        ListIterator lit = list.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.next()+" : "+lit.nextIndex());
        }
​
​
        //从后往前
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+" : "+lit.previous());
​
        }
​
        //判断
        System.out.println (list.contains("苹果"));
        
        //获取位置
        System.out.println (list.indexOf("华为"));
    }
}
​

package Collection;
​
import java.util.*;
import java.util.List;
​
​
public class Test04 {
    public static void main(String[] args) {
        //创建一个集合
        List list = new ArrayList();
        //添加数字数据(自动装箱)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println(list.size());
        System.out.println(list.toString());
​
        //删除操作
        list.remove(0); //删除的是根据下标来删除的
        System.out.println(list.size());
​
        //sunList : 返回子集合
        List subList = list.subList(1, 3);//包含一，不包含三
        System.out.println(subList);  
    }
}
​

1.List实现类总结

ArrayList 特点 ：

  1. 数组结构实现、查询快、增删慢。

  2. 运行效率快，线程不安全。

源码分析 ：

  1. DEFAULT_CAPACITY = 10; // 默认容量，这是向集合中添加元素的默认容量，

    如果没添加元素，默认容量为0，如果超过默认容量，每次扩容1.5倍。

  2. elementData // 存放数组元素

  3. size // 实际元素个数

  4. add() // 添加元素

Vector 特点 ：

  1. 数组结构实现、查询快、增上慢。

  2. 运行效率低、线程安全。

LinkList 特点 ：

  1. 链表结构实现、增删快、查询慢

  2. 双向链表

4、ArrayList

package Collection;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
​
//ArrayList演示
public class Test05 {
    public static void main(String[] args) {
        //创建集合
        ArrayList arrayList = new ArrayList();
​
        //添加元素
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",15);
        Student s3 = new Student("王五",18);
​
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
​
        System.out.println(arrayList.size());
        System.out.println(arrayList.toString());
​
        //删除元素
        arrayList.remove(s2);
        System.out.println(arrayList);
​
        //遍历
        //1.使用迭代器
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s);
        }
​
        //2.列表迭代器
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s);
        }
​
        while (lit.hasPrevious()){
            Student s = (Student) lit.previous();
            System.out.println(s);
        }
​
        //判断
        System.out.println(arrayList.contains(s1));
​
        //查找
        System.out.println(arrayList.indexOf(s1));
    }
}
​

5、Vector

package Collection;
​
import java.util.Enumeration;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Vector;
​
//Vector演示
public class Test06 {
    public static void main(String[] args) {
        //创建集合
        Vector vector = new Vector();
​
        //1.添加元素
        vector.add("草莓");
        vector.add("橘子");
        vector.add("苹果");
        vector.add("山楂");
​
        System.out.println(vector);
​
        //2.删除元素
        vector.remove("草莓");
​
        System.out.println(vector);
​
        //3.遍历
​
        Iterator it = vector.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
        }
​
​
        ListIterator i1 = vector.listIterator();
        while (i1.hasNext())
        {
            String s = (String) i1.next();
            System.out.println(s);
​
        }
​
​
        //使用枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            Object e = en.nextElement();
            System.out.println(e);
        }
​
        //4.判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());
​
        //5.vector其他方法
        vector.firstElement();
        vector.lastElement();
        Object o = vector.elementAt(0);
        System.out.println(o);
​
​
    }
}
​

6、LinkedList

package Collection;
​
import java.util.Iterator;
import java.util.LinkedList;
​
//LinkedList集合
public class Test07 {
    public static void main(String[] args) {
        //创建集合
        LinkedList list = new LinkedList();
​
        //1.添加元素
        Student s1 = new Student("刘德华",5);
        Student s2 = new Student("张学友",5);
        Student s3 = new Student("郭富城",5);
​
        list.add(s1);
        list.add(s2);
        list.add(s3);
        System.out.println(s1);
        System.out.println(list);
​
        //2.删除
        list.remove(1);
        System.out.println(list);
​
        //3.遍历
        //for
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("=================");
​
        //增强for
        for (Object object:list) {
            Student s = (Student) object;
            System.out.println(s);
        }
​
        //使用迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext())
        {
             Student s = (Student) iterator.next();
             System.out.println(s);
            }
​
        //4.判断
        System.out.println(list.contains(s1));
        System.out.println(list.isEmpty());
​
        //5.获取
        System.out.println(list.indexOf(s1));
​
    }
}
​

！ArrayList和LinkedList的区别

（1、1.2 ）

 

ArrayList : 是数组，空间连续、有角标、查询快、增删慢。

LinkedList : 是一个双向链表，Node、有first和Last，具有方向的一个链表，查询慢，增删快

CHONSK
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合框架使用总结
05-25
- 在Java集合框架中，部分类是线程安全的，这些类主要出现在JDK 1.1中。随着版本的发展，越来越多的非线程安全类被引入。典型的线程安全类包括`Vector`等。 通过对Java集合框架的这些核心概念的理解，开发者能够更...
Java 集合学习指南 - v1.1.pdf
04-12
Java集合框架是Java编程中不可或缺的一部分，它提供了一组用于存储和操作对象的高效数据结构。本指南将深入探讨HashMap、HashSet、HashTable、LinkedHashMap、LinkedHashSet、ArrayList、LinkedList、...
java集合框架全面进阶[归纳].pdf
10-12
Java集合框架是Java编程语言中的核心部分，它提供了一种高效、灵活的方式来组织和操作数据。这个框架包括一系列接口和类，它们定义了各种数据结构，如列表(List)、集(Set)、映射(Map)以及其他的集合类型。通过学习这...
java集合详解.pdf
10-04
本文将深入解析Java集合框架，包括Collection、List、Set、Map及其实现原理。 1. 集合框架概述 集合框架是Java标准库的核心组件，它定义了一组接口和类，使得开发者可以方便地处理对象的集合。这些接口和类为数据...
Java面试宝典 - v1.1_Java面试宝典-v1.1_
10-01
4. **集合框架**：深入学习ArrayList、LinkedList、HashSet、HashMap等数据结构，理解它们的工作原理及应用场景。 5. **多线程**：掌握线程的创建、同步与通信，包括synchronized关键字、wait()、notify()和...
枚举工具类
qq_43049583的博客
08-04 201
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 199
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 602
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 522
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
Servlet(2)
最新发布
xjdkxnhcoskxbco的博客
08-04 365
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 548
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 697
集合之Map
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 185
④创建artifact。②点击加号创建，选择。
安装ElasticSearch
diffiii
07-31 638
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
java中static关键字的作用
weixin_41020960的博客
08-01 622
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
面向对象程序设计之sort排序
嫌人闲事
07-31 394
敲过排序算法的都会的，Sort排序与compareTo的改写。
spring原理（第六天）
GD2604279407的博客
08-02 538
今天将会学到Aware 接口及 InitializingBean 接口我们可以先了解他们的作用：1. Aware 接口用于注入一些与容器相关信息, 例如a. BeanNameAware 注入 bean 的名字b. BeanFactoryAware 注入 BeanFactory 容器c. ApplicationContextAware 注入 ApplicationContext 容器2. InitializingBean 接口提供了一种【内置】的初始化手段。
day12 Java基础——自增自减运算符，初识Math类
Qhumaing的博客
07-30 322
int b = a++;//执行完这行代码后，先给b复制，再自增1
高级java每日一道面试题-2024年7月31日-并发篇-你对ThreadLocal了解多少?
qq_43071699的博客
07-31 928
是Java中提供的一个类，用于实现线程局部变量。它允许每个线程访问自己的独立变量副本，而不会影响到其他线程中的变量。为每个使用该变量的线程提供了独立的变量实例，因此，即使是多个线程同时访问同一个变量，它们也是访问自己线程内部的那个副本，从而实现了线程间的数据隔离,干扰和同步开销。
Java集合框架详解：关键类与实现原理
Java集合框架允许开发者以高效和灵活的方式组织和操作数据。它提供了一种容器化的概念，这些容器可以存储和管理元素，如ArrayList、LinkedList和HashMap等。框架内包含两类主要的集合类型： - 容器：这是集合框架的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值