Java（五）：Java（初级）数组

一、数组概述

1.1 概念

1. 数组是相同类型数据的有序集合
2. 每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问

1.2 特点

1. 长度是确定的，数组一旦被创建，它的大小就不可以改变
2. 元素类型必须相同，不允许出现混合类型
3. 元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于是该对象的成员变量。数组本身就是对象，在Java中对象是存储在堆中的。

二、数组的初始化

数组的初始化有两种方式，分别是动态初始化和静态初始化，具体如下：

2.1动态初试化

 数据类型[] 数组名称 = new 数据类型[数组长度]；
 Eg: int[] array = new int[10];

2.2 静态初始化

2.2.1 标准格式

 数据类型[] 数组名称 = new 数据类型[]{元素1，元素2…};

2.2.2 省略格式

 数据类型[] 数组名称 = {元素1，元素2…};

2.3 注意事项

1. 直接打印数组名称会得到在内存中的哈希值，如下：
     [I@14ae5a5，其中[代表是数组，大写字母I代表里面的元素是int类型，14ae5a5是十六进制数
   
2. 所有的引用类型都可以赋值为null，代表其中什么都没有，如果进行使用将会报空指针异常的错误。当使用数组作为返回值的时候，接收变量也应该使用数组类型的变量来接收。
3. 如果获取使用数组的元素不在数组的长度区间范围内，会报ArrayIndexOutOfBoundsException的错误！

package cn.lesson_ip;

public class ArrayDemo01 {
    public static void main(String[] args) {
//        三种不同额的初始化方式
//        1.动态初始化-指定长度(包含默认初始化)
        int[] arrays01 = new int[5];
        arrays01[0] = 1;
        for (int i = 0; i < arrays01.length; i++) {
            System.out.println(arrays01[i]);

        }
        System.out.println("==============");
//        2.静态初始化-指定内容（标准格式）
        int[] arrays02 = new int[]{1,2,3,4,5};
        for (int i = 0; i < arrays02.length; i++) {
            System.out.println(arrays02[i]);

        }
        System.out.println("==============");
//        3.静态初始化-指定内容（省略格式）
        int[] arrays03 = {1,2,3,4,5};
        for (int i = 0; i < arrays03.length; i++) {
            System.out.println(arrays03[i]);
        }
    }
}

2.4 补充

Java的内存需要划分为5个部分：

1. 栈（Stack）：存放的都是方法中的局部变量（方法的参数，或者是方法{}内部的变量）。方法的运行一定要在栈当中。
2. 堆（Heap）：凡是new出来的东西，都在堆当中。堆内存中的内容都有一个地址值：16进制。堆内存里面的数据，都有一个默认值，根据类型不同都是0。
3. 方法区（Method Area）：存储.class相关信息，包含方法的信息。
4. 本地方法栈（Native Method Stack）:与操作系统有关
5. 寄存器（PC Register）:与CPU相关
   
   
   

三、数组的使用

3.1 For-Each循环

package cn.lesson_ip;

public class ArrayDemo03 {
    public static void main(String[] args) {
//        3.静态初始化-指定内容（省略格式）
        int[] arrays03 = {1,2,3,4,5};
        printMethod(arrays03);
    }
    public static void printMethod(int[] arrays03) {
        for (int array : arrays03) {
            System.out.println(array);
        }
    }

}

注：如果方法前不加static关键字，在main方法中调用printMethod需要使用类对象.方法名（）的方法来调用。

3.2 数组作为方法入参

package cn.lesson_ip;

public class ArrayDemo03 {
    public static void main(String[] args) {

        int[] arrays03 = {1,2,3,4,5};
        printMethod(arrays03);
    }
    public static void printMethod(int[] arrays03) {
        for (int array : arrays03) {
            System.out.println(array);
        }
    }

}

3.3 数组作为返回值

package cn.lesson_ip;
//数组反转案例
public class ArrayDemo04 {
    public static void main(String[] args) {

        int[] arrays03 = {1,2,3,4,5};
        reverse(arrays03);
    }
    public static void reverse(int[] arrays03) {
//数组反转
//        定义存放反转后结果的数组
        int[] result = new int[arrays03.length];
        for (int i = 0,j = arrays03.length-1; i < arrays03.length; i++,j--) {
            result[j] = arrays03[i];
        }
        for (int xx : result) {
            System.out.println(xx);
        }
    }

}

四、Arrays类

关于数组的工具类Arrays，在使用时，不需要创建对象，直接通过类名.方法名（）的方式使用。

冒泡排序

1. 比较数组中俩个相邻元素，如果第一个数比第二个大，交换位置
2. 每次比较会产生一个最大或者最小的数
3. 下次循环会减少一次循环
4. 依次循环，直接结束

package cn.lesson_ip;

import java.util.Arrays;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] arrats = {2,545,45,845,4,94,4};
        int[] result =  sort(arrats);
        System.out.println(Arrays.toString(result));
    }

    public static int[] sort(int[] array){
        int temp;
//        外层循环，判断要循环几次
        for (int i = 0; i < array.length - 1; i++) {
//            内层循环，比较俩个数的大小，交换位置
            for (int j = 0; j < array.length -1-i; j++) {
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

五、稀疏数组

package cn.lesson_ip;

public class ArrayDemo06 {
    public static void main(String[] args) {
//        定义原始棋盘数组，指定数据值
        int[][] array01 = new int[5][5];
        array01[1][2]= 1;
        array01[2][3] = 2;
        System.out.println("输出原始数组如下：");
        for (int[] ints : array01) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("*-*-*-*-*-*-*-*-*-*");
//        获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array01[0].length; i++) {
            for (int j = 0; j < array01[1].length; j++) {
                if(array01[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("数组中有效值的个数为："+sum);
        System.out.println("*-*-*-*-*-*-*-*-*-*");
//创建接收稀疏数组的数组
        int[][] array02 = new int[sum+1][3];
        array02[0][0] = 5;
        array02[0][1] = 5;
        array02[0][2] = sum;
//遍历二维数组，将非零的值存放在稀疏数组中
        int count= 0;
        for (int i = 0; i < array01.length; i++) {
            for (int j = 0; j < array01[i].length; j++) {
                if (array01[i][j]!=0){
                    count++;
                    array02[count][0] = i;
                    array02[count][1] = j;
                    array02[count][2] = array01[i][j];
                }
            }
        }
//        输出稀疏数组
        System.out.println("稀疏数组:");
        for (int[] ints : array02) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }              
    }
}

六、ArrayList

  针对数组定义后数组长度无法改变这一缺点，我们可以使用ArrayList来解决。ArrayList是大小可变的数组，存储在内部的元素称为元素，可向其中添加元素，动态增长。

基本类型	包装类（引用类型）
int	Integer
byte	Byte
short	Short
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

系列
Java（一）：Java初识
Java（二）：Java基础语法
Java（三）：Java流程控制
Java（四）：Java方法