Java基础009-数组

数组

数组：数组是Java提供的一种容器，可以存放多个数据。数组的创建是存放在堆中的，栈中只有存放数组内存地址的数组变量。

特点：

1. 数组是一种引用数据类型。
2. 数组中当有多个数据，数据类型必须统一。
3. 数组的长度在程序运行期间不能改变。

数组初始化

含义：在内存中创建一个数组，并且向其中赋予一些默认值。

两种初始化方式：

• 静态初始化（指定内容）

  • 静态初始化标准格式：

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

  • 静态初始化省略格式：

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

  • 静态初始化拆分格式：

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

• 动态初始化（指定长度）

  • 动态初始化标准格式：

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

举例1:

public class Test {
    public static void main(String[] args){
        //静态创建数组
        {
            //创建一个int数据类型的数组。
            int [] array = new int[]{1, 2, 3, 4};
        }{
            //创建一个float类型的数组。
            float [] array = new float[]{1.23F,3.14F,1.22F};
        }{
            //创建一个字符串类型的数组
            String[] array = new String[]{"aa","bb","cc"};
        }{
            //使用拆分方式创建一个short类型的数组
            short[] array;
            array = new short[]{12,13,14};
        }{
            //使用省略方式创建一个double类型的数组
            double[] arrayC2 = {12.2,21.4,12.5};
        }
        //动态创建数组
        {
            //创建一个长度是10的int类型的数组
            int[] array = new int[10];
        }{
            //创建一个长度是10的float类型。
            float[] array = new float[10];
        }{
            //创建一个长度是10的字符串类型的数组。
            String[] array = new String[10];
        }
    }
}

数组元素访问

访问数组元素格式：

[数组名称] [索引值];

举例2：

public class Test {
    public static void main(String[] args){
        {
            //创建一个int数据类型的数组。
            int [] array = new int[]{10, 20, 30, 40};
            System.out.println(array);  //[I@1540e19d
            System.out.println(array[0]);   //10
            System.out.println(array[1]);   //20
            System.out.println(array[2]);   //30
            System.out.println(array[3]);   //40
            
            int num = array[1];
            System.out.println(num);    //20
        }{
            //创建一个int数据类型的数组。
            int [] array = new int[10];
            System.out.println(array);  //[I@677327b6
            System.out.println(array[0]);   //0
            System.out.println(array[1]);   //0
            System.out.println(array[2]);   //0
            System.out.println(array[3]);   //0
            
            int num = array[1];
            System.out.println(num);    //0
        }
    }
}

数组元素赋值

各类型数据类型的默认值：

数据类型	数组默认值
整数类型	0
浮点数类型	0.0
字符类型	'\u0000'
布尔类型	false
引用类型	null

举例3：

public class Test {
    public static void main(String[] args){
            //创建一个int数据类型的数组。
            int [] array = new int[3];
            System.out.println(array[0]);   //0
            System.out.println(array[1]);   //0
            System.out.println(array[2]);   //0
            //数组赋值
            array[0] = 123;
            System.out.println(array[0]);   //123
            System.out.println(array[1]);   //0
            System.out.println(array[2]);   //0
    }
}

数组其他操作

数组长度获取

格式：

[数组名称].length;	//返回值是int数据类型

数组的遍历

将数组中的元素逐个打印出来有三种方式。

举例4：

public class Test {
    public static void main(String[] args){
        
        int [] array = new int[]{12,13,14,15,16};
        //第一种方式
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
        //第二种方式
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
        //第三种方式
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        
    }
}

数组的最值

举例5：

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

        int [] array = new int[]{12,13,14,15,16,11,10,9};
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        System.out.println("最大值："+max);
        
    }
}

数组元素反转

举例6：

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

        int [] array = new int[]{10,20,30,40,50};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
        /*
            初始化语句：int min = 0,max = array.length - 1
            条件判断：min > max
            步进表达式：min++,max--
            循环体：用第三个变量到手
        */
        for (int min = 0,max = array.length - 1; min < max; min++,max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }

    }
}

对象数组

举例7：

package cn.test01;

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",20);
        Student stu3 = new Student("王五",22);
        Student[] array= new Student[]{stu1,stu2,stu3};
        System.out.println(array[0].getName());
        System.out.println(array[1].getName());
        System.out.println(array[2].getName());
    }
}

注意事项：

1. 静态创建数组虽然没有指定长度，但可以根据在数组初始化的时候，根据数组中数据的个数，确定数组的长度。
2. 静态初始化如果使用省略方式就不能进行拆分格式了。
3. 如果确定数组中的内容用静态初始化，否则用动态初始化。
4. 静态初始化也有默认值，不过是系统将默认值替换成大括号内的具体值。
5. 定义一个数组，每一个数组名称加索引值都等于是一个相同数据类型的变量。
6. 定义一个数组，被赋值了另一个数据，是赋值给的索引值。两个数组可同时操作堆里面的内容。因此数组的名称也叫做引用。这就是称为引用类型的原因。
7. 在访问数组元素的时候，如果索引编号不存在，将会发生数组索引越界异常。（java.lang.ArrayIndexOutOfBoundException）
8. 所有的引用数据类型，都可以被赋值一个null值。但是代表里面什么都没有。数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null，没有new创建，那么将会发生空指针异常。（Java.lang.NullPointerException）
9. 数组一旦创建在程序运行期间不可以改变，数组是存放在堆中的，数组的名称是存放在栈中的，而且只是堆中数组的一个引用，里面存放的是一个数组的引用，因此数组名称可以被其他相同数据类型的数组使用。
10. 数组可以作为方法的参数，当调用方法时，往方法内进行传参，传递进去的其实是数组的地址值。同理，数组作为返回值，返回的也是数组的地址值。