数组基础篇

一（数组定义）:相同数据类型元素的集合，是一种数据类型-----引用类型(除了基本类型以外的类型)。

二（创建数组的3种方式）：以整型为例

2.1数据类型[ ] 数组名=new 数据类型[数组长度];

     int[ ] 数组名=new int[ 数组长度]；

eg:int [ ] arr=new int[10]; 创建一个长度为10的int数组,里面存储值默认是0

2.2 数据类型[] 数组名 ={值1,值2,值3,,,,,,,,};

      int[ ] 数组名={值1,值2,值3……值n};

eg:int [ ] arr={1,2,3,4,5} 创建一个长度为5的int数组,里面存储值依次是12345

2.3 数据类型[] 数组名=new 数据类型[]{值1,值2,值3,,,,,,,,};

      int [ ] 数组名=new int[ ]{值1,值2,值3……值n};

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

2.4 int [ ] 数组名；数组名=new int[ ]{值1,值2,值3……值n}

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

 [注意]: 1.直接输出数组名会输出数组在内存中的地址,如果需要输出数组中的内容,需要通过                         Arrays.toString(数组名)[System.out.println(Arrays.toString(数组名))]来访问.
            2.如果定义的数组没有手动存放数据的话,数组中会默认存放对应数据类型的默认值(int :0                 boolean:false    double:0.0    String(引用数据类型的,默认值都是null.)
            3.数组定义时,必须指定长度.

三（数组的访问）：
        1.通过下标/索引来访问数组中的元素  [下标从0开始,最大到(数组的长度-1)]

           格式：数组名[下标]

 2.通过(数组名.length)可以获取数组的长度(元素个数)；

    格式：数组名.length；

3. 通过下标/索引来修改数组中的元素  [下标从0开始,最大到(数组的长度-1)]

    格式：数组名[下标]=修改值；

4.输出数组中的所有元素：通过Arrays.toString(数组名)方法

   格式：System.out.println(Arrays.toString(数组名))

5.数组的遍历：将数组中的元素逐个访问(核心原理:逐个使用数组下标,使用for循环将数组中的元素取出)。当数组的下标不在[0,数组的长度-1]时,就会出现ArraysIndexOutOfBoundsException(数组下标越界异常);

 6.将数组的长度+1（扩容）:  Arrays.copyOf(原数组名,原数组名.length+1)

    扩容后的数组不在是原数组，需要用一个新数组去接收扩容后的数组。

 7.将数组的长度-1（缩容）：Arrays.copyOf(原数组名,原数组名.length-1)

    缩容后的数组不在是原数组，需要用一个新数组去接收缩容后的数组。

8.删除数组中的某个元素：Java中删除数组中的元素是利用缩容实现的
                                       1.将要删除的数组，移动最末尾
                                       2.缩容指定长度（减小数组长度） 

package day06;

import java.util.Arrays;

public class Demo3 {
    public static void main(String[] args) {
        String [] books = {"霸道总裁爱上我","美女上司爱上我","活着"};
        //Java中删除数组中的元素是利用缩容实现的
        //  1.将要删除的数组，移动最末尾
        //  2.缩容指定长度（减小数组长度）
        String temp = books[0];
        books[0] = books[books.length-1];
        books[books.length-1] = temp;
        System.out.println(Arrays.toString(books));
        // 数组长度，缩容1（长度-1），将数组的最后一个元素删除
        books = Arrays.copyOf(books, books.length-1);
        System.out.println(Arrays.toString(books));
    }
}

四（数组的冒泡排序）：使用双层for循环完成，简单理解，就是从第一个元素开始，和数组中相邻的元素进行比较大小，若符合比较条件，就会将相邻两个元素的位置进行互换，经过多个回合比较下来，就能达到升序（从小到大）或降序（从大到小）的效果。

外层循环控制每个最大值的排序轮数=（数组长度-1）次

内层循环控制每一轮中最大值的排序次数

案例（升序排列）：

public class Demo2 {
    public static void main(String[] args) {
            int [] arr1={5,2,7,3,1};
        for (int i = 1; i <arr1.length ; i++) {//外层循环控制最大值的排序轮数，次数为数组的长度-1
            for (int j=0;j<arr1.length-i;j++){//内层循环控制每一轮中的最大值的排序次数
                //比较相邻的两个元素，大的放后面
                if(arr1[j]>arr1[j+1]){
                    //如果前面一个元素比后面一个元素大,则元素要互换
                    int temp=arr1[j];//temp作为中间变量
                    arr1[j]=arr1[j+1];
                    arr1[j+1]=temp;
                }
            }
        }

        System.out.println("排序后的数组为："+ Arrays.toString(arr1));
    }
}

9.系统自带的排序：Arrays.sort(数组名),会按照升序排列。

    int [] arr={26,78,34,12,56};
        System.out.println("排序前："+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后“"+Arrays.toString(arr));

 五（二维数组）：java中没有严格意义上的二维数组，所谓二维数组就是数组的数组，即数组的嵌套。可以把二维数组看成一个多行多列的矩阵,行和列都是从0开始

 5.1定义初始化
     1.
       数据类型[][] 数组名=new 数据类型[二维数组中有个多少个数组][每个数组中有多少个元素]
       eg：int[][] arr=new int[3][3];
     2.
       数据类型[][] 数组名={{值1,值2....},{值1,值2...},{值1,值2...}...}
       eg：int[][] arr={{1,2,3},{1,2,3},{1,2,3}}
     3.
     数据类型[][] 数组名=new int[][]{{值1,值2....},{值1,值2...},{值1,值2...}...}

5.2  访问二维数组中的二级元素（二维数组中的一维数组中的元素）：数组名[第几个数组][数组的第几个元素]

    

  int[][] arr2={{1,2,3},{4,5,6},{7,8,9}};
        //访问二维数组中的第二个数组的第三个元素（也就是6）
        System.out.println(arr2[1][2]);

    访问二维数组中的一级元素 （二维数组中的一维数组）：Arrays.toString(数组名[一维数组在二维数组中的索引])

        int[][] arr2={{1,2,3},{4,5,6},{7,8,9}};
      
        //访问二维数组中的第2个元素
        System.out.println(Arrays.toString(arr2[1]));

 5.3  遍历二维数组：仍然使用双层for循环，外层循环控制二维数组的长度，内层循环控制一维数组的长度

    int[][] arr2={{1,2,3},{4,5,6},{7,8,9}};
       
        for (int i=0;i<arr2.length;i++){
            for (int j=0;j<arr2[i].length;j++){
                System.out.print((arr2[i][j])+"\t");
            }
            //打印每一个一维数组后换行
            System.out.println();
        }