首页 > 其他分享 >一维数组、多维数组、Array（deepToString sort fill binarySearch）方法2024122620241226

一维数组、多维数组、Array（deepToString sort fill binarySearch）方法2024122620241226

时间：2024-12-26 23:41:05浏览次数：5  
标签：sort Arrays 2024122620241226 System int 数组 println out

数组20241226

[数组详情](深入理解 Java 数组 - 静默虚空 - 博客园)

什么是数组：

数组是相同类型数据的有序集合

  • 注意：必须是相同数据

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成其中,每一个数据称作一个数组元素。

每个数组元素可以通过一个下标来访问它们.

image-20241226164550840
类似创建了一个足球队数组，通过号码来对应球员

数组的内存模型

数组是存储多个相同类型变量的对象。数组的所有元素保存在堆内存中==
•数组创建后立即拥有默认值。
•索引从0开始。

graph LR A[Java内存]==>B[堆] A[Java内存]==>C[栈] A[Java内存]==>D[方法区] B[堆]==>E[存放new的对象和数组] B[堆]==>F[可以被所有的线程共享，不会存放别的对象引用] C[栈]==>G[存放（8种）基本变量类型（会包含这个基本类型变量的具体的值）] C[栈]==>H[引用对象的变量（会存放这个引用在堆里面的具体地址）] D[方法区]==>I[可以被所有的线程共享] D[方法区]==>J[包含了所有的class和static变量]

数组的声明和创建

两种声明方式

  1. 数组类型[] 数组名 //首选这种，第二种是迎合C语言
  2. 数组类型 数组名[]

数组的定义

1.数组类型 [] 数组名 = new 数组类型[数组长度] (常规定义)

int[] numbers01 = new int[10];
float[] numbers02 = new float[5];

2.数组类型 数组名[ ] = {元素1，元素2，…}

int[] number03 ={1,2,4,7,87};
float[] number04 ={1.0,32.3,23.6,7.2}

注意

int[] a;
a = new int[5] ;

等同于

int[] a = new int[5];

数组中的常见异常

// 异常一：数组没有创建
int a[] = null;
a[0] = 1;
System.out.println(a[0]);

输出空指针报错：java.lang.NullPointerException

Exception in thread "main" java.lang.NullPointerException
	at com.pangHuHuStudyJava.arrays.Demo02.main(Demo02.java:6)

// 异常二：下标越界
int a[] = { 1, 2, 3 };
System.out.println(a[3]);

输出数组指针越界！ java.lang.ArrayIndexOutOfBoundsException

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at com.pangHuHuStudyJava.arrays.Demo02.main(Demo02.java:8)

动态初始化（先定义再赋值）第9到第18行

package com.pangHuHuStudyJava.arrays;
import java.sql.SQLOutput;
//数组的创建、计算数组所有元素之和
public class Demo01 {
public static void main(String[] args) {
  int[] numbers01;
  numbers01 = new int[10];//定义数组  //等于 int[]  numbers01=new int[10];
  //给数组赋值  动态初始化
  numbers01[0] = 1;
  numbers01[1] = 2;
  numbers01[2] = 3;
  numbers01[3] = 4;
  numbers01[4] = 5;
  numbers01[5] = 6;
  numbers01[6] = 7;
  numbers01[7] = 8;
  numbers01[8] = 9;
  numbers01[9] = 10;//直接赋值
  //用array.length 来输出下数组的最大值和求和
  float[] numbers02 = new float[5];定义数组  //等于 int[]  numbers01=new int[10];
  double[] numbers03 = {12.2,3.2,5.2,312.3,2,23.2,332.2,4455.2};//直接定义
  double max=0;//请一定注意 局部变量在使用前无比赋明确的初值
  double sum=0 ;//请一定注意 局部变量在使用前无比赋明确的初值
  for (int i = 0; i < numbers03.length; i++) {
      max = numbers03[i];
      sum += numbers03[i];
      if(max < numbers03[i]){
          max=numbers03[i];
      }
  }
  System.out.println("数组三的最大值："+max);
  System.out.println("数组三的和："+sum);
}
}

输出：

数组三的最大值：4455.2
数组三的和：5145.5

数组的三种初始化方式

1.静态初始化：

int[] number03 ={1,2,4,7,87};
float[] number04 ={1.0,32.3,23.6,7.2}

2.动态初始化（包含默认初始化）

int[]  numbers01=new int[10];
  //给数组赋值  动态初始化
  numbers01[0] = 1;
  numbers01[1] = 2;
  numbers01[2] = 3;
  numbers01[3] = 4;
  numbers01[4] = 5;
  numbers01[5] = 6;

数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中的。

数组的边界

下标的合法区间：[0，length-1] 如果越界就会报错 java.lang.ArrayIndexOutOfBoundsException

◆小结:
数组是相同数据类型(数据类型可以为任意类型)的有序集合数组也是对象。
数组元素相当于对象的成员变量
数组长度的确定的，不可变的。如果越界，则报:ArrayIndexOutofBounds

数组的使用

1.简单for +array.length

2.增强型for循环 实现一个数组翻转

package com.pangHuHuStudyJava.arrays;
import java.util.Arrays;
// 数组的使用：增强型 for 循环
// 本程序实现了数组的反转，并打印原始数组和反转后的数组
public class Demo03 {
 public static void main(String[] args) {
     // 定义一个数组并静态初始化
     int[] numbers = {7, 3, 6, 11, 43, 1, 10, 4, 21, 10}; 
     // 获取数组的长度
     int count = numbers.length; 
     // 定义一个新的数组，用于存储反转后的数组
     int[] numberCopy = new int[count]; 
     // 使用 for 循环将原数组的元素从后往前赋值到新数组中
     for (int i = 0; i < count; i++) {
         numberCopy[i] = numbers[count - i - 1]; 
     }
     // 输出原始数组的元素
     System.out.println("原始数组的元素为："); 
     for (int number : numbers) { // 使用增强型 for 循环遍历数组
         System.out.print(number + " "); 
     }
     // 输出反转后的数组元素
     System.out.println("\n反转后数组的元素为："); 
     for (int number : numberCopy) { // 使用增强型 for 循环遍历反转后的数组
         System.out.print(number + " "); 
     }
 }
}

如果需要更简洁的方式，可以直接使用Arrays.toString()打印数组内容：

System.out.println("原始数组的元素为：" + Arrays.toString(numbers));
System.out.println("反转后数组的元素为：" + Arrays.toString(numberCopy));

这会直接将数组的所有元素以字符串形式输出，例如：

原始数组的元素为：[7, 3, 6, 11, 43, 1, 10, 4, 21, 10]
反转后数组的元素为：[10, 21, 4, 10, 1, 43, 11, 6, 3, 7]
改进下：做一个函数封装，这里涉及一个数组的返回，C有一个返回的数组名（数组的地址）
package com.pangHuHuStudyJava.arrays;
// 对 Demo03 的功能进行函数封装，增加代码复用性
// 本程序实现了数组反转功能，并通过函数返回反转后的数组
public class Demo04 {
    public static void main(String[] args) {
        // 定义一个数组并静态初始化
        int[] numbers = {7, 3, 6, 11, 43, 1, 10, 4, 21, 10};

        // 调用封装好的函数 arrayFlip 对数组进行反转，并打印反转后的数组元素
        for (int i : arrayFlip(numbers)) { // 直接使用增强型 for 循环输出反转结果
            System.out.print(i + " ");
        }
    }
    /**
     * 定义一个静态方法，用于反转数组
     *
     * @param array 传入的整型数组
     * @return 返回反转后的数组
     */
    public static int[] arrayFlip(int[] array) {
        // 获取数组长度
        int count = array.length;
        // 创建一个新数组用于存放反转结果
        int[] result = new int[count];
        // 使用循环将原数组从后往前赋值到新数组中
        for (int i = 0; i < count; i++) {
            result[i] = array[count - 1 - i];
        }
        // 返回反转后的数组
        return result;
    }
}
chatgpt 改进：

减少不必要的数组复制

如果允许直接修改原数组，可以省去创建新数组的开销： 注意这里直接把原数组翻转！！！

public static void arrayFlipInPlace(int[] array) {
    int left = 0,;
    int right = array.length - 1;
    while (left < right) {
        int temp = array[left];
        array[left] = array[right];
        array[right] = temp;
        left++;
        right--;
    }
    return array;
}

多维数组、Array（sort fill binarySearch）方法20241226

多维数组定义、赋值、理解

二维数组定义与初始化：

  • 动态初始化：先定义数组大小，然后逐个赋值。
  • 静态初始化：直接定义并赋值，适用于已知数据的场景。

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组

int\[][] a[][]= new int\[2][5];

理解：

image-20241226210758092

三维数组 numbers02[2][6][5]

未命名文件

遍历二维数组：

  • 增强 for 循环：适合简单遍历，不关心索引时使用。
  • 标准 for 循环：适合需要操作索引或灵活控制遍历时使用。

使用 Arrays.toString()：

  • Arrays.toString(array) 用于将一维数组转换为字符串格式，方便输出。
package com.pangHuHuStudyJava.arrays;
import java.util.Arrays; // 引入 Arrays 工具类
// 多维数组的定义、赋值与展示，使用增强 for 循环和标准 for 循环
public class Demo05 {
 public static void main(String[] args) {
     // 定义一个 2x2 的二维数组，并动态初始化
     int[][] numbers = new int[2][2]; 
     numbers[0][0] = 1; // 为二维数组的第 0 行第 0 列赋值
     numbers[0][1] = 2; // 为二维数组的第 0 行第 1 列赋值
     numbers[1][0] = 3; // 为二维数组的第 1 行第 0 列赋值
     numbers[1][1] = 4; // 为二维数组的第 1 行第 1 列赋值
     // 使用静态初始化方式定义一个二维数组
     int[][] numbers02 = {{1, 2, 5}, {3, 4, 6}};
     // 增强 for 循环遍历二维数组
     System.out.println("增强 for 循环遍历二维数组");
     for (int[] ints : numbers02) { // 遍历每一行
         for (int anInt : ints) { // 遍历当前行的每个元素
             System.out.print(anInt + " "); // 输出当前元素
         }
         System.out.println(); // 换行
     }
     System.out.println("=========================");
     // 标准 for 循环遍历二维数组
     System.out.println("标准 for 循环遍历二维数组");
     for (int i = 0; i < numbers02.length; i++) { // 遍历每一行
         for (int j = 0; j < numbers02[i].length; j++) { // 遍历当前行的每个元素
             System.out.print(numbers02[i][j] + " "); // 输出当前元素
         }
         System.out.println(); // 换行
     }
     System.out.println("=============");
     // 使用 Arrays 类中的方法将二维数组的每一行转换为字符串
     System.out.println("使用 Arrays 类中的方法实现 toString");
     for (int i = 0; i < numbers02.length; i++) { 
         System.out.print(Arrays.toString(numbers02[i]) + " "); // 将当前行转为字符串并输出
         System.out.println(); // 换行
     }
 }
}

增强 for 循环遍历二维数组
1 2 5 
3 4 6 
=========================
标准 for 循环遍历二维数组
1 2 5 
3 4 6 
=============
使用 Arrays 类中的方法实现 toString
[1, 2, 5] 
[3, 4, 6]

掌握 Arrays 工具类的常用方法，如 toString() 和 deepToString()（用于打印多维数组）。

Arrays.deepToString()是 Java 提供的一个工具方法，用于将多维数组的内容转换为字符串格式。与Arrays.toString()不同，它可以处理多维数组，并递归地对所有嵌套数组进行字符串化。

public static String deepToString(Object[] array)

功能

  • 将多维数组的每个元素（包括嵌套的数组）转换为字符串。
  • 生成的字符串格式类似于嵌套的方括号结构 [[], []]，表示数组的层级。

与 toString() 的区别

  1. Arrays.toString()：
    • 仅支持一维数组。
    • 如果传入多维数组，会直接输出对象的内存地址，如 [I@5e91993f。
  2. Arrays.deepToString()：
    • 支持多维数组。
    • 递归遍历所有嵌套数组，输出层级结构。

示例对比：

int[][] numbers = {{1, 2, 3}, {4, 5, 6}};
System.out.println(Arrays.toString(numbers));       // 输出：[[I@5e91993f, [I@1c4af82c]
System.out.println(Arrays.deepToString(numbers));  // 输出：[[1, 2, 3], [4, 5, 6]]

作业：

◆ 具有以下常用功能:
给数组赋值:通过 fill方法。
对数组排序:通过 sort 方法,按升序。
比较数组:通过 equals 方法比较数组中元素值是否相等
deepToString()将多维数组的每个元素（包括嵌套的数组）转换为字符串。

◆查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

package com.pangHuHuStudyJava.arrays;
import java.util.Arrays;
//熟悉Arrays类各种方法：deepToString, fill, sort, equals, binarySearch
//重点演示：deepToString 将多维数组的每个元素（包括嵌套的数组）转换为字符串，生成的字符串格式类似于嵌套的方括号结构 `[[], []]`
public class Demo06 {
 public static void main(String[] args) {
     // 使用 deepToString 方法输出二维数组
     System.out.println("deepToString 输出二维数组：");
     // 定义一个二维数组 numbers[3][3]
     int[][] numbers = {
         {1, 2, 3}, 
         {4, 5, 6}, 
         {7, 8, 9}
     };
     // 打印二维数组的内容
     System.out.println(Arrays.deepToString(numbers));

     // 定义一个三维数组 numbers02[2][3][5]
     int[][][] numbers02 = {
         {
             {4, 2, 4, 5, 6},
             {12, 3, 5, -2, 4},
             {23, 32, 5, 45, 65}
         },
         {
             {1, 2, 3, 4, 5},
             {6, 7, 8, 9, 10},
             {11, 12, 13, 14, 15}
         }
     };
     // 使用 deepToString 方法输出三维数组
     System.out.println("deepToString 输出三维数组：");
     System.out.println(Arrays.deepToString(numbers02));
 }
}

deepToString 输出二维数组：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
deepToString 输出三维数组：
[[[4, 2, 4, 5, 6], [12, 3, 5, -2, 4], [23, 32, 5, 45, 65]], [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]]

Arrays.sort方法

package com.pangHuHuStudyJava.arrays;
import java.util.Arrays;
//熟悉Arrays中的方法 fill sort
public class Demon07 {
    public static void main(String[] args) {
        int[] numbers = {2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65};
        System.out.println("原始数组：" + Arrays.toString(numbers));
        Arrays.sort(numbers);
        System.out.println("排序(正序)后数组：" + Arrays.toString(numbers));
        //倒序有点问题  要用到自定义比较器
        /*   Integer[] array = {1, 3, 2, 5, 4};//这里使用的是 Integer[]，而不是 int[]，因为 Comparator 只支持对象类型
        // 使用自定义比较器实现倒序
        Arrays.sort(array, (a, b) -> b - a);*/
        //所以我自己再写一个倒序（正序再翻转就行了）
        arrayReverse(numbers);
        //正序后再翻转，实现倒序
        System.out.println("排序(倒序)后数组：" + Arrays.toString(numbers));
    }
    public static void arrayReverse(int[] array){//这种方法时间复杂度为 O(n)O(n)O(n)，空间复杂度为 O(1)O(1)O(1)，非常高效。
        int left=0;
        int right= array.length-1;
        while(left<right){
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            left++;
            right--;
        }
    }
}

输出结果：

原始数组：[2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65]
排序(正序)后数组：[-234, -23, 2, 3, 5, 10, 12, 65, 76, 231, 435]
排序(倒序)后数组：[435, 231, 76, 65, 12, 10, 5, 3, 2, -23, -234]

Array.fill方法

package com.pangHuHuStudyJava.arrays;
import java.util.Arrays;
public class Demo08 {
    public static void main(String[] args) {
        // 示例 1：整体填充
        int[] array1 = {2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65};
        System.out.println("原始数组 array1：" + Arrays.toString(array1));
        // 将整个数组填充为 0
        Arrays.fill(array1, 0);
        System.out.println("执行 Arrays.fill(array1, 0) 后的数组：" + Arrays.toString(array1));
        System.out.println("------------------------------------------------");
        // 示例 2：部分区间填充
        int[] array2 = {2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65};
        System.out.println("原始数组 array2：" + Arrays.toString(array2));
        // 填充区间 [1, 4) 的元素为 666
        Arrays.fill(array2, 1, 4, 666);
        System.out.println("执行 Arrays.fill(array2, 1, 4, 666) 后的数组：" + Arrays.toString(array2));
    }
}

输出结果：

原始数组 array1：[2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65]
执行 Arrays.fill(array1, 0) 后的数组：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
------------------------------------------------
原始数组 array2：[2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65]
执行 Arrays.fill(array2, 1, 4, 666) 后的数组：[2, 666, 666, 666, -23, 3, 76, 231, 435, -234, 65]

Arrays.binarySearch方法

package com.pangHuHuStudyJava.arrays;
import java.util.Arrays;
// 使用 binarySearch 方法查找数组中的数
public class Demo09 {
    public static void main(String[] args) {
        int[] numbers = {2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65};
        System.out.println("原始数组：" + Arrays.toString(numbers));
        // 在查找之前必须排序数组
        Arrays.sort(numbers);
        System.out.println("排序后的数组：" + Arrays.toString(numbers));
        // 查找数值 5 的位置
        int[] target ={-666,4,10000};
        calbinarySearch(numbers,target);
    }
    public static void calbinarySearch(int[] array,int[] target) {
        //请确保 传入的array 是排好序的数组
        for (int i : target) {
            int result = Arrays.binarySearch(array, i);
            if (result >= 0) {
                System.out.println("数值 " + i + " 在数组中的索引为：" + result);
            } else {
                System.out.println("数值 " + i + " 不存在，返回值为：" + result);
                int insertionPoint = -(result + 1);
                System.out.println("如果插入，数值 " + i + " 应插入到索引位置：" + insertionPoint);
            }
        }

    }
}

原始数组：[2, 5, 10, 12, -23, 3, 76, 231, 435, -234, 65]
排序后的数组：[-234, -23, 2, 3, 5, 10, 12, 65, 76, 231, 435]
数值 -666 不存在，返回值为：-1
如果插入，数值 -666 应插入到索引位置：0
数值 4 不存在，返回值为：-5
如果插入，数值 4 应插入到索引位置：4
数值 10000 不存在，返回值为：-12
如果插入，数值 10000 应插入到索引位置：11

标签：sort,Arrays,2024122620241226,System,int,数组,println,out
From： https://www.cnblogs.com/panghuhu-space/p/18634401

相关文章

  • C中链表与数组的比较方法是什么？
    C中链表与数组的比较方法在C语言中，链表和数组是两种常用的数据结构，它们在数据存储和访问上各有优势。下面将详细比较这两种数据结构，并给出示例代码。1.内存分配「数组」：数组在内存中占用连续空间，所有元素按顺序排列。这种连续性使得数组的内存分配和访问非常高效。「链表」......
  • 多种实现数组去重的方法:适用场景和特点
    ......
  • 二维数组作函数参数的三种方式
    二维数组作函数参数的三种方式前言二维数组作函数参数的本质都是传递数组的首地址，但是具体的写法有3种，例子如下：voidwork1(int[][C])voidwork2(int(*)[C])voidwork3(int*)讲解第一种和第二种都可以自动计算索引，也就是可以使用下标[]去访问数组，而第三种不可以。第......
  • 二维数组 手动排序
    <template><div><el-dialogv-bind="$attrs"v-on="$listeners"@open="onOpen"@close="onClose":title="title"width="800px">......
  • LeetCode 2605 从两个数字数组里生成最小数字
    探寻两个数组数位关联下的最小数字问题题目描述给定两个只包含1到9之间数字的数组 nums1 和 nums2，并且每个数组中的元素都是互不相同的。我们需要返回最小的数字，要求这个数字满足两个数组都至少包含这个数字的某个数位。例如，若 nums1=[4,1,3]，nums2=[5,7]，那么......
  • 写一个js方法将字符串数组与数字数组互转
    在前端开发中，有时需要将字符串数组转换为数字数组，或者将数字数组转换为字符串数组。以下是一个简单的JavaScript方法，用于实现这两种转换：//将字符串数组转换为数字数组functionstringArrayToNumberArray(stringArray){returnstringArray.map(item=>{constnumber=......
  • JavaScript中的数组和函数在内存分别是如何存储的？
    在JavaScript中，数组和函数在内存中的存储方式涉及到JavaScript的内存管理机制，特别是堆（Heap）和栈（Stack）的使用。虽然这些概念在底层实现上可能因JavaScript引擎（如V8，SpiderMonkey等）的不同而有所差异，但我们可以从一个高层次的视角来理解它们。1.数组在内存中的存储数组在JavaScript......
  • LeetCode 209. 长度最小的子数组 (C++实现)
    1.题目描述给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其总和大于等于target的长度最小的子数组[numsl,numsl+1,…,numsr-1,numsr]，并返回其长度。如果不存在符合条件的子数组，返回0。示例1：输入：target=7,nums=[2,3,1,2,4,3]......
  • 【C/C++】字符数组和string字符串：从C语言到C++的演变
    字符数组和string字符串：从C语言到C++的演变在C语言和C++的编程中，字符数组和字符串（string）是非常重要的基础数据类型。它们在实际编程中常用于存储和操作文本数据，但是这两种类型的处理方式有所不同。在这篇博客中，我们将详细讲解字符数组和string字符串，从C语言的字符数组到C++......
  • 数组移除元素
    27.移除元素-力扣（LeetCode）26.删除有序数组中的重复项-力扣（LeetCode）283.移动零(opensnewwindow)844.比较含退格的字符串(opensnewwindow)977.有序数组的平方(opensnewwindow)暴力枚举intremoveElement(vector<int>&nums,intval){ intlen=nums.size();......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99