1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// 本实现基于维基百科的实现 [1]，并做了适当的简化
// 叫做 MyStack，而不是 Stack，是为了避免和 Java Util 中的 Stack 类重名造成混淆
class MyStack {
    private int[] elements = new int[10];   // 栈的容量为 10，这个实现是一个静态（固定大小）的栈
    private int top = 0;                    // 栈顶元素的下标，用于指示栈顶元素在数组中的位置

    /**
     * 将元素压入栈顶（入栈）
     * @param element 要入栈的元素
     */
    public void push(int element) {
        if (!isFull()) {
            // 仅在栈未满时才能入栈
            // 将元素放入栈顶，然后栈顶下标加 1，这样下次入栈时就会放在新的栈顶位置
            elements[top] = element;
            top++;
            // 也可以被写作
            // elements[top++] = element;
        } else {
            System.out.println("The stack is full. Cannot push any more elements.");
        }
    }

    /**
     * 将栈顶元素弹出（出栈）
     * @return 被弹出的元素（栈顶元素）
     */
    public int pop() {
        if (!isEmpty()) {
            // 只有在栈非空时才能出栈
            // 栈顶下标减 1，下标现在指向的是有元素的位置，然后返回该位置的元素
            top--;
            return elements[top];
            // 也可以被写作
            // return elements[--top];
        } else {
            // 栈为空时无法出栈
            System.out.println("The stack is empty. Cannot pop any more elements.");
            // 其实**绝对不应该**返回 -1，因为 -1 也是一个合法的元素，但为了简单起见，这里返回 -1
            return -1;
        }
    }

    /**
     * 显示栈中所有元素
     */
    public void show() {
        if (isEmpty()) {
            // 栈为空时无法显示任何元素
            System.out.println("The stack is empty. Cannot show any elements.");
            return;
        }
        for (int i = 0; i < top; i++) {
            // 从栈底到栈顶依次显示元素
            System.out.print(elements[i] + " ");
        }
        System.out.println();
    }

    /**
     * 查看栈顶元素
     */
    public void peek() {
        if (isEmpty()) {
            // 栈为空时无法查看栈顶元素
            System.out.println("The stack is empty. Cannot peek any element.");
        }
        // 栈顶元素就是数组中下标为 top - 1 的元素
        System.out.println("The top element is " + elements[top - 1]);
    }

    /**
     * 判断栈是否为空
     * @return 如果栈为空，返回 true；否则返回 false
     */
    public boolean isEmpty() {
        // 如果栈顶下标为 0，说明栈为空
        return top == 0;
    }

    /**
     * 判断栈是否已满
     * @return 如果栈已满，返回 true；否则返回 false
     */
    public boolean isFull() {
        // 如果栈顶下标等于数组的长度，说明栈已满
        return top == elements.length;
    }

    /**
     * 获取栈的大小（元素个数）
     * @return 栈的大小
     */
    public int size() {
        // top 的值就是栈的大小
        return top;
    }
}

public class Main {
    public static void main(String[] args) {
        // 可以自行测试 MyStack 类的功能，看看各项操作的表现
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

package org.qianq;

import java.util.ArrayList;

class MyStackArrayList {
    private ArrayList<Integer> elements = new ArrayList<>();    // 用于存放栈中元素的数组
    private int top = 0;                                        // 栈顶元素的下标，用于指示栈顶元素在数组中的位置

    /**
     * 将元素压入栈顶（入栈）
     * @param element 要入栈的元素
     */
    public void push(int element) {
        // 实现与普通数组没有太大区别，只不过不再需要检查栈是否已满
        // 将元素放入栈顶，然后栈顶下标加 1，虽然 ArrayList 会自动扩展，但这里还是加上这一步，这样访问栈顶元素时更方便
        elements.add(element);
        top++;
    }

    /**
     * 将栈顶元素弹出（出栈）
     * @return 被弹出的元素（栈顶元素）
     */
    public int pop() {
        if (!isEmpty()) {
            // 只有在栈非空时才能出栈
            // 栈顶下标减 1，下标现在指向的是有元素的位置，然后返回该位置的元素
            top--;
            return elements.remove(top);
        } else {
            // 栈为空时无法出栈
            System.out.println("The stack is empty. Cannot pop any more elements.");
            // 其实**绝对不应该**返回 -1，因为 -1 也是一个合法的元素，但为了简单起见，这里返回 -1
            return -1;
        }
    }

    /**
     * 显示栈中所有元素
     */
    public void show() {
        if (isEmpty()) {
            // 栈为空时无法显示任何元素
            System.out.println("The stack is empty. Cannot show any elements.");
            return;
        }
        for (int i = 0; i < top; i++) {
            // 从栈底到栈顶依次显示元素
            System.out.print(elements.get(i) + " ");
        }
        System.out.println();
    }

    /**
     * 查看栈顶元素
     */
    public void peek() {
        if (isEmpty()) {
            // 栈为空时无法查看栈顶元素
            System.out.println("The stack is empty. Cannot peek any element.");
        }
        // 栈顶元素就是数组中下标为 top - 1 的元素
        System.out.println("The top element is " + elements.get(top - 1));
    }

    /**
     * 判断栈是否为空
     * @return 如果栈为空，返回 true；否则返回 false
     */
    public boolean isEmpty() {
        // 如果栈顶下标为 0，说明栈为空
        return top == 0;
    }

    /**
     * 获取栈的大小（元素个数）
     * @return 栈的大小（元素个数）
     */
    public int size() {
        // top 的值就是栈的大小
        return top;
    }
}

public class Main {
    public static void main(String[] args) {
        // 可以自行测试 MyStackArrayList 类的功能，看看各项操作的表现
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

class MyQueue {
    private final static int CAPACITY = 10;     // 队列的最大容量
    private int[] elements = new int[CAPACITY]; // 用于存放队列元素的数组
    int front = 0, rear = -1, current_size = 0; // 队列的头指针、尾指针、当前元素个数（我们需要当前元素个数来判断队列是否为空或者满）

    /**
     * 将元素入队
     * @param element 要入队的元素
     */
    public void enqueue(int element) {
        if (isFull()) {
            // 如果队列已满，就不能再入队了
            System.out.println("The queue is full. Cannot enqueue.");
            return;
        }
        rear++;  // 尾下标后移，这样就可以将元素放入正确的位置
        elements[rear] = element;  // 将元素放入目前队列的队尾
        current_size++; // 当前元素个数加一
    }

    /**
     * 将元素出队
     * @return 被出队的元素
     */
    public int dequeue() {
        if (isEmpty()) {
            // 如果队列为空，就不能再出队了
            System.out.println("The queue is empty. Cannot dequeue.");
            // 仍然为了简单起见，我们返回 -1 表示出队失败
            return -1;
        }
        front++;  // 头下标后移，这样就可以将元素出队
        current_size--; // 当前元素个数减一
        return elements[front - 1];  // 返回出队的元素
    }

    /**
     * 显示队列中的元素
     */
    public void show() {
        for (int i = front; i <= rear; i++) {
            System.out.print(elements[i] + " "); // 基本上就是从头走到尾，然后输出每个元素
        }
        System.out.println();
    }

    /**
     * 判断队列是否为空
     * @return 如果队列为空，返回 true；否则返回 false
     */
    public boolean isEmpty() {
        return current_size == 0;
    }

    /**
     * 判断队列是否已满
     * @return 如果队列已满，返回 true；否则返回 false
     */
    public boolean isFull() {
        return current_size == CAPACITY;
    }
}

public class Main {
    public static void main(String[] args) {
        // 可以自行测试 MyQueue 类的功能，看看各项操作的表现
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

class MyCircularQueue {
    private final static int CAPACITY = 10;     // 队列的最大容量
    private int[] elements = new int[CAPACITY]; // 用于存放队列元素的数组
    int front = 0, rear = -1, current_size = 0; // 队列的头指针、尾指针、当前元素个数（我们需要当前元素个数来判断队列是否为空或者满）

    /**
     * 将元素入队
     * @param element 要入队的元素
     */
    public void enqueue(int element) {
        if (isFull()) {
            // 如果队列已满，就不能再入队了
            // 此处我们仍然需要检查队列是否已满，因为我们的队列是循环队列，如果不检查，可能会导致未出队的元素被覆盖
            System.out.println("The queue is full. Cannot enqueue.");
            return;
        }
        rear = (rear + 1) % CAPACITY; // 尾下标后移，这样就可以将元素放入队尾
        // 这里使用了取模运算，是为了实现循环队列，如果下标超出了数组的范围，到达了数组长度为值的下标，实际上就是回到了数组的开头（0）
        // 然后如果继续往前走，实际上就是继续经过下标为 1, 2, 3, ... 的位置
        elements[rear] = element;  // 将元素放入目前队列的队尾
        current_size++; // 当前元素个数加一
    }

    /**
     * 将元素出队
     * @return 被出队的元素
     */
    public int dequeue() {
        if (isEmpty()) {
            // 如果队列为空，就不能再出队了
            System.out.println("The queue is empty. Cannot dequeue.");
            // 仍然为了简单起见，我们返回 -1 表示出队失败
            return -1;
        }
        front = (front + 1) % CAPACITY; // 头下标后移，这样就可以将元素从队头取出
        current_size--; // 当前元素个数减一
        return elements[front - 1];  // 返回出队的元素
    }

    /**
     * 显示队列中的元素
     */
    public void show() {
        for (int i = 0; i < current_size; i++) {
            System.out.print(elements[(front + i) % CAPACITY] + " ");
            // 这样可以保证从队头开始，依次输出队列中的元素，取模运算是为了实现循环队列中的元素输出
        }
        System.out.println();
    }

    /**
     * 判断队列是否为空
     * @return 如果队列为空，返回 true；否则返回 false
     */
    public boolean isEmpty() {
        return current_size == 0;
    }

    /**
     * 判断队列是否已满
     * @return 如果队列已满，返回 true；否则返回 false
     */
    public boolean isFull() {
        return current_size == CAPACITY;
    }
}

public class Main {
    public static void main(String[] args) {
        // 可以自行测试 MyCircularQueue 类的功能，看看各项操作的表现
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 创建一个长度为 5 的 int 类型数组
int[] arr = new int[5];
// 获取数组的长度
int len = arr.length;
// 获取数组的第一个元素
int first = arr[0];
// 修改数组的第一个元素
arr[0] = 1;

// 数组的元素类型可以是原始数据类型 (primitive data type) ，也可以是一个类 (例如 String 类)
String[] strArray = new String[5];
// 或者任何一个用户自定义的类
MyClass[] myClassArray = new MyClass[5];

// 注意，与原始数据类型数组不同，以类为元素的数组在创建时并不会自动初始化（不会给元素授予默认值，每个元素都是 null），需要手动初始化
// 该示例也同样展示了一维数组的遍历
for (int i = 0; i < myClassArray.length; i++) {
    myClassArray[i] = new MyClass();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 创建一个 3x3 的 int 类型二维数组
int[][] arr = new int[3][3];
// 获取数组中的第二个数组中的第一个元素
int num = arr[1][0];
// 修改数组中的第二个数组中的第一个元素
arr[1][0] = 1;
// 获取整体数组的长度
int len = arr.length;
// 获取每个元素数组的长度
int len1 = arr[0].length;

// 同理，二维数组的元素类型也可以是一个类
MyClass[][] myClassArray = new MyClass[3][3];
// 一个二维数组的简单遍历
for (int i = 0; i < myClassArray.length; i++) {
    for (int j = 0; j < myClassArray[i].length; j++) {
        myClassArray[i][j] = new MyClass();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import java.util.ArrayList; // 导入 ArrayList 类，你的 IDE 或许可以帮你把这件事做了。

public class Main {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>(); // 创建一个 String 类型的 ArrayList
        strings.add("Hello"); // 使用 add 方法向 ArrayList 中添加元素，你可以直接写入元素的值，该元素会被添加到 ArrayList 的末尾
        strings.add("Java");
        strings.add("Programming");
        strings.add("Language");
        strings.add(1, "World"); // 你也可以使用 add 方法的重载版本，指定元素的索引，该元素会被添加到指定索引的位置
        System.out.println(strings); // [Hello, World, Java, Programming, Language]
        strings.remove(2); // 使用 remove 方法移除指定索引的元素
        System.out.println(strings); // [Hello, World, Programming, Language]
        strings.remove("World"); // 使用 remove 方法移除指定元素
        System.out.println(strings); // [Hello, Programming, Language]

        ArrayList<Integer> integers = new ArrayList<>(); // 创建一个 Integer 类型的 ArrayList
        // 值得注意的是，ArrayList 的元素类型不可以是原始数据类型，所以我们需要使用包装类 (wrapper class) 来代替
        // 你可以将包装类理解为只有一个对应的原始数据类型的类，例如 Integer 对应 int
        integers.add(1); // 你仍然可以使用 add 方法向 ArrayList 中添加元素
        integers.add(2);
        integers.add(3);
        integers.add(4);
        integers.add(5);
        integers.add(1, 6); // 你也可以使用 add 方法的重载版本，指定元素的索引，该元素会被添加到指定索引的位置
        System.out.println(integers); // [1, 6, 2, 3, 4, 5]
        integers.remove(2); // 使用 remove 方法移除指定索引的元素
        System.out.println(integers); // [1, 6, 3, 4, 5]
        integers.remove(Integer.valueOf(6)); // 使用 remove 方法移除指定元素，此处值得注意的是，你不能直接写入 “6”，因为这样会被认为是索引，而不是元素，所以你需要使用包装类的 valueOf 方法
        System.out.println(integers); // [1, 3, 4, 5]
        // 你可以使用 size 方法获取 ArrayList 的长度
        System.out.println(integers.size()); // 4
        // 虽然 ArrayList 的长度是可以动态变化的，但是如果频繁更改 ArrayList 的长度，会对性能产生一定的影响，所以你可以使用 ensureCapacity 方法来提前设置 ArrayList 的容量
        // 你也可以在初始化 ArrayList 时指定其容量而不再需要单独使用 ensureCapacity 方法，例如：ArrayList<Integer> integers = new ArrayList<>(10);
        integers.ensureCapacity(10);
        // 但是 ensureCapacity 方法只是设置了 ArrayList 的容量，size 方法返回的长度仍然是实际元素的个数
        System.out.println(integers.size()); // 4
        integers.add(6);
        integers.add(7);
        // 当你确认 ArrayList 的长度不会再发生变化时，你可以使用 trimToSize 方法来释放多余的空间，此时 ArrayList 的容量会被设置为实际元素的个数
        integers.trimToSize();
        // 同样的，size 方法返回的长度仍然是实际元素的个数
        System.out.println(integers.size()); // 6

        integers.set(0, 10); // 你可以使用 set 方法来修改指定索引的元素，此处将索引为 0 的元素修改为 10
        System.out.println(integers); // [10, 3, 4, 5, 6, 7]
        // 你也可以使用 get 方法来获取指定索引的元素
        System.out.println(integers.get(0)); // 10
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("String1");
        strings.add("String2");
        strings.add("String3");
        strings.add("String4");

        // 创建一个相同长度的新数组
        String[] array = new String[strings.size()];

        // 遍历 ArrayList，将其中的元素逐个添加到新数组中
        for (int i = 0; i < strings.size(); i++) {
            array[i] = strings.get(i);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("String1");
        strings.add("String2");
        strings.add("String3");
        strings.add("String4");

        // 使用 toArray 方法将 ArrayList 转换为数组
        // 注意，传入给 toArray 方法的参数是一个新的数组，该数组的长度为 ArrayList 的长度
        String[] array = strings.toArray(new String[strings.size()]);
    }
}