【Java】【基础篇】day04：数组

前言

本期任务：毕向东老师Java视频教程学习笔记（共计25天）

• 原视频链接：黑马程序员_毕向东_Java基础视频教程
• day01：编写HelloWorld程序
• day02：操作符与条件选择语句
• day03：循环语句与函数
• day04：数组
• day07：继承、抽象类与接口
• day08：多态
• day09：异常处理
• day11：多线程
• day12：线程安全与同步机制
• day13：String类
• day14：集合（ArrayList，LinkedList，HashSet）
• day15：集合（TreeSet）和泛型）
• day16：集合（HashMap、TreeMap）
• day17：集合框架的工具类（Arrays、Collections）
• day18：IO流（字符流读写）
• day19：IO流（字节流、转换流读写）
• day20：IO流（File对象）

---

一、进制转换

 /*
 需求：进制转换：十进制转二进制、八进制、十六进制
 
 思路：
    - 使用&运算，取最低位数
        - 二进制取1位（&1）
        - 八进制取3位（&7）
        - 十六进制取4位（&15）
    - 使用>>>运算，移动最低位数
        - 二进制右移1位
        - 八进制右移3位
        - 十六进制右移4位

 步骤：
    - 一重循环
        - 取最低位数（&）
        - 右移最低位数（>>>）
        - 若当前数值为0时，跳出循环
 */


public class HexConversion {
    public static void main(String[] args) {
        int number = 60;
        System.out.println("十进制：" + number);

        System.out.print("二进制：");
        printArray(toBin(number));

        System.out.print("八进制：");
        printArray(toOctal(number));

        System.out.print("十六进制：");
        printArray(toHex(number));
    }

    public static char[] toBin(int num) {
        return hexConversion(num, 1, 1);
    }

    public static char[] toOctal(int num) {
        return hexConversion(num, 3, 7);
    }

    public static char[] toHex(int num) {
        return hexConversion(num, 4, 15);
    }


    // 进制转换（通用）
    public static char[] hexConversion(int num, int base, int offset) {
        char[] chs = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] res = new char[32];

        int i = 0;
        while (num != 0) {
            int temp = num & offset;
            res[i++] = chs[temp];
            num = num >>> base;
        }
        return res;
    }

    // 打印数组所有元素
    public static void printArray(char[] arr) {

        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] != '\u0000') {
                if (i > 0)
                    System.out.print(arr[i]);
                else
                    System.out.print(arr[i]);
            }
        }
        System.out.println();
    }
}

---

二、数组排序

/*
 需求：数组排序实现
    - 支持升序，降序
 
 思路：
    - 冒泡排序
    - 选择排序
    - 插入排序
 
 步骤：
    - 交换函数
    - 打印数组函数
    - 排序函数
 */


public class ArraySort {
    public static void main(String[] args) {
        int[] array = {1, 3, 2, 5, 4};
        printArray(array);  // 打印排序完成的数组

        System.out.println("-----冒泡排序算法-----");
        bubbleSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组
        bubbleSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组

        System.out.println("-----选择排序算法-----");
        selectionSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组
        selectionSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组

        System.out.println("-----插入排序算法-----");
        insertionSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组
        insertionSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的数组
    }

    // 交换数组中的两个元素
    public static void swap(int[] arr, int x, int y) {
        int temp;
        temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }

    // 实现冒泡排序算法
    public static void bubbleSort(int[] arr, boolean reverse) {
        /*
         需求：冒泡排序算法的实现
            - 支持升序，降序

         思路：
            - 两重循环
            - 比较
            - 交换

         步骤：
            - 交换函数
            - 打印数组函数
            - 冒泡排序函数
                - 遍历n-1轮，降序关系则交换位置
                - 优化：设置哨兵，若本轮无需交换，说明排序完成，不再继续下一轮遍历
         */
        if (arr.length <= 1)    // 若数组长度小于等于1，无需排序
            return;

        boolean flag;
        for (int i = 0; i < arr.length - 1; i++) {
            flag = true;   // 提前结束遍历的信号
            for (int j = 0; j < arr.length - 1 - i; j++)    // 冒泡排序，每次升序降序，每次都是从首个位置开始
                if (reverse) {
                    if (arr[j] < arr[j + 1]) {
                        swap(arr, j, j + 1);
                        flag = false;       //
                    }

                } else {
                    if (arr[j] > arr[j + 1]) {
                        swap(arr, j, j + 1);
                        flag = false;       //
                    }
                }

            if (flag)   // 若本轮已无需交换，则退出
                break;
        }
    }

    // 实现选择排序算法
    public static void selectionSort(int[] arr, boolean reverse) {
        /*
         需求：选择排序算法的实现
            - 支持升序，降序

         思路：
            - 两重循环
            - 比较
            - 交换（每轮交换0次或1次）

         步骤：
            - 交换函数
            - 打印数组函数
            - 选择排序函数
                - 遍历n-1轮，每轮交换0次或1次
         */
        if (arr.length <= 1)    // 若数组长度小于等于1，无需排序
            return;

        for (int i = 0; i < arr.length - 1; i++) {
            int k = i;
            for (int j = i + 1; j <= arr.length - 1; j++)
                if (reverse) {
                    if (arr[j] > arr[k]) {
                        k = j;
                    }

                } else {
                    if (arr[j] < arr[k]) {
                        k = j;
                    }
                }
            if (k != i)
                swap(arr, k, i);
        }
    }

    // 实现插入排序算法
    public static void insertionSort(int[] arr, boolean reverse) {
        /*
         需求：插入排序算法的实现
            - 支持升序，降序

         思路：
            - 两重循环
            - 比较
            - 移动数组元素

         步骤：
            - 交换函数
            - 打印数组函数
            - 插入排序函数
                - 遍历n轮，每轮移动多次
         */
        if (arr.length <= 1)    // 若数组长度小于等于1，无需排序
            return;

        for (int i = 0; i < arr.length; i++) {
            int value = arr[i]; // 保存当前位置的值
            int j = i - 1;
            for (; j >= 0; j--) { // 从当前数组最后一个位置开始遍历
                if (reverse) {
                    if (value > arr[j])
                        arr[j + 1] = arr[j];// 当前位置比目标小，后移一位
                    else
                        break;  // 此时说明已找到插入的位置，退出
                } else {
                    if (value < arr[j])
                        arr[j + 1] = arr[j];      // 当前位置比目标大，后移一位
                    else
                        break;  // 此时说明已找到插入的位置，退出
                }
            }
            arr[j + 1] = value; //初始时有减一操作，插入时需加一
        }
    }

    // 打印数组所有元素
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1)
                System.out.print(arr[i] + ", ");
            else
                System.out.print(arr[i] + "]");
        }
        System.out.println();
    }
}