Java 复习笔记 - ArrayList 集合篇
文章目录
- 一，ArrayList 集合的基本使用
-
- （一）集合概述
- （二）集合存储数据类型的特点
- （三）集合的基本操作
- （四）拓展：基本数据类型对应的包装类
- 二，综合练习
-
- （一）集合的遍历方式
- （二）添加数字并遍历
- （三）添加学生对象并遍历
- （四）添加用户对象并判断是否存在
- （五）添加手机对象并返回要求的数据
一，ArrayList 集合的基本使用
（一）集合概述
Java中的ArrayList是一个动态数组，它实现了List接口。与普通数组相比，ArrayList具有以下特点：
- 大小可变：ArrayList的大小可以根据需要动态增加或减少，不需要事先指定数组的大小。
- 支持泛型：ArrayList可以存储任何类型的对象，通过使用泛型可以在编译时进行类型检查，避免了类型转换的问题。
- 内部实现：ArrayList内部使用数组来实现元素的存储，当数组不够大时，会自动进行扩容操作。
- 随机访问：由于ArrayList使用数组实现，可以通过索引快速访问元素，时间复杂度为O(1)。
- 允许重复元素和null值：ArrayList允许存储重复的元素，并且可以存储null值。
- 非线程安全：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集合可以存储任何引用类型的数据，包括自定义类对象。它的特点如下：
- 动态大小：ArrayList的大小可以根据需要动态增长或缩小，不需要事先指定数组的大小。
- 支持泛型：ArrayList可以使用泛型来指定存储的数据类型，通过在创建ArrayList对象时指定泛型类型，可以在编译时进行类型检查，避免了类型转换的问题。例如：
ArrayListlist = new ArrayList<>(); - 允许重复元素和null值：ArrayList可以存储重复的元素，并且可以存储null值。
- 通过索引访问元素：由于ArrayList使用数组实现，可以通过索引快速访问元素，时间复杂度为O(1)。
- 有序集合：ArrayList中的元素按照插入的顺序存储，并且可以根据索引进行访问和操作。
- 非线程安全：ArrayList是非线程安全的，在多线程环境下使用时需要进行外部同步处理。
需要注意的是，ArrayList只能存储引用类型的数据，不能存储基本数据类型（如int、double等）。如果需要存储基本数据类型，可以使用对应的包装类（如Integer、Double等）进行存储。在使用这些包装类时，Java会自动进行装箱和拆箱操作。
（三）集合的基本操作
Java集合框架提供了一系列常用的操作方法，可以对集合进行增删改查等操作。以下是Java集合的基本操作：
-
创建集合对象：
ArrayList<String> list = new ArrayList<>(); // 创建ArrayList对象 HashSet<Integer> set = new HashSet<>(); // 创建HashSet对象 -
添加元素：
list.add("apple"); // 向ArrayList中添加元素 set.add(1); // 向HashSet中添加元素 -
删除元素：
list.remove("apple"); // 从ArrayList中删除元素 set.remove(1); // 从HashSet中删除元素 -
获取元素：
String element = list.get(0); // 获取ArrayList中指定索引位置的元素 -
修改元素：
list.set(0, "banana"); // 修改ArrayList中指定索引位置的元素 -
判断集合是否包含某个元素：
boolean contains = list.contains("apple"); // 判断ArrayList是否包含指定元素 -
遍历集合：
-
使用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(); // 进行操作 }
-
-
获取集合的大小：
int size = list.size(); // 获取ArrayList的大小
这些是Java集合的一些基本操作方法，具体的操作方法还可以根据不同的集合类型进行适当调整。
（四）拓展：基本数据类型对应的包装类
Java的基本数据类型都有对应的包装类，用于将基本数据类型转换为对象。以下是Java基本数据类型对应的包装类：
- int：Integer
- long：Long
- float：Float
- double：Double
- boolean：Boolean
- byte：Byte
- char：Character
- 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集合，并输出每个手机对象的品牌和价格。