Java 复习笔记 - ArrayList 集合篇

编程语言 2023-09-05 18:31:31 阅读次数: 0

文章目录

一，ArrayList 集合的基本使用

（一）集合概述

Java中的ArrayList是一个动态数组，它实现了List接口。与普通数组相比，ArrayList具有以下特点：

  1. 大小可变：ArrayList的大小可以根据需要动态增加或减少，不需要事先指定数组的大小。
  2. 支持泛型：ArrayList可以存储任何类型的对象，通过使用泛型可以在编译时进行类型检查，避免了类型转换的问题。
  3. 内部实现：ArrayList内部使用数组来实现元素的存储，当数组不够大时，会自动进行扩容操作。
  4. 随机访问：由于ArrayList使用数组实现，可以通过索引快速访问元素，时间复杂度为O(1)。
  5. 允许重复元素和null值：ArrayList允许存储重复的元素，并且可以存储null值。
  6. 非线程安全：ArrayList是非线程安全的，如果在多线程环境下使用ArrayList，需要进行外部同步处理。

以下是创建和使用ArrayList的示例代码：

import java.util.ArrayList;

public class ArrayListDemo {
    
    
    public static void main(String[] args) {
    
    
        // 创建一个ArrayList对象
        ArrayList<String> fruits = new ArrayList<>();

        // 向ArrayList中添加元素
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("orange");

        // 获取ArrayList的大小
        System.out.println("Size of ArrayList: " + fruits.size());

        // 遍历ArrayList
        for (String fruit : fruits) {
    
    
            System.out.println(fruit);
        }

        // 获取指定位置的元素
        String firstFruit = fruits.get(0);
        System.out.println("First fruit: " + firstFruit);

        // 修改指定位置的元素
        fruits.set(1, "grape");
        System.out.println("Updated ArrayList: " + fruits);

        // 判断ArrayList是否包含某个元素
        boolean containsOrange = fruits.contains("orange");
        System.out.println("Contains orange: " + containsOrange);

        // 删除指定位置的元素
        fruits.remove(2);
        System.out.println("Updated ArrayList: " + fruits);

        // 清空ArrayList
        fruits.clear();
        System.out.println("Size of ArrayList after clearing: " + fruits.size());
    }
}

在示例代码中，首先创建一个ArrayList对象，然后使用add方法向ArrayList中添加元素。使用size方法获取ArrayList的大小，使用get方法获取指定位置的元素。使用set方法修改指定位置的元素。使用contains方法判断ArrayList是否包含某个元素。使用remove方法删除指定位置的元素。使用clear方法清空ArrayList。

你可以根据需要修改示例代码以适应你的需求。

（二）集合存储数据类型的特点

Java的ArrayList集合可以存储任何引用类型的数据，包括自定义类对象。它的特点如下：

  1. 动态大小：ArrayList的大小可以根据需要动态增长或缩小，不需要事先指定数组的大小。
  2. 支持泛型：ArrayList可以使用泛型来指定存储的数据类型，通过在创建ArrayList对象时指定泛型类型，可以在编译时进行类型检查，避免了类型转换的问题。例如：ArrayList<String> list = new ArrayList<>();
  3. 允许重复元素和null值：ArrayList可以存储重复的元素，并且可以存储null值。
  4. 通过索引访问元素：由于ArrayList使用数组实现，可以通过索引快速访问元素，时间复杂度为O(1)。
  5. 有序集合：ArrayList中的元素按照插入的顺序存储，并且可以根据索引进行访问和操作。
  6. 非线程安全：ArrayList是非线程安全的，在多线程环境下使用时需要进行外部同步处理。

需要注意的是，ArrayList只能存储引用类型的数据，不能存储基本数据类型（如int、double等）。如果需要存储基本数据类型，可以使用对应的包装类（如Integer、Double等）进行存储。在使用这些包装类时，Java会自动进行装箱和拆箱操作。

（三）集合的基本操作

Java集合框架提供了一系列常用的操作方法，可以对集合进行增删改查等操作。以下是Java集合的基本操作：

  1. 创建集合对象：

    ArrayList<String> list = new ArrayList<>(); // 创建ArrayList对象
HashSet<Integer> set = new HashSet<>(); // 创建HashSet对象

  2. 添加元素：

    list.add("apple"); // 向ArrayList中添加元素
set.add(1); // 向HashSet中添加元素

  3. 删除元素：

    list.remove("apple"); // 从ArrayList中删除元素
set.remove(1); // 从HashSet中删除元素

  4. 获取元素：

    String element = list.get(0); // 获取ArrayList中指定索引位置的元素

  5. 修改元素：

    list.set(0, "banana"); // 修改ArrayList中指定索引位置的元素

  6. 判断集合是否包含某个元素：

    boolean contains = list.contains("apple"); // 判断ArrayList是否包含指定元素

  7. 遍历集合：

    • 使用for循环：

      for (int i = 0; i < list.size(); i++) {
        
        
    String element = list.get(i);
    // 进行操作
}

    • 使用增强for循环：

      for (String element : list) {
        
        
    // 进行操作
}

    • 使用迭代器：

      Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
        
        
    String element = iterator.next();
    // 进行操作
}

  8. 获取集合的大小：

    int size = list.size(); // 获取ArrayList的大小

这些是Java集合的一些基本操作方法，具体的操作方法还可以根据不同的集合类型进行适当调整。

（四）拓展：基本数据类型对应的包装类

Java的基本数据类型都有对应的包装类，用于将基本数据类型转换为对象。以下是Java基本数据类型对应的包装类：

  1. int：Integer
  2. long：Long
  3. float：Float
  4. double：Double
  5. boolean：Boolean
  6. byte：Byte
  7. char：Character
  8. short：Short

这些包装类提供了许多方法来操作基本数据类型，比如进行类型转换、比较值等。同时，包装类还提供了一些常量和静态方法来处理基本数据类型，比如最大值、最小值等。

可以使用包装类来实现将基本数据类型转换为对象的操作。以下是示例代码：

public class WrapperClassDemo {
    
    
    public static void main(String[] args) {
    
    
        int num1 = 10;
        Integer wrapperNum1 = Integer.valueOf(num1); // 将int转换为Integer对象
        System.out.println("Wrapper Class: " + wrapperNum1);

        double num2 = 3.14;
        Double wrapperNum2 = Double.valueOf(num2); // 将double转换为Double对象
        System.out.println("Wrapper Class: " + wrapperNum2);

        boolean flag = true;
        Boolean wrapperFlag = Boolean.valueOf(flag); // 将boolean转换为Boolean对象
        System.out.println("Wrapper Class: " + wrapperFlag);
    }
}

输出结果：

Wrapper Class: 10
Wrapper Class: 3.14
Wrapper Class: true

在示例中，使用valueOf()方法将基本数据类型转换为对应的包装类对象，并将其打印出来。

二，综合练习

（一）集合的遍历方式

需求：定义一个集合，添加字符串，并进行遍历。
遍历格式：[元素1，元素2，元素3]。

可以使用ArrayList来实现这个需求，以下是使用不同的遍历方式来遍历集合并输出结果：

import java.util.ArrayList;

public class CollectionDemo {
    
    
    public static void main(String[] args) {
    
    
        // 创建ArrayList对象
        ArrayList<String> list = new ArrayList<>();

        // 向ArrayList中添加元素
        list.add("元素1");
        list.add("元素2");
        list.add("元素3");

        // 使用for循环遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
    
    
            System.out.print(list.get(i));
            if (i != list.size() - 1) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");

        // 使用增强for循环遍历集合
        System.out.print("[");
        for (String element : list) {
    
    
            System.out.print(element);
            if (list.indexOf(element) != list.size() - 1) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");

        // 使用迭代器遍历集合
        System.out.print("[");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
    
    
            System.out.print(iterator.next());
            if (iterator.hasNext()) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");
    }
}

输出结果：

[元素1，元素2，元素3]
[元素1，元素2，元素3]
[元素1，元素2，元素3]

以上代码使用了for循环、增强for循环和迭代器三种方式来遍历集合，并按照指定格式输出集合中的元素。

（二）添加数字并遍历

需求：定义一个集合，添加数字，并进行遍历。
遍历格式：[元素1，元素2，元素3]。

同样可以使用ArrayList来实现这个需求，以下是使用不同的遍历方式来遍历集合并输出结果：

import java.util.ArrayList;

public class CollectionDemo {
    
    
    public static void main(String[] args) {
    
    
        // 创建ArrayList对象
        ArrayList<Integer> list = new ArrayList<>();

        // 向ArrayList中添加元素
        list.add(1);
        list.add(2);
        list.add(3);

        // 使用for循环遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
    
    
            System.out.print(list.get(i));
            if (i != list.size() - 1) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");

        // 使用增强for循环遍历集合
        System.out.print("[");
        for (int element : list) {
    
    
            System.out.print(element);
            if (list.indexOf(element) != list.size() - 1) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");

        // 使用迭代器遍历集合
        System.out.print("[");
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
    
    
            System.out.print(iterator.next());
            if (iterator.hasNext()) {
    
    
                System.out.print("，");
            }
        }
        System.out.println("]");
    }
}

输出结果：

[1，2，3]
[1，2，3]
[1，2，3]

以上代码使用了for循环、增强for循环和迭代器三种方式来遍历集合，并按照指定格式输出集合中的元素。

（三）添加学生对象并遍历

需求：定义一个集合，添加一些学生对象，并进行遍历。
学生类的属性：姓名，年龄。

以下是一个示例代码，演示如何使用Java集合来添加学生对象并进行遍历：

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

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 int getAge() {
    
    
        return age;
    }

    public static void main(String[] args) {
    
    
        List<Student> students = new ArrayList<>();

        // 添加学生对象
        students.add(new Student("Alice", 18));
        students.add(new Student("Bob", 20));
        students.add(new Student("Charlie", 19));

        // 遍历学生对象
        for (Student student : students) {
    
    
            System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());
        }
    }
}

输出结果：

姓名：Alice，年龄：18
姓名：Bob，年龄：20
姓名：Charlie，年龄：19

在示例中，先定义了一个Student类，包含了姓名和年龄两个属性，以及构造方法和访问这些属性的方法。

然后，在main方法中创建了一个ArrayList集合对象，用于存储学生对象。

接着，使用add方法向集合中添加了三个学生对象。

最后，使用增强的for循环遍历集合中的学生对象，并逐个打印出姓名和年龄。

（四）添加用户对象并判断是否存在

需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性：id，username，password。
2，要求：定义一个方法，根据id查找对应的用户信息。
如果存在，返回true，如果不存在，返回false。

以下是一个示例代码，演示如何使用Java集合来添加用户对象并根据id查找用户信息：

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

public class User {
    
    
    private int id;
    private String username;
    private String password;

    public User(int id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
    
    
        return id;
    }

    public String getUsername() {
    
    
        return username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public static void main(String[] args) {
    
    
        List<User> users = new ArrayList<>();

        // 添加用户对象
        users.add(new User(1, "Alice", "123456"));
        users.add(new User(2, "Bob", "abcdef"));
        users.add(new User(3, "Charlie", "qwerty"));

        // 根据id查找用户
        int targetId = 2;
        boolean exists = findUserById(targetId, users);
        if (exists) {
    
    
            System.out.println("用户存在");
        } else {
    
    
            System.out.println("用户不存在");
        }
    }

    public static boolean findUserById(int id, List<User> users) {
    
    
        for (User user : users) {
    
    
            if (user.getId() == id) {
    
    
                return true;
            }
        }
        return false;
    }
}

输出结果：

用户存在

在示例中，先定义了一个User类，包含了id、username和password三个属性，以及构造方法和访问这些属性的方法。

然后，在main方法中创建了一个ArrayList集合对象，用于存储用户对象。

接着，使用add方法向集合中添加了三个用户对象。

在main方法中调用findUserById方法，并传入要查找的id和用户集合。该方法使用一个增强的for循环遍历集合中的用户对象，通过比较id判断是否存在目标用户，若存在则返回true，若不存在则返回false。

最后，根据返回的结果打印出相应的提示信息。

（五）添加手机对象并返回要求的数据

需求：
定义一个JavaBean类Phone
Phone的属性：品牌，价格。
main方法中定义一个集合，存三个手机对象。
分别为：小米，1999。华为，2999。苹果，4350.
定义一个方法，将价格低于3000的手机信息返回。

以下是一个示例代码，演示如何使用Java集合来添加手机对象并返回价格低于3000的手机信息：

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

public class Phone {
    
    
    private String brand;
    private double price;

    public Phone(String brand, double price) {
    
    
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
    
    
        return brand;
    }

    public double getPrice() {
    
    
        return price;
    }

    public static void main(String[] args) {
    
    
        List<Phone> phones = new ArrayList<>();

        // 添加手机对象
        phones.add(new Phone("小米", 1999));
        phones.add(new Phone("华为", 2999));
        phones.add(new Phone("苹果", 4350));

        // 返回价格低于3000的手机信息
        List<Phone> cheapPhones = getCheapPhones(phones);
        for (Phone phone : cheapPhones) {
    
    
            System.out.println("品牌：" + phone.getBrand() + "，价格：" + phone.getPrice());
        }
    }

    public static List<Phone> getCheapPhones(List<Phone> phones) {
    
    
        List<Phone> cheapPhones = new ArrayList<>();
        for (Phone phone : phones) {
    
    
            if (phone.getPrice() < 3000) {
    
    
                cheapPhones.add(phone);
            }
        }
        return cheapPhones;
    }
}

输出结果：

品牌：小米，价格：1999.0
品牌：华为，价格：2999.0

在示例中，首先定义了一个Phone类，包含了brand和price两个属性，以及构造方法和访问这些属性的方法。

然后，在main方法中创建了一个ArrayList集合对象，用于存储手机对象。

接着，使用add方法向集合中添加了三个手机对象。

在main方法中调用getCheapPhones方法，并传入手机集合。该方法使用一个增强的for循环遍历集合中的手机对象，通过比较价格判断是否低于3000，若是则将该手机对象添加到新的集合cheapPhones中。

最后，使用一个普通的for循环遍历cheapPhones集合，并输出每个手机对象的品牌和价格。

猜你喜欢

转载自blog.csdn.net/m0_62617719/article/details/132654678
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022