Java_数组

Java_数组

1.数组的概念：是一种容器，可以同时存放多个数据值
2.数组的特点：
（1）数组是一种引用数据类型
（2）数组当中的多个数据，类型必须统一
（3）数组的长度在程序运行期间不可改变
3.数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值
4.数组初始化方式：
（1）动态初始化：指定长度
（2）静态初始化：指定内容
5.动态初始化数组的格式：

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

public class test{
    public static void main(String[] args){
        //创建一个数组，存放100个int类型的数据
        int[] arrayA=new int[100];

        //创建一个数组，存放50个doubel类型的数据
        double[] arrayB=new double[50];

        //创建一个数组，存放10个字符串类型的数据
        String[] arrayC=new String[10];
    }
}

6.静态初始化基本格式：
注意：可以根据数组里面的具体内容，推算出长度

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

public class test{
    public static void main(String[] args){
        //创建一个int类型的数组，存放1,2,3
        int[] arrayA=new int[] {1,2,3};

        //创建一个double类型的数组，存放5.6,8.7
        double[] arrayB=new double[] {5.6,8.7};

        //创建一个String类型的数组，存放"hello","world","java"
        String[] arrayC=new String[] {"hello","world","java"};
    }
}

7.静态初始化的省略格式：
注意事项：
（1）静态初始化没有直接指定长度，但是仍然可以自动推算得到长度
（2）静态初始化标准格式可以拆分成为两个步骤
（3）动态初始化也可以拆分成两个步骤
（4）静态初始化一旦使用省略格式，就不能拆分成两个步骤了

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

public class test{
    public static void main(String[] args){
        //省略格式的静态初始化
        int[] arrayA={1,2,3};

        //静态初始化的标准格式，可以拆分成两个步骤：
        // (1)步骤1：
        int[] arrayB;

        // (2)步骤2：
        arrayB=new int[] {4,5,6};

        //动态初始化也可以拆分成两个步骤：
        // (1)步骤1：
        int[] arrayC;

        // (2)步骤2：
        arrayC=new int[7];
    }
}

8.访问数组的格式：数组名称[索引值]
（1）索引值：int类型的数字，代表数组中元素的编号
（2）索引值从0开始，一直到“数值长度-1”为止
（3）直接打印数组名称，得到的是数组对应的内存地址哈希值

public class test{
    public static void main(String[] args){
        int[] arrayA=new int[] {1,2,3};

        //直接打印数组中的元素
        System.out.println(arrayA[0]); //1
        System.out.println(arrayA[1]);  //2
        System.out.println(arrayA[2]);  //3

        //将数组中的元素赋值交给变量，然后打印
        int num1=arrayA[2];
        System.out.println(num1);  //3
    }
}

9.使用动态数组时，其中的元素会自动拥有一个默认值，规则如下：
（1）整数类型，默认为0；
（2）浮点类型，默认为0.0；
（3）字符类型，默认为’\u0000’；
（4）布尔类型，默认为false；
（5）引用类型，默认为null；

10.java的内存划分：

（1）栈（Stack）：存放的都是方法中的局部变量，方法的运行一定要在栈中进行

• 局部变量：方法的参数，或者是方法{}内部的变量
• 作用域：一旦超出作用域，立刻从栈内存当中消失

（2）堆(Heap)：凡是new出来的东西，都在堆中

• 堆内存里面的东西都有一个地址值：16进制
• 堆内存里面的数据，都有默认值。规则：
• 整数类型，默认为0；
• 浮点类型，默认为0.0；
• 字符类型，默认为’\u0000’；
• 布尔类型，默认为false；
• 引用类型，默认为null

（3）方法区（Method Area）：存储.class相关信息，包含方法的信息
（4）本地方法栈（Native Method Stack）：与操作系统相关
（5）寄存器（PC Register）：与CPU相关

11.数组赋值

public class test{
    public static void main(String[] args){
        int[] arrayA=new int[3];
        System.out.println(arrayA);  //内存地址
        System.out.println(arrayA[0]);  //0
        System.out.println(arrayA[1]);  //0
        System.out.println(arrayA[2]);  //0
        System.out.println("============");

        arrayA[1]=56;
        arrayA[2]=89;
        System.out.println(arrayA); //内存地址
        System.out.println(arrayA[0]);  //0
        System.out.println(arrayA[1]);  //56
        System.out.println(arrayA[2]);  //89
        System.out.println("============");

        int[] arrayB=arrayA;
        System.out.println(arrayB);  //内存地址
        System.out.println(arrayB[0]);  //0
        System.out.println(arrayB[1]);  //56
        System.out.println(arrayB[2]);  //89
        System.out.println("============");

        arrayB[1]=100;
        arrayB[2]=200;
        System.out.println(arrayB);  //内存地址
        System.out.println(arrayB[0]);  //0
        System.out.println(arrayB[1]);  //100
        System.out.println(arrayB[2]);  //200
        System.out.println("============");
    }
}

12.数组索引越界异常（ArrayIndexOutOfBoundsException）

public class test{
    public static void main(String[] args){
        int[] array={1,2,6};
        System.out.println(array[0]);  //1
        System.out.println(array[1]);  //2
        System.out.println(array[2]);  //6
        System.out.println(array[3]);  //数组索引越界异常
    }
}

13.空指针异常（NullPointerException）

（1）注意：

• 所有的引用类型变量，都可以赋空值（Null）
• 数组必须进行new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常

public class test{
    public static void main(String[] args){
        int[] array=null;
        // array=new int[]{1,2,3};
        System.out.println(array[0]);//空指针异常
    }
}

14.获取数组长度

（1）语法格式：

数组名称.length

（2）注意：数组一旦创建，程序运行期间，长度不可改变
（3）代码演示：

public class test{
    public static void main(String[] args){
        int[] array={1,5,8,4,554,951,5154,454,5,4,54,4,5,1};
        int len=array.length;
        System.out.println("数组长度为: "+len);//14
    }
}

15.数组的遍历

public class test{
    public static void main(String[] args){
        int[] array={1,8,2,54,554};
        
        //方法一：
        System.out.println(array[0]);  //1
        System.out.println(array[1]);  //8
        System.out.println(array[2]);  //2
        System.out.println(array[3]);  //54
        System.out.println(array[4]);  //554
        System.out.println("=============");

        //方法二：
        int len=array.length;//获取数组长度
        for(int i=0;i<len;i++){
            System.out.println(array[i]);
        }
    }

16.求数组的最大值

public class test{
    public static void main(String[] args){
        int[] array={1,8,2,54,554};
        int len=array.length;
        int max=array[0];
        for(int i=1;i<len;i++){
            if(max<array[i]){
                max=array[i];
            }
        }
        System.out.println("最大值为 "+max);//554
    }
}

17.求数组的最小值

public class test{
    public static void main(String[] args){
        int[] array={1,8,2,54,554};
        int len=array.length;
        int min=array[0];
        for(int i=1;i<len;i++){
            if(min>array[i]){
                min=array[i];
            }
        }
        System.out.println("最小值为 "+min);//1
    }
}

18.数组元素的反转：对称位置的元素交换

public class test{
    public static void main(String[] args){
        int[] array={1,5,89,46,78};
        int len=array.length;

        //正向输出{1,5,89,46,78};
        for(int i=0;i<len;i++){
            System.out.println(array[i]);
        }
        System.out.println("=============");

        //反向输出{78,46,89,5,1};
        for(int min=0,max=len-1;min<max;min++,max--){
            int temp=array[min];
            array[min]=array[max];
            array[max]=temp;
        }
        for(int i=0;i<len;i++){
            System.out.println(array[i]);
        }
    }
}

19.数组的方法调用

（1）注意：

• 数组可以作为方法的参数
• 当调用方法的时候，向方法的小括号中进行传参，传递进去的其实是数组的地址值

（2）代码展示：

public class test{
    public static void main(String[] args){
        int[] array={45,445,5456};
        System.out.println(array);//地址值
        arrayPrint(array);//传入的是array中保存的地址值
    }

    //数组的方法调用
    public static void arrayPrint(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

20.使用数组作为返回值类型

（1）注意：

• 任何数据类型都能作为方法的参数类型，或者是返回值类型
• 数组作为方法的参数，传递进去的是数组的地址
• 数组作为方法的返回值，返回的是数组的地址

public class test{
    public static void main(String[] args){
        int[] result=calculata(1, 8, 7);
        System.out.println(result);  //[I@372f7a8d
        System.out.println("sum= "+result[0]);  //sum= 16
        System.out.println("avg= "+result[1]);  //avg= 5
    }
    public static int[] calculata(int a,int b,int c){
        int sum=a+b+c;
        int avg=sum/3;
        int[] array={sum,avg};
        System.out.println(array);  //[I@372f7a8d
        return array;
        
    }
}