Random

作用：
– 用于产生一个伪随机数
• 使用步骤(和Scanner类似)
– 导包
• import java.util.Random;
– 创建对象
• Random r = new Random();
– 获取伪随机数
• int number = r.nextInt(10);
• 产生的数据在0到10之间，包括0，不包括10。
• 括号里面的10是可以变化的，如果是100，就是0-100之间的数据

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-19-9:22
  4.  */
  5. //1.导入Random包
  6.     import java.util.Random;
  7. public class TestRandom01 {
  8.     public static void main(String[] args) {
  9.         //2.创建Random对象
  10.         Random r=new Random();
  11.         //3.使用random对象
  12.         //返回int类型中的数据，范围就是int类型定义的范围之间
  13.         int a;
  14.         for(int i=1;i<10;i++){
  15.             a=r.nextInt();
  16.             System.out.println(a);
  17.         }
  18.         //取出某一范围整数 [0-54)=0...54
  19.         int b=r.nextInt(54);//返回包含0，不包含54的随机数
  20.         System.out.println(b);
  21.     }
  22. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-19-9:32
  4.  */
  6. import java.util.Random;
  7. import java.util.Scanner;
  9. /**
  10.  *  猜数字小游戏案例
  11.  * * 系统产生一个1-100之间的随机数，请猜出这个数据是多少。
  12.  * * 分析：
  13.  * * A:系统产生一个随机数1-100之间的。
  14.  * * int number = r.nextInt(100) + 1;
  15.  * * B:键盘录入我们要猜的数据
  16.  * * 用Scanner实现
  17.  * * C:比较这两个数据(用if语句)
  18.  * * 大了：给出提示大了
  19.  * * 小了：给出提示小了
  20.  * * 猜中了：给出提示，恭喜你，猜中了
  21.  * * D:多次猜数据，而我们不知道要猜多少次，怎么办呢?
  22.  * * while(true) {循环的内容}
  23.  */
  24. public class TestRandom02 {
  25.     public static void main(String[] args) {
  27.         //2.产生1-100之间的随机数
  28.         Random r = new Random();
  29.         //bound(不包含100），直接在括号内输入100
  30.         int ranNum = r.nextInt(100) + 1;
  31.         //1.输入猜的数据
  32.         while (true) {
  33.                 Scanner sc = new Scanner(System.in);
  34.                 System.out.println("输入一个数：");
  35.                 int num = sc.nextInt();
  37.                 if (num > ranNum) {
  38.                     System.out.println("大了");
  39.                 } else if (num < ranNum) {
  40.                     System.out.println("小了");
  41.                 } else {
  42.                     System.out.println("恭喜你，猜中了！");
  43.                     break;
  44.                 }
  45.         }
  46.     }
  47. }

数组

数组概念

数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。

数组初始化概述：

Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组的初始化方式

动态初始化:初始化时只指定数组长度，由系统为数组分配初始值

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化:初始化时指定每个数组元素的初始值，由元素个数决定数组长度

特点：

1.是定长（声明长度之后不能改变长度）
2.有索引

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-19-9:46
  4.  */
  5. public class A {
  6.     public static void main(String[] args) {
  7.         String[] names;
  8.         //表示该容器放35个元素，每个元素的默认值是null（它是字符串）
  9.         names=new String[35];
  10.         //给第一个元素赋值
  11.         names[0]="Lynn";
  12.         System.out.println(names[0]);
  14.         int[] arr=new int[100];
  15.         arr[0]=5;
  16.         //数组容器中放100个元素，整型元素默认值是0
  17.         System.out.println(arr[0]);
  18.         //动态赋值，分2步
  19.         //第一步：创建数组容器大小
  20.         //第二步：给容器中元素赋值
  22.         //静态创建数组，只需要一步，直接创建数组容器后赋值
  23.         String[] names2={"Lynn","cheery","linda"};
  24.         System.out.println(names2[2]);
  26.         //把0--10000的数放入数组
  27.         int [] arr3=new int[10000];
  28.         for (int i = 0; i < 10000; i++) {
  29.             arr3[i]=i;
  30.             System.out.println(i);
  31.         }
  32.     }
  33. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-19-10:21
  4.  */
  5. public class B {
  6.     public static void main(String[] args) {
  7.         int[] arr={11,22,33,44,55,66,77,88};
  8.         //数组有下标（索引），从0开始，如果一个数组有8个元素，那么他的下标最大是7
  9.         System.out.println(arr[0]);
  10.         System.out.println(arr[7]);
  11.         System.out.println("------------------------");
  12.         //length属性可以获取数组元素的个数
  13.         System.out.println(arr.length);//下标的最大值是length-1
  14.         //遍历数组中所有元素
  15.         for (int i = 0; i < arr.length; i++) {
  16.             System.out.print(arr[i]+"\t");
  17.         }
  18.         System.out.println("------------------------");
  19.         //使用foreach遍历数组
  20.         //遍历数组，把每次遍历到的值给a
  21.         for (int a:arr){
  22.             System.out.print(a+"\t");
  23.         }
  24.         //for 和foreach的区别：for在遍历过程中可以随时知道数组的下标，而foreach不行
  26.         //数组访问过程中出现的问题
  27.         //System.out.println(arr[8]);
  28.         //ArrayIndexOutOfBoundsException  数组越界
  29.         //访问的范围超过了数组定义的范围
  30.         int[] arr2;//声明一个数组，还没有规定数组大小
  31.         //直接访问这个数组，会产生java.lang.NullPointerException，空指针异常
  32.         //数组已经不指向堆内存的数据了，你还使用数组名去访问元素
  34.     }
  35. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-19-14:04
  4.  */
  5. public class F_search {
  6.     public static void main(String[] args) {
  7.         int[] arr={99,33,55,77,88,66};
  8.         //查找数组中是否存在55这个数
  9.         //普通方法 遍历 查找
  10.         //设置一个布尔类型标志
  11.         boolean flag=false;
  12.         for (int i = 0; i <arr.length ; i++) {
  13.             if(arr[i]==22){
  15.                 System.out.println("22在数组中的索引是："+arr[i]);
  16.                 //设置flag为true，表示已经找到
  17.                 flag=true;
  18.             }
  19.         }
  20.         //判断flag
  22.         if(!flag){
  23.             System.out.println("没有这个数！");
  24.         }
  25.     }
  26. }
  1. import java.security.Key;
  2. import java.util.Arrays;
  4. /**
  5.  * @author Lynn
  6.  * @create 2020-11-19-14:10
  7.  */
  8. public class F_search1 {
  9.     public static void main(String[] args) {
  10.         int[] arr={99,33,55,77,88,66};
  11.         //1.排序
  12.         Arrays.sort(arr);
  13.         //
  14.         //2.使用二分查找数据
  15.         //第一个参数：数组；第二个参数：要找的值
  16.         //返回这个值在数组中的索引
  17.         int index=Arrays.binarySearch(arr,88);
  18.         System.out.println("index:"+index);
  19.     }
  20. }
  1. import java.util.Arrays;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-19-13:43
  6.  */
  7. public class F_sort {
  8.     public static void main(String[] args) {
  9.         int[] arr={99,33,55,77,88,66};
  10.         System.out.println("排序前：");
  11.         for(int i:arr){
  12.             System.out.print(i+"\t");
  13.         }
  14.         System.out.println();
  15.         //对数组进行排序，使用快速排序算法
  16.         Arrays.sort(arr);
  17.         System.out.println("排序后：");
  18.         for (int i:arr){
  19.             System.out.print(i+"\t");
  20.         }
  21.         System.out.println();
  22.         //获取最值
  23.         System.out.println("最小值："+arr[0]);
  24.         System.out.println("最大值："+arr[arr.length-1]);
  25.     }
  26. }
  1. import java.util.Arrays;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-19-13:52
  6.  */
  7. public class F_sort1 {
  8.     public static void main(String[] args) {
  9.         //实现数组从大到小排序
  10.         int[] arr={99,33,55,77,88,66};
  11.         //1.对数组进行正序排列
  12.         Arrays.sort(arr);
  13.         //2.进行反转
  14.         int[] other=new int[arr.length];
  15.         //2.1遍历arr数组 33 55 66 77 88 99
  16.         for(int i=0;i<arr.length;i++){
  17.             //i=0
  18.             other[i]=arr[arr.length-1-i];
  19.         }
  20.         //打印
  21.         for(int i:other){
  22.             System.out.print(i+"\t");
  23.         }
  24.         System.out.println("------------------");
  25.         int[] other2=new int[arr.length];
  26.         //2.2遍历arr数组，33,55,66,77,88,99 从最后一个开始遍历
  27.         for(int i= arr.length-1;i>=0;i--){
  28.             //arr.length-1-i
  29.             other2[arr.length-1-i]=arr[i];
  30.         }
  31.             //打印
  32.         for (int i :other2) {
  33.             System.out.print(i+"\t");
  34.         }
  35.     }
  36. }

image.png