数组

ArrayList 类：一个可调整大小的数组，在 java.util 包中

内置数组和 ArrayList 的区别：

内置数组的大小不能修改（如果要在数组中添加或删除元素，则必须创建一个新的）
While 元素可以随时在 ArrayList 中添加和删除

创建

创建一个名为 cars 的 ArrayList 对象，该对象将存储字符串

1
2
3

import java.util.ArrayList; // import the ArrayList class

ArrayList<String> cars = new ArrayList<String>(); // Create an ArrayList object

添加

add()
索引

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    ArrayList<String> cars = new ArrayList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");

    cars.add(0, "Mazda"); // Insert element at the beginning of the list (0)

    System.out.println(cars);
  }
}

访问：get()

1	cars.get(0);

更改：set()

1	cars.set(0, "Opel");

删除：remove()

1	cars.remove(0);

删除所有元素：.clear()

大小：.size()

遍历：

for

1
2
3

for (int i = 0; i < cars.size(); i++) {
      System.out.println(cars.get(i));
    }

for - each

1
2
3

for (String i : cars) {
      System.out.println(i);
    }

其他类型：ArrayList 中的元素实际上是对象

Java 中的 String 是一个对象（不是原始类型），要使用其他类型（如 int），必须指定等效的包装类：Integer。对于其他基元类型，请使用：Boolean 表示布尔值，Character 表示 char， Double 表示 double

排序

调用java.util 包中的 Collections 类，其中包括用于按字母或数字顺序排序的 sort() 方法：默认升序（reverseOrder()降序）

import java.util.ArrayList;
import java.util.Collections;  // Import the Collections class

public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> myNumbers = new ArrayList<Integer>();
    myNumbers.add(33);
    myNumbers.add(15);
    myNumbers.add(20);

    Collections.sort(myNumbers);  // Sort myNumbers
	Collections.sort(myNumbers, Collections.reverseOrder()); // Sort myNumbers
      
    for (int i : myNumbers) {
      System.out.println(i);
    }
  }
}

链表

LinkedList

// Import the LinkedList class
import java.util.LinkedList;

public class Main {
  public static void main(String[] args) {
    LinkedList<String> cars = new LinkedList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");
    System.out.println(cars);
  }
}

LinkeList 和 ArrayList：

LinkedList 类是一个集合，可以包含许多相同类型的对象，就像 ArrayList
LinkedList 类具有与 ArrayList 类相同的所有方法，因为它们都实现了 List 接口。这意味着您可以以相同的方式添加项目、更改项目、删除项目和清除列表。
虽然 ArrayList 类和 LinkedList 类可以以相同的方式使用，但它们的构建方式截然不同

工作原理：

ArrayList 类中有一个常规数组。添加元素时，会将其放入数组中。如果数组不够大，则会创建一个新的、更大的新数组来替换旧数组，并删除旧数组。
LinkedList 将其项存储在 “容器” 中。该列表具有指向第一个容器的链接，每个容器具有指向列表中下一个容器的链接。若要将元素添加到列表中，请将该元素放入新容器中，并且该容器将链接到列表中的其他容器之一。
使用 ArrayList 存储和访问数据，使用 LinkedList 操作数据

方法：

方法	作用
addFirst()	在链表头部添加元素
addLast()	在链表尾部添加元素
removeFirst()	删除链表头部元素，并返回它
removeLast()	删除链表尾部元素，并返回它
getFirst()	获取链表头部元素，但不删除
getLast()	获取链表尾部元素，但不删除

哈希表

HashMap：将数据以键值对的方式存储

创建：

1
2
3

mport java.util.HashMap; // import the HashMap class

HashMap<String, String> capitalCities = new HashMap<String, String>();

添加：put()

1 2	// Add keys and values (Country, City) capitalCities.put("England", "London");

访问：get() - 访问 HashMap 中的值

1	capitalCities.get("England");

删除：remove() 并引用键

1	capitalCities.remove("England");

删除所有数据：.clear()

大小：.size()

**遍历：**使用 for - each 循环

只需要键：keySet()
只需要值：values()

// Print keys
for (String i : capitalCities.keySet()) {
  System.out.println(i);
}

// Print values
for (String i : capitalCities.values()) {
  System.out.println(i);
}

// Print keys and values
for (String i : capitalCities.keySet()) {
  System.out.println("key: " + i + " value: " + capitalCities.get(i));
}

**其他类型：**HashMap 中的键和值实际上是对象，要使用其他类型（如 int），必须指定等效的包装类（同ArrayList）

// Import the HashMap class
import java.util.HashMap;

public class Main {
  public static void main(String[] args) {

    // Create a HashMap object called people
    HashMap<String, Integer> people = new HashMap<String, Integer>();

    // Add keys and values (Name, Age)
    people.put("John", 32);
    people.put("Steve", 30);
    people.put("Angie", 33);

    for (String i : people.keySet()) {
      System.out.println("key: " + i + " value: " + people.get(i));
    }
  }
}

哈希集

HashSet 是数据的集合，其中每个数据都是唯一的，它位于 java.util 包：

创建：

1
2
3

import java.util.HashSet; // Import the HashSet class

HashSet<String> cars = new HashSet<String>();

添加：add()

// Import the HashSet class
import java.util.HashSet;

public class Main {
  public static void main(String[] args) {
    HashSet<String> cars = new HashSet<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("BMW");
    cars.add("Mazda");
    System.out.println(cars);
  }
}

注意：在上面的示例中，即使 BMW 被添加了两次，它也只在集合中出现一次，因为集合中的每个数据都必须是唯一的。

检查是否存在：contains()

删除：remove()

删除所有数据：clear()

大小：size()

**遍历：**for - each 循环

**其他类型：**HashSet 中的项目实际上是对象，同 ArrayList

迭代器

Iterator：一个可用于循环遍历集合（ArrayList、HashSet）的对象，从 java.util 包中导入

获取 Iterator：iterator()

// Import the ArrayList class and the Iterator class
import java.util.ArrayList;
import java.util.Iterator;

public class Main {
  public static void main(String[] args) {

    // Make a collection
    ArrayList<String> cars = new ArrayList<String>();
    cars.add("Volvo");
    cars.add("BMW");
    cars.add("Ford");
    cars.add("Mazda");

    // Get the iterator
    Iterator<String> it = cars.iterator();

    // Print the first item
    System.out.println(it.next());
  }
}

**遍历集合：**用 Iterator 的hasNext() 和 next() 方法

1
2
3

while(it.hasNext()) {
  System.out.println(it.next());
}

删除：remove()

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(12);
    numbers.add(8);
    numbers.add(2);
    numbers.add(23);
    Iterator<Integer> it = numbers.iterator();
    while(it.hasNext()) {
      Integer i = it.next();
      if(i < 10) {
        it.remove();
      }
    }
    System.out.println(numbers);
  }
}

不能使用 for 循环或 for - each 循环：因为它们步能在遍历集合同时改变集合大小

包装类

包装类提供了一种将原始数据类型（int、boolean 等）用作对象的方法

原始数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

有时必须使用包装类，如在使用 Collection 对象时，例如 ArrayList，其中不能使用原始类型（列表只能存储对象）

创建：

public class Main {
  public static void main(String[] args) {
    Integer myInt = 5;
    Double myDouble = 5.99;
    Character myChar = 'A';
  }
}

访问：

直接
xxxValue()
toString

System.out.println(myInt);
System.out.println(myInt.intValue());
String myString = myInt.toString();
System.out.println(myString.length());