数据类型[] 数组名
int[] arr;        
double[] arr;      
char[] arr;

数据类型 数组名[]
int arr[];
double arr[];
char arr[];  //一般使用这种格式

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];
byte[] bArr = new byte[3];

public class Demo2Array {
    /*
        数组的动态初始化:
                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.

        动态初始化格式:
                        数据类型[] 数组名 = new 数据类型[数组的长度];

        注意:
                        打印数组变量的时候, 会打印出数组的内存地址

        [I@10f87f48 :

                        @ : 分隔符
                        [ : 当前的空间是一个数组类型
                        I : 当前数组容器中所存储的数据类型
                        10f87f48 : 十六进制内存地址

                                0 1 2 3 4 5 6 7 8 9 a b c d e f
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);

    }
}

数组名[索引];

public class Demo3ArrayIndex {
    /*
        数组动态初始化:
                初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.

        数组的元素访问格式:
                数组名[索引]

                索引: 数组中数据的编号方式, 编号从0开始
                作用: 访问数组容器中的空间位置

        注意:
                数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
     */
    public static void main(String[] args) {
        int[] arr = new int[3];         // 0 1 2
        System.out.println(arr);        // 数组的内存地址  [I@10f87f48

        // 数组名[索引]  访问数组容器中的空间位置
        System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 数组名[索引]
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

// 这里的int a是一个基本类型变量，存储的是一个数值
int a = 10;
//这里的int[] arr是一个引用类型的变量，存储的是一个地址值
int[] arr = new int[]{44,55,66};

public class Demo1Array {
    /*
        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度

        完整格式:
                    数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        简化格式:
                    数据类型[] 数组名 = {数据1,数据2,数据3...};
     */
定义int数组array,并采用标准格式静态初始化
int[] array = new int[]{100, 200, 300};//100的索引编号是0,200的索引编号是1,300的索引编号是2

System.out.println(array);//地址值: [I@1540e19d
System.out.println(array[0]);//打印数组array中索引编号为0的元素: 100

System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值


 //把int数字1000,存储到数组array中的索引编号为0的元素中,原有的数据100将被 替换/覆盖
array[0] = 1000;
System.out.println(array[0]);//打印数组array中索引编号为0的元素: 1000

//获取数组长度
int size = array.length;//保存到int变量size中
System.out.println("数组长度: "+size);//3
System.out.println("数组长度: "+array.length);//3

System.out.println(array[array.length-1]); // 3000

public class Test2Array {
    /*
        需求: 从数组中查找最大值

                int[] arr = {12,45,98,73,60};

        实现步骤:
                1. 假设数组中的第一个元素为最大值
                2. 遍历数组, 获取每一个元素, 准备进行比较
                3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
                4. 循环结束后, 打印最大值.
     */
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        // 1. 假设数组中的第一个元素为最大值
        int max = arr[0];
        // 2. 遍历数组, 获取每一个元素, 准备进行比较
        for(int i = 1; i < arr.length; i++){
            // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //  4. 循环结束后, 打印最大值.
        System.out.println("max:" + max);
    }
}

public class Test3Array {
    /*
        需求：键盘录入5个整数，存储到数组中，并对数组求和

        思路：
            1.创建键盘录入对象，准备键盘录入
            2.定义一个求和变量，准备记录累加后的结果
            3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
            4.将键盘录入的数值存储到数组中
            5.遍历数组，取出每一个元素，并求和
            6.输出总和
     */
    public static void main(String[] args) {
        // 1.创建键盘录入对象，准备键盘录入
        Scanner sc = new Scanner(System.in);
        // 2.定义一个求和变量，准备记录累加后的结果
        int sum = 0;
        // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr = new int[5];
        // 4.将键盘录入的数值存储到数组中
        for(int i = 0; i < arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个整数:");
            //arr[i] = 10;
            arr[i] = sc.nextInt();
        }

        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 6.输出总和
        System.out.println("sum:" + sum);

    }
}

for (元素类型 变量名 : 数组名) {
    // 使用变量名操作当前元素
}
//增强for循环让你用最少的代码，安全地遍历数组的每个元素。

//增强for循环只能读取，不能修改数组内容
//需要下标索引时，需要用传统for循环

import java.util.Scanner;
/*
    键盘输入一个数字,用二分查找的思路从数组中找元素的索引位置

    思路:
        1: 准备3个索引,一个代表查找范围内的最大索引,一个代表最小索引,另一个代表中间索引
        2: 每次循环查找的时候,中间索引 = (最大索引+最小索引)/2
        3: 使用要查询的元素和 中间索引位置的元素比较,
            要查询的元素大于中间元素,最小索引 = 中间索引+1
            要查询的元素小于中间元素,最大索引 = 中间索引-1
       4: 找到了,或 最小索引 > 最大索引就停止查询

 */
public class Test07_3 {
    public static void main(String[] args) {
        int[] arr = {2,5,8,9,11,23,55,77,88,99};
        Scanner sc = new Scanner(System.in);
        System.out.println("亲,请输入一个要查询的整数:");
        int a = sc.nextInt();
        // 1: 准备3个索引,一个代表查找范围内的最大索引,一个代表最小索引,另一个代表中间索引
        int max = arr.length-1,min=0,mid;
        //2: 每次循环查找的时候,中间索引 = (最大索引+最小索引)/2
        while (min <= max){
            // 计算中间索引
            mid = (max+min)/2;
            // 使用要查询的元素和 中间索引位置的元素比较,
            if(a > arr[mid]){
                //要查询的元素大于中间元素,最小索引 = 中间索引+1
                min = mid+1;
            }else if(a < arr[mid]){
                max = mid-1;
            }else {
                System.out.println(a+"在数组的"+mid+"位置");
                break;
            }
        }
        if(min > max){
            System.out.println(a+"在数组中不存在!");
        }
    }
}

/*
    选择排序:

    1: 使用循环嵌套,外循环控制比较的轮数,(数组长度 - 1轮)
    2: 内循环,控制参与排序的元素,找最小值,放在当前轮的最左边

 */
public class MyTest10_1 {
    public static void main(String[] args) {
        // 1: 准备数组
        int[] arr = {2,5,8,3,6,9,1,4,7};
        // 2: 选择排序
        for (int i = 0; i < arr.length-1; i++) {
            // 从 i 索引位置开始,与后面的每个元素都比较一次,如果发现了更小的元素,这交换位置
            for (int j = i+1; j < arr.length; j++) {
                // 判断大小
                if(arr[i] > arr[j]){
                    // 交换 i 和 j 位置的元素
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

/*
    冒泡排序:

    1: 使用循环嵌套,外循环控制比较的轮数,(数组长度 - 1轮)
    2: 内循环,控制参与排序的元素,找最大值,放在当前轮的最右边
    核心思路,是相邻的两个元素比较

 */
public class MyTest10_2 {
    public static void main(String[] args) {
        // 1: 准备数组
        int[] arr = {2,5,8,3,6,9,1,4,7};
        // 2: 冒泡排序  这里的 -1 是为了提升性能
        for (int i = 0; i < arr.length-1; i++) {
            // 内循环,实现 相邻的两个元素比较,小的放左边,大的放右边  这里的 -1 是为了 让 j+1这个索引不能越界!
            for (int j = 0; j < arr.length - i -1; j++) {
                // 比较 j 和 j+1位置的元素
                if(arr[j] > arr[j+1]){
                    // 交换
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

    }
}