【01 Java 语言基础：8. 数组】

江桥诗

已于 2022-03-02 17:57:56 修改

阅读量721

点赞数 1

分类专栏： Java SE 文章标签： java 排序算法算法

于 2022-02-26 13:47:49 首次发布

本文链接：https://blog.csdn.net/weixin_50707328/article/details/123148804

版权

Java SE 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

文章目录

- 8. 数组

8. 数组

8.1 一维数组

格式：数据类型[] 数组名称=new 数据类型[数组长度]

1）概念和特点

**概念：**是一种容器，可以同时存放多个数据值；

特点：

数组是一种引用数据类型
数组当中的多个数据，类型必须统一
数组的长度在程序运行期间不可改变

2）数组的使用

public class ArrayTest{
    public static void main(String[] args) {
        //1.声明一个长度为2，类型为int的数组
        //int arr[]=new int[2];		//两种声明方式从结果上来说没有区别，C语言和C++上是这样声明的
        int[] arr=new int[2];		//推荐使用这种，提高了代码的可读性
        
        //2.打印输出数组的长度和元素
        System.out.println("数组的长度为："+arr.length);	//2；下标是从0~1
        System.out.println("下标为0的元素是："+arr[0]);		//0		数组的下标是0~本身减1
        System.out.println("下标为1的元素是："+arr[1]);		//0		int默认值是0
//System.out.println("下标为1的元素是："+arr[1]);//编译ok，运行出现数组索引越界异常：ArryIndexOutOfBoundsException
        
        //3.使用for循环打印数组的元素
        for(int i=0;i<arr.length;i++) {
            System.out.println("下标为："+i+"的元素是："+arr[i]);
        }
    }
}

3）数组的初始化

基本类型的数组（数据元素为基本类型）创建后，

元素的初始值：

byte、short、char、int、long为0；

float和double为0.0；

boolean为false;

String为null;

格式：

**动态：**数据类型[] 数组名称 = new 数据类型 [数组长度]；

int[] arrayA = new int[300];	///创建一个数组，里面可以存放300个int数据

静态：

标准格式：数据类型[] 数组名称 = new 数据类型 [] {元素1,元素2…}；

int[] arrayA = new int[]{5, 15, 25};	//直接创建一个数组，全是int数据（5，15，25）

省略格式：数据类型[] 数组名称 ={元素1,元素2…}；

 String[] arrayB = new String[] {"Hello", "Java", "World"};	//直接创建一个数组，全是字符串（Hello，Java，World）

8.2 数组原理内存图

1）内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

2）Java虚拟机的内存划分

区域名称	作用
寄存器	给cpu使用，与开发无关
本地方法栈	JVM使用操作系统功能时使用，和开发无关
方法区	存储class相关信息，包含方法的信息
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
栈内存	存放的都是方法中的局部变量；方法的运行一定要在栈中运行。

流程：

main方法进入方法栈执行。
创建数组，JVM会在堆内存中开辟空间，存储数组。
数组在内存中会有自己的内存地址，以十六进制表示。
JVM将数组的内存地址赋值给引用类型变量。
变量保存的是数组内存中的地址，而不是一个具体的数值，因此被称为引用数据类型。

8.3 数组的增删改查

• 声明一个长度为5元素类型为int类型的一维数组，打印数组中所有元素值；

public class ArrayOpTest {
    public static void main(String[] args) {
        //声明
        int[] arr=new int[5];
        //打印
        System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }
    }
}

• 使用元素11、22、33、44分别对数组中前四个元素赋值后再次打印；

System.out.println();
//接上

//方式一
System.out.print("数组中的元素有：");
arr[0]=11;
arr[1]=22;
arr[2]=33;
arr[3]=44;
for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }

//方式二
//先赋值
for(int i=0;i<arr.length-1;i++) {
    arr[i]=(i+1)*11;
}
//再打印
System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }

• 将元素55插入到下标为0的位置，原有元素向后移动，再打印所有元素值；

//接上

//方式一
//先赋值
arr[4]=arr[3];
arr[3]=arr[2];
arr[2]=arr[1];
arr[1]=arr[0];
arr[0]=55;
//再打印
System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }

//方式二：
for(int i=arr.length-1;i>0;i--) {
    arr[i]=arr[i-1];
} arr[0]=55;
System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }

• 将元素55从数组中删除，删除方式为后续元素向前移动，最后位置置为0并打印；

//接上
//先赋值
for(int i=0;i<arr.length-1;i++) {
    arr[i]=arr[i+1];
} arr[4]=0;
System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            System.out.print(arr[i]+" ");
        }

• 查找数组中是否存在元素22，若存在则修改为220后再次打印所有元素；

//打印
System.out.print("数组中的元素有：");
        for(int i=0;i<arr.length;i++) {		//length=5;所以i<5
            if(arr[i]==22) {
                arr[i]=220;
            }
            System.out.print(arr[i]+" ");
        }

1）数组的copy

public class ArrayCopyTest {
    public static void main(String[] args) {
    //1、声明一个初始值为11 22 33 44 55的一维数组并打印所有元素
    int[] arr={11,22,33,44,55};
    System.out.print("第一组数组的数据是：");
    for(int i=0;i<arr.length;i++) {
        System.out.print(arr[i]+" ");
    } System.out.println();
    
    //2、声明一个长度为3元素类型为int类型的一维数组并打印所有元素
    int[] brr=new int[3];
    System.out.print("第二组数组的数据是：");
    for(int i=0;i<brr.length;i++) {
        System.out.print(brr[i]+" ");
    } System.out.println();
    
    //3、实现将第一个数组中间3个元素赋值到第二个数组中
        //方式一
        brr[0]=arr[1];
        brr[1]=arr[2];
        brr[2]=arr[3];
        System.out.print("第二组数组的数据是：");
    	for(int i=0;i<brr.length;i++) {
        	System.out.print(brr[i]+" ");
    	} System.out.println();
        //方式二
        for(int i=0;i<brr.length;i++) {
            brr[i]=arr[i+1];
        }
        System.out.print("第二组数组的数据是：");
    	for(int i=0;i<brr.length;i++) {
        	System.out.print(brr[i]+" ");
    	} System.out.println();
        //方式三
        //表示将数组arr下标从1开始的3个元素复制到数组brr下标从0开始的位置
        System.arraycopy(arr,1,brr,0,3);
        System.out.print("第二组数组的数据是：");
    	for(int i=0;i<brr.length;i++) {
        	System.out.print(brr[i]+" ");
    	} System.out.println();
        
        
        //注意事项！！！
        //表示将数组arr的数值赋值给数组brr，覆盖变量brr中原来的数值
        //数组名arr的内存空间中存放的是数据在堆区中的内存地址信息，赋值后让brr存放了arr所指向堆区的内存地址
        //也就是让brr和arr指向了同一块堆区地址，所以本质上就是改变了指向
        //原来地址的堆空间会被自动释放
        brr=arr;
     System.out.print("第二组数组的数据是：");
    	for(int i=0;i<brr.length;i++) {
        	System.out.print(brr[i]+" ");	//11,22,33,44
    	} System.out.println();       
  }
}

8.4 数组的工具类

java.util.Arrays类可以实现对数组中元素的遍历、查找、排序等操作。

打印

格式：Arrays.toString(数组名)

用法：System.out.println("第一个数组的元素有："+Arrays.toString(arr1));

//实现工具类的使用
public class ArraysTest {
    public static void main(String[] args) {
        //1、声明一个初始值：10，20，30，40，50的一维数组
        int[] arr1={10,20,30,40,50};
        
        //2、使用原始方式打印数组的元素，要求打印格式为：[10,20,30,40,50]
        System.out.print("第一个数组的元素有：[");
        for(int i=0;i<arr1.length;i++) {
            //如果打印的元素是最后一个时，直接打印它本身即可
            if(i==arr1.length-1) {
                System.out.print(arr1[i]);
            
            //否则打印元素后面加“，”
            } else {
                System.out.print(arr1[i]+",");
            }
        }
        System.out.println("]");
        //3、使用数组工具类实现数组中所有元素的打印
        //!!!
        //Arrays.toString(数组名)；
        System.out.println("第一个数组的元素有："+Arrays.toString(arr1));
    }
}

填充

格式：Arrays.fill(数组名,元素)；

用法：Arrays.fill(arr2,10);

public class ArraysTest {
    public static void main(String[] args) {
        //1、定义一个数组
        int[] arr1={10,20,30,40,50};
        //2、打印
        System.out.println("第一个数组的元素有："+Arrays.toString(arr1));	//[10,20,30,40,50]
        
        //填充
        //定义一个长度为5的数组
        int[] arr2=new int[5];
        //使用10来填充数组arr2的每个元素，每个元素都赋值为10
        
        //Arrays.fill(数组名,元素)；
        Arrays.fill(arr2,10);
        System.out.println("第二个数组的元素有："+Arrays.toString(arr2));	//[10,10,10,10,10]
    }
}

比较

格式：Arrays.equals(数组名1,数组名2)

用法：System.out.println(Arrays.equals(arr2,arr3)); //false true

//接上
int[] arr3=new int[5];
Arrays.fill(arr3,10);
System.out.println("第三个数组的元素有："+Arrays.toString(arr3));	//[10,10,10,10,10]

//比较
//Arrays.equals(数组名1,数组名2)
System.out.println(Arrays.equals(arr2,arr3));//true

//修改数组中的元素
arr2[4]=20;
System.out.println("第二个数组的元素有："+Arrays.toString(arr2));	//[10,10,10,10,20]
System.out.println(Arrays.equals(arr2,arr3));//false
//修改顺序
arr3[3]=20;
System.out.println("第三个数组的元素有："+Arrays.toString(arr3));	//[10,10,10,20,10]
System.out.println(Arrays.equals(arr2,arr3));//false

排序

格式：Arrays.sort(数组名);

使用：Arrays.sort(arr);

int[] arr={30,10,20};
Arrays.sort(arr);
System.out.println("这个数组的元素有："+Arrays.toString(arr));	//[10,20,30]
System.out.println("最小的元素是："+arr[0]+"，最大的元素是："+arr[arr.length-1]);

查找

格式：Arrays.binarySearch(数组名,需要查找的元素)

使用：Arrays.binarySearch(arr,30)

int[] arr={30,10,20};
System.out.println("元素30在数组的下标位置是："+Arrays.binarySearch(arr,30));	//0
System.out.println("元素29在数组的下标位置是："+Arrays.binarySearch(arr,29));	//负数；	无效下标

8.5 二维数组

1）概念

二维数组本质上就是由多个一维数组摞在一起组成的数组，二维数组中的每个元素都是一维数组，而一维数组中的每个元素才是数据内容。
在这里插入图片描述

2）二维数组的声明和使用

声明格式：数据类型[][] 数组名称 = new 数据类型[行数][列数];

数据类型[][] 数组名称 = {{元素1, 元素2，...}, ...};

public class ArraysTest {
    public static void main(String[] args) {
        //1、声明一个2行3列int类型的二维数组
        int[][] arr=new int[2][3];
        //2、打印数组
        //外层打印行数
        for(int i=0;i<arr.length;i++) {
            //内层打印数组的列数
            for(int j=0;j<arr[i].length;j++) {
                System.out.print(arr[i][j]+" ");	//全是0
            }
            System.out.println();
        }
        
        //2、实现数组的赋值
        int cnt=1;
        for(int i=0;i<arr.length;i++) {    
            for(int j=0;j<arr[i].length;j++) {
                arr[i][j]=cnt++;
            }
         }
        for(int i=0;i<arr.length;i++) {
            //内层打印数组的列数
            for(int j=0;j<arr[i].length;j++) {
                System.out.print(arr[i][j]+" ");	//1 2 3   4 5 6 
            }
            System.out.println();
        }
        
        //3、初始化数组的赋值
        int[][] brr={{1,2,3},{1,2,6}};
         for(int i=0;i<brr.length;i++) {
            //内层打印数组的列数
            for(int j=0;j<brr[i].length;j++) {
                System.out.print(arr[i][j]+" ");	//1 2 3   1 2 6 
            }
            System.out.println();
        }
        
        //！！！
        //考点
        //创建一个3行不知道多少列的二维数组
        int[][] crr=new int[3][];
        //第1行有3列
        crr[0]=new int[3];
        //第2行有5列
        crr[1]=new int[5];
        //第3行有6列
        crr[2]=new int[6];
    }
}