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

最新推荐文章于 2024-08-15 12:41:05 发布
最新推荐文章于 2024-08-15 12:41:05 发布
阅读量3.4k 收藏 18
点赞数 27
分类专栏： Java 实用教程 文章标签： 算法 java 编程语言 数组 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46518461/article/details/113062269
版权

数组

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<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
*/
FEI..
关注
专栏目录
Java从入门到精通 第六章 数组
zhengzaifeidelushang的博客
12-08 710
Java从入门到精通 第六章 数组 数组是具有相同数据类型的一组数据的集合，因此数组中的每个元素具有相同的数据类型。在Java中虽然基本数据类型不是对象，但由基本数据类型组成的数组确是对象。 一、一维数组的创建及使用 1）创建一维数组 数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。 1.先声明，再用new运算符进行内存分配 声明一维数组有下列两种方式： 符号"[ ]“指明该变量是一个数组类型变量。单个”[ ]"表示要创建的数组是一个一维数组。 数组元素类型 数
Java数组的常用方法
hldfight
08-14 606
java数组排序，二分查找，等等
数据结构——数组篇java版（完整+简洁+通俗易懂）
最新发布
guo214214的博客
08-15 1776
讲解通俗易懂，适合初学的小白、复习巩固的老手。如果您准备刷力口，也可以看一下这篇文章，里面包含数组大量的方法，会让您做题更加得心应手。
java数组详解
热门推荐
oguro的博客
10-30 13万+
1 数组 概念 同一种类型数据的集合。其实数组就是一个容器。 数组的好处 可以自动给数组中的元素从0开始编号，方便操作这些元素。 格式1： 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = new int[5]; 格式2：
14 数组
qq_53537301的博客
03-21 940
数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成 其中,每一个数据称作一个数组元素每个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] array
学习java Day10
Angeefly的博客
07-05 151
①数组 定义 数组是相同类型数据的集合。 数组描述相同类型的若干个数据，按一定的先后次序排列组合而成。 每个数据称作一个数组元素，每个数据元素可以通过一个下标来访问。 声明 首先必须声明数组变量，才能在程序中使用数组。 声明数组变量语法如下： dataType[] arrayRefVar; //首选方法 或 dataType arrayRefVar[]; //效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar
java 数组
Claroja
03-14 2125
定义数组 float[] arr = new float[10]; // arr可以装10个float数据 int[] arr2 = new int[8]; // arr2可以装8个int数据 String[] arr3 = new String[7]; //arr3 可以装7个String数据 添加数据 arr[0] = 1.8; arr2[2]=5; arr3[1] = ...
完整超详细版 耿祥义 Java大学实用教程（第2版）PPT课件 第10章 成绩统计-数组与字符串 （共67页）.ppt
12-28
在耿祥义的《Java大学实用教程（第2版）》的第10章中，主要讲解了如何使用数组来处理成绩统计的问题，并涵盖了数组、多维数组、数组操作、引用类型作方法参数、字符串类以及正则表达式等多个知识点。 首先，数组是...
陈国君编著的《Java程序设计基础》第七版的授课课件PPT完整版
08-07
陈国君编著的《Java程序设计基础》第七版的授课课件PPT完整版。分为18章来全面讲解Java开发的基础语法到高级开发，分别是： 第1章 Java语言概述(第7版).pptx 第2章 Java语言开发环境(第7版).pptx 第3章 Java语言基础...
完整版java基础入门教程由浅入深讲解 Java语言编程基础 含辅助PPT资料 全套PPT课件 共15个章节.rar
12-05
完整版java基础入门教程由浅入深讲解 Java语言编程基础 第07章 数组与字符串（共20页）.ppt 完整版java基础入门教程由浅入深讲解 Java语言编程基础 第08章 异常处理（共20页）.ppt 完整版java基础入门教程由浅入深...
java数组转化为字符串，意外的惊喜
m0_57205780的博客
07-21 130
微服务架构 第1章　微服务概述 什么是微服务 常见的微服务组件 常用的微服务框架 微服务架构设计模式 如何实施微服务 从微服务的起源和现实业务的角度探讨微服务 第2章　微服务设计原则 设计原则之分层架构 设计原则之统一通信协议 设计原则之单一职责 设计原则之服务拆分 设计原则之前后端分离 设计原则之版本控制 设计原则之围绕业务构建 设计原则之并发流量控制 设计原则之CAP 设计原则之EDA事件驱动 设计原则之CQRS 设计原则之基础设施自动 设计原则之 数据一致性 设计原则之设计模式 设计原则之
推荐课程 完整版优质java教程 java精品教学课件 Java语言程序设计 第5章 数组（共58页）.ppt
12-06
2. 多维数组：多维数组通常用于表示表格或矩阵数据，其中最常见的就是二维数组。二维数组声明类似`类型标识符 数组名 [ ][ ];`或`类型标识符 [ ][ ] 数组名;`。例如，声明一个3x4的二维整型数组`int a[][];`，然后...
Java 数组
Naion的博客
03-22 2万+
本文章介绍了Java中数组的一些概念和一些方法的使用。
Java中的数组
weixin_52071901的博客
05-27 3210
day05部分,day06部分
java array_Java 数组
weixin_39850062的博客
02-16 199
Java 数组数组对于每一门编辑应语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java语言中提供的数组是用来存储固定大小的同类型元素。你可以声明一个数组变量，如numbers[100]来代替直接声明100个独立变量number0，number1，....，number99。本教程将为大家介绍Java数组的声明、创建和初始化，并给出其对应的代码。声明数组变量首先必须声明...
JAVA数组详解
缘
03-06 1725
最近看了一些关于java数组的资料，在此总结一下： 一、数组的定义和类型：       数组就是类型相同的数据对象元素集合。简单的说：就是类型相同的数据存储在一个容器里面【注意:Java中的数组是引用类型，即使一个数组中存放的都是基本数据类型，
Java数组详解
TAO
04-09 1622
Java数组详解 本文将介绍Java数组的一些基本语法及应用，如java一维数组，二维数组的声明，分配空间，数组访问，赋值，数组排序，查找等等。 数组定义 数组是相同数据的有序集合，简单来说，就是将若干相同元素按一定的次序存放在一起。其特点如下： 数组存放元素类型必须相同，不能有混合类型。 数组各元素按先后顺序有序的存放在内存中，每个元素通过数组名和下标来访问。 数组的长度固定，一旦创建，无法进...
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FEI..

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值