数组的使用，多维数组，Array类，冒泡排序

数组的使用

• 普通for循环
• for-Each 循环
• 数组方法入参
• 数组作返回值

练习代码：

package array;

public class ArrayDemo04 {

    public static void main(String[] args) {

        int[] arrays ={2,4,6,8,10};
        //采用调用方法的方式打印数组
//        printArrays(arrays);
        //调用reverse方法里的arrays数组后会返回一个数组，我们将返回的数组赋值给int[] reverse接收
        int[] reverse = reverse(arrays);
        //最后打印数组
        printArrays(reverse);


     /*   //增强型for循环，优点是很方便的取出数组里的元素。缺点是取不到下标。
        for(int i:arrays){
            System.out.println(i);
            } */
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        //这里的意思我猜是给result数组开辟一个和arrays数组元素个数相同的空间
        int[] result = new int[arrays.length];
        //反转元素
        //j = result.length  会发生Array Index Out Of Bounds Exception 数组索引越界异常
        for (int i = 0, j = result.length-1; i < arrays.length ; i++,j--) {
            //
            result[j] = arrays[i];
        }

        return  result;
    }

            //创建一个遍历、打印数组的方法
            public static void printArrays(int[] arrays){
                for (int i = 0; i <arrays.length ; i++) {
                    System.out.print(arrays[i]+" ");
                }
         }
}

多维数组

• 多维数组可以看成是数组的数组。

练习代码：

package array;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class ArrayDemo05 {
    public static void main(String[] args) {
        
        //二维数组
        int[][] arrays = {{1,2},{3,4},{5,6},{7,8}};
        
        //遍历二维数组
        for (int i = 0; i < arrays.length ; i++) {
            for (int j = 0; j < arrays[i].length ; j++) {
                System.out.print(arrays[i][j]+" ");

            }
        }
    }
}

Array类的使用

练习代码：

package array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo06 {

    public static void main(String[] args) {
        int[] a = {1,50,20,5646,456,99999};

        System.out.println(a);
        //[1, 50, 20, 5646, 456, 99999]
        System.out.println(Arrays.toString(a));
        printArray(a);

        //排序数组,sort升序排序
        // [1, 20, 50, 456, 5646, 99999]
        System.out.println("使用sort排序之后");
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //填充 fill(数组名,始下标,未下标,替换值)
        // [1, 20, 50, 456, 0, 0]
        System.out.println("使用fill将4~6填充成0后输出效果");
        Arrays.fill(a,4,6,0);
        System.out.println(Arrays.toString(a));
    }
    //打印、并排列数组的一个方法
    //[1, 50, 20, 5646, 456, 99999]
    public static void printArray(int[] a){
        for (int i = 0; i <a.length ; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }
        System.out.println();
    }

}

冒泡排序

冒泡排序的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较。

冒泡排序使用的嵌套循环，这种算法的时间复杂度为n的二次方。

练习代码：

package array;

import com.sun.prism.shader.Solid_TextureRGB_AlphaTest_Loader;

import java.util.Arrays;

public class ArrayDemo07 {
    /*  冒泡排序思路
        1. 比较数组中两个相邻的元素，如果第一个比第二个大，我们就交换它们的位置
        2. 每次比较都会产生一个最大，或者最小的数字
        3. 下一轮则可以少一次排序
        4. 一次循环，直到结束！
     */
    public static void main(String[] args) {

        int[] a ={55,33,22,11,99,88,77};
        //数组a调用我们写的sort方法后生成一个新的数组，我们创建一个sort数组来接收它
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }

    //冒泡排序法
    public static int[] sort(int[] array){
        //临时变量
        int room = 0;
        //外层循环，读取数组长度，决定循环次数。length-1防止下标溢出
        for (int i = 0; i <array.length-1 ; i++) {
            boolean flag = false;
            //内层循环，判断两个数，如果第一个数比第二个数大，则二者交换位置
            // （交换位置规则是，从大的下标朝小的下标移动）
            for (int j = 0; j <array.length-1 ; j++) {
                if (array[i+1] < array[j]){
                    room = array[i+1];
                    array[i+1] = array[j];
                    array[j] = room;
                    //这里的意思是，如果没有进这个if判断则flag还是为false，
                    // 那么下面的if判断结果就为true，执行break跳出循环。
                    flag = true;
                }
            }
            if (flag==false){
                break;
            }
        }

        return array;

    }

}