标签：arr Java 记录 int 元素数据类型学习数组 new

数组

数组的概述

数组：

是一个可以存储同一种数据类型元素的容器，对于同一个数组而言，里面的元素数据类型都是一样。
数组长度是固定大小的，其实一块内存中的连续空间，数组一旦创建，长度不可变
数组具有索引的概念，从左向右，从0开始

数组的特点：

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
数组，一旦初始化完成，其长度就是确定的。数组的长度一旦确定，就不能修改。
数组具有索引的概念，从左向右，从0开始

数组的分类：

1、按照元素类型分：

基本数据类型元素的数组：每个元素位置存储基本数据类型的值
引用数据类型元素的数组：每个元素位置存储对象（本质是存储对象的首地址）（在面向对象部分讲解）

2、按照维度分：

一维数组：存储一组数据
二维数组：存储多组数据，相当于二维表，一行代表一组数据。

一维数组

一维数组的声明

格式：

//推荐
元素的数据类型[] 一维数组的名称;

//不推荐
元素的数据类型  一维数组名[];

数组的静态初始化：

语句定义格式：数据类型[] 数组名 = new 数据类型[m];

1.数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
    
2.数据类型[] 数组名;
  数组名 = new 数据类型[]{元素1,元素2,元素3,...};

3.数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分成两个语句写

例如：

int[] arr = new int[]{1,2,3,4,5};

//或
int[] arr;
arr = new int[]{1,2,3,4,5};

//或
int[] arr = {1,2,3,4,5};

数组的动态初始化：

数组变量的初始化和数组元素的赋值操作分开进行，即为动态初始化。

当我们使用动态初始化方式创建数组时，元素值是默认值0。

动态初始化中，只确定了元素的个数（即数组的长度），而元素值此时只是默认值，还并未真正赋自己期望的值。真正期望的数据需要后续单独一个一个赋值。

格式：

数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];

或

数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];

例如：

int[] arr = new int[5];

int[] arr;
arr = new int[5];

一维数组的使用

数组的长度

数组的元素总个数，即数组的长度
每个数组都有一个属性length指明它的长度，例如：array.length 指明数组arr的长度
每个数组都具有长度，而且一旦初始化，其长度就是确定，且是不可变的

数组元素的引用

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个编号称为数组索引或下标，可以通过数组的索引/下标访问到数组中的元素。

索引范围**

Java中数组的索引从[0]开始，索引范围是[0, 数组的长度-1]，即[0, 数组名.length-1]

一维数组的遍历

例：

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        //打印数组的属性，输出结果是5
        System.out.println("数组的长度：" + arr.length);

        //遍历输出数组中的元素
        System.out.println("数组的元素有：");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
    }

二维数组

二维数组：元素为一维数组的数组

二维数组的定义

语句定义格式1：
数据类型[][] 数组名 = new 数据类型[m][n];

举例：创建由3个长度为4的一维数组组成的二维数组，元素是int类型

int[][] arr1 = new int[3][4];
int[] arr2[] = new int[3][4];
int arr3[][] = new int[3][4];
int [] [] arr4 = new int[3][4];

public static void main(String[] args) {
          int[][] arr1 = new int[3][4];
//        int[] arr2[] = new int[3][4];
//        int arr3[][] = new int[3][4];
//        int [] [] arr4 = new int[3][4];
        System.out.println(arr1);
        System.out.println(arr1[0]);  // 获取第一个一维数组
        System.out.println(arr1[0][0]); //获取第一个一维数组中的第一个元素
    }

二维数组语句定义格式2：
数据类型[][] 数组名 = new 数据类型[m][];

public static void main(String[] args) {
        int[][] arr1 = new int[3][];
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        System.out.println("------------------------");
        int[] arr2 = {1,2,3,4,5};
        int[] arr3 = {1,2,3};
        int[] arr4 = {1,2,3,4,5,6,7,8};
        arr1[0] = arr2;
        arr1[1] = arr3;
        arr1[2] = arr4;
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }

二维数组语句定义格式3：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..},....};

简化写法：数据类型[][] 数组名 = {{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..},....};

 public static void main(String[] args) {
        /*
            int[] arr2 = {1,2,3,4,5};
            int[] arr3 = {1,2,3};
            int[] arr4 = {1,2,3,4,5,6,7,8};
         */
//      int[][] arr1 = new int[][]{{1,2,3,4,5},{1,2,3},{1,2,3,4,5,6,7,8}};
        int[][] arr1 = {{1,2,3,4,5},{1,2,3},{1,2,3,4,5,6,7,8}};

        //获取第3个一维数组中的第4个元素
        System.out.println(arr1[2][3]);
    }

二维数组的初始化

静态初始化：

格式：

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

说明：定义一个名称为arr的二维数组，二维数组中有三个一维数组

每一个一维数组中具体元素也都已初始化
- 第一个一维数组 arr[0] = {3,8,2};
- 第二个一维数组 arr[1] = {2,7};
- 第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

动态初始化：

如果二维数组的每一个数据，甚至是每一行的列数，需要后期单独确定，那么就只能使用动态初始化方式了。动态初始化方式分为两种格式：

格式1：规则二维表：每一行的列数是相同的

例：

int[][] arr = new int[3][2];

说明：

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素

格式2：不规则：每一行的列数不一样

例：

int[][] arr = new int[3][];

说明：

二维数组中有3个一维数组。
每个一维数组都是默认初始化值null（注意与一维数组默认值区分）

二维数组的遍历：

public class Array2Demo4 {
    public static void main(String[] args) {
        int[][] arr1 = {{1, 2, 3, 4, 5}, {1, 2, 3}, {1, 2, 3, 4, 5, 6, 7, 8}};
        //双重for循环
//        for(int i=0;i<arr1.length;i++){ // 得到每个一维数组
//            for(int j=0;j<arr1[i].length;j++){ // 得到每个一维数组中每个元素
//                System.out.println(arr1[i][j]);
//            }
//            System.out.println("----------------------");
//        }

        for(int i=0;i<arr1.length;i++){ // 得到每个一维数组
            printIntArray(arr1[i]);
            System.out.println("====");
        }
    }

    public static void printIntArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }
}

数组的常见算法

数值型数组特征值统计

数组统计：求总和、均值

		int[] arr = {4,5,6,1,9};
        //求总和、均值
        int sum = 0;//因为0加上任何数都不影响结果
        for(int i=0; i<arr.length; i++){
            sum += arr[i];
        }
        double avg = (double)sum/arr.length;

        System.out.println("sum = " + sum);
        System.out.println("avg = " + avg);

数组获取最值(获取数组中的最大值最小值)
**

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] arr3 = {123, 4, 1, 3, 6};

        int maxNum2 = getMaxNumber(arr3);
        System.out.println("数组中的最大值为：" + maxNum2);
        int minNum2 = getMinNumber(arr3);
        System.out.println("数组中的最小值为：" + minNum2);
    }
    /*
       定义一个方法所需要考虑的东西：
       1、返回值类型 int
       2、参数类型和个数 int[] arr
   */
    public static int getMinNumber(int[] arr) {
        if (arr == null) {
            return -1;
        }
        //默认将第一个元素作为最小值
        int minNum = arr[0];
        //从第二个元素遍历数组，与minNum变量值进行比较，如果比它小，直接覆盖旧值
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < minNum) {
                minNum = arr[i];
            }
        }
        return minNum;
    }

    /*
       定义一个方法所需要考虑的东西：
       1、返回值类型 int
       2、参数类型和个数 int[] arr
   */
    public static int getMaxNumber(int[] arr) {
        if (arr == null) {
            return -1;
        }
        //默认将第一个元素作为最大值
        int maxNum = arr[0];
        //从第二个元素遍历数组，与maxNum变量值进行比较，如果比它大，直接覆盖旧值
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNum) {
                maxNum = arr[i];
            }
        }
        return maxNum;
    }
}

数组元素逆序**

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println("反转之前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //反转
         /*
        思路：首尾对应位置的元素交换
        （1）确定交换几次
           次数 = 数组.length / 2
        （2）谁和谁交换
        for(int i=0; i<次数; i++){
             int temp = arr[i];
             arr[i] = arr[arr.length-1-i];
             arr[arr.length-1-i] = temp;
        }
         */
        for(int i=0; i<arr.length/2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }

        System.out.println("反转之后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

标签：arr,Java,记录,int,元素,数据类型,学习,数组,new
From： https://www.cnblogs.com/yinzhanpeng123/p/18671494

大数据学习记录，Java基础（2）

数组