本文主要是介绍数组的使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 数组
• • 数组概述
  • 一维数组
  • • 数组的声明
    • 数组初始化
    • • 动态初始化
      • 静态初始化
    • 数组的使用
    • 一维数组的遍历
    • Java中内存分配
    • 数组操作常见的问题
    • 获取最值
  • 二维数组
  • • 创建二维数组
    • 二维数组初始化
    • 遍历二维数组
  • 数组的基本操作
  • • 填充替换数组元素
    • 对数组进行排序
    • 复制数组
    • 数组查询
    • 数组排序算法

数组

数组概述

数组是具有相同数据类型的一组数据的集合。

一维数组

数组的声明

数据类型 数组名字[];
int array[];//定义了一个int类型的变量，变量名是array数组。
数据类型[] 数组名字;
int[] array;//定义了一个int类型的数组，数组名是array。

数组初始化

java中的数组必须先初始化，然后才能使用。

初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

动态初始化

初始化时只指定数组长度，由系统为数组分配初始值。

数据类型[] 变量名 = new 数据类型[数组长度];
int[] array = new int[3];//使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0。
//整数：默认值0
//浮点数：默认值0.0
//布尔值：默认值false
//字符：默认值是空字符串
//引用数据类型：默认值是null

静态初始化

初始化时指定每个元素的初始值，由系统决定数组长度。

数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3，...};
int[] array = new int[]{1,2,3};
int[] array2 = {1,2,3};//简化

数组的使用

//输出数组名
System.out.println(array);//[I@4554617c
//输出数组元素
System.out.println(array[0]);//0
System.out.println(array[1]);//0
System.out.println(array[2]);//0

一维数组的遍历

int[] array = new int[]{1,2,3,4,5};
for(int i = 0 ; i<array.length ; i++){
    System.out.println(array[i]);
}

Java中内存分配

数组操作常见的问题

• 下标越界：访问了数组中不存在的下标对应的元素，造成下标越界。
• 空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常。
  null：空值，引用数据类型的默认值，表示不指向任何有效对象。

获取最值

//获取最值
int[] array = {12,45,98,73,60};
//定义两个变量，取数组的第一个数据作为初始值
int max = array[0];//保存最大值
int min = array[0];//保存最小值
//与数组中剩余的数据逐个对比
for(int i=1 ; i<array.length ; i++){
    if(array[i] > max){
        max = array[i];//每次对比将最大值保存到变量max中
    }else if(array[i] < min){
        min = array[i];//每次对比将最小值保存到变量min中
    }
}
//循环结束后打印变量的值
System.out.println("最大值为：" + max );
System.out.println("最小值为：" + min );

二维数组

二维数组可以看作是特殊的一维数组。

创建二维数组

int[][] array = new int[2][3];//创建了二维数组array1，包括两个长度都为3的一维数组

int[][] array2 = new int[2][];//创建了二维数组array2，长度为2
array2[0] = new int[3];//分别为每一维分配内存
array2[1] = new int[4];

二维数组初始化

int[][] array3 = {{1,2,3},{4,5,6},{7,8,9}};
array3[1][1]=2;//单个赋值

遍历二维数组

int[][] array3 = {{1,2,3},{4,5,6},{7,8,9}};
for(int i=0; i<array3.length ; i++){
    for(int j=0; j<array3[i].length; j++){
        System.out.print(array3[i][j] + " ");
    }
    System.out.println();//输出空格
}

数组的基本操作

填充替换数组元素

数组的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。

fill(int[ ] a , int value)

该方法可将指定的int值分配给int型数组的每个元素。

int[] a = new int[5];
Arrays.fill(a,8);
for(int i = 0 ; i<a.length ; i++){
    System.out.print(a[i] + " ");
}
//输出结果：8 8 8 8 8 

fill(int[ ] a , int fromIndex , int toIndex , int value)

该方法将指定的int值分配给int型数组指定范围内的每个元素。填充的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。

如果fromIndex == toIndex ，则填充范围为空。

int[] a = new int[5];
Arrays.fill(a,1,3,8);
for(int i = 0 ; i<a.length ; i++){
    System.out.print(a[i] + " ");
}
//输出结果：0 8 8 0 0 

对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。

sort()方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

Arrays.sort(object) // 其中object是指进行排序的数组名称。

int[] array = new int[]{6,1,3,2,5,4};
Arrays.sort(array);
for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
}
//输出结果：1 2 3 4 5 6 

复制数组

Arrays 类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。

copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

copyOf(arr , int newlength)
newlength，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充。（填充内容根据复制数组的类型来决定）

int[] array = new int[]{1,2,3,4,5,6,7,8,9};
int[] newarray = Arrays.copyOf(array,5);
for (int i = 0; i < newarray.length; i++) {
    System.out.print(newarray[i] + " ");
}
//输出结果：1 2 3 4 5 

copyOfRange(arr , int fromIndex , int toIndex)
fromIndex：指定开始复制数组的索引位置。fromIndex必须在0至整个数组的长度之间。新数组包括索引是fromIndex的元素。
toIndex：要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。

int[] array = new int[]{1,2,3,4,5,6,7,8,9};
int[] newarray1 = Arrays.copyOfRange(array,1,5);
int[] newarray2 = Arrays.copyOfRange(array,1,11);
for (int i = 0; i < newarray1.length; i++) {
    System.out.print(newarray1[i] + " ");
}
System.out.println();
for (int i = 0; i < newarray2.length; i++) {
    System.out.print(newarray2[i] + " ");
}
//输出结果：2 3 4 5 
//输出结果：2 3 4 5 6 7 8 9 0 0 

数组查询

Array类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。

该方法返回要搜索元素的索引值。

binarySearch(Object[ ] a , Object key)
a：要搜索的数组
key：要搜索的值
如果key包含在数组中，则返回搜索值的索引；否则范围-1或“-”（插入点）。
插入点是搜索键将要插入数组的那一个点，即第一个大于此间的元素索引。

int[] array = new int[]{6,1,3,2,5,4};
Arrays.sort(array);//排序
int index = Arrays.binarySearch(array,2);
System.out.println(index);
int index2 = Arrays.binarySearch(array,9);
System.out.println(index2);
//输出结果：1
//输出结果：-7

注意：必须在进行此调用之前对数组进行排序（通过sort()方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

int[] array = new int[]{6,4,3,2,5,4,1};
int index = Arrays.binarySearch(array,1);
System.out.println(index);
//输出结果：-1

binarySearch(Object[ ] a , int fromIndex , int toIndex , Object key)
该方法在指定的范围内检索某一元素。
fromIndex：指定范围的开始处索引（包含）。
toIndex：指定范围的结束处索引（不包含）。

int[] array = new int[]{1,2,3,4,5,6,7,8,9};
int index = Arrays.binarySearch(array,1,2,3);
System.out.println(index);
//输出结果：-3

在使用该方法前同样要对数组进行排序，来获得准确的索引值。如果要搜索的元素key在指定的范围内

数组排序算法

这篇关于数组的使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！