第三组 数组

数组的基本概念及作用

java数组存储一组数据类型相同的数据，在内存中空间是连续的,长度一旦给定,就不能改变了

数组属于引用数据类型(对象)，但是可以存储基本类型,也可以存储引用类型

数组的创建

声明数组

int指的是数组中可以存储的数据类型为int

int[] a；

创建数组

默认值

整数:0

浮点:0.0

char:空格

布尔:false

引用类型:null

       //创建数组方式1,动态创建
        int[] a = new int[10];//创建一个长度为10的连续空间.
        System.out.println(Arrays.toString(a));//将数组对象以字符串的形式输出.
​
       //方式2
        char x = 'a';//97
        int [] b = new int[]{1,2,3,4,x};
        System.out.println(Arrays.toString(b));
​
       //方式3
        int [] c = {1,2,3,4,5};
        System.out.println(Arrays.toString(c));
​
        String[] s = new  String[]{"a","b","c"};
        System.out.println(Arrays.toString(s));

数组的长度：

length属性

int [] b1 = new int []{1,2,3,4,5,6,7};

System.out.println(b1.length);

数组的访问与迭代

● 数组元素的访问：

• 数组名字[索引]

例如：a[0],a[1];

• 注意：

• 数组的索引从0开始。

• 索引的数据类型是整型

• 索引最大值和数组长度始终差1

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

访问数组元素时,注意数组越界

 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
           
              at day1.Demo2.main(Demo2.java:18)

数组的遍历（迭代）

输出数组

      int [] a = new int[5];
         for(int i=0;i<=4;i++){
             a[i] = i+2;
         }
         System.out.println(Arrays.toString(a));

for循环

 int []a = {2,3,4,1,5};
 for (int i = 0; i < a.length; i++) {
             System.out.println(a[i]);

增强for循环

int []a = {2,3,4,1,5};
for(int t : a){
             System.out.println(t);
         }

数组排序

冒泡排序

每次取出相邻的两个元素进行比较

将较大向后移动,直到将所有的元素比较完.

       int [] a = {4,3,5,2,1};
                 // 3 4 2 1 5
                 // 3 2 1 4 5
                 // 2 1 3 4 5
                 // 1 2 3 4 5
        for (int i = 0; i < a.length-1; i++) {//外层循环,控制循环几次
            for (int j=0;j<a.length-1-i;j++){//内层循序 控制每次比较次数
               if(a[j]>a[j+1]){
                   int temp= a[j];
                   a[j] = a[j+1];
                   a[j+1] = temp;
               }
            }
        }
​
        System.out.println(Arrays.toString(a));

选择排序

从第一个开始与后面的每个元素比较，如果满足条件，就将较大/较小的进行对调

第一种方式

每次比较符合后直接进行交换，交换多次

    int []a = {3,1,2,6,4,5};
        for (int i = 0; i < a.length-1; i++) {//取出数组中将要比较的位置
            for (int j = i+1; j <a.length; j++) {//取出位置之后的每个数依次与取出的值比较
                if(a[i]>a[j]){
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }

第二种方式

使用minIndex记录最小数的索引，减少交换次数

    int []a = {3,1,2,6,4,5};
        for (int i = 0; i < a.length-1; i++) {//取出数组中将要比较的位置
            int minIndex = i;//minIndex记录最小值的索引
            for (int j = i+1; j <a.length; j++) {//取出位置之后的每个数依次与取出的值比较
                if(a[j]<a[minIndex]){//将更小的数的索引赋值给minIndex
                    minIndex=j;
                }
            }
            //内循环比较结束后，交换索引为minIndex和i的元素(即将最小值交换到i的位置）
            int temp = a[minIndex];
            a[minIndex] = a[i];
            a[i] = temp;
        }

第二种方式虽然多了一些代码语句，但是交换的次数更少一些，运行时间相对变短

插入排序

在需要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插入到前面的有序序列中，使得这n个数都是排好序的。

如此循环直至全部排好序

第一种方式

将需要插入的第n个数与前面依次比较并交换

    int []a = {3,2,1,5,4};
​        for (int i = 1; i<a.length; i++) {
            for (int j = i; j >0 ; j--) {
                if(a[j]<a[j-1]){
                    int t = a[j];
                    a[j] = a[j-1];
                    a[j-1] = t;
                }
            }
        }

第二种方式

使用两个变量，第一个记录需要插入的数，第二个记录当前所比较的位置

若比较位置的值与插入数比较的为所要结果且比较位置在数组中

就将比较位置的值给perIndex+1（也就是将perIndex的值后移，空出这个位置）

不符合循环条件后将需要插入的数放在比较位置的后一个（比较位置多走一步才跳出循环）

  int []a = {3,2,1,5,4};
      for (int i = 1; i <a.length; i++) {
            int correntvalue = a[i];//记录排序需要插入的数
            int perIndex = i-1;//记录当前所比较的位置
            while (perIndex>=0 && correntvalue<a[perIndex]){
                a[perIndex+1] = a[perIndex];
                perIndex--;
            }
            a[perIndex+1] = correntvalue;
        }

二维数组

二维数组定义

二维数组是数组的数组

二维数组的每一个元素是一个一维数组

二维数组的声明

int [][] a;
int a2[][];
//一般选择第一种，不容易混淆a的数据类型

二维数组的创建

int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
int [] [] b = {{1,2,3},{1,2,3},{1,2,3}}; 
int [][] c = new int[3][5];//二维数组中有3个长度为5的一维数组




int [][]d = new int[3][];
        /*
        只声明了二维数组的长度为3，但是里面一维数组的值为null
        输出d,结果即[null,null,null];
        在后面的一维数组赋值时，自己指定一维数组的长度*/

二维数组的迭代

int [][]a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }
        }

开发工具中Debug调试

断点（idea内是红色的圆圈）在需要调试代码进行设置断点

使用Debug模式进行

F8 step over 逐步调试，不会进入到调用的方法中

shift+F8 step out 跳出调试

F7 step into 进去所调用的方法中