Java数组02[数组的使用、二维数组、Arrays类讲解、冒泡排序、稀疏数组]

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量97 收藏
点赞数
分类专栏： Java SE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45334172/article/details/115184291
版权
本文详细介绍了Java中数组的使用，包括For-Each循环遍历数组，数组作为方法参数和返回值，以及二维数组的处理。还探讨了如何使用Arrays工具类进行数组操作，如排序和填充，并通过冒泡排序展示了排序算法的实现和优化。最后，解释了稀疏数组的概念及其在数据存储中的应用。
摘要由CSDN通过智能技术生成

数组的使用

  • For-Each循环 及 数组作方法入参(数组作为方法的传入形参，即将数组封装成参数)
代码实现
package com.ruomeng.array;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/24 20:16
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7};
        //返回值类型为void，单独调用
        printArray(arrays);
    }
    /**
     * 定义一个遍历数组元素的方法      （for-each遍历数组）
     *
     * Java 5引入了一种主要用于数组或集合的增强型for循环，不再使用下标，好处是遍历数组或集合非常简便
     * 坏处是由于不可以访问下标，所以当我们需要对数组中的元素进行操作时就不在适用
     * 增强for循环的IDEA快捷键：arrays.for
     * 在前面循环的学习中我们有提过增强for的概念，只是没重点讲
     * 后面arrays代表数组名，前面新声明的局部变量array相当于数组中的每一个元素
     */
    public static void printArray(int[] arrays){
        for (int array : arrays) {
            System.out.print(array + " ");
        }
    }
}
  • 数组作返回值
代码实现1
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/24 21:15
 */
public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7};
        //赋值调用：
        int[] reverse = reverse(arrays);
        System.out.println(Arrays.toString(reverse));
        //String reverse = Arrays.toString(reverse(arrays));
        //System.out.println(reverse);

        //Arrays是一个工具类，专门用来操作数组的
        //toString：是Arrays类中的一个方法，打印数组，返回指定数组的内容的字符串表示形式。

        //打印调用：
        //相当将赋值调用与输出语句System.out.println();合并成一句
        //System.out.println(Arrays.toString(reverse(arrays)));
    }
    /**反转数组*/
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //实现反转操作
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}
代码实现2
package com.ruomeng.array;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/24 23:02
 */
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7};
        //赋值调用  数据类型 变量名 = 方法名(实参列表);
        int[] reverse = reverse(arrays);
        //如果只为实现反转数组的话，Demo06显然是写复杂了
        //但Demo06只是为了让你知道 方法调用不仅可以是main来调自定义方法，也可以自定义调自定义
        //printArray方法的返回值类型为void，单独调用  这里用main方法以外的printArray方法调用reverse方法
        //由于在同一类中，reverse方法的修饰符列表含有static，则其调用格式为：方法名(实参列表);
        printArray(reverse);
    }
    /**反转数组的方法*/
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //实现反转操作
        for (int i = 0, j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    /**打印数组元素的方法*/
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

二维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组。
  • 图解
  • 语法格式：
举个栗子：
int a[][] = new int[4][2];
  • 解析：以上二维数组 a 可以看成一个四行两列的数组。
  • 思考：多维数组如何分析和使用？
二维数组元素遍历代码实现
package com.ruomeng.array;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/25 21:09
 */
public class ArrayDemo07 {
    public static void main(String[] args) {

        //[4][2]
        /*
         * 1,2  array[0]
         * 2,3  array[1]
         * 3,4  array[2]
         * 4,5  array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        //单独调用
        printArray(array);
    }
    public static void printArray(int[][] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]);
            }
        }
    }
}
二维数组遍历代码实现
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/25 23:36
 */
public class ArrayDemo08 {
    public static void main(String[] args) {
        //[4][2]
        /*
         * 1,2  array[0]
         * 2,3  array[1]
         * 3,4  array[2]
         * 4,5  array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        //赋值调用
        int[][] ints = printArray1(array);
        System.out.println(Arrays.deepToString(ints));
    }
    public static int[][] printArray1(int[][] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
            }
        }
        return array;
    }
}

Arrays类

  • 数组的工具类java.util.Arrays

  • 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作

  • 查看JDK帮助文档JDK1.6 1.8帮助文档获取 提取码：ruom

  • Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是“不用”而不是“不能”）

  • 具有以下常用功能：

    • 给数组赋值：通过fill方法
    • 对数组排序：通过sort方法，按升序
    • 比较数组：通过equals方法比较数组中元素值是否相等
    • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分法查找操作
  1. 调用Arrays.toString()打印数组、写一个类 toString() 的方法 printArray() 实现数组遍历
代码实现1
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/26 16:58
 */
public class ArrayDemo09 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        //[I@1b6d3586  a的hashcode值 现在看不懂没关系，学完反射就能看得懂了！
        //System.out.println(a);

        //利用    Arrays.toString()   打印数组
        System.out.println(Arrays.toString(a));

        //单独调用    自己写的方法    打印数组
        printArray(a);
    }
    /**
     * 其实我们自己也可以写一个遍历一位数组的方法
     * 只是不建议“重复造轮子”（别人已经做好的东西，不建议我们重新再去做）
     * 但我们应该知道或者可以去了解这个东西是怎么实现的
     */
    public static void printArray(int[]a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }
}
  1. Arrays工具类下的方法使用（以sort()、fill()为例）
代码实现2
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/26 17:49
 */
public class ArrayDemo10 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        // 利用 Arrays.sort()    对Demo09中（即上述数组)进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //利用 Arrays.fill() 将0填充到数组下标为3和5的元素之间，左闭右开（包含下标3，不包含5）
        Arrays.fill(a,3,5,0);
        System.out.println(Arrays.toString(a));
    }
    public static void printArray(int[]a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
    }
}

冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序。

  • 冒泡排序的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人尽皆知。

  • 图解冒泡排序的机制

  • 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度O(n2)。

  • 思考：如何优化？

冒泡排序基本代码代码实现
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/26 23:21
 */
public class ArrayDemo11 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    /**
     * 冒泡排序1.比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
     * 2.每一次比较，都会产生出一个最大数。那么相应的下一轮我们就可以少一次排序
     * 3.依次循环，直到结束
     */
    public static int[] sort(int[] array){
        //定义临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比较两个数，如果第一个数大于第二个，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

临时变量定义原则：哪个代码块需要时就定义！！！而不是在类变量或者方法变量里面！（如果定义为方法变量，那么在各个代码块，可以能使用到相同的变量值。特别是在用for(object o:object List)时，如果o在方法变量里面定义了，虚拟机会认为o是方法变量，而方法变量可能已经被其他代码块修改过，这是o就会取到被其他代码块修改过的值。）

冒泡排序第一次优化（减少内层循环比较的次数–增加标记位）
代码实现：
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/27 9:15
 */
public class ArrayDemo12 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        int[] sort = sort(a);
        System.out.println("排序结果为:"+Arrays.toString(sort));
	}
    /**
     * 1.第一次优化（减少内层循环比较次数）
     * 增加一个标记（flag），每次发生交换，就进行标记，如果某次循环完没有标记，
     * 则说明已经完成排序，数组有序，剩下的几次排序就不需要再去执行了，可以提前结束排序
     */
    public static int[] sort(int[] array){

        //外层循环，判断我们这个要走多少趟
        for (int i = 0; i < array.length-1; i++) {
            //优化冒泡排序，增加标记位，有序，跳出外层循环，每一轮初始为true
            boolean flag = true;
            //内层循环，比较两个数，如果第一个数大于第二个，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                //定义临时变量
                int temp = 0;
                if (array[j]>array[j+1]){

                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    //有元素交换，所以不是有序，标记变为false
                    flag = false;
                }
            }
            //说明内层for循环中，没有交换任何元素，直接跳出外层循环
            if (flag){
                break;
            }
        }
        return array;
    }
}
冒泡排序第二次优化（减少每趟循环次数–定义无序数组的边界arrBoundary）
代码实现：
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/27 9:59
 */
public class ArrayDemo13 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        int[] sort = sort(a);
        System.out.println("排序结果为:"+Arrays.toString(sort));
    }
    /**
     * 2.第二次优化（减少每趟循环次数）
     *
     * 在第一次优化后的结果我们会发现，在每趟排序中，右边的许多元素已经是有序的结果了，
     * 可算法还是进行后面数值的排序，因此进行第二次优化
     *
     * 定义arrBoundary是无序数组的边界，每次比较到这里，就不需要进行后面的排序了
     */
    public static int[] sort(int[] array){

        //最后一次交换索引（下标）
        int lastSwapIndex = 0;
        //无序数组的边界，每次比较到这里为止
        int arrBoundary = array.length-1;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //优化冒泡排序，增加标记位，有序，跳出外层循环，每一轮初始为true
            boolean flag = true;
            //内层循环，比较两个数，如果第一个数大于第二个，则交换位置
            for (int j = 0; j < arrBoundary; j++) {
                //定义临时变量   
                int temp = 0; 
                if (array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    //有元素交换，所以不是有序，标记变为false
                    flag = false;
                    //最后一次交换元素的位置
                    lastSwapIndex = j;
                }
            }
            //把最后一次交换元素的位置赋值给无序数组的边界
            arrBoundary = lastSwapIndex;
            //说明内层for循环中，没有交换任何元素，直接跳出外层循环
            if (flag){
                break;
            }
        }
        return array;
    }
}
冒泡排序第三次优化（减少内存开销–用异或的方式交换两个元素）（了解）
代码实现：
package com.ruomeng.array;

import java.util.Arrays;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/27 11:39
 */
public class ArrayDemo14 {
    public static void main(String[] args) {
        int[] a = {1,2,3,123,3434,35,35234};
        int[] sort = sort(a);
        System.out.println("排序结果为:"+ Arrays.toString(sort));
    }
    /**
     * 3.第三次优化（减少内存开销）  了解（哈哈哈，其实能掌握还是掌握了好）
     * 冒泡排序里面需要交换两个元素的位置，交换两个元素可以用异或的操作，这样不需要创建第三个变量
     */
    public static int[] sort(int[] array){

        //最后一次交换索引（下标）
        int lastSwapIndex = 0;
        //无序数组的边界，每次比较到这里为止
        int arrBoundary = array.length-1;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //优化冒泡排序，增加标记位，有序，跳出外层循环，每一轮初始为true
            boolean flag = true;
            //内层循环，比较两个数，如果第一个数大于第二个，则交换位置
            for (int j = 0; j < arrBoundary; j++) {
                if (array[j]>array[j+1]){
                    //对交换过程中两个元素的方式进行修改
                    array[j+1] ^= array[j];
                    array[j] ^= array[j+1];
                    array[j+1] ^= array[j];
                    //有元素交换，所以不是有序，标记变为false
                    flag = false; 
                    //最后一次交换元素的位置
                    lastSwapIndex = j;
                }
            }
            //把最后一次交换元素的位置赋值给无序数组的边界
            arrBoundary = lastSwapIndex;
            //说明内层for循环中，没有交换任何元素，直接跳出外层循环
            if (flag){
                break;
            }
        }
        return array;
    }
}
用户输入想要排序的数，将其输入数据进行冒泡排序(以最优方式)并打印输出（前面所学综合）
代码实现：
package com.ruomeng.array;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/27 11:50
 */
public class ArrayDemo15 {
    public static void main(String[] args) {
        //创建扫描器对象用于获取用户输入
        Scanner scanner = new Scanner(System.in);
        //接受用户输入数据
        System.out.println("请输入需要排序的值，值之间用英文逗号隔开：");
        //将获取的数据存放在一个变量里
        String str = scanner.nextLine();

        //将字符串按照“,”拆分成字符串数组
        String[] strArray = str.split(",");
        //将新建的数组用来存储拆分出来的每个值   String.split 字符串拆分 详解移步链接
        int[] newArray = new int[strArray.length];
        //给数组循环遍历赋值
        for (int i = 0; i < strArray.length; i++) {
            newArray[i] = Integer.parseInt(strArray[i]);
        }
        sort(newArray);
        System.out.println("排序的结果为："+Arrays.toString(newArray));
    }

    public static void sort(int[] newArray){

        //最后一次交换索引（下标）
        int lastSwapIndex = 0;
        //无序数组的边界，每次比较到这里为止
        int arrBoundary = newArray.length-1;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < newArray.length-1; i++) {
            //优化冒泡排序，增加标记位，有序，跳出外层循环，每一轮初始为true
            boolean flag = true;
            //内层循环，比较两个数，如果第一个数大于第二个，则交换位置
            for (int j = 0; j < arrBoundary; j++) {
                if (newArray[j]>newArray[j+1]){
                    //对交换过程中两个元素的方式进行修改
                    newArray[j+1] ^= newArray[j];
                    newArray[j] ^= newArray[j+1];
                    newArray[j+1] ^= newArray[j];
                    //有元素交换，所以不是有序，标记变为false
                    flag = false;
                    //最后一次交换元素的位置
                    lastSwapIndex = j;
                }
            }
            //把最后一次交换元素的位置赋值给无序数组的边界
            arrBoundary = lastSwapIndex;
            //说明内层for循环中，没有交换任何元素，直接跳出外层循环
            if (flag){
                break;
            }
        }
    }
}

稀疏数组

  • 当一个数组大部分元素为0或同一值的数组时，可以使用稀疏数组来保存该数组。
  • 稀疏数组的处理方式是：
  1. 记录数组一共有几行几列，有多少个不同值
  2. 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  • 如下图 ：左边是原始数组，右边是稀疏数组

  • 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。

  • 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。

  • 解决方法：稀疏数组

  • 思路分析：

    • 存盘退出：
    1. 创建二维数组array1
    2. 遍历输出原数组
    3. 转换为稀疏数组保存（I.先得(知道)获取有效值个数II.创建存放稀疏数组的数组array2 III.遍历二维数组，将有效(非零)值存放到前面创建好的数组array2里）
    4. 输出（遍历）稀疏数组
    • 续上盘：
    1. 读取稀疏数组获取原数组行列信息，创建一个与原数组同大小的数组array3
    2. 将稀疏数组中的有效值还原到array3里
    3. 访问数组array3，输出与原数组同样的数组
代码实现：
package com.ruomeng.array;

/**
 * @author 1301450090@qq.com
 * @date 2021/3/27 15:56
 */
public class ArrayDemo16 {
    public static void main(String[] args) {
        //创建一个二维数组array1     11*11     0：没有棋子    1：黑棋     2：白棋
        
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组:");
        //增强for循环遍历二维数组  外层控制行，内层控制列
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        System.out.println("=======================");
        //转换为稀疏数组来保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //创建一个存放稀疏数组的数组Array2  数组的行等于有效值数+数组头的一行  列就三列：行、列、有效值
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的（有效）值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    //第几行，第一列存放它的横坐标
                    array2[count][0] = i;
                    //第几行，第二列存放它的纵坐标
                    array2[count][1] = j;
                    //第几行，第三列存放它的值
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }

        System.out.println("=====================");
        //读取稀疏数组，获取原数组的行和列的信息，创建一个与原数组相同大小的数组array3
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //将稀疏数组中有效值还原到与原数组同大小的数组array3里（还原通过循环和赋值实现）  i为1是因为，不算稀疏数组的头部
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("将稀疏数组还原输出：");
        //打印还原      增强for循环，访问数组array3
            for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

如果我的博客对你有一点点帮助，望请大侠可以给文章点个赞再走，你们的鼓励将是我创作优质内容的动力！

声明：

因个人能力有限，博文中必有不足之处，望学术同仁不吝赐教！一起学习一起进步！

以上内容均为原创，转载请注明出处！

小帆也能远航️
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组的整理
sinat_40775402的博客
06-07 237
有关数组的学习应该不是大家的痛点，但还是希望能够通过小编的整理，让大家理解起来更通俗易懂。希望大家看完后能够持续关注哦！！！
Java数组高级算法与Arrays类常见操作小结【排序、查找】
08-26
本文主要介绍了Java数组高级算法与Arrays类常见操作，结合实例形式总结分析了Java数组常见的排序算法、查找算法相关原理、实现与使用技巧。 一、冒泡排序 冒泡排序是一种简单且常用的排序算法。其原理是通过相邻...
Arrays类的讲解（冒泡排序，稀疏数组转换）
yaoshutong的博客
05-17 137
Arrays类的讲解 数组的工具类Java.util.Arrays 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。 查看JDK帮助文档 Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”） 具有以下常用功能： 给数组赋值：通过fill方法 对数组排序：通过sort方法，按升序 比较数组：通过equals方法比较数组
Day13-01 P56 Java数组06：二维数组 P57Java数组07：Arrays类讲解 P58 Java数组08：冒泡排序 P59 Java数组09：稀疏数组
jackyzhang202212的博客
12-14 82
Day13-01 P56 Java数组06：二维数组 P57Java数组07：Arrays类讲解 P58 Java数组08：冒泡排序 P59 Java数组09：稀疏数组
java-数组的使用，多维数组，Arrays类，稀疏数组等
m0_70880145的博客
08-26 334
数组定义，使用，多维数组，Arrays类基础，稀疏数组等。
Java数组概述及三维数组拓展分析
江南、寻你的博客
03-06 987
Java数组的概述详解，超详细！！！
java 不带下标数组名_第二十二讲——JAVA数组
weixin_36200739的博客
02-24 281
第二十二讲——JAVA数组数组就是相同类型(比如int，byte...)数据的有序集合每一个数据是整个数组中的一个组成元素调用元素，要通过下标来调用(10，11，12，13，14(下标是从0开始第几个就是第n个标))01—数组创建和声明和所有数据一样都需要声明datatype//变量类型 变量名 = 变量值;//int num01 = 1;1—声明datatype//int(long,by...
Java数组知识
weixin_40283803的博客
12-26 121
Java数组 数组概述 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中每一个数据称作一个数组的元素，每个数组元素可以通过一个下标来访问它们（数组的下标是从0开始的） 数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组，其语法为： dataType[] arrayRefVar;//首选的方法 //或者 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法
Java——数组
m0_59800431的博客
02-27 1516
本文主要介绍了基于java编程语言的数组的基础内容,主要包括数组的定义、数组的声明和创建、三种初始化及内存分析、下标越界、数组的使用、二维数组、Arrays类、冒泡排序和稀疏数组的介绍。
五. Java数组
初心不改
06-01 246
1. 什么是数组 数组是相同数据类型数据的有序集合 相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每个数据被称作一个数组元素，每个数组元素可以通过一个下表来访问 2. 数组的声明和创建 首先必须声明数组变量才能在程序中使用数组，语法如下： dataType[] arrayName; //首选写法 或 dataType arrayName[]; //效果相同，但不是首选写法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar =
java数组排序示例(冒泡排序、快速排序、希尔排序、选择排序)
09-04
`qsort`方法展示了快速排序的实现，其中使用了Java内置的`Arrays.sort()`方法，该方法通常采用优化过的快速排序算法。 3. **希尔排序**： 希尔排序是插入排序的一种改进版本，由Donald Shell于1959年提出。它通过...
java的arrays数组排序示例分享
09-04
Java中的`Arrays`类是处理数组的重要工具，它包含了多种操作数组的方法，其中包括排序功能。在Java中，数组排序有两种主要情况：基本数据类型的数组排序和复合数据类型的数组排序。 对于基本数据类型的数组，例如`...
Java多维数组和Arrays类方法总结详解
08-19
Java多维数组和Arrays类方法总结详解 Java多维数组是指数组的元素也是数组，例如二维数组、三维数组等。Java中可以声明多维数组的方式有多种，下面我们将详细介绍。 一、数组的三种声明方式 Java中数组的声明方式...
java数组排序
09-04
冒泡排序是一种直观的排序方法，通过重复遍历数组，每次比较相邻两个元素并根据需要交换它们的位置，使得较大的元素逐渐“浮”到数组的顶端。其核心是两层循环结构，外层控制遍历次数，内层负责相邻元素的比较与交换...
C++ - 函数重载
jiaowenjie的专栏
08-06 311
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1076
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Spring事务
最新发布
c1tenj2的博客
08-07 425
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 387
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
Java对象数组与二维数组详解
"本资源主要讲解了Java中的对象数组和二维数组的概念，包括如何使用数组存储对象、对数组元素进行排序、在排序数组中查找、以及二维数组的应用。此外，还提到了对象数组的初始化方法，包括静态初始化和动态初始化。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值