javase基础4

1.random

　　用于产生 一个随机数

案例代码:

/*
 * Random:用于产生随机数
 * 
 * 使用步骤：
 *         A:导包
 *             import java.util.Random
 *         B:创建对象
 *             Random r = new Random();
 *         C:获取随机数
 *             int number = r.nextInt(10);
 *             获取的是0-10之间的随机数，包括0，不包括10
 * 
 * 需求：如何获取到一个1-100之间的随机数呢?
 */
public class RandomDemo {
    public static void main(String[] args) {
        // 创建对象
        Random r = new Random();

        for (int x = 0; x < 10; x++) {
            // 获取随机数
            int number = r.nextInt(10);
            // 输出随机数
            System.out.println("number:" + number);
        }
        System.out.println("--------------------");

        // 如何获取到一个1-100之间的随机数呢?
        int i = r.nextInt(100) + 1;
        System.out.println("i:" + i);
    }
}

2.1-100的猜数字

public static void main(String[] args) {
        // 系统产生一个随机数1-100之间的。
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while(true){
            // 键盘录入我们要猜的数据
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字(1-100)：");
            int guessNumber = sc.nextInt();
    
            // 比较这两个数据(用if语句)
            if (guessNumber > number) {
                System.out.println("你猜的数据" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数据" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你,猜中了");
                break;
            }
        }
}

3.数组概述

　　数组是存储同一种数据类型多个元素的容器

　　数组既可以存储基本数据类型,也可以存储引用数据类型

定义格式:

　　

格式1：数据类型[] 数组名;

格式2：数据类型 数组名[];

注意：这两种定义做完了，数组中是没有元素值的。

4.数组的初始化

　　java中的数组必须先初始化才可以使用

　　就是必须为数组中的数组元素分配内存空间,并为每个数组元素赋值

动态初始化:

　　

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

数组的长度其实就是数组中元素的个数

静态初始化:

/*
 * 静态初始化的格式：
 *         数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
 * 
 *         简化格式：
 *             数据类型[] 数组名 = {元素1,元素2,...};
 * 
 *         举例：
 *             int[] arr = new int[]{1,2,3};
 * 
 *         简化后：
 *             int[] arr = {1,2,3};
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3};
        
        //输出数组名和元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

5.JVM内存划分

　　java程序在运行时,需要在内存中的分配空间,为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理方式和内存管理方式

　　栈:存储局部变量

　　堆:存储new出来的东西

6.两个数组指向同一个地址的内存图

　　

/*
 *定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
 * 然后给第二个数组赋值，再次输出两个数组的名及元素。
 */
public class ArrayTest {
    public static void main(String[] args) {
        // 先定义一个数组，赋值，输出
        int[] arr = new int[3];
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组
        int[] arr2 = arr;
        // 然后给第二个数组赋值
        arr2[0] = 111;
        arr2[1] = 222;
        arr2[2] = 333;

        // 再次输出两个数组的名及元素
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

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

7.数组的元素访问

　　

public static void main(String[] args) {
        //数据类型[] 数组名 = new 数据类型[数组长度];
        int[] arr = new int[3];
        /*
         * 左边：
         *         int:说明数组中的元素的数据类型是int类型
         *         []:说明这是一个数组
         *         arr:是数组的名称
         * 右边：
         *         new:为数组分配内存空间
         *         int:说明数组中的元素的数据类型是int类型
         *         []:说明这是一个数组
         *         3:数组的长度，其实就是数组中的元素个数
         */`
        
        System.out.println(arr); //[I@3fa5ac,地址值
        //其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度-1
        //用数组名和编号的配合我们就可以获取数组中的指定编号的元素
        //这个编号的专业叫法：索引
        //格式：数组名[编号] -- 数组名[索引]
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

8.数组的两个常见异常

　　数组越界异常:java.lang.ArrayIndexOutOfBoundsException

　　　　访问了不存在的索引元素

　　空指针异常:java.lang.NullPointerException

　　　　数组已经不指向堆内存的数据了,你还使用数组去访问元素

9.一维数组遍历

　　

public static void main(String[] args) {
        // 定义数组
        int[] arr = { 11, 22, 33, 44, 55 };
        // 原始做法
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println("--------------------");

        //改进
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }

10.数组获取最大值

　　

public static void main(String[] args) {
        //定义数组
        int[] arr = {12,98,45,73,60};
        
        //定义参照物
        int max = arr[0];
        
        //遍历数组，进行比较
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        System.out.println("最大值是："+max);
    }

11.二维数组

　　就是元素为一维数组的数组

　　

定义格式：

 *      A:数据类型[][] 数组名;

 *      B:数据类型 数组名[][];

 *      C:数据类型[] 数组名[];

初始化:

　　

A:动态初始化

 *          数据类型[][] 数组名 = new 数据类型[m][n];

　　　　　　m表示这个二维数组有多少个一维数组

　　　　　　n表示每一个一维数组的元素有多少个

B:静态初始化

 *         数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};

 *          简化格式：

 *          数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};

 12.二维数组的遍历

public static void main(String[] args) {
        // 定义二维数组
        int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        // 二维数组中的一维数组名称：二维数组名[索引]
        // arr[0] 其实就是二维数组中的第一个一维数组的名称
        // arr[1] 其实就是二维数组中的第二个一维数组的名称
        // arr[2] 其实就是二维数组中的第三个一维数组的名称

        // for (int x = 0; x < arr[0].length; x++) {
        // System.out.println(arr[0][x]);
        // }

        // System.out.println("hello");
        // System.out.println("world");
        // System.out.print("hello");
        // System.out.print("world");

        /*
        // 第一个一维数组的元素
        for (int x = 0; x < arr[0].length; x++) {
            System.out.print(arr[0][x] + "  ");
        }
        System.out.println();

        // 第二个一维数组的元素
        for (int x = 0; x < arr[1].length; x++) {
            System.out.print(arr[1][x] + "  ");
        }
        System.out.println();

        // 第三个一维数组的元素
        for (int x = 0; x < arr[2].length; x++) {
            System.out.print(arr[2][x] + "  ");
        }
        System.out.println();
        */
        
//        for(int y=0; y<3; y++) {
//            for (int x = 0; x < arr[y].length; x++) {
//                System.out.print(arr[y][x] + "  ");
//            }
//            System.out.println();
//        }
        //最后
        for(int y=0; y<arr.length; y++) {
            for (int x = 0; x < arr[y].length; x++) {
                System.out.print(arr[y][x] + "  ");
            }
            System.out.println();
        }

    }