学点Java打小工_Day4_数组_冒泡排序

1 数组基本概念

程序=算法+数据结构
算法：解决程序的流程步骤
数据结构：将数据按照某种特定的结构来存储
设计良好的数据结构会导致良好的算法。
ArrayList、LinkedList

数组是最简单的数据结构。
数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。
int num = 3;
int[] array = new int[4];
①存放整数类型的数组
②长度是4 （数组缺点长度固定，ArrayList解决长度固定的问题）//面试题：底层用数组实现
③只能存放int类型
数组的访问：数组名[下标]

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

int[] array1 = new int[3];
double[] array2 = new double[3];
boolean[] array3 = new boolean[3];
char[] array4 = new char[3];
// Student[] array5 = new Student[3];
1
2
3
4
5

数组定义的方式：
①在定义的时候直接赋值
int[] array = {32,5,7,87};
int[] array = new int[]{32,5,7,87};
②先定义后赋值
int[] array = new int[4];
array[0] = 34;

Demo不放了，没啥难的

2 数组下标越界异常

java.lang.Array Index OutOf Bounds Exception: 4
数组下标越界异常
//面试题 Java常见异常

3 数组遍历——求最大最小值

  老生常谈，Java的函数(方法)不一定非要先定义后用(这点比C方便)
  /**+回车 给函数加注释，调用的时候可以显示
  带有函数调用的Debug，加断点/step into

    @Test
    public void test4() {
        int arr1[] = {1, 9, 3, 4};
        //array.fori
        //int max = arr1[0];
        int min = arr1[0];
        /*for (int i = 0; i < arr1.length; i++) {
            max = (arr1[i] > max) ? arr1[i] : max;
        }*/
        //方法调用: 方法名(参数)
        //debug: 可以在函数里边加断点 省的点step into了, 前提是知道函数在哪个位置
        int max = getMax(arr1);

        for (int i = 0; i < arr1.length; i++) {
            min = (arr1[i] < min) ? arr1[i] : min;
        }

        System.out.println("max: " + max);
        System.out.println("min: " + min);
    }

    /** /**+enter
     *求最大值
     * @param arr  要求最大值的数组
     * @return 返回数组最大值
     */
    public int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            max = (arr[i] > max) ? arr[i] : max;
        }
        return max;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

数组遍历快捷写法：
数组名.fori
双重循环中结合shift+F6，可以快速修改循环变量名

4 冒泡排序

    老生常谈

数组的排序：冒泡排序
int[] array = {40, 17, 21, 1}; // 1, 17,21,40
第一轮：40冒到最右边
17,40,21,1
17,21,40,1
17,21,1,40 ------- 40 冒出来
第二轮：21冒出来
17,21,1,40
17,1,21,40 ------- 21冒出来
第三轮：17冒出来
1,17,21,40 ------- 17冒出来

    //bubble sort
    @Test
    public void bubbleSort() {
        int[] arr = new int[] {45, 70, 35, 99, 6, 3};
        //这里老师说建议i从1开始, 他说的理由是符合正常逻辑, 
        //但也间接解决了可能存在的数组越界问题, 没讲到这个知识点
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  这里老师说建议i从1开始, 他说的理由是符合正常逻辑, 但也间接解决了内层循环可能存在的数组越界问题, 没讲到这个知识点

5 IDEA——Alt+Enter快速修复错误

  调用一个不存在的函数，也会报错，用Alt+Enter快捷键，快速修复“错误”，自己会生成一个函数（快一点）

6 二维数组(非重点掌握)

  二维数组里面又是个一维数组

//二维数组的创建和初始化：
int[][] array = {{1,2},{2,3},{3,4,5}};

//从最高维开始，分别为每一维分配空间：
int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[2];
array[2] = new int[3];
array[0][0] = 1;
array[1][1] = 3;
1
2
3
4
5
6
7
8
9
10

//两行互换：
int[] temp = array[0];
array[0] = array[1];
array[1] = temp;

//直接为每一维分配空间：
int[][] array = new int[2][3];
1
2
3
4
5
6
7