【JAVA数组最详细讲解（完整版）】-俄罗斯世界杯阿根廷-世界杯非洲区预选赛_世界杯彩票

数组

1 数组概述2 一维数组的创建与使用2.1 创建一维数组2.2 初始化一维数组2.3 使用一维数组

3 二维数组的创建与使用3.1 创建二维数组3.2 初始化二维数组3.3 使用二维数组

4 数组的基本操作4.1 遍历数组4.2 填充替换数组元素4.3 对数组进行排序4.4 复制数组4.5 数组查询

5 数组排序算法5.1 冒泡排序5.1.1 基本思想5.1.2 算法实现

5.2 直接选择排序5.2.1 基本思想5.2.2 算法实现

5.3 反转排序5.3.1 基本思想5.3.2 算法实现

1 数组概述

数组是具有相同数据类型的一-组数据的集合。例如，球类的集合一-足球、篮球、羽毛球等;电器集合一电视机、洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作是一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组…

2 一维数组的创建与使用

2.1 创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型，一维数组的创建有两种方式。

1. 先声明，再用new运算符进行内存分配

数组元素类型名字[];

数组元素类型[] 名字;

//具体声明如下：

int arr[];

String str[];

声明数组后还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用数组，还要为它分配内存空间，必须指明数组的长度，格式如下：

数组名字 = new 数组元素的类型[数组元素的个数];

//实例代码如下：

arr = new int[5];

注意：使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0

2. 声明的同时为数组分配内存：(java)中普遍使用的方法语法如下：

数组元素的类型数组名 = new 数组元素的类型[数组元素个数]

//实例代码如下：

int month[] = new int[12];

2.2 初始化一维数组

2.3 使用一维数组

例2.3 创建类GetDay,在主方法中创建int型数组，并实现将各月的天数输出：

public class GetDay //创建类

{

public static void main(String[] args) //创建主方法

{

int[] day = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};

for(int i=0;i<12;i++)

System.out.println((i+1)+"月有"+day[i]+"天");

}

//输出示例

1月有31天

2月有28天

3月有31天

4月有30天

5月有31天

6月有30天

7月有31天

8月有31天

9月有30天

10月有31天

11月有30天

12月有31天

Process finished with exit code 0

3 二维数组的创建与使用

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。

3.1 创建二维数组

1. 先声明，再用new运算符进行内存分配

数组元素类型名字[][];

数组元素类型[][] 名字;

//具体声明如下：

int myarr[][];

同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以进行访问每个元素，对于高维数组，有两种为数组分配内存的方式：

//（1）直接为每一维分配内存空间，实例如下：

a = new int[2][4];

//(2)分别为每一维分配内存空间

a = new int[2][];

a[0] = new int[2];

a[1] = new int[3];

2. 声明的同时为数组分配内存

3.2 初始化二维数组

type arrayname[][] = {value1,value2...valuen};

//type:数组数据类型

//arrayneme:数组名称，一个合法的标识符

//value:数组中各元素的值

//初始化实例如下：

int myarr[][] = {{12,0},{45,10}};

3.3 使用二维数组

例3.3 创建类Matrix,在主方法中编写代码实现输出一个3行4列且所有元素都为0的矩阵：

public class Matrix //创建类

{

public static void main(String[] args) //创建主方法

{

int[][] a = new int[3][4];

for(int i=0;i

{

for(int j=0;j

System.out.print(a[i][j]);

System.out.println();

}

//输出示例

0000

Process finished with exit code 0

4 数组的基本操作

4.1 遍历数组

遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度例4.1.1 创建类Trap，在主方法中编写代码，定义二维数组，将二维数组中的元素呈梯形输出：

public class Trap {

public static void main(String[] args) {

int[][] a = new int[][]{{1}, {2, 3}, {4, 5, 6}};//定义二维数组

for (int i = 0; i < a.length; i++) {//循环遍历二维数组中的每个元素

for (int j = 0; j < a[i].length; j++) {

System.out.print(a[i][j]);//将数组中的元素输出

}

System.out.println();//输出空格

}

//输出示例：

456

Process finished with exit code 0

在遍历数组时，使用foreach语句可能会更加简单，下面的实例就是通过foreach语句遍历二维数组。例4.1.2 创建类Tautog,在主方法中定义二维数组，使用foreach语句遍历二维数组：

public class Tautog {

public static void main(String[] args) {

int[][] arr2 = new int[][]{{4, 3}, {1, 2}}; //定义二维数组

System.out.println("数组中的元素是：");

int i = 0;//外层循环计数器变量

for (int[] x :

arr2) { //外层循环变量为一维数组

i++; //外层计数器递增

int j = 0; //内层循环计数器

for (int e :

x) { // 循环遍历每一个数组元素

j++; // 内层循环计数器递增

if (i == arr2.length && j == x.length) { // 判断变量是二维数组中的最后一个元素

System.out.print(e); //输出二维数组最后一个元素

} else {

//如果不是二维数组中的最后一个元素

System.out.print(e + "、"); // 输出信息

}

//输出示例：

数组中的元素是：

4、3、1、2

Process finished with exit code 0

4.2 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法il()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。fll()方法有两种参数类型。下面以int型数组为例介绍ill()方法的使用方法。

（1）fill(int[] a,int value)

//该方法可将指定的int值分配给int型数组的每个元素，语法如下：

fill(int[] a,int value);

//a:要进行元素替换的数组

//value:要存储数组中所有元素的值

例4.2.1 创建类Swap，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中各个元素输出。

import java.util.Arrays; // 导入java.util.Arrays类

public class Swap {

public static void main(String[] args) {

int[] arr = new int[5]; // 创建int型数组

Arrays.fill(arr, 8); // 使用同一个值对数组进行填充

for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素

System.out.println("第" + i + "个元素是" + arr[i]);

}

//输出示例：

第0个元素是8

第1个元素是8

第2个元素是8

第3个元素是8

第4个元素是8

Process finished with exit code 0

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

//该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）到索引toIndex（不包括），如果fromIndex==toIndex,则填充范围为空，语法如下：

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

//a:要进行填充的数组

//fromIndex:要使用指定值填充的第一个元素的索引（包括）

//toIndex:要使用指定值填充的最后一个元素的索引（不包括）

//value:要存储在数组所有元素的值

注意：如果指定的索引位置大于或者等于要进行填充的数组长度，则会报出ArrayIndexOutOf-BoundsException(数组越界异常) 异常。

例4.2.2 创建类Displace,创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。

import java.util.Arrays; // 导入java.util.Arrays类

public class Displace {

public static void main(String[] args) {

int[] arr = new int[]{45,12,2,10}; // 创建int型数组

Arrays.fill(arr,1,2,8); // 使用同一个值对数组进行填充

for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素

System.out.println("第" + i + "个元素是" + arr[i]);

}

//输出示例：

第0个元素是45

第1个元素是8

第2个元素是2

第3个元素是10

Process finished with exit code 0

4.3 对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

Arrays.sort(object)

//object:指进行排序的数组名称

例4.3 创建类Taxis，在主方法中创建一维数组，将数组排序后输出。

import java.util.Arrays; // 导入java.util.Arrays类

public class Taxis {

public static void main(String[] args) {

int[] arr = new int[]{23,42,12,8}; // 创建int型数组

Arrays.sort(arr); // 将数组进行排序

for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素

System.out.println(arr[i]);

}

//输出示例：

Process finished with exit code 0

4.4 复制数组

Arrarys类的copyOf()方法与copyOfRange()方法可实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

（1）copyOf()方法，语法如下：

copyOf(arr,int newlength);

//arr:要进行复制的数组

//newlenghth:int型常量，指复制后的新数组长度。如果新数组长度大于数组arr的长度，则用0填充（整型0填充，char型null填充），如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取到满足新数组长度为止

例4.4.1 创建类Cope,在主方法中创建一维数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出：

import java.util.Arrays; // 导入java.util.Arrays类

public class Cope {

public static void main(String[] args) {

int[] arr = new int[]{23, 42, 12}; // 创建int型数组

int[] newarr = Arrays.copyOf(arr, 5); // 复制数组arr

for (int i = 0; i < newarr.length; i++) { // 循环遍历数组中的元素

System.out.println(newarr[i]);

}

//输出示例：

Process finished with exit code 0

（2）copyOfRange()方法，语法如下：

copyOfRange(arr,int fromIndex,int toIndex);

//arr:要进行复制的数组对象

//fromIndex:指定开始复制数组的索引位置，必须在0-整个数组长度之间，新数组包括fromIndex元素

//toIndex:要复制范围的最后索引位置，可以大于数组arr长度，新数组不包括toIndex元素

例4.4.2 创建类Repeat,在主方法中创建一维数组，并将数组中索引位置是0-3的元素复制到新数组中，最后将新数组输出：

import java.util.Arrays; // 导入java.util.Arrays类

public class Repeat {

public static void main(String[] args) {

int[] arr = new int[]{23, 42, 12, 84, 10}; // 创建int型数组

int[] newarr = Arrays.copyOfRange(arr, 0, 3); // 复制数组arr

for (int i = 0; i < newarr.length; i++) { // 循环遍历数组中的元素

System.out.println(newarr[i]);

}

//输出示例：

Process finished with exit code 0

4.5 数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

(1) binarySearch(Object[] a, Object key)

//a:要搜索的数组

//key:要搜索的值

例5.1.1 创建Reference类，在主方法中创建一维数组arr,实现查找元素4在数组中的索引：

import java.util.Arrays; // 导入java.util.Arrays类

public class Reference {

public static void main(String[] args) {

int[] arr = new int[]{1, 8, 9, 4, 5}; // 创建int型数组

Arrays.sort(arr);//对数组进行排序

int index=Arrays.binarySearch(arr,4);

System.out.println("4的索引位置是："+index);

}

//输出示例：

/*cd

4的索引位置是：1

Process finished with exit code 0

（2）binarySearch(Object[] a,int fromlndex , int tolndex,Object key)

//该方法在指定的范围内检索某一元素

//a:要进行检索的数组

//fromIndex:指定范围的开始索引处（包含）

//toIndex:指定范围处的索引（不包含）

//key:要搜索的元素

例5.1.2 创建Rakel类，在主方法创建String数组，实现查找元素“cd”在指定范围的数组str中的索引位置：

import java.util.Arrays; // 导入java.util.Arrays类

public class Rakel {

public static void main(String[] args) {

String[] str = new String[]{"ab","cd","ef","yz"};//定义String型数组

Arrays.sort(str); // 将数组进行排序

int index = Arrays.binarySearch(str,0,2,"cd");

System.out.println("cd的索引位置是："+index);

}

//输出示例：

cd的索引位置是：1

Process finished with exit code 0

5 数组排序算法

5.1 冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

5.1.1 基本思想

是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面，这样较小的元素就像气泡一样从底部上升到顶部。

5.1.2 算法实现

例5.1.2 创建BubbleSort类，实现冒泡排序的一个演示，其中排序使用的是正排序：

/**

* 冒泡排序算法实例

* @author Codeplus

public class BubbleSort {

public static void main(String[] args) {

//创建一个数组，这个数组元素是乱序的

int[] array = new int[]{64, 4, 24, 1, 3, 15};

//创建冒泡排序类的对象

BubbleSort sorter = new BubbleSort();

//调用排序方法将数组进行排序

sorter.sort(array);

}

/**

* 冒泡排序

* @param array 要排序的数组

public void sort(int[] array) {i

for (int i = 1; i < array.length; i++) {

//比较相邻的两个元素，较大的数往后冒泡

for (int j = 0; j < array.length - i; j++) {

if (array[j] > array[j + 1]) {

int temp = array[j];//把第一个元素的值保存在临时变量里

array[j] = array[j + 1];//把第二个元素值保存到第一个元素单元里

array[j + 1] = temp;//把临时变量保存到第二个元素中

}

showArray(array); //输出冒泡排序后的数组元素

}

/**

* 显示数组中的所有元素

* @param array 要显示的数组

public void showArray(int[] array) {

for (int i :

array) { //遍历数组

System.out.print(" >" + i); //输出每个数组元素值

}

System.out.println();

}

//输出示例：

>1 >3 >4 >15 >24 >64

Process finished with exit code 0

5.2 直接选择排序

5.2.1 基本思想

将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换，这样排序好的位置逐渐扩大，最后整个数组都成为已经排序好的格式。

5.2.2 算法实现

例5.2.2 创建SelectSort类，这个类作为直接选择排序的一个演示，其中排序选择的是正排序：

/**

* 直接选择排序算法实例

* @author Codeplus

public class SelectSort {

public static void main(String[] args) {

//创建一个数组，这个数组元素是乱序的

int[] array = new int[]{64, 4, 24, 1, 3, 15};

//创建直接选择排序类的对象

SelectSort sorter = new SelectSort();

//调用排序方法将数组进行排序

sorter.sort(array);

}

/**

* 直接选择排序

* @param array 要排序的数组

public void sort(int[] array) {

int index;

for (int i = 1; i < array.length; i++) {

index=0;

for (int j = 1; j <= array.length - i; j++) {

if (array[j] > array[index]) {

index=j;

}

//交换在位置array.length-i和index（最大值）上的两个数

int temp = array[array.length-i];//把第一个元素的值保存在临时变量里

array[array.length-i] = array[index];//把第二个元素值保存到第一个元素单元里

array[index] = temp;//把临时变量保存到第二个元素中

}

showArray(array); //输出冒泡排序后的数组元素

}

/**

* 显示数组中的所有元素

* @param array 要显示的数组

public void showArray(int[] array) {

for (int i :

array) { //遍历数组

System.out.print(" >" + i); //输出每个数组元素值

}

System.out.println();

}

//输出示例：

>1 >3 >4 >15 >24 >64

Process finished with exit code 0

5.3 反转排序

5.3.1 基本思想

把数组最后一个元素与第一个元素交换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

5.3.2 算法实现

例5.3.2 创建ReverseSort类，实现反转排序演示：

/**

* 反转排序算法实例

* @author Codeplus

public class ReverseSort {

public static void main(String[] args) {

// 创建一个数组

int[] array = {10, 20, 30, 40, 50, 60};

// 创建反转排序类的对象

ReverseSort sorter = new ReverseSort();

// 调用排序对象的方法将数组反转

sorter.sort(array);

}

/**

* 直接选择排序法

* @param array 要排序的数组

public void sort(int[] array) {

System.out.println("数组原有内容：");

showArray(array);// 输出排序前的数组值

int temp;

int len = array.length;

for (int i = 0; i < len / 2; i++) {

temp = array[i];

array[i] = array[len - 1 - i];

array[len - 1 - i] = temp;

}

System.out.println("数组反转后内容：");

showArray(array);// 输出排序后的数组值

}

/**

* 显示数组所有元素

* @param array 要显示的数组

public void showArray(int[] array) {

for (int i : array) {// foreach格式遍历数组

System.out.print("\t" + i);// 输出每个数组元素值

}

System.out.println();

}

//输出示例：

数组原有内容：

10 20 30 40 50 60

数组反转后内容：

60 50 40 30 20 10

Process finished with exit code 0