欢迎光临
我们一直在努力
        找回密码
当前位置：171主机测评 > 服务器技术 > 正文

Java基础学习——数组

2026-03-15 分类：服务器技术 阅读(26) 评论(0)

数组

  • 定义：数组是相同类型数据的有序集合。可以通过下标来访问数组元素。

  • 数组的声明：

  • 数据类型[ ] 数组名；//首选的方法

  • 数据类型 数组名[ ] ；

  • Java使用new操作符来创建数组：

    • dataType[] arrayRefVar = new dataType[arraySize];

  • 数组的元素通过索引访问的，索引从0开始。

  • 获取数组长度： arrays.length

  • 数组的四个基本特点：

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

  • 数组下标：下标的合法区间：[0,length-1]，如果越界会报错；ArrayIndexOutOfBoundsException:数组下标越界异常！

数组的三种初始化

  • 静态初始化

//静态初始化：创建+赋值
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

  • 动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

    • 数组的默认初始化:在动态初始化中，当创建数组后，未赋值的元素默认为0(int)、null(String)。

数组的使用

  • 普通for循环

public class arrayDemo01 {
   public static void main(String[] args) {
       //遍历数组
       int[] a = {1,3,4,3,7};
       for(int i=0;i<a.length;i++){
           System.out.print(a[i] + " ");
      }
  }
}

  • 增强for循环(for-each)

public class arrayDemo01 {
   public static void main(String[] args) {
       //遍历数组
       int[] a = {1,3,4,3,7};
        for(int array:a){
           System.out.print(array + " ");
      }
  }
}

  • 数组作为方法入参

public class arrayDemo01 {
   public static void main(String[] args) {
       int[] a = {1,3,4,3,7};
       print(a);
  }
   public static void print(int[] a){
       int sum = 0;
       for (int i = 0; i < a.length; i++) {
           sum += a[i];
      }
       System.out.print(sum);
  }
}

  • 数组作返回值

public class arrayDemo01 {
   public static void main(String[] args) {
       int[] a = {1,3,4,3,7};
       int[] array = reverse(a);
       for (int i = 0; i < array.length; i++) {
           System.out.println(array[i]);
      }
  }
//数组反转
   public static int[] reverse(int[] a){
       int[] result = new int[a.length];
       for(int i=0,j = a.length-1;i<a.length;i++,j–){
           result[j] = a[i];
      }
       return result;
  }
​
}
//注意：定义方法时要设置返回值为数组类型(int[]，double[]····)

二维数组

  • 定义：二维数组是一种特殊的一维数组。相当于一个数组中嵌套着另一个数组。索引都从0开始。

int[][] array = {{1,2},{2,3},{3,4}};
//array[0],array[1],array[2]是一个数组，而array[0][1],array[1][0]····是一个元素。如：array[0][0]是1；array[1][1]是3。

  • 遍历二维数组

public class arrayDemo02 {
   public static void main(String[] args) {
       //遍历二维数组
       int[][] array = {{1,2},{2,3},{3,4}};
       for (int i = 0; i < array.length; i++) {
           for(int j=0;j<array[i].length;j++){
               System.out.println(array[i][j]);
          }
      }
  }
}

Arrays讲解

Arrays类中有许多的工具可以使用，但并非完全依赖工具。

  • 打印数组

import java.util.Arrays;
​
public class arrayDemo03 {
   public static void main(String[] args) {
       int[] a = {1,3,4,3,7};
       System.out.println(Arrays.toString(a));
  }
}
//通过引入Arrays的导包来利用toString方法来打印数组。

  • 数组排序

import java.util.Arrays;
​
public class arrayDemo03 {
   public static void main(String[] args) {
       int[] a = {1,3,4,3,7};
       Arrays.sort(a);
       System.out.println(Arrays.toString(a));
  }
}

总结

  • 查看JDK帮助文档

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

  • 具有以下常用功能: 给数组赋值：通过 fill 方法。 对数组排序：通过sort方法,按升序。 比较数组：通过equals方法比较数组中元素值是否相等。 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

冒泡排序(重点)

  • 冒泡排序:是最为出名的排序算法之一，总共有八大排序。时间复杂度为：O(n2)。

  • 冒泡排序原理：两层循环，外层冒泡轮数，里层依次比较。

    //冒泡排序
    //1.比较数组中，两个相邻的元素， 如果第一个数比第二个数大,我们就交换他们的位置
    //2.每一次比较，都会产生出一个最大，或者最小的数字；
    //3.下一轮则可以少一次排序!
    //4.依次循环,直到结束!

    import java.util.Arrays;
    ​
    public class arrayDemo05 {
       public static void main(String[] args) {
           int[] array = {12,43,1,54,75,2,4,76};
           int[] result = sort(array);
           System.out.println(Arrays.toString(result));
      }
       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; j++) {
                   //如果第一个数比第二个数大，那么交换位置
                   if (array[j] > array[j + 1]) {
                       temp = array[j];
                       array[j] = array[j + 1];
                       array[j + 1] = temp;
                  }
              }
          }
           return array;
      }
    }
    ​

  • 思考：如何优化？

import java.util.Arrays;
​
public class arrayDemo05 {
   public static void main(String[] args) {
       int[] array = {12,43,1,54,75,2,4,76};
       int[] result = sort(array);
       System.out.println(Arrays.toString(result));
  }
   public static int[] sort(int[] array){
       int temp = 0;
       //外层循环用来判读我们需要循环多少次
       for (int i = 0; i < array.length-1; i++) {
           //优化：通过设立一个标志，判断是否有进入比较，如果没有，说明数组已排序，直接跳出循环。
           boolean flag = false;
           //内存循环用来寻找元素来依次进行比较
           for (int j = 0; j < array.length-1; j++) {
               //如果第一个数比第二个数大，那么交换位置
               if (array[j] > array[j + 1]) {
                   temp = array[j];
                   array[j] = array[j + 1];
                   array[j + 1] = temp;
                   flag = true;
              }
          }
           if(flag == false){
               break;
          }
      }
​
       return array;
  }
}
​

注：一定要理解冒泡排序的原理！！！

稀疏数组

  • 作用：当一个数组的大部分值都为0，或者都为同一个值时，就可以用稀疏数组来记录这个数组，从而缩小程序的规模。

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

  • 用法：

    • 稀疏数组只有3列，分别是：行，列，值。

    • 稀疏数组的第一行来记录数组有多少行和多少列和有效值的个数。

    • 从第二行开始用来记录有效值的横纵坐标，以及值。

  • 创建普通数组、遍历数组、转换为稀疏数组、还原数组：

public class arrayDemo04 {
   public static void main(String[] args) {
       //创建数组 //五子棋
       int[][] array = new int[11][11];
       array[1][2] = 1;
       array[2][3] = 2;
       for(int[] arr:array){
           for(int ar:arr){
               System.out.print(ar+"\\t");
          }
           System.out.println();
      }
       //创建稀疏数组
       //首先获取有效数值的个数
       int sum = 0;
       for(int[] arr:array){
           for(int ar:arr){
               if(ar!=0){
                   sum+=1;
              }
          }
      }
       System.out.println("有效数值个数为："+sum);
​
       //创建稀疏数组
       int[][] array1 = new int[sum+1][3];//难点
       array1[0][0] = 11;
       array1[0][1] = 11;
       array1[0][2] = sum;
       int count = 0;
       for(int i = 0;i<array.length;i++){
           for(int j = 0;j<array[i].length;j++){
               if(array[i][j]!=0){
                   //难点
                   count += 1;
                   array1[count][0] = i;
                   array1[count][1] = j;
                   array1[count][2] = array[i][j];
              }
          }
      }
       for (int i = 0; i < array1.length; i++) {
           System.out.println(array1[i][0]+"\\t"+array1[i][1]+"\\t"+array1[i][2]+"\\t");
      }
       //输出原始数组
       int[][] array2 = new int[array1[0][0]][array1[0][1]];
       for (int i = 1; i < array1.length; i++) {
               array2[array1[i][0]][array1[i][1]] = array1[i][2];//难点
      }
       for(int[] arr:array2){
           for(int ar:arr){
               System.out.print(ar+"\\t");
          }
           System.out.println();
      }
  }
}
​

注意：

  • 在转换为稀疏数组时，在遍历当中设一个count来记录是第几个有效值，从而来充当稀疏数组的横坐标。

  • 在输出原始数组时，要理解好稀疏数组的规则，利用原理来进行赋值输出

  • 弄清需遍历哪个数组

    • 赞(0)
    未经允许不得转载：171主机测评 » Java基础学习——数组
    分享到： 更多 (0)
    标签：

    相关推荐

    评论 抢沙发

    取消

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址

    热门标签

    #人工智能(57763)#python(19684)#开发语言(16563)#java(15201)#运维(15139)#linux(14768)#大数据(14335)#服务器(12894)#算法(11605)#前端(10683)#网络(9208)#数据库(8747)#ai(8639)#c++(8043)#课程设计(6758)#学习(6632)#机器学习(6607)#区块链(5837)#OpenClaw(5376)#后端(5056)#spring boot(4954)#深度学习(4840)#c语言(4324)#毕业设计(4276)#数据结构(4143)#安全(3944)#docker(3889)#架构(3766)#javascript(3761)#大模型(3593)

    热门文章

    最新文章

    归档

    分类