数组

数组的第一种定义格式，int[] arr

xxxxxxxxxx
数据类型[] 变量名 //定义了int类型的数组,数组名是arr。推荐使用这种写法定义数组

数组的第二种定义格式，int arr[]

xxxxxxxxxx
数据类型 变量名[] //定义了int类型的数组,变量名是arr数组

数组的动态初始化: 初始化时，只指定数组长度，由系统为数组分配初始值

数据类型[] 变量名 = new 数据类型[数组长度]
int[] arr = new int[3]

数组的静态初始化: 初始化时，指定每个数组元素的初始值，由系统决定数组长度

数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,……}
int[] arr = new int[]{1,2,3,……}
数据类型[] 变量名 = {数据1,数据2,数据3,……}
int[] arr = {1,2,3,……}

数组元素访问:

(1)数组变量的访问方式

数组名

(2)数组内部保存的数据的访问方式

数组名[索引]

内存分配: 数组元素、内存地址存放在堆，数组名存放在栈，数组名指向内存地址，数组在初始化时，会为存储空间添加默认值，相关默认值如下

堆内存

xxxxxxxxxx
存储局部变量，即存储定义在方法中的变量，例如arr
使用完毕立即消失

栈内存

xxxxxxxxxx
存储new出来的内容(实体、对象)。数组在初始化时，会为存储空间添加默认值 。每一个new出来的东西都有一个地址值
使用完毕立即消失

数组操作的两个常见小问题

(1)索引越界: 访问了数组中不存在的索引对应的元素

int[] sdk = new int[3];
System.out.println(sdk[3]);

(2)空指针异常: 访问的数组已经不再指向堆内存的数据

x
int[] gym = new int[3];
System.out.println(gym[2]);
//把null赋值给数组
gym = null;
//输出元素
System.out.println(gym[0]);

数组

xxxxxxxxxx
package ch1;

public class a2_1数组 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //输出数组名
        System.out.println(arr); //输出[I@2d98a335,为地址值
        //输出数组中的元素
        System.out.println(arr[0]);//输出0
        System.out.println(arr[1]);//输出0
        System.out.println(arr[2]);//输出0

        int[] svg = new int[3];

        //输出数组名及元素
        System.out.println(svg);
        System.out.println(svg[0]);
        System.out.println(svg[1]);
        System.out.println(svg[2]);

        //给数组中的元素赋值
        svg[0] = 100;
        svg[2] = 200;

        //再次输出数组名及元素
        System.out.println(svg);
        System.out.println(svg[0]);
        System.out.println(svg[1]);
        System.out.println(svg[2]);

        //栈内存的arr2和arr3都指向堆内存里面new int[3]
        //多个数组指向相同的内存图，如下
        int[] arr2 = new int[3];
        arr2[0] = 9;
        arr2[1] = 99;
        arr2[2] = 999;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

        //定义第二个数组指向第一个数组
        int[] arr3 = arr2;
        arr3[0] = 1;
        arr3[1] = 11;
        arr3[2] = 111;

        //输出两个数组的名及元素
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr3);
        System.out.println(arr3[0]);

        //简化格式,静态初始化定义数组
        int[] cfg = {1,2,3,4,5};

        //输出数组名
        System.out.println(cfg); //输出地址值

        //输出数组中的元素
        System.out.println(cfg[0]);
        System.out.println(cfg[1]);
        System.out.println(cfg[2]);
        System.out.println(cfg[3]);
        System.out.println(cfg[4]);

        //遍历数组中的每一个元素
        int[] syk = {11,22,33,44,55};
        for(int x=0; x<5; x++){
            System.out.println(syk[x]);
        }
        
        //如何在不知道原数组长度的情况下，对数组进行遍历，如下
        int[] gkh = {12,21,13,31,14,41,15,51};
        for(int n=0; n<gkh.length;n++){
            System.out.println(gkh[n]);
        }

        //获取数组中元素的最值
        int[] val = {2,45,21,8,57,9,10,34,76,35,47};
        //定义一个变量，用于保存最值
        //int max;
        //取数组中第一个数据作为max变量的初始值
        int max = val[0];
        //val[0]与数组中剩余的数据逐个比对
        for(int m=1; m<val.length; m++){
            //每次对比将最大值保存到变量中
            if(val[m] > max){
                max = val[m];
            }
        }
        //循环结束后打印变量的值
        System.out.println("max:" + max);
    }
}

数组遍历

x
public static void main(String[] args) {
    
        //print输出:多条输出语句不换行，在同一行输出
        System.out.print("hello");
        System.out.print("world");
        //println输出:语句之间自动换行
        System.out.println("");
        System.out.println("hello");
        System.out.println("world");

        //如何遍历数组
        //先定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {1,2,3,4,5,6,7,8,9,0};
        //再然后调用一下方法
        printArray(arr);
}

//再定义一个方法，用数组遍历通用格式对数组进行遍历
public static void printArray(int[] arr){
    System.out.print("[");
    for(int x = 0; x < arr.length; x++){
        //如果是最后一个元素直接打印
        if(x == arr.length-1){
            System.out.print(arr[x]);
        } else{
            //拼接字符串，加一个逗号
            System.out.print(arr[x] + ",");
        }
    }
    System.out.println("]");
}

数组最大值

x
public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {17,3,34,23,12,5,0,32};
        //调用
        int number = getMax(arr);
        System.out.println("number:" + number);
}
//定义一个方法，用来获取数组中的最大值
public static int getMax(int[] arr){
    int max = arr[0];
    for(int x = 1; x < arr.length; x++){
       if(arr[x] > max){
            max = arr[x];
        }
    }
    return max;
}

数组求和

xxxxxxxxxx
public static void main(String[] args) {
    //需求:求和的元素个位和十位都不能是7，并且只能是偶数
    //定义一个数组，用静态初始化完成数组元素的初始化
    int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
    //定义一个求和变量，初始值是0
    int sum = 0;
    //遍历数组，获取到数组中的每一个元素
    for(int x=0; x<arr.length; x++){
        //判断该元素是否满足条件
        if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0){
            sum += arr[x];
        }
    }
    //输出求和变量的值
    System.out.println("sum:" + sum);
}

数组内容相同

xxxxxxxxxx
//需求:比较两个数组的内容是否相同
public static void main(String[] args) {
    //定义两个数组，分别使用静态初始化完成数组元素的初始化
    int[] arr = {11, 22, 33, 44, 55};
    int[] arr2 = {11, 22, 33, 44, 55};
    //调用方法，用变量接收
    boolean flag = compare(arr, arr2);
    //输出结果
    System.out.println(flag);
}

//定义一个方法，用于比较两个数组内容是否相同
public static boolean compare(int[] arr, int[] arr2) {
    //首先比较数组的长度
    if (arr.length != arr2.length) {
        return false;
    }
    //然后遍历，比较数组中的每一个元素，只要有元素不同，返回false
    for (int x = 0; x < arr.length; x++) {
        if (arr[x] != arr2[x]) {
            return false;
        }
    }
    //最后循环结束后，返回true
    return true;
}

数组查找元素

x
public static void main(String[] args) {
    //调用一个数组，用静态初始化完成数组元素的初始化
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    //键盘录入要查找的数据，用一个变量接收
    Scanner sc = new Scanner(System.in);

    System.out.println("input a sum of 1-10");
    int number = sc.nextInt();

    //定义一个索引变量，初始值为-1
    int index = -1;

    //遍历数组，获取到数组中的每一个元素
    for (int x = 0; x < arr.length; x++) {
        //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
        if (arr[x] == number) {
            index = x;
            break;
        }
    }
    //输出索引变量
    System.out.println("index:" + index);
}

使用方法查找元素

x
public static void main(String[] args) {
    //调用一个数组，用静态初始化完成数组元素的初始化
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    //键盘录入要查找的数据，用一个变量接收
    Scanner sc = new Scanner(System.in);

    System.out.println("input a sum of 1-10");
    int number = sc.nextInt();

    //调用方法
    int index = getIndex(arr, number);

    //输出索引变量
    System.out.println("index:" + index);
}

//定义一个方法，用于查找指定的元素在数组中的索引
public static int getIndex(int[] arr, int number) {
    //定义一个索引变量，初始值为-1
    int index = -1;
    //遍历数组，获取到数组中的每一个元素
    for (int x = 0; x < arr.length; x++) {
        //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
        if (arr[x] == number) {
            index = x;
            break;
        }
    }
    //返回索引
    return index;
}

翻转数组元素

x
public static void main(String[] args) {

    //定义一个数组，用静态初始化完成数组元素的初始化
    int[] arr = {1, 2, 3, 4, 5, 6, 7};

    //循环遍历数组，这一次初始化语句调用两个索引变量，判断条件是开始索引小于等于结束索引
    for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
        //变量交换，定义一个临时变量temp
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
    //调用下面写好的方法，遍历数组
    printArray(arr);
}

//遍历数组，这里使用方法对数组进行遍历
public static void printArray(int[] arr) {
    System.out.print("[");

    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) { //当遍历到最后一个元素时
            System.out.print(arr[x]);
        } else { //如果遍历到的不是最后一个元素
            System.out.print(arr[x] + ",");
        }
    }
    System.out.println("]");
}

使用方法翻转数组

x
public static void main(String[] args) {
    //定义一个数组，用静态初始化完成数组元素的初始化
    int[] arr = {1, 2, 3, 4, 5, 6, 7};

    //调用下面写好的方法，实现翻转数组
    reverse(arr);
    //调用下面写好的方法，实现遍历数组
    printArray(arr);
}

//翻转数组，这里使用方法对数组进行翻转
public static void reverse(int[] arr){
    //循环遍历数组，这一次初始化语句调用两个索引变量，判断条件是开始索引小于等于结束索引
    for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
        //变量交换，定义一个临时变量temp
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}


//遍历数组，这里使用方法对数组进行遍历
public static void printArray(int[] arr) {
    System.out.print("[");
    for (int x = 0; x < arr.length; x++) {
        if (x == arr.length - 1) { //当遍历到最后一个元素时
            System.out.print(arr[x]);
        } else { //如果遍历到的不是最后一个元素
            System.out.print(arr[x] + ",");
        }
    }
    System.out.println("]");
}