java:数组(一维数组)

数组：

现在需要统计某公司员工，例如计算平均工资，找到最高工资等；

假设该公司有80人，用之前所学的方法，我们需要定义80变量来分别记住每个员工的工资，这样会显得很麻烦。为了解决这一文体，Java提供了数组给我们使用；

那什么是数组呢？有什么用呢？通过上面的问题我们知道：

1.数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

2.数组既可以存储基本数据类型，也可以存储引用数据类型。

语句定义格式：

1.数据类型[ ] 数组名：int[ ] arr;(推荐第一种方式)

2.数据类型 数组名[ ]：int arr[ ];定义一个存放int类型数据的数组；

原因：因为第一种方式一眼就能看出来是一个数组，从长久看来日后的使用趋势是第一种，第二种会逐渐被淘汰；

数组初始化：

1.动态初始化：

数据类型[] 数组名=new存放数据的类型[];

int[] arr=new int[3];

2.静态初始化：初始化定义每个元素的初值，由系统决定数组长度；

public class Cherris {
    public static void main(String[] args) {
        //第一种格式定义
//        int[] arr;
        //第二种格式定义
//        int arr1[];
        //没有初始化能直接赋值
//        System.out.println(arr);

        //动态初始化一个数组:定义一个可以存放3个int类型数据的数组。
        /**
         *  左半部分：
         *      int: 表示数组中存放元素的数据类型是int类型
         *      []: 表示是一个一维数组
         *      arr: 数组名字，符合标识符规则
         *
         *  右半部分：
         *      new: 就是为数组在堆内存中开辟一个内存空间
         *      int: 表示数组中存放元素的数据类型是int类型
         *      []: 表示是一个数组
         *      3: 表示数组中最多可以存放元素的个数（数组本身的长度）
         *      ;: 表示一个语句的结尾
         *
         */
        int[] arr = new int[3];
        //[I@4554617c arr数组在堆内存中的地址值，地址是一个十六进制的形式。
        System.out.println(arr);

        //我们仅仅获取的是一个地址值是没有任何意义的，
        //我们更期望获取的是数组中的元素
        //如何获取数组中的元素呢？
        //java在数组中提供了一个类似于下标的说法，我们可以通过下标获取到该下标位置上的元素
        //这个下标有一个专业的叫法：索引(index)
        //从左往右编号，从0开始
        // 举例：现在数组的长度是3，索引从0开始，最大可以到2，也就是长度-1
        // 获取数组元素的格式：数组名[想要获取元素的对应索引]
        System.out.println(arr[0]); //获取第一个元素 0
        System.out.println(arr[1]); //获取第二个元素 0
        System.out.println(arr[2]); //获取第三个元素 0




    }
}

2.如何给数组中的元素进行赋值：通过数组中的索引赋值

public class Cherris {
    public static void main(String[] args) {
        //定义一个数组并动态初始化
        //定义一个存放int元素类型的数组，最多可以存放3个。
        int[] arr = new int[3];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("============================");
        //手动赋值
        //给数组中第一个元素进行赋值
        arr[0] = 10;
        //给数组中第二个元素进行赋值
        arr[1] = 20;
        //给数组中第三个元素进行赋值
        arr[2] = 30;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);


    }
}

定义两个数组，并赋值输出：

public class Cherris {
    public static void main(String[] args) {
        //定义第一个数组
        int[] arr1 = new int[3];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("============================================");
        //定义第二个数组
        int[] arr2 = new int[4];
        arr2[0] = 100;
        arr2[1] = 200;
        arr2[2] = 300;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);



    }
}

定义两个数组，先定义第一数组进行赋值输出，在定义第二个数组，把第一个数组的地址赋值给第二个数组，然后给第二个数组赋值，再次输出两个数组的名和元素；

public class Cherris {
    public static void main(String[] args) {
        //定义第一个数组
        int[] arr1 = new int[3];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        //定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
        int[] arr2 = arr1;
        arr2[0] = 100;
        arr2[1] = 200;
        System.out.println(arr1);
        System.out.println(arr2);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}

一维数组的静态初始化：

静态初始化的语句格式：

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

int[] arr=new int[]{1,2,3,4,5}

表示定义一个存放五个int类型元素的数组，元素名为1,2,3,4,5

简化版：

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

int[] arr={1,2,3,4,5}

表示定义一个存放五个int类型元素的数组，元素名为1,2,3,4,5

public class Cherris {
    public static void main(String[] args) {
        //定一个数组并静态初始化
        int[] arr = {100,200,300,400};
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);

    }
}

数组中常见的错误：数组索引越界异常，空指针异常；

/*
        数组中常见的错误：
            1、ArrayIndexOutOfBoundsException: 5  数组索引越界异常
                访问了不该访问的索引。

            2、NullPointerException 空指针异常
 */
public class Cherris {
    public static void main(String[] args) {
        //定义一个数组，静态初始化
        int[] arr = {11,22,33,44,55};

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
//        System.out.println(arr[5]);

        arr = null;
        System.out.println(arr[0]);

    }
}

数组遍历（依次输出数组中的每一个元素）

public class ArrayDemo7 {
    public static void main(String[] args) {
        //定义一个数组并动态初始化
//        int[] arr = new int[3]{11,22,33};
        //注意动态初始化不能与静态初始化混合使用！！
        int[] arr = new int[8];
        //手动获取每个元素并赋值
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        arr[3] = 44;
        arr[4] = 55;
        arr[5] = 66;
        arr[6] = 77;
        arr[7] = 88;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println(arr[5]);
        System.out.println(arr[6]);
        System.out.println(arr[7]);
//        System.out.println(arr[8]);

        System.out.println("=======用for循环改进========");
        for(int i=0;i<=7;i++){
            System.out.println(arr[i]);
        }
        System.out.println("=======用for循环改进2=======");
        //由于上面的数组我们一眼就可以数清有多少个元素，所以在循环的时候，可以确定一个范围
        //但是呢，真正的开发中，数组中的元素远远不止这么点，可能会有很多
        //这时候我们再去数的话，不仅会数错，而且消耗大量时间
        //那怎么办？我想要用for循环，就必须得确定一个范围
        //如果有一个办法可以获取数组的长度就好了
        //java中数组提供了一个属性供我们使用，可以获取数组的长度
        //这个属性叫做：length
        //使用格式：数组名.length
        //当长度可以确定后，for循环的索引范围就能确定了：length-1
        int[] arr2 = {100,20,3,132,4232,413,132,434241,3213,21,312,321,3,213,213,21,32,3,435,4,5,43,3245,3,4,342343,2,423,43,4,324,265,5,645};
//        int length = arr2.length;
//        System.out.println(length);
        // [100,20,3....]
        for(int i=0;i<arr2.length;i++){
            if(i==0){
                System.out.print("["+arr2[i]+",");
            }else if(i==arr2.length-1){
                System.out.print(arr2[i]+"]");
            }else {
                System.out.print(arr2[i]+",");
            }
        }

        //\r\n是windows中的换行符
        System.out.println("\r\n======将打印数组封装成一个方法==========");
        printArray(arr2);

    }

    /**
     *  定义遍历数组的方法
     *      返回值类型：void
     *      参数列表：int[] arr
     *
     */
    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

数组获取最值：

public class Cherris {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //思路：任意取一个值，假设它就是最大值
        //然后拿着这个值与其余的值做比较，如果说遇到了比它还大的值，将该值作为临时最大值，当遍历完之后，获取到真正的最大值
        //一般情况下，取第一个元素为最大值
        int max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        System.out.println("数组中最大值为：" + max);

        System.out.println("==============用方法改进==============");
        int maxNumber = getMaxNumber(arr); //0x001
        System.out.println("数组中最大值为：" + maxNumber);

    }
    /**
     *      定义一个获取数组最大值的方法
     *          返回值类型：int
     *          参数列表：int[] arr
     */
    public static int getMaxNumber(int[] arr1){ //0x001
        int max = arr1[0];

        for (int i = 1; i < arr1.length; i++) {
            if (arr1[i] > max) {
                max = arr1[i];
            }
        }
        return max;
    }
}

数组的逆序：

public class Cheeris {
    public static void main(String[] args) {
        int[] arr = {43,31,123,1,21};//{43,31,123,1,21} ==> {21,1,123,32,43}
        System.out.print("数组逆序之前：");
        printArray(arr);

        //将0索引位置的元素与length-1位置上的元素进行交换
        //将1索引位置的元素与length-1-1位置上的元素进行交换
        //直到length/2
        int temp = arr[0];
        arr[0] = arr[arr.length-1];
        arr[arr.length-1] = temp;

        int temp2 = arr[1];
        arr[1] = arr[arr.length-1-1];
        arr[arr.length-1-1] = temp2;

        //调用方法遍历数组
        System.out.print("\r\n数组逆序之后：");
        printArray(arr);

        System.out.println("\r\n==================用for循环改进实现数组逆序1：==================");
        int[] niXuArray1 = niXu(arr);
        printArray(niXuArray1);

//        System.out.println("\r\n==================用for循环改进实现数组逆序2(创建新的数组)：==================");
//        int[] niXuArray2 = niXu2(arr);
//        printArray(niXuArray2);

        System.out.println("\r\n==================用for循环改进实现数组逆序3(定义指针)：==================");
        int[] niXuArray3 = niXu3(arr);
        printArray(niXuArray3);


    }

    /**
     *  定义方法实现数组的逆序(方法3)指针
     *      返回值类型：int[]
     *      参数列表：int[] array
     *
     */
    public static int[] niXu3(int[] array){
        for(int start=0,end=array.length-1;start<=end;start++,end--){
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return array;
    }

    /**
     *      定义方法实现数组逆序(方法2)
     *          返回值类型：int[]
     *          参数列表：int[] array
     *
     *          这种方式不推荐：
     *              1、由于创建了新的数组，开辟了新的堆内存空间，这样会造成内存资源浪费
     *              2、题目本来的意思，在原数组上做逆序
     *
     */
    public static int[] niXu2(int[] array){
        int[] arr2 = new int[array.length];
        for(int i=array.length-1;i>=0;i--){
            arr2[arr2.length-1-i] = array[i];
        }
        return arr2;
    }

    /**
     *      实现数组逆序的方法(第一种方式实现)
     *          返回值类型：int[]
     *          参数列表：int[] array
     *
     */
    public static int[] niXu(int[] array){
        for(int index=0;index<array.length/2;index++){
            int temp = array[index];
            array[index] = array[array.length-1-index];
            array[array.length-1-index] = temp;
        }
        return array;
    }


    /**
     *  定义遍历数组的方法
     *      返回值类型：void
     *      参数列表：int[] arr
     *
     */
    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

使用键盘录入查找星期数：

import java.util.Scanner;

public class cherris {
    public static void main(String[] args) {
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        boolean flag = true;

        while (flag) {
            System.out.println("请输入数据（1-7）:");
            int number = sc.nextInt();
            if (number >= 1 & number <= 7) {
                System.out.println(week[number - 1]);
            } else if (number == 0) {
                flag = false;
            } else {
                System.out.println("输入的数据有误，请重新输入！");
            }
        }


    }
}

数组元素查找（查找指定元素第一次在数组中的位置）

import java.util.Scanner;
public class Cherris {
    public static void main(String[] args) {
        //定义一个数组并静态初始化
        int[] arr = {12,32,12,43,53,32,100,12};
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你要查找的元素：");
        int number = sc.nextInt();

        for(int i=0;i<arr.length;i++){
            if(arr[i]==number){
                System.out.println(number+"2在数组中第一次出现的索引为"+i);
                //正确做法是查找到对应元素后，应该结束整个循环
                break;
            }
            if(i==arr.length-1 && arr[arr.length-1]!=number){
                System.out.println("您要查找的元素"+number+"不在数组中！");
            }
        }


    }
}