了解数组（#）

（以下内容部分为原创，另加入狂神说、黑马程序员等素材仅供个人学习使用）

一组相同类型数据的集合称为数组，数组中的每个数据成为元素 声明创建数组

模板：

public static void main(String[] args) {
        int[] str =new int[10];//创建数组
        //数组长度为：str.length
        str[0] = 1;
        str[1] = 2;
        System.out.println("str[0]="+str[0]);//str[0] = 1
    }

创建数组：

一、数据类型[ ] 数组名 = new 数据类型[长度];（此为动态初始化格式，具体初始化见下文）

二、数据类型[ ] 数组名 = null;

数组长度：数组名.length

索引：

如上代码：str数组拥有十个元素,每个数组都有一个特定的编号，自动编号成为数组索引，通过数组索引可以准确的访问某个编号的元素。

索引的范围是0~“数组长度-1” 即str[0]----str[9]

方法栈：存储局部变量，定义在方法中的变量。例如：str。使用完毕后立即消失。堆内存：存储new出来的内容（实体，对象）main方法进栈执行，Java会对str变量在堆内存中开辟出特定内存（具有特定地址）

此中引用型变量str中储存的是在堆内存的地址而不是某一元素当数据索引某一编号的元素时，则会先指向在堆内存中的地址，后取出对应编号下的元素 堆栈内存的区别

栈内存：运行方法的内存，无默认值，使用时需要手动赋值堆内存：存储实体的内存，具有默认值 多数组内存

public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 1;
        arr[1] = 2;
        arr[2] = 3;
        System.out.println("arr的地址为"+arr);
        System.out.println("arr[1]="+arr[1]);//2
        int[]  arr2 = arr;   // arr与arr2将指向统一地址名
        arr2[0] = 4;
        arr2[1] = 5;
        arr2[2] = 6;
        System.out.println("arr2的地址为："+arr2);
        System.out.println("arr2[1]="+arr2[1]);//5
    }

int[] arr2 = arr; 后arr2与arr将指向同一地址名，此时可以通过给arr2[ i ]赋值来改变arr[ ]的值代码输出为： 初始化

动态初始化: 定义数组时只定义数组长度，由系统自动为元素赋值

静态初始化：在定义数组的同时为每个元素赋值

public static void main(String[] args) {
        int[] str1 = new int[]{1,2,3,4,5};//静态初始化
        int[] str11 = {1,2,3,4,5};//（推荐）静态初始化
        int[] str2 = new int[3];//动态初始化
        int[] str3;
        str3 = new int[3];
    }

静态初始化：

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

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

空指针异常：

public static void main(String[] args) {
        int[] str = {1,2,3,4,5};//静态初始化
        System.out.println("str[0]="+str[0]);
        str = null;
        System.out.println("str[0]="+str[0]);
}
//变量必须指向一个有效的数组对象，变量值为null，即未指向任何数组
//报错：NullPointerException空指针异常

越界异常

public static void main(String[] args) {
        int[] str = {1,2,3,4,5};//静态初始化
        System.out.println("str[5]="+str[5]);
}
//当索引数据编号超出数组长度范围，出现越界异常 
// * ArrayIndexOutOfBoundsException

如代码所示：str数组只有五个元素，因此该数组长度应该为4，str[5]则超过了数组长度范围

定义：依次访问数组中的每一个元素，将某一数组中的元素，逐一打印

public class Demo07 {
    public static void main(String[] args) {
        int[] str = new int[]{1,2,3,4,5};//定义静态初始化数组
        for (int ntr : str) {//增强for循环  格式（str.for）
            
            System.out.println(ntr);//打印str数组中所有元素
        }
        System.out.println("=================================================");
        int[] simon = simon(str);
        
        buling(simon);
    }
    public static int[] simon(int[] arrays){//反转数组
        int[] result = new int[arrays.length];//新建与arrays长度相同的一个数组
        for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
            /**
             * arrays（i）长度为5  0 1 2 3 4     i
            result[j] = arrays[i];
        }
        return result;//result数组作为返回值
        //此时result数组为反转后的arrays数组
    }
    public static int[] zoe(int[] arrays){// 打印数组所有元素
        for (int array : arrays) {
            System.out.println(array);
        }
        return arrays;
    }
    public static void buling(int[] arrays){//打印数组所有元素（逐个打印）
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+" ");
        }
    }
}

由上述代码可以了解到知道

打印某一数组中的全部元素两种方法：

for-each循环，即增强for循环，直接打印出数组中所有元素的值。

格式：数组名.for

普通for循环，逐个打印

//获取最大值
public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        int max = limit(arrays);
        System.out.println(max);
    }
    public static int limit(int[] arrays){//最大值
        int limit = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (limit