数组和冒泡排序

数组

数组用于存储相同类型的一组数据，它是一种数据结构，也是Java中的一种类型

• 一个数组有多个数据（元素）
• 一个数组里面都是相同类型
• 数组中的元素都是用序号（下标，从0开始）来访问
• 数组一旦初始化后，长度不能改变

定义数组

数组的定义跟变量的定义类似，就是在变量类型加一对方括号

• 只定义数组，没有分配内存空间

• 没有长度

  **注意：**数组可以按这样的方式定义，但是不推荐int arrXxx[]

//数组的定义跟变量的定义类似，就是在变量类型加一对方括号
int[]arrInt;
char[]arrChar;
boolean[]arrBoolean;
String[]arrStr;

初始化数组

指定长度，分配内存空间，每个元素初始化的值

• new 类型[长度]
• new 类型 [ ]{ }
• 类型 [ ] 数组变量 = { }

如果数组初始化时没有赋值，按下面的规则给数组赋默认值

数据类型	默认值
byte,short,int,long	0
float	0.0
char	‘\u0000’不可见字符
boolean	false
引用类型（类，接口，数组）	null

//数组的初始化
arrInt  = new int[5];  //int 类型数组默认初始值是0
arrChar = new char[]{'a','b','c'};//初始化的同时赋值
arrStr = new String[]{"Tom","Jack"};
arrBoolean = new boolean[]{true,false};
String[] arrStr2 = {"Tom","Jack"};
//在数组定义时，直接用大括号赋值和初始化。定义和初始化同时进行
float[] arrFloat = {3.12f,3.25f,63.2f};

创建数组 a 并初始化

//创建 a 数组并初始化
int[]a;
a = new int[]{1,2,6,2,3,36,6,6,};

//定义一个数组。并且规定数组长度
String[] arrStr = new String[5]

使用数组

用数组变量名加[ ]，中括号里面写上下标，就可以读写数组的元素

• 下标不能越界，否则要报（抛出）异常
• 数组长度可以通过length属性获得

//数组使用
//变量名[下标]这样读取指定元素的值
System.out.println(arrInt[4]);
System.out.println(arrStr2[1]);
System.out.println(arrFloat[2]);

arrInt[0] = 888;
arrStr2[1] = "重新赋值";
arrFloat[2] = 8.2f;

System.out.println(arrInt[0]);
System.out.println(arrStr2[1]);
System.out.println(arrFloat[2]);

//访问数组时，如果下标超出范围，抛出异常 ArrayIndexOutOfBoundsException（数组下标越界异常）
arrInt[5] = 100;//报错

用循环遍历数组

• for循环

• foreach

  for(类型 变量名：数组名){

  ​ //变量的值就是数组里的元素

  }

//遍历数组
System.out.println("=======顺序遍历数组========");
for (int i = 0; i < arrStr2.length ; i++) {
    System.out.println(arrStr2[i]);
}

System.out.println("=======倒叙遍历数组=======");
for (int i = arrStr2.length - 1; i >= 0; i--) {
    System.out.println(arrStr2[i]);
}

System.out.println("======遍历数组，给数组赋值========");
for (int i = 0; i < arrStr2.length ; i++) {
    arrInt[i] = i;
}
System.out.println(arrInt[3]);

//foreach,增强的for循环
//只能读取数据，不能给数组赋值
System.out.println("========foreach循环遍历数组===========");
for(int i:arrInt){
    System.out.println(i);
}

二维数组

//二维数组
int[][] arrInt = {{1,2,3},
                    {4,5,6},
                     {7,8,9}};
System.out.println(arrInt.length);
System.out.println(arrInt[0][2]);
System.out.println(arrInt[1][1]);
System.out.println(arrInt[2][0]);

//用循环的嵌套遍历二维数组
for (int i = 0; i < arrInt.length; i++) {
    for (int j = 0; j < arrInt[i].length; j++) {
        System.out.print(arrInt[i][j]);
    }
}

二维数组的定义及初始化

int[][] arrInt1 = new int[5][3];
//初始化时外层数组和内层数组都指定长度
int[][] arrInt2 = new int[5][];
//初始化时可以只指定外层数组长度
int[][] arrInt3 = new int[][]{{3,5},{1,4,7,20,30,60}};
//初始化的时候赋值，内层数组长度可以不一样

数组冒泡排序

//原始的数组
int[] arrInt = {20,6,9,56,25,20};
//外层循环，控制需要排序的元素个数，只需要数组的长度减 1
for (int i = 0; i < arrInt.length - 1; i++) {    // i 表示进行第几轮比较
    //用第一个元素依次跟后面的数进行比较，已经排好在后面的数不需要进行比较
    //每排好一个数之后，最大的下标就减 1 ：arrInt.length - i -1
    for (int j = 1; j < arrInt.length - 1 - i; j++) {   //  j 表示进行第i轮的第几次比较
        if (arrInt[j+ 1] > arrInt[j]){  //比较 j 和 j +1 的大小
            //相邻两个数进行比较，大的往后面放（交换）
            //交换 j 和 j + 1的值  使用中间变量法
            int temp = arrInt[j + 1];  
            arrInt[j + 1] = arrInt[j];  
            arrInt[j] = temp;
        }
    }
}
System.out.println(Arrays.toString(arrInt));