重学Java六＜数组＞

数组

简述

数组就是用来存储数据的，在程序设计中，为了方便处理数据，我们将相同类型的数据集合起来，集中管理，这就是数组。

1. 数组就是相同类型的有序集合，按照先后次序排列起来组合而成，数据在数组中被称为元素，每一个元素都可以通过他对应的索引进行访问。
2. 数组的长度是固定的，一旦被创建，它的大小无法被改变。
3. 元素类型必须统一，不能混合。
4. 数组的索引从0开始，到它的长度-1结束
5. 数组时引用类型。

数组的定义

public class demo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr;
        arr = new int[3];
        //为数组进行赋值
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        //输出查看一下
        System.out.println(arr[0]);
        //如果我们输出的数组索引，超出了他的范围，就出报异常。
        //System.out.println(arr[5]);
        /**java.lang.ArrayIndexOutOfBoundsException: 5
        	at com.test.demo.main(demo.java:15)
        这个异常就是数组索引越界异常。说明我们输出的索引超出了数组索引的范围
         */
        //我们还可以通过数组中自带的方法获取它的长度信息。
         int len = arr.length;
        System.out.println(len);
    }
}

数组遍历

遍历就是将数组中所有的数据进行输出（访问）。

  public static void main(String[] args) {
        //假设，我们把员工的工资都放在一个数组里面，这个公司有十个员工
        int[] salarys = new int[10];
        //现在我们手动录入员工的工资
        Scanner scanner = new Scanner(System.in);
        for (int i=0;i<10;i++){
            System.out.println("请开始录入员工工资");
             int salary = scanner.nextInt();
             salarys[i] = salary;
        }
      //for循环
        for (int i = 0;i<salarys.length;i++){
            System.out.println("各个员工的工资为："+salarys[i]);
        }

    }
    //增强for循环
    for (int num :salarys){
            System.out.println(num);
        }

以上就是数组遍历的方式

数组初始化

静态初始化

可以在数组定义的同时近视赋值

  //静态初始化
        int[] array = new int[]{10,20,30};

动态初始化

动态初始化分配空间和赋值是分开进行的

//动态初始化
        int[] arr;
        arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

  int[] a = new int[3];
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);

以上就是数组的三种初始化方式

求数组中的最大数

 public static void main(String[] args) {
        int[] arr = new int[]{10,20,30,60,22,1,90};
        int max = arr[0];
        for (int i =0;i<arr.length;i++){
            if (arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("arr中的最大数是："+max);
    }

排序

 int[] arr =new int[]{10,20,30,40,50};
        //升序
        //Arrays是数组的工具类，里面封装了很多固定的方法
//        Arrays.sort(arr);
//        for (int num:arr) {
//            System.out.println(num);
//        }
        //binarySeach 二分查找，找到对应元素的索引值
        System.out.println(Arrays.binarySearch(arr,10));
        //对于数组还有另外一种方法就是冒泡排序

        for (int i =0;i<arr.length-1;i++){
            for (int j = 0 ;j<arr.length-1-i;i++){
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

Arrays工具类

在上面排序的时候我们用到了Arrays工具类，在这里我们就具体的来了解一下Arrays工具类。
其实就是 Java为了我们能够更好的操作数组，给我们将具体方法封装好，放在了Arrays类中，方便我们调用。
具体方法有：
toString：直接对数组进行遍历，返回一个字符串。
binarySeach：查找对应元素的索引。
sort：将数组进行升序排序。
copyOf：完成数组复制
copyOfRange：区间复制
equals：比较两个数组是否一样
fill：数组填充

二维数组

public class demo{
	public static void main(String[]args){
	//二维数组,就像是一个双层列表，每一个列表里面都有不同的数据，但是
        int[][] array = new int[3][5];
        int[] a = new int[]{10,20,30,40,50};
        int[] b = new int[]{100,200,300,400,500};
        int[] c = new int[]{1000,2000,3000,4000,5000};

        array[0] = a;
        array[1] = b;
        array[2] = c;
        System.out.println(array[0][4]);

        //二维数组遍历
        for (int i = 0;i<array.length;i++){
            for (int j =0;j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
            System.out.println();
        }
        //方法2
        for (int i = 0;i<array.length;i++){
            for (int num:array[i]){
                System.out.println(num);
            }
        }

        //方法3
        for (int[] arr:array){
            for (int num:arr){
                System.out.println(num);
            }
            System.out.println();
        }
	}
}

二维数组，在以后的开发中并不常用，所以我们在这里只做了解即可。