Java 基本语法---Java数组

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