Javase（day10：包、数组排序和查找简单算法）

1、包

• 为什么需要包
1、通过包来管理类，类似于通过文件夹来管理大片。
2、包的出现，为类提供了多层的命名空间，也就是完整的类名为“包名+类名”。
注意：在不同的包中，我们可以定义同名的类；但是同一个包中，我们不能定义同名的类。
• 如何去定义包
1、规则：必须遵守“标识符”的命名规则。
2、规范：必须遵守“字母全部小写，多个单词之间以“.”链接，并且做到顶级域名倒着写”的命名规范。
• 如何使用包
在源文件有效代码的第一行，我们使用package关键字来声明当前源文件中的类在哪个包中
注意：使用IDEA来运行程序的时候，则必须有包声明；但是使用DOS命令来运行程序，则必须删除包声明
• 认识常见的包
1、java.lang 包含一些Java语言的核心类，如String、Math、System等。
2、java.awt 包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
3、java.net 包含执行与网络相关的操作的类。
4、java.io 包含能提供多种输入/输出功能的类。
5、java.util 包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。
• 类的访问方式
1、第一种：简化访问
当我们需要访问“当前包”或“java.lang”中的类时，则就可以直接通过“类名”来简化访问
2、第二种：带包名访问
当我们需要访问“当前包”之外的类时（排除java.lang包中的类），则我们就应该使用“带包名”的方式来访问
例如：java.util.Scanner input = new java.util.Scanner(System.in);

2、import关键字

当我们需要访问“当前包”之外的类时（排除java.lang包中的类），如果采用“带包名”的方式来访问该类，则操作的代码就很复杂，
如果想要通过“类名”的方式来简化访问，则必须通过import关键字导入该类后，再去通过类名来简化访问。

• import关键字的注意点
1、当我们需要使用某个包中的多个类时，则就可以通过”*“通配符来导入某个包中的所有类

  注意：开发中，不建议使用通配符来导入某个包中的所有类，因为此方式效率非常低
2、当我们需要使用“不同包”中的“同名类”时，则其中一个类必须通过“带包名”的方式来访问。
3、JDK1.5之后，还新增了“静态导入”，也就是能导入某个类中的“静态属性”和“静态方法”
（开发中不建议使用，会导致阅读性变差）

3、冒泡排序

// 优化之前，在排序过程中，可能会提前完成排序，这时就不需要继续比较交换了public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 6, 7, 1, 4, 3};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

// 优化后public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 6, 7, 1, 4, 3};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            // 在每一次排序开始前，都假设已经排序完成
            boolean flag = true;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 发生了交换，所以推翻假设
                    flag = false;
                }
            }
            if (flag)
                break;
        }
    }
}

4、选择排序

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 6, 7, 1, 4, 3};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i; j <= arr.length - 1; j++) {
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (min != i) {
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }
}

5、二分法查找

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        int index = binarySearch(arr, 5);
        System.out.println(index);
    }

    public static int binarySearch(int[] arr, int element) {
        int min = 0;
        int max = arr.length - 1;
        int mid = 0;
        while (true) {
            mid = (min + max) / 2;
            if (element > arr[mid]) {
                min = mid + 1;
            }else if (element < arr[mid]) {
                max = mid - 1;
            }else {
                return mid;
            }

            if (min > max) {
                // 返回负数，表示没有找到该元素
                return -1;
            }
        }
    }

}