2021-03-04

创建随机数

1. 导包 import java.util.Random;
2. 创建对象 Random r = new Random();
3. 使用 int num = r.nextInt(参数);
   无参表示随机数范围是int的范围。
   例如10，范围[0,10)。

数组

一维数组

动态初始化

初始化时只指定数组长度，由系统为数组分配初始值。
数据类型[ ] 数组名 = new 数据类型[数组长度];
int[] arr = new int[10];

静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度。
数据类型[ ] 数组名 = new 数据类型[ ]{元素1，元素2，…，元素n};
int[ ] arr = new int[ ]{元素1，元素2，…，元素n};
一般方式:int[ ] arr = {元素1，元素2，…，元素n};

访问数组

通过数组的索引访问，索引从0开始，到数组长度减1。

二维数组

二维数组定义格式

• 数据类型[][] 数组名;
• 数据类型 数组名[][]; （不推荐）
• 数据类型[] 数组名[]; （不推荐）

初始化方式

• m： 二维数组的长度（二维数组中一维数组的个数）
• n： 二维数组中一维数组的长度
• 数据类型 变量名 = new 数据类型{{元素…},{元素…},{元素…}};
• 简化版格式：数据类型 变量名 = {{元素…},{元素…},{元素…}};

数组常见报错

• 数组索引越界异常ArrayIndexOfBoundsException
  访问到了数组中的不存在的索引时发生。
• 空指针异常NullPointerException
  数组引用没有指向对象，却在操作对象中的元素时。

数组问题练习

冒泡排序

public static void main(String[] args) {
//        冒泡排序
        int[] arr = {32,13,3124,3,32,5};
        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]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for(int i : arr){
            System.out.println(i);
        }
    }

选择排序

public static void main(String[] args) {
//        选择排序
        int[] arr = {32,13,3124,3,32,5};
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for(int i : arr){
            System.out.println(i);
        }
    }

二分查找

public static void main(String[] args) {
        //二分查找必须有序
        int[] arr = {32,13,3124,3,32,5};
        int num = 99;
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        // 先排序
        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]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        while(true){
            if(arr[mid] > num){
                max = mid - 1;
            }
            if(arr[mid] < num){
                min = mid + 1;
            }
            mid = (min + max) / 2;
            if(arr[mid] == num){
                System.out.println(mid);
                break;
            }
            if(min > max){
                System.out.println("查无此数");
                break;
            }
        }
    }

数组反转

int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

Java中的内存分配

Java中分为5个区域
栈：存放局部变量，使用完毕立即回收。
堆：存放new出来的对象，每个对象都有一个首地址值，16进制表示。
对象中的默认值

• byte,short,int,long 0
• float,double 0.0
• char ‘\u0000’,一个空格
• boolean false
• 引用类型 null

方法区：和.class相关内容
本地方法区：用于本地方法的计算
寄存器：和CPU相关,效率极高