从零开始编写数字处理程序：一个Java小白的完整指南

1
// 定义入口点：main 是 Java 程序启始位
2
void main() {
3
    // 主逻辑占位：此处待实现功能
4
    // 当前空，表未写具体代
5
}
6

7
// 睡函 - 造延效果
8
// 入参：milliseconds - 线程停多长（毫秒）
9
void sleep(int milliseconds) {
10
    try {
11
        // 调 Thread.sleep，让当线程休指时长
12
        Thread.sleep(milliseconds);
13
    } catch (InterruptedException e) {
14
        // 若线程睡中被断，则恢其断状
15
        Thread.currentThread().interrupt();
16
    }
17
}
18

19
// 打印数组 - 以 [a,b,c] 格式输到控台
20
// 入参：arr - 要打的 int 型数组
21
void printArray(int[] arr) {
22
    System.out.print("[");              // 先打左括，表数组开
23
    for (int i = 0; i < arr.length; i++) { // 遍数每元
24
        System.out.print(arr[i]);       // 打当元
25
        if (i < arr.length - 1) {       // 判是为最一元
26
            System.out.print(",");      // 非末则加逗隔
27
        }
28
    }
29
    System.out.println("]");            // 打右括并换行，表数组束
30
}

1
void main() {
2
    // 取系统语种（如：zh=中文，en=英文）
3
    String language = System.getProperty("user.language");
4
    // 判是否为中文环：zh 或 cn 即视为中
5
    boolean isChinese = "zh".equals(language) || "cn".equals(language);
6

7
    // 按语种显对应提语
8
    String input = readInput(isChinese ? "请输入数字: " : "Enter numbers: ");
9

10
    // 抽字串中所数，转为整数数
11
    int[] numbers = extractSingleDigits(input);
12

13
    // 原样打数组（带[ ]格式）
14
    printArray(numbers);
15
    // 停300毫秒，造延缓效
16
    sleep(300);
17
}
18

19
// 读用户输的一行文
20
// 入参：prompt - 提示语（中or英）
21
// 出参：用户输内（错时为空串）
22
String readInput(String prompt) {
23
    // 显提语不换行
24
    System.out.print(prompt);
25

26
    try {
27
        // 建读器，用读键输
28
        java.io.BufferedReader reader = new java.io.BufferedReader(
29
                new java.io.InputStreamReader(System.in));
30
        // 读一整并回
31
        return reader.readLine();
32
    } catch (Exception e) {
33
        // 出错（如IO异常）则回空串
34
        return "";
35
    }
36
}
37

38
// 抽字串中所单数，转为int数组
39
// 入参：input - 原始输字串
40
// 出参：只含数的整型数组
41
int[] extractSingleDigits(String input) {
42
    int count = 0; // 记数个数
43

44
    // 一遍历：数有几数
45
    for (int i = 0; i < input.length(); i++) {
46
        char c = input.charAt(i);           // 取当字
47
        if (c >= '0' && c <= '9') {         // 是0-9间？
48
            count++;                        // 是则计+1
49
        }
50
    }
51

52
    // 新数组，长=数个数
53
    int[] numbers = new int[count];
54
    int index = 0; // 数组写位指针
55

56
    // 二遍历：数抽整存数组
57
    for (int i = 0; i < input.length(); i++) {
58
        char c = input.charAt(i);                   // 取当字
59
        if (c >= '0' && c <= '9') {                 // 是数？
60
            numbers[index++] = c - '0';             // 转整存，指针++
61
        }
62
    }
63

64
    // 回抽完的数数组
65
    return numbers;
66
}

1
// 随机选一排序法
2
// 出参：返回一个排序算名（如“冒泡排序”）
3
String selectRandomSort() {
4
    // 定义支持的四种排序法
5
    String[] sorts = {"冒泡排序", "快速排序", "选择排序", "归并排序"};
6
    // 用当前时间毫秒取模4，得0-3的索引
7
    int index = (int)(System.currentTimeMillis() % 4);
8
    // 返回随机选中的排序法名
9
    return sorts[index];
10
}
11

12
// 按指定排序法对数列排序
13
// 入参：numbers - 原数组；sortType - 排序类名
14
// 出参：已排序的新数组
15
int[] sortNumbers(int[] numbers, String sortType) {
16
    // 克隆原数组，避免修改原数据
17
    int[] sorted = numbers.clone();
18

19
    // 根据排序类名调对应算法
20
    switch (sortType) {
21
        case "冒泡排序":
22
            bubbleSort(sorted);           // 调冒泡
23
            break;
24
        case "快速排序":
25
            quickSort(sorted, 0, sorted.length - 1); // 调快排
26
            break;
27
        case "选择排序":
28
            selectionSort(sorted);        // 调选排
29
            break;
30
        case "归并排序":
31
            // 归并返新数组，需重赋值
32
            sorted = mergeSort(sorted);
33
            break;
34
    }
35

36
    // 回排完的数
37
    return sorted;
38
}
39

40
// 冒泡排序：相临比，大者后移
41
// 入参：arr - 待排数组（直改原数组）
42
void bubbleSort(int[] arr) {
43
    int n = arr.length;                 // 数长
44
    for (int i = 0; i < n - 1; i++) {   // 控制趟数
45
        for (int j = 0; j < n - i - 1; j++) { // 每趟比前n-i-1个
46
            if (arr[j] > arr[j + 1]) {  // 前>后则交
47
                int temp = arr[j];
48
                arr[j] = arr[j + 1];
49
                arr[j + 1] = temp;
50
            }
51
        }
52
    }
53
}
54

55
// 快速排序：分治法，选基，小左大右
56
// 入参：arr - 数组；low - 起位；high - 终位
57
void quickSort(int[] arr, int low, int high) {
58
    if (low < high) {                   // 至少两元才需排
59
        int pi = partition(arr, low, high); // 分区得基位
60
        quickSort(arr, low, pi - 1);    // 排左区
61
        quickSort(arr, pi + 1, high);   // 排右区
62
    }
63
}
64

65
// 分区操作：将数组按基分两部
66
// 入参：arr, low, high
67
// 出参：基元素最终位
68
int partition(int[] arr, int low, int high) {
69
    int pivot = arr[high];              // 取最末为基
70
    int i = low - 1;                    // 小于区的边界指针
71

72
    for (int j = low; j < high; j++) {  // 遍除基外所元
73
        if (arr[j] <= pivot) {          // 当元≤基
74
            i++;                        // 扩小分区
75
            // 交arr[i]与arr[j]
76
            int temp = arr[i];
77
            arr[i] = arr[j];
78
            arr[j] = temp;
79
        }
80
    }
81

82
    // 交基（arr[high]）与i+1位元
83
    int temp = arr[i + 1];
84
    arr[i + 1] = arr[high];
85
    arr[high] = temp;
86

87
    return i + 1;                       // 回基位
88
}
89

90
// 选择排序：每轮选最，放当位
91
// 入参：arr - 待排数组
92
void selectionSort(int[] arr) {
93
    int n = arr.length;
94
    for (int i = 0; i < n - 1; i++) {   // 控制选位
95
        int minIdx = i;                 // 假设当元最
96
        for (int j = i + 1; j < n; j++) { // 遍后所元
97
            if (arr[j] < arr[minIdx]) { // 找更小的
98
                minIdx = j;             // 记其索引
99
            }
100
        }
101
        // 交arr[i]与最元
102
        int temp = arr[minIdx];
103
        arr[minIdx] = arr[i];
104
        arr[i] = temp;
105
    }
106
}
107

108
// 归并排序：分而治之，递归拆合
109
// 入参：arr - 原数组
110
// 出参：新排数组
111
int[] mergeSort(int[] arr) {
112
    if (arr.length <= 1) {              // 基线：长≤1直回
113
        return arr;
114
    }
115

116
    int mid = arr.length / 2;           // 找中点
117
    int[] left = new int[mid];          // 左半
118
    int[] right = new int[arr.length - mid]; // 右半
119

120
    // 拷数到左右子组
121
    for (int i = 0; i < mid; i++) {
122
        left[i] = arr[i];
123
    }
124
    for (int i = mid; i < arr.length; i++) {
125
        right[i - mid] = arr[i];
126
    }
127

128
    // 递归排左右
129
    left = mergeSort(left);
130
    right = mergeSort(right);
131

132
    // 合并两有序子组
133
    return merge(left, right);
134
}
135

136
// 合并：将两个有序数组合为一个有序数组
137
// 入参：left, right - 两个有序子数组
138
// 出参：合并后的有序大数组
139
int[] merge(int[] left, int[] right) {
140
    // 新数组长=左长+右长
141
    int[] result = new int[left.length + right.length];
142
    int i = 0, j = 0, k = 0;            // 三指针：左、右、结果
143

144
    // 同有数时，取小者入结
145
    while (i < left.length && j < right.length) {
146
        if (left[i] <= right[j]) {
147
            result[k++] = left[i++];
148
        } else {
149
            result[k++] = right[j++];
150
        }
151
    }
152

153
    // 处左剩
154
    while (i < left.length) {
155
        result[k++] = left[i++];
156
    }
157

158
    // 处右剩
159
    while (j < right.length) {
160
        result[k++] = right[j++];
161
    }
162

163
    // 回合完的有数
164
    return result;
165
}

1
// 获取唯一数字（去重）
2
int[] getUniqueNumbers(int[] numbers) {
3
    if (numbers.length == 0) return new int[0];
4

5
    // 先计算唯一数字的数量
6
    int uniqueCount = 1;
7
    for (int i = 1; i < numbers.length; i++) {
8
        if (numbers[i] != numbers[i - 1]) {
9
            uniqueCount++;
10
        }
11
    }
12

13
    // 创建结果数组
14
    int[] unique = new int[uniqueCount];
15
    unique[0] = numbers[0];
16
    int index = 1;
17

18
    for (int i = 1; i < numbers.length; i++) {
19
        if (numbers[i] != numbers[i - 1]) {
20
            unique[index++] = numbers[i];
21
        }
22
    }
23

24
    return unique;
25
}

1
// 用单调栈处数，并打每步
2
// 入参：numbers - 数列；isChinese - 是否中提
3
void processWithMonotonicStack(int[] numbers, boolean isChinese) {
4
    if (numbers.length == 0) return;    // 空则直退
5

6
    // 用数组模栈结：stack 数组 + top 指针
7
    int[] stack = new int[numbers.length]; // 栈存数
8
    int top = -1;                       // 栈顶指针（-1 = 空）
9

10
    // 入栈序：保栈单递增（从底到顶）
11
    for (int num : numbers) {           // 遍每数
12
        // 弹所小栈顶：保单性
13
        while (top >= 0 && stack[top] < num) {
14
            if (isChinese) {
15
                System.out.println(stack[top] + " 已出栈！");
16
            } else {
17
                System.out.println(stack[top] + " popped!");
18
            }
19
            sleep(200);                 // 停0.2秒，造动效
20
            top--;                      // 出栈：指针减1
21
        }
22

23
        // 当数入栈
24
        stack[++top] = num;             // 先+1，再赋值
25
        if (isChinese) {
26
            System.out.println(num + " 已进栈！");
27
        } else {
28
            System.out.println(num + " pushed!");
29
        }
30
        sleep(200);                     // 停0.2秒
31
    }
32

33
    // 完提
34
    if (isChinese) {
35
        System.out.println("完成！");
36
        System.out.println("=======================");
37
    } else {
38
        System.out.println("Completed!");
39
        System.out.println("=======================");
40
    }
41
}
42

43
// 出栈流：模后进先出（LIFO）
44
// 入参：numbers - 原数组（视为栈中数）
45
// 出参：出栈顺的新数组
46
int[] popFromStack(int[] numbers, boolean isChinese) {
47
    // 栈为LIFO，故出栈序 = 原序逆
48
    int[] result = new int[numbers.length];
49
    for (int i = 0; i < numbers.length; i++) {
50
        // 从尾到头取数
51
        result[i] = numbers[numbers.length - 1 - i];
52
        if (isChinese) {
53
            System.out.println(result[i] + " 已出栈！");
54
        } else {
55
            System.out.println(result[i] + " popped!");
56
        }
57
        sleep(200);                     // 每出一停0.2秒
58
    }
59
    return result;                      // 回出栈序
60
}

1
void main() {
2
    // 检测系统语言
3
    String language = System.getProperty("user.language");
4
    boolean isChinese = "zh".equals(language) || "cn".equals(language);
5

6
    // 读取输入
7
    String input = readInput(isChinese ? "请输入数字: " : "Enter numbers: ");
8

9
    // 提取每个单独的数字字符
10
    int[] numbers = extractSingleDigits(input);
11

12
    // 原样输出
13
    printArray(numbers);
14
    sleep(300);
15

16
    // 随机选择排序算法
17
    String sortType = selectRandomSort();
18
    if (isChinese) {
19
        System.out.println("当前自动选择：" + sortType);
20
    } else {
21
        System.out.println("Currently selected: " + sortType);
22
    }
23
    sleep(500);
24

25
    int[] sorted = sortNumbers(numbers, sortType);
26
    printArray(sorted);
27
    sleep(200);
28

29
    // 唯一性处理
30
    if (isChinese) {
31
        System.out.println("唯一性处理,启动！");
32
    } else {
33
        System.out.println("Unique processing, starting!");
34
    }
35
    sleep(100);
36

37
    int[] unique = getUniqueNumbers(sorted);
38
    printArray(unique);
39

40
    // 单调栈处理
41
    if (isChinese) {
42
        System.out.println("进栈！");
43
    } else {
44
        System.out.println("Pushing to stack!");
45
    }
46

47
    processWithMonotonicStack(unique, isChinese);
48

49
    sleep(500);
50

51
    if (isChinese) {
52
        System.out.println("出栈！");
53
    } else {
54
        System.out.println("Popping from stack!");
55
    }
56

57
    // 出栈流程
58
    int[] stackResult = popFromStack(unique, isChinese);
59

60
    if (isChinese) {
61
        System.out.println("出栈完成！");
62
        System.out.println("入表！");
63
    } else {
64
        System.out.println("Popping completed!");
65
        System.out.println("Adding to table!");
66
    }
67

68
    printArray(stackResult);
69

70
    if (isChinese) {
71
        System.out.println("工作完成！");
72
        System.out.println("=======================");
73
        sleep(500);
74
        System.out.println("tips:本示范来自blog.meowhead.cn，建议jdk版本24，盗文章死马。");
75
        System.out.println("微信公众号：绪方小原");
76
    } else {
77
        System.out.println("Work completed!");
78
        System.out.println("=======================");
79
        sleep(500);
80
        System.out.println("tips: This demo is from blog.meowhead.cn, recommended JDK version 24.");
81
        System.out.println("WeChat public account: 绪方小原");
82
    }
83
}

1
请输入数字: 7744233336899641024
2
[7,7,4,4,2,3,3,3,3,6,8,9,9,6,4,1,0,2,4]
3
当前自动选择：快速排序
4
[0,1,2,2,3,3,3,3,4,4,4,4,6,6,7,7,8,9,9]
5
唯一性处理,启动！
6
[0,1,2,3,4,6,7,8,9]
7
进栈！
8
0 已进栈！
9
0 已出栈！
10
1 已进栈！
11
1 已出栈！
12
2 已进栈！
13
2 已出栈！
14
3 已进栈！
15
3 已出栈！
16
4 已进栈！
17
4 已出栈！
18
6 已进栈！
19
6 已出栈！
20
7 已进栈！
21
7 已出栈！
22
8 已进栈！
23
8 已出栈！
24
9 已进栈！
25
完成！
26
=======================
27
出栈！
28
9 已出栈！
29
8 已出栈！
30
7 已出栈！
31
6 已出栈！
32
4 已出栈！
33
3 已出栈！
34
2 已出栈！
35
1 已出栈！
36
0 已出栈！
37
出栈完成！
38
入表！
39
[9,8,7,6,4,3,2,1,0]
40
工作完成！
41
=======================
42
tips:本示范来自blog.meowhead.cn，建议jdk版本24，盗文章死马。
43
微信公众号：绪方小原