Java Day05

一、数组

1.1 数组的定义和访问

1.1.1 容器概述

• 容器：是将多个数据存储到一起，每个数据称为该容器的元素

1.1.2 数组概念

• 数组概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致

1.1.3 数组的定义

方式一：

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

• 数组定义格式详解
  • 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
  • [ ]：表示数组
  • 数组名字：为定义的数组起个变量名，满足标示符规范，可以使用名字操作数组
  • new：关键字，创建数组使用的关键字
  • 数据存储的数据类型：创建的数组容器可以存储什么数据类型
  • [长度]：数组的长度，表示数组容器可以存储什么数据类型
  • 注意：数组有定长特性，长度一旦指定，不可更改。

package cn.itcast.day05.demo01;

/*
* 数组：是一种容器，可以同时存放多个数据值。
*
* 数组的特点：
* 1、数组是一种引用数据类型
* 2、数组当中的多个数据，类型必须统一
* 3、数组的长度在程序运行期间不能改变
*
* 数组的初始化：
* 两种常见的初始化方式：
*   1、动态初始化（指定长度）
*   2、静态初始化（指定内容）
*
* 动态初始化数组的格式：
*   数据类型[] 数组名称 = new 数据类型[数组长度]
* 解析含义：左侧数据类型，也就是数组当中保存的数据，全都是统一的什么类型
* 左侧的中括号，代表我是一个数组
* 左侧的数据名称：给数组取一个名称
* 右侧的new：代表创建数组的动作
* 右侧的数据类型：必须和左边的数据类型保持一致
* 右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字
* */

public class Demo01Array {
    public static void main(String[] args) {
        // 创建一个数组，里面可以存放300个int数据
        // 格式：数据类型[] 数组名称 = new 数据类型[数组长度]
        int[] arrayA = new int[300];

        // 创建一个数组能够存放10个double类型的数据
        double[] arrayB = new double[10];

        // 创建一个数组，能存放5个字符串
        String[] arrayC = new String[5];
    }
}

方式二：

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

package cn.itcast.day05.demo01;

/*
* 动态初始化：在创建数组的时候，直接指定数组当中的数据元素个数。
* 静态初始化：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
*
* 静态初始化的基本格式：
*   数据类型[] 数组名称 = new 数据类型[] {元素1， 元素2， 元素3...}
* 注意事项：
*   虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。
* */

public class Demo02Array {
    public static void main(String[] args) {
        // 直接创建一个数组，里面装的全部都是int数字，具体为：5、15、25
        int[] arrayA = new int[] {5, 15, 25};

        // 创建一个数组，用来装字符串："Hello"，"World"，"Java"
        String[] arrayB = new String[] {"Hello", "World", "Java"};
    }
}

方法三：

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

package cn.itcast.day05.demo01;

/*
* 静态初始化的基本格式：
*   数据类型[] 数组名称 = new 数据类型[] {元素1， 元素2， 元素3...}
* 省略格式：
*   数据类型[] 数组名称 = {元素1， 元素2， 元素3...}
*
* 注意事项：
*   1、静态初始化没有直接指定长度，但是仍然会自动推算得到长度
*   2、静态初始化标准格式可以拆分成为两个步骤
*   3、动态初始化也可以拆分为两个步骤
*   4、静态初始化一旦使用省略格式，就不能拆分为两个步骤了
*
* 使用建议：
*   如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
* */

public class Demo03Array {
    public static void main(String[] args) {
        int[] arrayA = {10, 12, 14};

        //静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] {11, 22, 33};

        // 动态初始化也可以拆分为两个步骤
        int[] arrayC;
        arrayC = new int[5];


    }
}

1.1.4 数组的访问

• 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组的索引，可以通过数组的索引访问到数组中的元素。
• 数组的长度：每个数组都有长度，而且是固定的，java中赋予了数组的一个属性，可以获取到数组的长度。语句为：数组名.length

package cn.itcast.day05.demo01;

/*
* 直接打印数组名称，得到的是数组对应的，内存地址的哈希值。
* 访问数组元素的格式：数组名[索引值]
* 索引值：就是一个int数字，代表数组当中的元素的编号
* 注意：索引值从0开始，一直到"数组的长度-1"为止
* */
public class Demo04ArrayUse {
    public static void main(String[] args) {
        int[] array = {10, 20, 30};

        // 直接打印数组当中的某一个单个元素
        System.out.println(array[0]);

        int num = array[1];
        // 也可以将数组当中的某一个单个元素，赋值给变量
        System.out.println(num);
    }
}

1.2 数组的内存

1.2.1 Java中虚拟机的内存划分

为了提高运算效率，对内存空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

1.2.2 数组在内存中的存储

• 一个数组的情况

package cn.itcast.day05.demo02;

public class Demo01ArrayOne {
    public static void main(String[] args) {
        int[] array = new int[3];  // 动态初始化
        System.out.println(array);  // 地址值
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println("=========================");

        // 改变数组当中元素的内容
        array[1] = 10;
        array[2] = 20;
        System.out.println(array);  // 地址值
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);


    }
}

• 两个数组的情况

package cn.itcast.day05.demo02;

public class Demo02ArrayTwo {
    public static void main(String[] args) {
        int[] arrayA = new int[3];  // 动态初始化
        System.out.println(arrayA);  // 地址值
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
        System.out.println("=========================");

        // 改变数组当中元素的内容
        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA);  // 地址值
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);

        int[] arrayB = new int[3];  // 动态初始化
        System.out.println(arrayB);  // 地址值
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);
        System.out.println("=========================");

        // 改变数组当中元素的内容
        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB);  // 地址值
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);



    }
}

• 两个变量指向一个数组

package cn.itcast.day05.demo02;

public class Demo03ArraySame {
    public static void main(String[] args) {
        int[] arrayA = new int[3];  // 动态初始化
        System.out.println(arrayA);  // 地址值
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);
        System.out.println("=========================");

        // 改变数组当中元素的内容
        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA);  // 地址值
        System.out.println(arrayA[0]);
        System.out.println(arrayA[1]);
        System.out.println(arrayA[2]);

        int[] arrayB = arrayA;  // 动态初始化
        System.out.println(arrayB);  // 地址值
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);
        System.out.println("=========================");

        // 改变数组当中元素的内容
        arrayB[1] = 100;
        arrayB[2] = 200;
        System.out.println(arrayB);  // 地址值
        System.out.println(arrayB[0]);
        System.out.println(arrayB[1]);
        System.out.println(arrayB[2]);


        System.out.println(arrayA[2]);


    }
}

1.3 数组的常见操作

1.3.1 数组越界异常

package cn.itcast.day05.demo03;

/*
* 数组的索引编号从0开始，一直到"数组的长度-1"为止
*
* 如果访问数组元素的时候，索引编号并不存在，那么将会发生数据索引越界异常
* ArrayIndexOutOfBoundsException
*
*
* */

import org.w3c.dom.ls.LSOutput;

public class Demo01ArrayIndex {
    public static void main(String[] args) {
        int[] array = {15, 25, 35};
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        // 错误写法
        // 并不存在3号元素，所以发生异常
//        System.out.println(array[3]);
    }
}

1.3.2 数组空指针异常

package cn.itcast.day05.demo03;

/*
* 数组必须进行new初始化才能使用其中的元素。
* 如果只是赋值了一个null，没有进行new创建
* 那么将会发生
* 空指针异常：NullPointerException
* */

public class Demo02ArrayNull {
    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array[0]);
    }
}

1.3.3 数组的遍历

• 数组遍历：就是将数组中的每个元素获取出来

package cn.itcast.day05.demo03;

/*
* 遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个处理，默认的处理方式就是打印输出
* */

public class Demo04Array {
    public static void main(String[] args) {
        int[] array = {15, 25, 35, 45, 55, 75};
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }
}

1.3.4 获取数组最大值

package cn.itcast.day05.demo03;

public class Demo04ArrayMax {
    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};
        int max = 0;
        for(int i = 0; i < array.length; i++){
            if(i == 0){
                max = array[i];
            } else if(array[i] > max) {
                max = array[i];
            }
        }
        System.out.println(max);
    }
}

1.3.5 数组反转

package cn.itcast.day05.demo03;

/*
* 数组元素的反转：
* 要求不能使用新数组，就用原来的唯一一个数组
*
* */

public class Demo07ArrayReverse {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//        for (int i = 0; i < array.length; i++) {
//            int temp = array[i];
//            array[i] = array[array.length - i - 1];
//            array[array.length - i - 1] = temp;
//            if(i == array.length-i-1){
//                break;
//            } else if (i > array.length-i-1){
//                break;
//            }
//        }
        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.println(array[i]);
        }
    }
}

1.4 数组作为方法参数和返回值

1.4.1数组作为方法参数

• 数组作为方法参数传递，传递的是数组的内存地址

package cn.itcast.day05.demo04;
/*
* 数组可以作为方法的参数
* 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
* */

public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.println(array);
        printArray(array);
    }
    /*
    三要素：
    返回值类型：只是进行打印而已，不需要进行计算，没有返回值
    方法名称：printArray
    参数列表：数组
    */

    public static void printArray(int[] array) {
        System.out.println(array);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

1.4.2 数组作为方法的返回值

• 数组作为方法的返回值，返回的是数组的内存地址

package cn.itcast.day05.demo04;

/*
* 一个方法可以有多个参数；但是只能有0个或者1个返回值，不能有多个返回值。
* 如果希望一个方法中产生了多个结果数据能进行返回，怎么办；
* 解决方案：使用一个数组作为返回值类型即可
*
* 任何数据类型都能作为方法的参数类型，或者返回值类型；
* 数组作为方法的参数，传递进去的其实是数组的地址值
* 数组作为方法的返回值，返回的其实也是数组的地址值
* */

public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int[] result = calculate(10, 20, 30);
        System.out.println("总和：" + result[0]);
        System.out.println("平均数：" + result[1]);
    }
    public static int[] calculate(int a, int b, int c) {
        int sum = a + b + c;
        int avg = sum / 3;

        // 两个结果都希望进行返回
        // 需要一个数组来保存多个结果
//        int[] array = new int[2];
//        array[0] = sum;
//        array[1] = avg;
        int[] array = {sum, avg};
        return array;
    }
}