Java 基本语法---Java数组

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

0. 概述

数组：相同类型的数据按照顺序组成的一种引用数据类型。

数据类型：基本数据类型 + 引用数据类型；

引用数据类型：类 + 接口 + 数组；

一维数组：声明，创建，初始化，元素的引用，长度

1. 数组声明

变量声明的语法格式：变量类型变量名；

数组声明的语法格式：数据类型 [ ] 数组名；（数据类型数组名[ ]）

int[] myIntArray;  //首选方法

(int myIntArray[];) //来源于C/C++，效果相同，但不是首选方法

String[] strArray;

2. 数组创建

语法格式一先声明后创建

数据类型[] 数组名；

数组名 = new 数据类型[ 数组长度 ]；

int[] array;

array = new int[10];

//创建一个长度为 10 的整型数组array；

语法格式二声明的同时进行创建数组

数据类型 [] 数组名 =  new 数据类型 [ 数组长度 ]；

dataType[] arrayRefVar = new dataType[arraySize];
// 1.使用 dataType[arraySize] 创建了一个数组；
// 2.把新创建的数组的引用赋值给了变量 arrayRefVar。

int[] arr = new int[10];    //创建一个长度为10的整型数组arr

//注意：数组的长度必须给定

3. 数组的初始化

声明数组的同时给数组赋值，叫做数组的初始化；

int[] arr = {1,2,3,4,5,6,7,8,9,10};

// 数组的长度就是初始化数组时所给数组元素的个数。

4. 数组元素的引用

数组元素的访问是通过索引访问的。

语法格式：数组名[ 下标 ]；

注意：下标从0开始（数组索引从0开始，所以索引值从0到array.length - 1)；

5. 数组的长度

int[] arr = {0,1,2,3,4,5,6,7,8,9};

//属性 length 表示数组的长度，例如：arr.length;

6. 案例

6.1 案例1：一维数组的应用

int 数组创建时数组元素默认值为0；

double数组创建时数组元素默认为0.0；

char 数组创建时数组元素默认为；

String 数组创建时数组元素默认为 null；

public class ArrayTest {
    public static void main(String[] args) {
        //声明一个整型数组
        int[] intArray;
        //声明一个字符串类型的数组
        String strArray[];
        //创建数组
        intArray = new int[5];
        strArray = new String[10];
        //声明数组的同时进行创建数组
        double[] doubleArray = new double[4];
        //初始化数组
        char[] chArray = {'a','b','c','d'};
        char[] ch1Array = new char[5];
        System.out.println("ch1Array 数组的长度为：" + ch1Array.length);
        System.out.println("ch1Array 数组中的第2个元素为：" + ch1Array[3]);
        System.out.println("chArray 数组的长度为：" + chArray.length);
        System.out.println("chArray 数组中的第2个元素为：" + chArray[1]);
        System.out.println("intArray 数组的长度为：" + intArray.length);
        System.out.println("intArray 数组中的第二个元素为：" + intArray[1]);
        System.out.println("strArray 数组的长度为：" + strArray.length);
        System.out.println("strArray 数组中的第5个元素为：" + strArray[4]);
        System.out.println("doubleArray 数组的长度为：" + doubleArray.length);
        System.out.println("doubleArray 数组中的第4个元素为：" + doubleArray[3]);
        System.out.println();

        //循环为整型数组赋值
        for(int i = 0;i < 5;i++)
        {
            intArray[i] = i + 2;
        }
        //循环输出整型数组中的元素
        System.out.println("整型数组intArray 中的元素值分别为：");

        //数组下标越界（数组下标超出范围）Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
        //  at com.ryanjie.ArrayTest.main(ArrayTest.java:51)
//        for(int i= 0;i < 6;i++)
//        {
//            System.out.print(intArray[i] + "    ");
//        }
//        System.out.println();
        for(int i = 0;i < 5;i++)
        {
            System.out.print(intArray[i] + "    ");
        }
        System.out.println();
    }

}

Output：
    ch1Array 数组的长度为：5
    ch1Array 数组中的第2个元素为：
    chArray 数组的长度为：4
    chArray 数组中的第2个元素为：b
    intArray 数组的长度为：5
    intArray 数组中的第二个元素为：0
    strArray 数组的长度为：10
    strArray 数组中的第5个元素为：null
    doubleArray 数组的长度为：4
    doubleArray 数组中的第4个元素为：0.0

    整型数组intArray 中的元素值分别为：
    2    3    4    5    6

6.2 案例2：求数组元素的累加和

public class ArraysSum {
    public static void main(String[] args) {
        //求整型数组的累加和
        //定义整型数组
        int[] intArray = new int[5];

        //从键盘开始接收数据，为元素进行赋值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++)
        {
            System.out.println("请输入第 " + (i + 1) + "个元素的值：");
            intArray[i] = sc.nextInt();
        }

        //输出intArray 数组中的元素
        System.out.println("数组中的元素分别为：");
        for(int i = 0;i < intArray.length; i++ )
        {
            System.out.print(intArray[i] + "  ");
        }
        System.out.println();

        //输出intArray数组中的元素的和
        int sum = 0;
        for(int i= 0; i < intArray.length;i++)
        {
            sum += intArray[i];
        }
        System.out.println("intArray数组的元素和为：" + sum);
    }
}

Output：
    请输入第 1个元素的值：
    100
    请输入第 2个元素的值：
    100
    请输入第 3个元素的值：
    50
    请输入第 4个元素的值：
    50
    请输入第 5个元素的值：
    150
    数组中的元素分别为：
    100  100  50  50  150
    intArray数组的元素和为：450

6.3 案例3：求数组元素的最大值

public class MaxElement {
    public static void main(String[] args) {
        //求数组中的最大值

        //定义整型数组
        //int[] intArray = {34,23,78,56,31,66};
        int[] intArray = new int[6];

        //从键盘读取数组元素值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++ )
        {
            System.out.println("请输入第 " + (i+1) + "个元素的值：");
            intArray[i] = sc.nextInt();
        }

        //输出intArray数组中的元素
        System.out.println("intArray 数组中的元素分别为：");
        for(int i = 0;i < intArray.length;i++)
        {
            System.out.print(intArray[i] + "  ");
        }
        System.out.println();

        int max = intArray[0];
        for(int i = 1;i < intArray.length;i++)
        {
            if(max < intArray[i])
            {
                max = intArray[i];
            }
        }
        System.out.println("intArray 数组元素的最大值为：" + max);
    }
}

Output：
    请输入第 1个元素的值：
    34
    请输入第 2个元素的值：
    23
    请输入第 3个元素的值：
    78
    请输入第 4个元素的值：
    56
    请输入第 5个元素的值：
    31
    请输入第 6个元素的值：
    66
    intArray 数组中的元素分别为：
    34  23  78  56  31  66
    intArray 数组元素的最大值为：78

7. foreach 循环

foreach 循环又称为增强型循环，它能在不使用下标的情况下遍历数组。

int[] arr = {1,2,3,4,5,6};
for(int n:arr)
    System.out.print(n + "  ");
//每次把数组中的元素存放到n中，输出。循环遍历一遍就终止；

public class Test {
    public static void main(String[] args) {
        //定义整型数组
        //int[] intArray = {34,23,78,56,31,66};
        int[] intArray = new int[6];

        //从键盘读取数组元素值
        Scanner sc = new Scanner(System.in);
        for(int i = 0;i < intArray.length;i++ )
        {
            System.out.println("请输入第 " + (i+1) + "个元素的值：");
            intArray[i] = sc.nextInt();
        }

        //foreach循环
        for(int n:intArray)
        {
            System.out.print(n + "    ");
        }
        System.out.println();
    }
}

8. 数组作为函数的参数

数组作为参数传递给方法。

调用printfDoubleArray方法打印doubleArray数组：

public static void printfDoubleArray(double[] doubleArray) {
    for (double element: doubleArray )
    {
        System.out.println(doubleArray[i] + "   ");
    }
}

//调用printfDoubleArray方法打印doubleArray数组
printfDoubleArray(new double[] {3.14,6.66,8,88,3.59,7.84});

9. 数组作为函数的返回值

数组可以作为函数的返回值。

将list数组中的元素值赋值给result数组：

public atstic int[] reverse(int[] list){
    //声明 result 数组 并创建 result 数组
    int[] result = new int[list.length];

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--)
    {
        result[j] = list[i];
    }
    return result;
}

10. 冒泡排序 BubbleSort

public class BubbleSort {
    public static void main(String[] args) {
        //冒泡排序BubbleSort
        int[] intArray = {34,23,78,56,31,66};
        System.out.println("排序前的数组元素分别为：");
        for(int element:intArray)
        {
            System.out.print(element + "    ");
        }
        System.out.println();

        //BubbleSort
        int temp;
        for (int i = 0; i < intArray.length; i++)
        {
            for (int j = 0; j < intArray.length-i-1; j++)
            {
                if(intArray[j] > intArray[j+1])
                {
                    temp = intArray[j];
                    intArray[j] = intArray[j+1];
                    intArray[j+1] = temp;
                }
            }
        }

        //输出排序后的数组
        System.out.println("排序后的数组元素分别为：");
        for(int element:intArray)
        {
            System.out.print(element + "    ");
        }
        System.out.println();
    }
}

OutPut：
    排序前的数组元素分别为：
    34    23    78    56    31    66
    排序后的数组元素分别为：
    23    31    34    56    66    78

正文

Java 基本语法---Java数组