Java基础快速入门: 数组高级操作与算法基础

原创 于 2026-06-26 21:30:00 发布 · 204 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法 #java #排序算法

本文纲要

  1. 二分查找
    思路分析
    代码实现
  2. 冒泡排序
    思路分析
    分步实现
    完整实现
  3. 递归
    概念与示例
    求阶乘案例
    递归内存图
  4. 快速排序
    思路分析
    核心代码实现
    完整递归实现
  5. Arrays工具类
    toString
    sort
    binarySearch

二分查找

1 ) 思路分析

二分查找的前提条件：数组元素必须按照大小顺序排列。

核心思想：每次去掉一半的查找范围，在剩余的范围中继续查找，直到找到目标元素或范围无效。

  • 定义两个变量 min 和 max，表示当前查找范围（最小索引和最大索引）。
  • 根据 min 和 max 计算出中间位置 mid：mid = (min + max) / 2。
  • 判断 arr[mid] 与目标值的关系：
    • 相等：直接返回 mid。
    • 目标值较小：说明目标在左半边，更新 max = mid - 1。
    • 目标值较大：说明目标在右半边，更新 min = mid + 1。
  • 循环条件：min <= max。
  • 如果 min > max，说明元素不存在，返回 -1。

2 ） 代码实现

项目结构：

src/
└── com/
    └── wb/
        └── arrsearch/
            └── MyBinarySearchDemo.java

package com.wb.arrsearch;
 
public class MyBinarySearchDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int number = 11;
 
        // 1. 我现在要干嘛? --- 二分查找
        // 2. 我干这件事情需要什么? --- 数组 元素
        // 3. 我干完了,要不要把结果返回调用者 --- 把索引返回给调用者
        int index = binarySearchForIndex(arr, number);
        System.out.println(index);
    }
 
    private static int binarySearchForIndex(int[] arr, int number) {
        // 1. 定义查找的范围 
        int min = 0;
        int max = arr.length - 1;
        // 2. 循环查找 min <= max
        while (min <= max) {
            // 3. 计算出中间位置 mid
            int mid = (min + max) >> 1;   // 右移1位相当于除以2 
            // mid指向的元素 > number
            if (arr[mid] > number) {
                // 表示要查找的元素在左边 
                max = mid - 1;
            } else if (arr[mid] < number) {
                // mid指向的元素 < number
                // 表示要查找的元素在右边
                min = mid + 1;
            } else {
                // mid指向的元素 == number
                return mid;
            }
        }
        // 如果min大于了max就表示元素不存在,返回-1
        return -1;
    }
}

运行结果：查找 3 返回索引 2；查找 11 返回 -1。

冒泡排序

1 ) 思路分析

冒泡排序的核心：相邻元素两两比较，小的放前面，大的放后面，每一轮确定一个最大值放到最右边。

  • 如果有 n 个数据，需要比较 n-1 轮。
  • 每一轮结束后，下一轮比较时就会少一个元素参与（因为最右边的最大值已经确定）。

2 ）分步实现

先按轮次拆开，逐步理解每一轮的操作。

package com.wb.mybubble;
 
public class MyBubbleSortDemo {
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 1, 4};
        // 期望结果: 1 2 3 4 5
 
        // 第一轮：把最大值5找出,并把它放到数组的最右边
        // -1 是为了让索引不超出范围
        for (int i = 0; i < arr.length - 1 - 0; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        printArr(arr);
 
        // 第二轮
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        printArr(arr);
 
        // 第三轮
        for (int i = 0; i < arr.length - 1 - 2; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        printArr(arr);
 
        // 第四轮
        for (int i = 0; i < arr.length - 1 - 3; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        printArr(arr);
    }
 
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

完整实现

将四轮循环合并为外层循环控制轮次，内层循环负责实际比较，内层循环的上限为 arr.length - 1 - i。

package com.wb.mybubble;
 
public class MyBubbleSortDemo2 {
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 1, 4};
        bubbleSort(arr);
    }
 
    private static void bubbleSort(int[] arr) {
        // 外层循环控制的是次数，比数组的长度少一次
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层循环就是实际比较的
            // -1 是为了让数组不要越界
            // -i 每一轮结束之后,我们就会少比一个数字
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        printArr(arr);
    }
 
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

递归

1 ) 概念与示例

递归：方法定义中调用方法本身。把复杂问题层层转化为与原问题相似的规模更小的问题。

递归的两个核心：

  1. 递归出口：必须要有结束条件，否则会导致栈内存溢出（StackOverflowError）。
  2. 递归规则：找到将大问题拆分为小问题的规律，且每次递归的参数更靠近出口。

先用循环方式求 1~100 的和，再改为递归方式。

package com.wb.myfactorial;
 
public class MyFactorialDemo1 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

递归实现：

package com.wb.myfactorial;
 
public class MyFactorialDemo2 {
    public static void main(String[] args) {
        int sum = getSum(100);
        System.out.println(sum);
    }
 
    private static int getSum(int i) {
        // 1~100之间的和
        // 100 + (1~99之间的和)
        //     99 + (1~98之间的和)
        //         ...
        //            1
        // 方法的作用: 求 1~i 之间和
        if (i == 1) {
            return 1;
        } else {
            return i + getSum(i - 1);
        }
    }
}

2 ) 求阶乘案例

需求：用递归求 5 的阶乘，并在控制台输出结果。

阶乘定义：5! = 5 × 4 × 3 × 2 × 1。

package com.wb.myfactorial;
 
public class MyFactorialDemo3 {
    public static void main(String[] args) {
        int result = getJc(5);
        System.out.println(result);
    }
 
    private static int getJc(int i) {
        // 1. 一定要找到出口 
        if (i == 1) {
            return 1;
        } else {
            // 2. 递归的规则
            return i * getJc(i - 1);
        }
    }
}

3 ) 递归内存图

以 getJc(5) 为例，方法调用与返回的过程如下：

getJc(1)getJc(2)getJc(3)getJc(4)getJc(5)maingetJc(1)getJc(2)getJc(3)getJc(4)getJc(5)main调用 getJc(5)5 * getJc(4)4 * getJc(3)3 * getJc(2)2 * getJc(1)return 1return 2return 6return 24return 120
  • 方法调用时依次进栈，到达出口 i == 1 时返回 1，然后依次出栈计算结果。
  • 如果没有出口，方法会无限进栈，最终导致 StackOverflowError。

快速排序

1 ) 思路分析

快速排序（快排）利用递归，每一次递归以左边第一个数作为 基准数，将比基准数小的放左边，比基准数大的放右边，从而确定基准数在数组中应存入的正确位置。

一次递归的步骤：

  1. 从右边开始找比基准数小的元素。
  2. 从左边开始找比基准数大的元素。
  3. 交换两个元素的位置。
  4. 重复上述过程，直到左右两个指针相遇。
  5. 基准数归位（与相遇位置的元素交换）。

一次递归结束后，基准数左边的元素都比它小，右边的都比它大，但左右两边内部的顺序尚未确定。接下来对左右两部分分别递归进行同样的操作。递归停止条件：left > right。

2 ) 核心代码实现（只确定一个基准数的位置）

package com.wb.myquitesort;
 
public class MyQuiteSortDemo {
    public static void main(String[] args) {
        // 1. 从右开始找比基准数小的
        // 2. 从左开始找比基准数大的
        // 3. 交换两个值的位置
        // 4. 红色继续往左找，蓝色继续往右找，直到两个箭头指向同一个索引为止
        // 5. 基准数归位
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
 
        quiteSort(arr, 0, arr.length - 1);
 
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
 
    private static void quiteSort(int[] arr, int left, int right) {
        int left0 = left;
        int right0 = right;
 
        // 计算出基准数
        int baseNumber = arr[left0];
 
        while (left != right) {
            // 1. 从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            // 2. 从左开始找比基准数大的 
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            // 3. 交换两个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        // 基准数归位
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;
    }
}

3 ) 完整递归实现

加入递归停止条件和左右递归调用。

package com.wb.myquitesort;
 
public class MyQuiteSortDemo2 {
    public static void main(String[] args) {
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
 
        quiteSort(arr, 0, arr.length - 1);
 
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
 
    private static void quiteSort(int[] arr, int left, int right) {
        // 递归停止条件 
        if (right < left) {
            return;
        }
 
        int left0 = left;
        int right0 = right;
 
        // 计算出基准数
        int baseNumber = arr[left0];
 
        while (left != right) {
            // 1. 从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            // 2. 从左开始找比基准数大的
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            // 3. 交换两个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        // 基准数归位
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;
 
        // 递归处理左边部分
        quiteSort(arr, left0, left - 1);
        // 递归处理右边部分
        quiteSort(arr, left + 1, right0);
    }
}

运行结果：1 2 3 4 5 6 7 8 9 10

Arrays工具类

java.util.Arrays 类提供了操作数组的静态方法，常用方法：

  • toString(array)：将数组内容拼接成字符串返回。
  • sort(array)：对数组进行升序排序（底层使用快速排序）。
  • binarySearch(array, key)：使用二分查找法查找元素索引，数组必须有序。

代码示例

package com.wb.myutils;
 
import java.util.Arrays;
 
public class MyArraysDemo {
    public static void main(String[] args) {
        int[] arr = {3, 2, 4, 6, 7};
 
        // 1. toString: 将数组转换为字符串
        System.out.println(Arrays.toString(arr)); // [3, 2, 4, 6, 7]
 
        // 2. sort: 排序（升序）
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); // [2, 3, 4, 6, 7]
 
        // 3. binarySearch: 二分查找（数组必须有序）
        int[] sortedArr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int index = Arrays.binarySearch(sortedArr, 10);
        System.out.println(index); // 9
 
        // 查找不存在的元素: 返回 -插入点 - 1
        int index2 = Arrays.binarySearch(sortedArr, 11);
        System.out.println(index2); // -11  (-10 - 1)
        int index3 = Arrays.binarySearch(sortedArr, 0);
        System.out.println(index3); // -1   (-0 - 1)
    }
}

注意点：

  1. binarySearch 调用前数组必须有序。
  2. 如果元素存在，返回实际索引。
  3. 如果元素不存在，返回 -插入点 - 1。插入点是指该元素如果存在应该在的索引位置，减1是为了避免与索引0冲突（例如查找0时返回 -1 而不是 0）。

总结

以上内容涵盖了数组高级操作中的二分查找、冒泡排序、递归、快速排序以及 Arrays 工具类的核心知识与代码实现，适合作为 Java 基础阶段的算法入门参考

AcWing算法基础课-785快速排序-Java题解
何书悦的技术博客
09-02 4079
这篇文章介绍了使用快速排序算法对整数数列进行排序的方法，包括选择基准元素、分区操作和递归排序子数组。通过详细的步骤和示例，解释了快速排序的过程及其非稳定性特征，并提供了相应的 Java 代码实现。
Java数组详解：从基础到高级应用
2202_75382767的博客
08-29 474
《Java数组详解：从基础到高级应用》全面介绍了Java数组的核心概念与操作技巧。主要内容包括：数组的声明与初始化方法（如int[] a = new int[5]）、基本操作（访问、遍历、获取长度）、内存模型（连续存储特性）以及常用操作（排序、搜索、拷贝）。文章还详细讲解了多维数组、可变长参数和动态数组ArrayList的应用，并对比了数组与集合框架的差异。最后提供了数组性能分析（随机访问O(1)）、应用场景和最佳实践建议（避免数组越界等常见错误）。适合Java开发者系统学习数组知识的参考指南。
【Java数据结构与算法】Day2-高级排序（希尔、归并、快速、计数）
Hhzzy99的博客
01-08 8022
Java数据结构与算法中的比较高级的排序，希尔排序、归并排序、快速排序、计数排序
精通数组创建与操作：从基础到高级应用
weixin_42605397的博客
06-07 676
数组是一组有序的元素集合，可以存储相同类型的数据项。在编程中，数组提供了一种高效访问和管理多个值的方式。对于IT专业人员来说，数组使得数据操作变得简单，且经常用于处理一系列数据，如列表、矩阵或任何线性数据结构。数组是编程中常用的数据结构之一，它可以存储一系列相同类型的元素。理解数组的定义及其在程序中的作用是掌握编程基础的关键步骤。数组是由一系列按顺序排列的相同类型的变量组成的集合。每个变量称为一个数组元素，每个元素可以通过索引来访问，索引通常以0开始。
java快速入门
m0_74013450的博客
04-13 1394
Java 集合框架主要由两大接口派生而出：Collection 和 Map。Collection 接口用于存储单个元素，而 Map 接口用于存储键值对。集合框架提供了统一的接口和方法，方便开发者对不同类型的集合进行操作，同时也提高了代码的可复用性和可维护性。
排序算法全景：从基础到高级的Java实现
interest_ing_的博客
03-10 984
排序算法是计算机科学中的一个基础概念，它在数据处理和信息检索中扮演着至关重要的角色。本文将通过几个简单的Java程序，带你了解几种常见的排序算法：插入排序、希尔排序、归并排序、快速排序和选择排序，以及一个用于生成和打印测试数据的工具类。
Java基础编程实践：数组操作及数值统计
weixin_29717341的博客
06-09 813
Java作为一门静态类型的编程语言，对于数组的处理有着严格和明确的规范。本章节将带领读者深入了解Java一维数组的定义方法，包括数组的基本概念、声明、初始化、实例化、赋值以及访问和遍历。数组是一个用来存储固定大小的同类型元素的数据结构。在Java中，数组是一种对象，它能够存储多个变量，并且可以通过索引快速访问这些变量。数组的特性包括固定大小、线性存储和能够存储基本类型或对象引用。定义一维数组涉及选择数组的数据类型和分配内存空间。例如，创建一个整型一维数组。
算法之Java快速排序：深入剖析与优化策略
wj_rdk的博客
04-02 1586
在编程的学习道路上，排序算法是提升编程技能的关键知识点。今天，咱们一起深入研究Java中的快速排序算法，从基本原理、性能分析到优化改进，希望能和大家共同进步，让我们在算法的世界里探索得更深更远！
Java数组终极指南：从基础到高级应用
本博客聚焦 YOLOv11 全流程落地，涵盖架构优化、数据集处理、训练技巧与多场景部署，兼及国产数据库、Java 开发与 AI 模型应用，内容兼顾理论与工程实践，为开发者提供系统干货，助力高效提升技术能力。
04-23 517
Java 数组，编程界的 “数据列车”。一列列整齐的车厢（元素）等待着你放入各种数据货物。但这列车有个规矩，一旦确定了车厢数量（数组长度），就很难再临时加车厢。要是你一不小心坐错了车厢号（索引错误），那就得像在迷宫里找出口一样，被程序错误提示搞得晕头转向咯！
【双路快速排序算法】详解：原理、图示与Java实现
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！✨
10-16 7109
双路快速排序是快速排序的改进版本，由C. A. R. Hoare提出，主要用于解决**含有大量重复元素**数组的排序问题。相比传统快速排序，它能更均衡地分配重复元素，避免分区不平衡导致的性能下降。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 597
超详细的Floyd算法教程，一看就懂！
医用超声图像模拟系统算法：线密度详解
alxraves的博客
06-23 604
在超声成像中，线密度（Line Density）是指单位扫描角度或单位扫描宽度内超声扫描线的数量。简单来说，它描述了超声探头在扫描区域内发射和接收声波线的密集程度。核心概念扫描线：超声探头发射的每一条声波束，对应图像中的一条垂直线（A-mode）或图像重建的一个数据采集通道（B-mode）。线间距：相邻两条扫描线中心之间的距离，是线密度的倒数。单位：通常表示为线/度（对于扇形扫描）或线/厘米（对于线性扫描）。更高的线密度意味着更密集的采样，理论上能获得更丰富的图像细节和更好的横向分辨率。
CodeQUEEN 2026 -qual- (AtCoder Beginner Contest 462)题解
Timmylyx0518的博客
06-20 276
第六次 AK，记录一下。
算法日记 | 二分查找
在读大学生
06-23 201
本文介绍了二分查找算法的核心思想与实战应用，通过三道经典题目由浅入深地讲解： 基础入门：通过洛谷P1833模拟二分查找过程，展示如何通过中间值比较收缩区间，时间复杂度O(log n)。关键是用变量维护查找区间，注意大数溢出问题。 STL实战：在P1678高考志愿题中，利用lower_bound快速定位最接近分数线的学校，强调预处理排序和边界处理（如估分超出所有学校范围的情况）。
数据结构基础复习——排序算法的关键代码片段
2301_80025611的博客
06-22 415
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
linux内核内存二次机会算法&refualt算法
Network, Linux Kernel
06-23 300
linux 内核传统LRU的二次机会算法实现细节
【leetcode】983.最低票价js
2402_83244812的博客
06-23 1009
本文介绍了两种动态规划方法解决旅行购票问题。第一种方法基于自然日定义dp数组，dp[i]表示从第i天到最后一天覆盖所有旅行日的最小花费，分当天是否旅行两种情况处理。第二种方法基于旅行日索引定义dp数组，dp[i]表示处理前i个旅行日的最小花费，通过三种购票方式（1天/7天/30天票）寻找最优解。两种方法都通过状态转移方程和边界条件实现，代码示例展示了具体实现逻辑。
leetcode 3737. 统计主要元素子数组数目 I 中等
最新发布
2401_88085478的博客
06-25 239
因此，不可能有任何以 4 为主要元素的子数组。所有 10 个子数组都以 1 为主要元素。是指该元素在该子数组中出现的次数。因此共有 5 个这样的子数组。是数组中的一段连续且。
【STL】算法
呆瓜的博客
06-22 354
本文介绍了C++标准库算法的术语规范与基本要求。主要内容包括：1) 标准区间表示法如[A,B)及其遍历规则；2) 等值判断二元谓词的三项强制要求；3) 排序/堆算法中严格弱序的定义及合法谓词示例；4) 升序序列和大顶堆的具体判定标准；5) 算法头文件<algorithm>和<numeric>的功能划分。特别强调所有比较函数必须满足不修改参数、结果一致性和严格弱序等核心规范。
现代CAD几何内核中的求交算法——从曲线求交到曲面求交的原理与实现
m0_53082780的博客
06-21 237
无论是模型布尔运算、特征建模、曲面修剪、装配分析，还是数控加工中的刀具路径规划，其底层都离不开各种形式的几何求交。然而在工业级CAD内核中，由于大量采用NURBS曲线与曲面表示复杂几何对象，传统解析求解方法已经难以适用，取而代之的是基于参数空间、数值迭代以及拓扑重建的一整套工程化算法体系。本文从CAD几何内核的角度出发，系统介绍曲线求交、曲线曲面求交以及曲面曲面求交的数学本质和工程实现流程，并结合OpenCASCADE等主流CAD内核的实现思想，帮助读者建立完整的几何求交知识框架。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值