Java中的数组

数组

定义

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成的
  • 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们

声明和创建

首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法

java 复制代码
dataType[] arrayRefVar;	//首选的方法
或
dataType arrayRefVar[];	//效果相同,但不是首选方法
//Java语言使用new操作符来创建数组,语法如下:
dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的,数组索引从0开始

获取数组长度

java 复制代码
arrays.length
java 复制代码
package com.kuang.array;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-01 2:10
 */
public class ArrayDemo01 {
    //变量的类型 变量的名字   =   变量的值
    //数组类型
    public static void main(String[] args) {
        int[] nums; //1.声明一个数组
//        int nums2[];
        nums = new int[10]; //2.创建一个数组

        int[] nums2 = new int[10];

        //3.给数组元素中赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        //计算所有元素的和
        int sum=0;
        
        //获取数组长度:arrays.length
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
        }
        System.out.println("总和为:"+sum);
        //数组下标越界错误
        System.out.println(nums[10]);   //java.lang.ArrayIndexOutOfBoundsException: 10
    }
}



三种初始化状态

静态初始化

java 复制代码
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,3)};

动态初始化

java 复制代码
int[] a = new int[2];
a[0]=1;
a[1]=2;

数组的默认初始化

数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点

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

数组边界

下标的合法区间:[0,length-1],如果越界就会报错;

java 复制代码
public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);	java.lang.ArrayIndexOutOfBoundsException: 数组下标越界异常
}
小结
  • 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度是确定的,不可改变的。如果越界,则报:java.lang.ArrayIndexOutOfBoundsException:

数组的使用

普通for循环

java 复制代码
package com.kuang.array;

import org.omg.CORBA.ARG_OUT;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-01 3:30
 */
public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("=============");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("=============");
        //查找最大元素
        int max=arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

增强for循环

  • 普通的for循环
  • For-Each循环
  • 数组作方法入参
  • 数组作返回值
java 复制代码
package com.kuang.array;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-01 3:35
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //增强for循环
        //JDK1.5,没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
        //打印数组元素
        printArray(arrays);
        int[] reverse = reverse(arrays);
        System.out.println();
        printArray(reverse);

    }
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"");
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];
        //反转的操作
        for (int i = 0,j= result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

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

二维数组

java 复制代码
int a[][] = new int[2][5];	//可以看成一个两行五列的数组


java 复制代码
package com.kuang.array;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-02 2:31
 */
public class ArrayDemo05 {
    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}};
        System.out.println(array[0]);
        printArray(array[0]);
        System.out.println(array[0][0]);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"");
        }
    }
}

Arrays类

  • 数组的工具类java.util.Arrays
  • 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作
  • 查看JDK帮助文档
  • Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是'不用'而不是"不能")
  • 具有以下功能
    • 给数组赋值:通过fill方法
    • 对数组排序:通过sort方法,按升序
    • 比较数组:通过equals方法比较数组中元素值是否相等。
    • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作
java 复制代码
package com.kuang.array;

import java.util.Arrays;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-02 3:04
 */
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9090,31231,543,21,3,23};
        System.out.println(a);  //[I@1b6d3586
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printArray(a);
        Arrays.sort(a); //数组进行排序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0);   //数组填充
        printArray(a);
        Arrays.fill(a,2,4,1);   //数组填充  // [2,4)=>2,3
        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]+", ");
            }
        }
        System.out.println();
    }
}

冒泡排序

  • 冒泡排序无疑是最为出名的排序算法之一,总共有八大排序
  • 冒泡排序的代码还是相当简单的,两层循环,外层冒泡轮数,内层依次比较,人尽皆知。
  • 我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n^2)
  • 如何优化?
java 复制代码
package com.kuang.array;

import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-02 3:27
 */
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,7,8,2,1,3,5,4,6,8};

        int[] sort=sort(a); // 调用完我们自己写的排序算法以后,返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }
    // 冒泡排序
    // 1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
    // 2.每一次比较都会产生出一个最大或者最小的数字
    // 3.下一轮则可以少一次排序
    // 4.依次循环,直到结束
    public static int[] sort(int[] array){
        // 临时变量
        int temp = 0;
        // 外层循环,判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {
            boolean flag = false;   // 通过flag标志位较少没有意义的比较
            // 内层循环,比较判断两个数,如果第一个数,比第二个数大,则交换位置
            for (int j = 0; j <array.length-1-i; j++) {
                if(array[j+1]>array[j]){    // 从大到小排序
//                if(array[j+1]<array[j]){    // 从小到大排序
                    temp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

需求:编写五子棋游戏中,有存盘退出和续上盘的功能

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

解决:稀疏数组

稀疏数组介绍

  • 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组
  • 稀疏数组的处理方式是:
    • 记录数组一共有几行几列,有多少个不同值
    • 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
  • 如下图:左边是原始数组,右边是稀疏数组
java 复制代码
package com.kuang.array;

/**
 * @version:java version 1.8
 * @Author:Mr Cao
 * @Description:
 * @Date:2024-02-02 4:03
 */
public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11  0:没有棋子,1:黑棋,2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        // 输出原始数组
        System.out.println("输出原始数组");
        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 < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数:"+sum);
        // 2.创建一个稀疏数组
        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("=============");
        System.out.println("还原");
        //还原
        // 1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        // 2.给其中的元素还原他的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        // 3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}
相关推荐
hqxstudying14 分钟前
Java创建型模式---原型模式
java·开发语言·设计模式·代码规范
Dcs33 分钟前
VSCode等多款主流 IDE 爆出安全漏洞!插件“伪装认证”可执行恶意命令!
java
保持学习ing39 分钟前
day1--项目搭建and内容管理模块
java·数据库·后端·docker·虚拟机
京东云开发者1 小时前
Java的SPI机制详解
java
超级小忍1 小时前
服务端向客户端主动推送数据的几种方法(Spring Boot 环境)
java·spring boot·后端
程序无bug1 小时前
Spring IoC注解式开发无敌详细(细节丰富)
java·后端
小莫分享1 小时前
Java Lombok 入门
java
程序无bug1 小时前
Spring 对于事务上的应用的详细说明
java·后端
食亨技术团队1 小时前
被忽略的 SAAS 生命线:操作日志有多重要
java·后端
苦学编程的谢2 小时前
Maven
java·maven·intellij-idea