Java基础学习-Random类和Java数组

1.随机数类（Random）

package com.denniscui;

 

import java.util.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.Random类练习之猜数字小游戏案例

package com.denniscui;

 

import java.util.Random;

import java.util.Scanner;

/*

 * 猜数字小游戏案例

 *         系统产生一个1-100之间的随机数，请猜出这个数据是多少。

 * 分析：

 *         A:系统产生一个随机数1-100之间的。

 *              int number = r.nextInt(100) + 1;

 *         B:键盘录入我们要猜的数据

 *              用Scanner实现

 *         C:比较这两个数据(用if语句)

 *              大了：给出提示大了

 *              小了：给出提示小了

 *              猜中了：给出提示，恭喜你，猜中了

 *         D:多次猜数据，而我们不知道要猜多少次，怎么办呢?

 *              while(true) {循环的内容}

 */

public class RandomTest {

     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.Java数组

    3.1 数组概述

 

    需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。

    那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：

    数组是存储多个变量(元素)的东西(容器)

    这多个变量的数据类型要一致。

 

    3.2 Java数组格式和动态初始化

package com.denniscui_01;

/*

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

 *

 * 定义格式：

 *         A:数据类型[] 数组名;(推荐的定义方式)

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

 * 举例：

 *         A:int[] a; 定义一个int类型的数组，数组名是a

 *         B:int a[]; 定义一个int类型的变量，变量名是a数组

 *

 * 数组初始化：

 *         A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值

 *         B:我们有两种方式对数组进行初始化

 *              a:动态初始化     只指定长度，由系统给出初始化值

 *              b:静态初始化     给出初始化值，由系统决定长度

 *

 * 动态初始化：

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

 */

public class ArrayDemo {

     public static void main(String[] args) {

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

           int[] arr = new int[3];

           /*

            * 左边：

            *         int:说明数组中的元素的数据类型是int类型

            *         []:说明这是一个数组

            *         arr:是数组的名称

            * 右边：

            *         new:为数组分配内存空间

            *         int:说明数组中的元素的数据类型是int类型

            *         []:说明这是一个数组

            *         3:数组的长度，其实就是数组中的元素个数

            */

     

     }

}

    3.3 对Java数组的访问

package com.denniscui_01;

/*

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

 *

 * 定义格式：

 *         A:数据类型[] 数组名;(推荐的定义方式)

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

 * 举例：

 *         A:int[] a; 定义一个int类型的数组，数组名是a

 *         B:int a[]; 定义一个int类型的变量，变量名是a数组

 *

 * 数组初始化：

 *         A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值

 *         B:我们有两种方式对数组进行初始化

 *              a:动态初始化     只指定长度，由系统给出初始化值

 *              b:静态初始化     给出初始化值，由系统决定长度

 *

 * 动态初始化：

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

 */

public class ArrayDemo {

     public static void main(String[] args) {

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

           int[] arr = new int[3];

           /*

            * 左边：

            *         int:说明数组中的元素的数据类型是int类型

            *         []:说明这是一个数组

            *         arr:是数组的名称

            * 右边：

            *         new:为数组分配内存空间

            *         int:说明数组中的元素的数据类型是int类型

            *         []:说明这是一个数组

            *         3:数组的长度，其实就是数组中的元素个数

            */

           //输出数组名

           System.out.println("arr:"+arr);//输出的是地址值arr:[I@15db9742

           //我们获取数组的地址值是没有意义的，我要的是数组中的元素值，该怎么办呢？

           //不用担心，Java已经帮你想好了这个问题

           //其实数组中的每个元素都是由编号的，编号从0开始，最大的编号是数组的长度-1

           //这个编号的专业名称是索引

           //访问格式：数组名[索引]

           System.out.println(arr[0]);

           System.out.println(arr[1]);

           System.out.println(arr[2]);

     }

}

    3.4 Java中的内存分配

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

            栈 存储局部变量，特点：局部变量就是定义在方法中的变量；使用完毕，立即回收。

            堆 存储new出来的东西，特点：每一个对象都有地址值；每一个对象的数据都有默认值，其中byte、short、int、long为0，float、double为0.0，char为'\u0000',boolean为false，引用类型为null；使用完毕后，会在垃圾回收器空闲的时候回收。

            方法区 (面向对象进阶讲)

            本地方法区 (和系统相关)

            寄存器 (给CPU使用)

 

        3.5 静态初始化

package com.denniscui_02;

/*

 * 静态初始化的格式：

 *         数据类型[] 数组名 = 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]);

     }

}

 

    3.6 Java数组中的两个常见小问题

package com.denniscui_03;

/*

 * 两个常见小问题：

 *         A:java.lang.ArrayIndexOutOfBoundsException

 *              数组越界异常

 *              产生的原因：就是你访问了不存在的索引元素。

 *         B:java.lang.NullPointerException

 *              空指针异常

 *              产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。

 * 为什么我们要记住这样的小问题呢?

 *         编程不仅仅是把代码写出来，还得在出现问题的时候能够快速的解决问题。

 */

public class ArrayDemo {

     public static void main(String[] args) {

           // 定义数组

           int[] arr = { 1, 2, 3 };

           

           //System.out.println(arr[3]);

           

           //引用类型：类,接口,数组

           //常量：空常量 null，是可以赋值给引用类型的

           //arr = null;

           System.out.println(arr[1]);

     }

}

    3.7 一维数组的遍历

package com.denniscui_03;

/*

 * 需求：数组遍历(依次输出数组中的每一个元素)

 * 获取数组中元素的个数：数组名.length

 */

public class ArrayTest {

     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循环改进

           for (int x = 0; x < 5; x++) {

                System.out.println(arr[x]);

           }

           System.out.println("--------------------");

           

           //为了解决我们去数数组中元素个数的问题，数组就提供了一个属性：length

           //用于获取数组的长度

           //格式：数组名.length

           System.out.println("数组共有："+arr.length+"个");

           System.out.println("--------------------");

           

           for(int x=0; x<arr.length; x++) {

                System.out.println(arr[x]);

           }

     }

}

 

    3.8 获取数组中的最值

package com.denniscui_03;

/*

 * 需求：数组获取最值(获取数组中的最大值最小值)

 */

public class ArrayTest2 {

     public static void main(String[] args) {

           //定义数组

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

           

           //定义参照物

           int max = arr[0];

           

           //遍历数组，获取除了0以外的所有元素，进行比较

           for(int x=1; x<arr.length; x++) {

                if(arr[x] > max) {

                     max = arr[x];

                }

           }

           System.out.println("数组中的最大值是："+max);

     }

}

 

    3.9 二维数组的格式

package com.denniscui_04;

/*

 * 二维数组：就是元素为一维数组的数组。

 *

 * 定义格式：

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

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

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

 *

 * 如何初始化呢?

 *         A:动态初始化

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

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

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

 *         B:静态初始化

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

 *              简化格式：

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

 */

public class ArrayArrayDemo {

     public static void main(String[] args) {

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

           int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

           System.out.println(arr); // [[I@104c575

           System.out.println(arr.length); // 二维数组中的一维数组的个数

           System.out.println(arr[0]);// [I@3fa5ac

           System.out.println(arr[0].length);

           System.out.println(arr[1]);// [I@95cfbe

           System.out.println(arr[2]);// [I@179dce4

           

           //我如何获取到一个二维数组的元素呢?

           System.out.println(arr[0][0]);

           System.out.println(arr[1][1]);

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

     }

}

 

    3.10 二维数组的遍历

package com.denniscui_04;

/*

 * 二维数组遍历

 *

 * System.out.println():输出内容并换行

 * System.out.print():输出内容

 * System.out.println():换行

 */

public class ArrayArrayTest {

     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();

           }

     }

}