【JAVA数组最详细讲解（完整版）】

小咪咪 2023-01-10 10:27 246阅读 0赞

### 数组 ###

*  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 初始化一维数组 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70]

## 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<a.length;i++)
            {
        
                for(int j=0;j<a[i].length;j++)
                    System.out.print(a[i][j]);
                System.out.println();
            }
        }
    }
    //输出示例
    /*
    0000
    0000
    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();//输出空格
            }
        }
    }
    
    //输出示例：
    /*
    1
    23
    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]);
            }
        }
    }
    
    //输出示例：
    /*
    8
    12
    23
    42
    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]);
            }
        }
    }
    
    //输出示例：
    /*
    23
    42
    12
    0
    0
    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]);
            }
        }
    }
    
    //输出示例：
    /*
    23
    42
    12
    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
    */

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2NTE4NDYx_size_16_color_FFFFFF_t_70]: /images/20221119/29e82861602b414fa854d3519a46fc22.png