Java基础核心-5

数组

数组的概念

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器 数组既可以存储基本数据类型，也可以存储引用数据类型
数组是一组相关数据的集合，一个数组实际上就是一连串的变量.

数组声明与使用

数据类型[] 数组名 = 初值

例：int[] array = new int[5]

注意：[ ]中5就是数组array的长度
数组的长度一旦给定 就不能修改

数组： 内存空间连续的一块区域,用来存储同一种数据类型的多个元素
重点：
1 连续 同一种数据类型
2 索引： 从0开始

 *  1 索引：从0开始，到数组的长度-1结束
 *  2 数据的长度： 数组名.length
 *   3 数组名[索引]  定位数组中的元素

数组的三种使用方法：

// 第一种： 一般情况下,当我们不知道数据里面有什么内容的时候,我们会先声明一个数组,然后再去赋值
        int[] array = new int[5];

        array[0] = 1;
        array[1] = 3;
        array[2] = 5;
        array[3] = 6;
        array[4] = 7;

        // 第二种 ，一般不使用
        int[] array2 = new int[]{1,3,5,7,9};


        // 第三种, 虽然我们没有明确的指定数组的长度,但是一旦声明了以后,长度就固定了
        int[] array3 = {1,3,5,7,9};
//        array3[5] = 10;

数组的工具类：Arrays的使用

1 Arrays.toString(array) 数组的打印
System.out.println(Arrays.toString(array));

2 Arrays.sort(array); 数组的排序
会在原来的数组上修改

3 Arrays.copyOf(要复制的数组，指定新数组的长度)
会得到一个新的数组
案例：

   int[] arrays = {50,20,11,8,4,21,19};
   //打印  Arrays.toString(arrays)
   System.out.println(Arrays.toString(arrays));
   //排序  先排序后打印 sort升序，
   Arrays.sort(arrays);
   System.out.println(Arrays.toString(arrays));
   //扩容  先扩容后打印      Arrays.copyOf(组名, 长度); 重新定义一个数组
   int[] ints = Arrays.copyOf(arrays, arrays.length + 1);
   System.out.println(Arrays.toString(ints));

掌握数组常用操作

最大最小值

int[] array01 = {10,50,8,6,9,60,80};
        // 最大值
        // 第一种排序
        int max = array01[0];
        for (int i = 0; i < array01.length; i++) {
            if (max < array01[i]){
                max = array01[i];
            }
        }
        System.out.println(max);
        //第二种方式
        Arrays.sort(array01);
        System.out.println(array01[array01.length-1]);
        //最小值
        //第一种方式
        int min = array01[0];
        for (int i = 0; i < array01.length; i++) {
            if (min > array01[i]){
                min = array01[i];
            }
        }
        System.out.println(min);
        //第二种方式
        Arrays.sort(array01);
        System.out.println(array01[0]);

数据元素的位移

//原理：将第一个数一直往后换所以只换索引为0的数
       int[] arrays = {1,2,3,4,5};
       for (int i = 0;i < arrays.length;i++){
                int temp = arrays[0];
                arrays[0] = arrays[i];
                arrays[i] = temp;
        }
        System.out.println(Arrays.toString(arrays));

冒泡排序法

int[] arrays = {5,7,2,16,8,3,78,51};
        //升序
        for (int i = 0;i < arrays.length-1;i++){
            for (int j = 0;j < arrays.length-1-i;j++){
                if (arrays[j] > arrays[j+1]){
                    int temp = arrays[j+1];
                    arrays[j+1] = arrays[j];
                    arrays[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
        System.out.println("================");
        // 降序
        for (int i = 0; i < arrays.length-1; i++) {
            for(int j = 0;j < arrays.length-1-i;j++){
                if (arrays[j] < arrays[j+1]){
                    int temp = arrays[j+1];
                    arrays[j+1] = arrays[j];
                    arrays[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));

二维数组

<数据类型> [ ][ ] 数组名; 或者 <数据类型> 数组名 [ ][ ];

方法一、

      int [ ][ ] scores;   		 //定义二维数组
  	  scores=new int[5][50]; 		 //分配内存空间

//或者
方法二、

      int [ ][ ] scores = new int[5][50]; 

注意：定义二维数组时，要定义最大维数

例：

int [ ][ ] scores = new int[5][];
//第二行这种是错误的
int [ ][ ] scores = new int[][];

二维数组实际上是一个以一维数组做为元素的一维数组