【后端Java】Java体系（五）

数组、排序和查找

一、数组介绍

• 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
• 即：数组就是一组数据

二、数组的使用

• 动态初始化
  • 数据类型 数组名[] = new 数据类型[大小]
  • int a[] = new int[5]; // 创建了一个数组，名字a，存放了5和int
• 静态初始化
  • 数据类型 数组名[] = {元素值，元素值…}

三、数组使用注意事项

• 数组是多个相同类型数据的组合，实现对这些数据的统一管理
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
• 数组创建后，如果没有赋值，有默认值
  • int 0
  • char \u0000
  • boolean false
  • String null
• 数组下标必须在指定范围内使用，否则报：下标越界异常
• 数组属引用类型，数组型数据是对象（object）

四、数组赋值机制

• 基本数据类型赋值，这个值就是具体的数据，而且相互不影响，赋值方式为值传递
• 数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用传递
  
• arr1[0] = 10;
• 分析：
  • 基本数据类型直接放在栈
  • 在内存里面只要分配了一个数据空间一定会对应一个地址
    

五、排序

• 是将一群数据，依指定的顺序进行排序的过程
• 分类
  • 内部排序
    • 指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）;
  • 外部排序
    • 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）。
• 冒泡排序（Bubble Sorting）：
  • 通过对待排序序列从后向前，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。

六、二维数组

• 使用
  • 动态初始化
    • 类型[][] 数组名 = new 类型[大小][大小]
    • int a[][] = new int[2][3];
      
  • 动态初始化-列数不确定 int a[][] = new int[3][];
  • 静态初始化 int[][] arr = {{1,1,1},{8,8,9},{100}};
• 细节
  • 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。
  • 声明方式：
    • int[][] y
    • int[] y[]
    • int y[][]

七、实例

// 1.创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。使用 for 循环访问所有元素并打印出来。
public class ArrayExercise01 {
    public static void main(String[] args) {
        char[] chars = new char[26];
        for(int i = 0; i < chars.length; i++) {
            chars[i] = (char)('A' + i);
        }
        for(int i = 0; i < chars.length; i++) {
            System.out.print(chars[i] + " ");
            // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
        }
    }
}

// 2.请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。
public class ArrayExercise02 {
    public static void main(String[] args) {
        int[] arr = {4,-1,9,10,23};
        int max = arr[0];
        int maxIndex = 0;
        for (int i = 0; i < arr.length; i++) {
            if(max < arr[i]) {
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("max=" + max + " maxIndex=" + maxIndex);
    }
}

// 3.把数组的元素内容反转。
public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        int temp = 0;
        int len = arr.length;
        for(int i = 0; i < len / 2; i++) {
            temp = arr[i];
            arr[i] = arr[len - i - 1];
            arr[len - i - 1] = temp;
        }

        System.out.println("===翻转后数组===");
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
            // 66	55	44	33	22	11
        }
    }
}

// 4.实现动态的给数组添加元素效果，实现对数组扩容。
public class ArrayAdd {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        int[] arr = {1,2,3};
        do {
            int[] arrNew = new int[arr.length + 1];
            for(int i = 0; i < arr.length; i++) {
                arrNew[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addNum = myScanner.nextInt();
            arrNew[arrNew.length - 1] = addNum;
            arr = arrNew;
            System.out.println("====arr 扩容后元素情况====");
            for(int i = 0; i < arr.length; i++) {
                System.out.println(arr[i] + "\t");
            }
            // 问用户是否继续
            System.out.println("是否继续添加 y/n");
            char key = myScanner.next().charAt(0);
            if(key == 'n') {
                break;
            }
        }while(true);
        System.out.println("你退出了添加...");
    }
}

// 5.冒泡排序
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13,-1,30,200,-110};
        int temp = 0;   // 用于辅助交换的变量

        for(int i = 0; i < arr.length - 1; i++) {
            for(int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j] > arr[j+1]) {
                    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]+" ");
            // -110 -1 13 24 30 57 69 80 200 
        }
    }
}

// 6.杨辉三角
public class YangHui {
    public static void main(String[] args) {
        int[][] yangHui = new int[12][];
        for(int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i+1];
            for(int j = 0; j < yangHui[i].length; j++) {
                // 每一行的第一个元素和最后一个元素都是1
                if(j == 0 || j == yangHui[i].length - 1) {
                    yangHui[i][j] = 1;
                } else { // 中间的元素
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        // 输出杨辉三角
        for(int i = 0; i < yangHui.length; i++) {
            for(int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
            //1	
            //1	1	
            //1	2	1	
            //1	3	3	1	
            //1	4	6	4	1	
            //1	5	10	10	5	1	
            //1	6	15	20	15	6	1	
            //1	7	21	35	35	21	7	1	
            //1	8	28	56	70	56	28	8	1	
            //1	9	36	84	126	126	84	36	9	1	
            //1	10	45	120	210	252	210	120	45	10	1	
            //1	11	55	165	330	462	462	330	165	55	11	1	
        }
    }
}