数组学习

Posted 2021-05-27 littlebear_s

数组

数组定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数组称作一个数组元素，每个数组元素可以通过一个下表来访问他们

数组的特点

• 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
• 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型
• 数组对象本身是在堆中的

数组的初始化

1. 声明一个空的数组：int[] array = null;这个时候，计算机就会在栈里面创建一个array

2. 创建数组，给它定义大小：array = new int[10];这个时候，计算机会在堆里面开辟10个空间

3. 给数组元素赋值的时候，就会给堆里面对应的元素赋值

   图解：

一般声明和创建是写在一起的：int[] array = new int[10];

• 静态初始化：创建+赋值

  int[] a = {1,2,3,4,5,6};

• 动态初始化

  int[] a = new int[10];

数组的应用

• JDK1.5开始可以使用arrays.for直接可以遍历数组

int[] arrays = {1,2,3,4,5,6};
//arrays.for
for (int array : arrays) {

}

• 打印数组元素

public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5,6};
    printArray(arrays);
}
public static void printArray(int[] a){
    for (int i = 0; i < a.length; i++) {
        System.out.print(a[i]+" ");
    }
}
//输出结果为：1 2 3 4 5 6

• 打印反转数组

public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5,6};//创建一个arrays数组并赋值（1）
    int[] reverse = reverse(arrays);//=号左边：在这个函数里面创建一个名为revers的数组；=号右边：调用reverse方法，给reverse方法传递一个arrays数组，并且得到返回值，赋给左边（7）
    printArrary(reverse);//调用打印的方法，最终通过这个方法打印出得到的反转数组（8）
}

//反转数组
public static int[] reverse(int[] b){//定义反转方法，将传过来的参数，在这个方法里面取个名字b（3）
    int[] result = new int[b.length];//创建一个result数组，用于存放反转过后的数组，长度与传来的参数长度保持一致（4）
    for (int i = 0,j = b.length-1; i < b.length; i++,j--) {
        result[j] = b[i];//因为要反转，所以将传过来的参数第一个值赋给新定义的result的第一个值（5）
    }
    return result;//这个方法执行完毕过后，返回一个result的值（6）
}

//打印数组元素
public static void printArrary(int[] array){//定义打印方法（2）
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]+" ");
    }
}

• 打印二维数组

public static void main(String[] args) {
    int[][] array ={{1,2},{3,4},{5,6}};
    printArray(array);
}
//打印二位数组
public static void printArray(int[][] abc){//注意这里要把参数类型和传递过来的参数类型保持一致
    for (int i = 0; i < abc.length; i++) {
        for (int j = 0; j < abc[i].length; j++) {
            System.out.print(abc[i][j]+" ");
        }
        System.out.println();
    }
}

冒泡算法

public static void main(String[] args) {
    int[] arrays = {2,16,7,8,3};//随便设置一个数组（1）
    bubble(arrays);
}

public static int[] bubble(int[] b){//定义冒泡排序（2）
    int tmp = 0;
//外层循环，设置循环次数，最多也就循环b.length-1次，直接就<b.length（3）
    for (int i = 0; i < b.length; i++) {
//设置一个flag，在内层循环里面改为true，可以通过内层循环来检测数组是否排序完毕，如果数组一排比较过去都没有需要交换的值（即不满足内层循环的条件），flag的值就不会变成true，就会触发下面的break，终止循环，不需要再执行了，直接得出结论，输出数组（6）
        boolean flag = false;
//内层循环，用于给两个元素比较大小，升序排列，从左至右依次比一遍，一遍比完了过后，又回到外层循环，让i++过后，再重复，直到外层循环结束，特别注意，内层循环里面的j < b.length-1是因为下面的数组有b[j+1],如果不减的话就溢出了（4）
        for (int j = 0; j < b.length-1; j++) {
            if (b[j+1] < b[j]){
                tmp = b[j+1];
                b[j+1] = b[j];
                b[j] = tmp;
                flag = true;
            }
        }
        if (flag==false){
            break;
        }
        System.out.println(Arrays.toString(b));//每次内层循环完毕过后就输出一次，观察排序情况，如果已经排序完了，这个还是重复输出，就说明代码重复运行，没有意义，需要优化（5）
    }
    return b;
}