花几千上万学习Java，真没必要！（二十）

news2024/9/22 19:38:24

ArrayList 是一种可以动态增长和缩减的数组，与普通的数组相比，它提供了更加灵活的操作方式。ArrayList 内部使用数组来存储元素，但是它会根据需要自动调整数组的大小，以便能够存储更多的元素。

ArrayList 的主要特点包括：

动态数组：ArrayList 的大小是动态变化的，可以在运行时向其中添加或删除元素，而不需要担心数组越界的问题。
随机访问：与 LinkedList 相比，ArrayList 提供了更好的随机访问性能。可以通过索引（位置）快速地访问或修改 ArrayList 中的元素。
内存连续性：ArrayList 在物理内存中占用一段连续的空间（直到它需要扩容为止）。这种内存连续性有助于快速访问元素，但也可能导致在添加大量元素时需要进行内存复制操作以扩容。
扩容机制：当 ArrayList 中的元素数量超过其内部数组的大小时，ArrayList 会自动创建一个更大的数组，并将原数组中的元素复制到新数组中，以便能够存储更多的元素。扩容操作通常会导致性能开销，因为它需要分配新的内存空间并进行数据复制。
非同步：ArrayList 不是同步的。如果多个线程同时访问一个 ArrayList 实例，并且至少有一个线程从结构上修改了列表（即添加或删除元素），那么它必须保持外部同步。通常通过对自然封装该列表的对象进行同步操作来完成。
泛型支持：ArrayList 是一个泛型类，可以指定它存储的元素类型。泛型支持有助于在编译时检查类型错误，并提供更清晰的代码。

测试代码1：

package arraylist.com;
import java.util.ArrayList;  
import java.util.Iterator;  
  
public class ArrayListExample {  
    public static void main(String[] args) {  
        // 创建 ArrayList 实例  
        ArrayList<String> list = new ArrayList<>();  
        ArrayList<Integer> numbers = new ArrayList<>(10);  
  
        // 向 ArrayList 添加元素  
        list.add("Hello");  
        list.add("World");  
        numbers.add(1);  
        numbers.add(2);  
  
        // 访问 ArrayList 中的元素  
        System.out.println("First element in list: " + list.get(0));  
        System.out.println("Second number in numbers: " + numbers.get(1));  
  
        // 遍历 ArrayList  
        System.out.println("\nElements in list:");  
        for (String item : list) {  
            System.out.println(item);  
        }  
  
        System.out.println("\nElements in numbers:");  
        Iterator<Integer> iterator = numbers.iterator();  
        while (iterator.hasNext()) {  
            System.out.println(iterator.next());  
        }  
  
        // 移除 ArrayList 中的元素  
        list.remove(0); // 移除第一个元素  
        if (numbers.contains(1)) {  
            numbers.remove((Integer) 1); // 移除值为 1 的元素  
        }  
  
        // 再次遍历 ArrayList 查看变化  
        System.out.println("\nAfter removal:");  
        System.out.println("Elements in list:");  
        for (String item : list) {  
            System.out.println(item);  
        }  
  
        System.out.println("\nElements in numbers:");  
        for (Integer num : numbers) {  
            System.out.println(num);  
        }  
  
        // 获取 ArrayList 的大小  
        System.out.println("\nSize of list: " + list.size());  
        System.out.println("Size of numbers: " + numbers.size());  
  
        // 检查 ArrayList 是否为空  
        System.out.println("\nIs list empty? " + list.isEmpty());  
        System.out.println("Is numbers empty? " + numbers.isEmpty());  
    }  
}

运行结果如下：

测试代码2：

package arraylist.com;
import java.util.ArrayList;  

//用户类  
class User {  
 private String name;  
 private int age;  
 private String email;  


 public User(String name, int age, String email) {  
     this.name = name;  
     this.age = age;  
     this.email = email;  
 }  

 @Override  
 public String toString() {  
     return "User{" +  
             "name='" + name + '\'' +  
             ", age=" + age +  
             ", email='" + email + '\'' +  
             '}';  
 }  
}  

//ArrayList<User>用来存储用户对象的列表。
public class UserManager {
	private ArrayList<User> users;  

 public UserManager() {  
     this.users = new ArrayList<>();  
 }  

//通过addUser方法，可以向列表中添加新用户。
 public void addUser(User user) {  
     users.add(user);  
 }  

//通过printUsers方法，遍历列表并打印出每个用户的信息。 
 public void printUsers() {  
     for (User user : users) {  
         System.out.println(user);  
     }  
 }  

 public static void main(String[] args) {  
     UserManager userManager = new UserManager();  
     userManager.addUser(new User("Alice", 30, "alice@example.com"));  
     userManager.addUser(new User("Bob", 25, "bob@example.com"));  

     // 打印所有用户信息  
     userManager.printUsers();  
 }  
}

运行结果如下：

测试代码3：

package arraylist.com;
import java.util.ArrayList;  

//商品类  
class Product {  
 private String name;  
 private double price;  

 public Product(String name, double price) {  
     this.name = name;  
     this.price = price;  
 }  

 @Override  
 public String toString() {  
     return "Product{" +  
             "name='" + name + '\'' +  
             ", price=" + price +  
             '}';  
 }

 public double getPrice() {  
     return price;  
 }  
}  
//ArrayList<Product>用来存储购物车中的商品项。
public class ShoppingCart {  
	
 private ArrayList<Product> items;  

 public ShoppingCart() {  
     this.items = new ArrayList<>();  
 }  

//通过addItem方法，向购物车中添加商品。
 public void addItem(Product product) {  
     items.add(product);  
 }  

 //通过printCart方法，遍历并打印出购物车中的商品信息。
 public void printCart() {  
     for (Product item : items) {  
         System.out.println(item);  
     }  
 }  

 // 通过calculateTotal方法，计算购物车中商品的总价。
 public double calculateTotal() {  
     double total = 0;  
     for (Product item : items) {  
         total += item.getPrice(); 
     }  
     return total;  
 }  

 public static void main(String[] args) {  
     ShoppingCart cart = new ShoppingCart();  
     cart.addItem(new Product("Laptop", 999.99));  
     cart.addItem(new Product("Headphones", 59.99));  

     // 打印购物车内容  
     cart.printCart();  

     // 计算并打印购物车总价  
     System.out.println("Total: $" + cart.calculateTotal());  
 }  
}

运行结果如下：

测试代码4：

package arraylist.com;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ArrayListTest {
    public static void main(String[] args) {
        // 动态数组
        ArrayList<String> dynamicArray = new ArrayList<>();
        
        dynamicArray.add("element1");
        dynamicArray.add("element2");
        dynamicArray.remove(0);
        
        System.out.println(dynamicArray); 
        
        // 随机访问
        dynamicArray.add("element1");
        dynamicArray.add("element2");
        
        String element = dynamicArray.get(0);
        System.out.println(element);  
        
        dynamicArray.set(1, "newElement");
        System.out.println(dynamicArray);  
        
        // 非同步示例
        List<String> synchronizedList = Collections.synchronizedList(dynamicArray);
        
        synchronized(synchronizedList) {
            // 执行需要同步的操作  
        }
        
        // 泛型支持
        ArrayList<Integer> integerList = new ArrayList<>();
        
        integerList.add(100);
        int value = integerList.get(0);
        System.out.println(value); 
    }
}

运行结果如下：