1. 课前回顾:
  2.    1.Scanner:键盘录入
  3.      a.导包:import java.util.Scanner
  4.      b.创建对象:Scanner sc = new Scanner(System.in)
  5.      c.调用方法:
  6.        nextInt()录入一个整数
  7.        nextDouble()录入一个小数
  8.        next()录入一个字符串  遇到空格就结束
  9.        nextLine()录入一个字符串  遇到回车就结束
  10.    2.switch:
  11.      格式:
  12.       switch(变量){
  13.           case 目标值1:
  14.               执行语句1;
  15.               break;
  16.           ...
  17.               default:
  18.               执行语句n;
  19.               break
  20.       }
  21.       break:结束switch的
  22.       case的穿透性:没有break的时候出现,就一直往下穿透执行,直到遇到break或者switch结束为止
  23.    3.if:如果
  24.      if(boolean表达式){
  25.        执行语句
  26.      }
  28.      if(boolean表达式){
  29.          执行语句 
  30.      }else{
  31.          执行语句
  32.      }
  34.      if(boolean表达式){
  35.          执行语句
  36.      }else if(boolean表达式){
  38.      }else{
  40.      }
  41.    4.循环
  42.      for(初始化变量;比较;步进表达式){
  43.        循环语句
  44.      }
  45.      a.初始化变量
  46.      b.比较,如果是true,执行循环语句,步进
  47.      c.再次比较,如果还是true,再次执行循环语句,如果比较失败了,for结束
  49.      初始化变量
  50.      while(比较){
  51.        循环语句
  52.        步进表达式
  53.      }
  55.      初始化变量
  56.      do{
  57.        循环语句
  58.        步进表达式
  59.      }while(比较);
  61. 1.今日重点:
  62.   a.会死循环,以及嵌套循环(执行流程)
  63.   b.会使用Random在指定的范围内随机一个数
  64.   c.数组
  65.     静态初始化
  66.     动态初始化
  67.     往数组中存元素
  68.     从数组中获取元素
  69.     遍历数组
  70.   d.会冒泡排序的编写

第一章.循环语句

3.循环的区别

  1. 1.for循环,for循环中初始化的变量,出了for循环就使用不了了(按照常用的方式去理解)
  2. 2.while循环,初始化的变量出了while循环还能使用
  3. 3.do...while循环,初始化的变量出了do...while循环还能使用,至少执行一次
  4. 4.确定次数用for,不确定次数用while

4.循环控制关键字

  1. break:
  2.   在switch中代表结束switch语句
  3.   在循环中,代表结束循环
  4. continue:
  5.   在循环中,代表结束本次循环,进入到下一次循环
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         for (int i = 1; i <= 5; i++) {
  4.             if (i==3){
  5.                 //break;//结束循环
  6.                 continue;//结束本次循环,进入到下一次循环
  7.             }
  8.             System.out.println("我爱大数据"+i);
  9.         }
  10.     }
  11. }

5.死循环

  1. 1.什么时候会出现死循环:判断一直为true的时候
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         //for循环的死循环
  4.         int i = 0;
  5.         for(;;){
  6.             i++;
  7.             System.out.println("我是:"+i);
  8.         }
  10.         //while死循环
  11.        /* while(true){
  12.             i++;
  13.             System.out.println("我是:"+i);
  14.         }*/
  15.     }
  16. }

6.嵌套循环

  1. 1.循环体中还是一个循环
  2. 2.执行流程:
  3.   先执行外层for循环,然后进入到内层for循环,然后内层for循环就一直循环,直到内层for循环结束了;外层for循环进行第二次循环
  4.   等到外层for循环也结束了,那么整体就都结束了
  6. 3.开发中,尽量避免嵌套循环层数过多
  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         for (int fen = 0; fen < 60; fen++) {
  4.             for (int miao = 0; miao < 60; miao++) {
  5.                 System.out.println(fen+"分"+miao+"秒");
  6.             }
  7.         }
  8.     }
  9. }

第二章.Random随机数

  1. 1.概述:java自带的类
  2. 2.作用:在指定的范围内随机一个数
  3. 3.使用:
  4.   a.导包:import java.util.Random
  5.   b.创建对象
  6.     Random 对象名 = new Random()
  7.   c.调用方法,真正实现生成随机数
  8.     nextInt()->在int范围内随机一个数
  9.     nextDouble()->在0.0到1.0之间随机一个数
  11.     在指定的范围内随机一个数:
  12.     nextInt(int bound)->在  0- (bound-1)之间随机一个数
  14.     nextInt(10)->  在0-9之间随机
  16.     问题:
  17.       在1-10之间随机一个数-> nextInt(10)+1 -> (0-9)+1  -> 1-10
  18.       在100-999之间随机一个数-> nextInt(900)+100 -> (0-899)+100-> 100-999
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Random rd = new Random();
  4.         double data = rd.nextDouble();
  5.         System.out.println(data);
  6.     }
  7. }
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         Random rd = new Random();
  4.         int data1 = rd.nextInt(100) + 1;
  5.         System.out.println(data1);
  6.     }
  7. }
  1. /*
  2.   猜数字小游戏
  3.   在1-100之间随机一个数,键盘录入一个数当做我们要猜的数字
  4. */
  5. public class Test03 {
  6.     public static void main(String[] args) {
  7.         //1.创建Random对象
  8.         Random random = new Random();
  9.         //2.创建Scanner对象
  10.         Scanner sc = new Scanner(System.in);
  11.         //3.调用nextInt()随机一个数
  12.         int rdNumber = random.nextInt(100) + 1;
  13.         while (true) {
  14.             //4.调用Scanner的nextInt方法去录入一个要猜的数字
  15.             System.out.println("请你猜一个数:");
  16.             int scNumber = sc.nextInt();
  17.             if (scNumber > rdNumber) {
  18.                 System.out.println("对不起,您猜大了!");
  19.             } else if (scNumber < rdNumber) {
  20.                 System.out.println("对不起,您猜小了!");
  21.             } else {
  22.                 System.out.println("恭喜您,猜中了!");
  23.                 break;
  24.             }
  25.         }
  26.     }
  27. }

第三章.数组的介绍以及定义

  1. 1.概述:容器
  2. 2.作用:存放数据
  3. 3.特点:
  4.   a.定长:长度固定,数组在定义之后,后续不能改变数组的长度
  5.   b.既能存储基本类型,还能存储引用类型的数据
  6. 4.定义格式:
  7.   a.静态初始化:
  8.    数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3...}->推荐使用
  9.    数据类型 变量名[] = new 数据类型[]{元素1,元素2,元素3...}->不推荐使用
  11.    简化形式:
  12.     数据类型[] 变量名 = {元素1,元素2,元素3...}->静态初始化中最最推荐使用的
  14.   b.动态初始化
  15.     数据类型[] 变量名 = new 数据类型[数组的长度]->推荐使用
  16.     数据类型 变量名[] = new 数据类型[数组的长度]->不推荐使用
  18.     数据类型:决定了数组中只能存什么类型的元素
  19.     []:代表的数组
  20.     变量名:见名知意
  21.     new:代表的是真正的将数组创建出来了
  22.     数据类型:要和等号左边的数据类型保持一致
  23.     [数组的长度]:代表的是数组最多能存多少个数据
  25. 5.动态初始化和静态初始化区别:
  26.   动态初始化:
  27.     创建的时候需要手写new,刚开始没有具体的元素存储
  29.     当创建数组的时候,还不确定将来存储什么元素,只知道了个数
  31.   静态初始化:
  32.     创建的时候不需要手写new,刚开始就将具体的元素存进去了
  33.     长度可以通过存储的元素个数来确定
  34.     当创建的时候,确定了要存储什么数据
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3. //        数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3...}
  4.         int[] arr = new int[]{1,2,3,4,5,6};
  5.         int arr1[] = new int[]{1,2,3,4,5,6};
  7.         int[] arr2 = {1,2,3,4,5,6};
  9.         String[] arr3 = {"张无忌","张翠山","张三丰","赵敏","周芷若","灭绝","紫衫龙王","小昭"};
  11.         //动态初始化
  12.         int[] arr4 = new int[3];
  13.         String[] arr5 = new String[3];
  14.     }
  15. }

第四章.操作数组

1.获取数组的长度

  1. 1.格式:
  2.   数组名.length
  3. 2.注意:
  4.   length是数组的一个属性,代表数组的长度
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         String[] arr = {"努尔哈赤","皇太极","顺治","康熙","雍正","乾隆","嘉庆","道光","咸丰","同治","光绪","宣统"};
  4.         int len = arr.length;
  5.         System.out.println(len);
  6.     }
  7. }

2.索引

  1. 1.概述:记录元素在数组中存储的位置
  2. 2.特点:
  3.   索引唯一,不能重复
  4.   从0开始,最大索引是:数组的长度-1 (数组名.length-1)
  6. 3.注意:
  7.   往数组中存数据,还是从数组中获取数据,都必须依靠索引

3.存储元素

  1. 1.格式:
  2.   数组名[索引值] = 元素值->将等号右边的元素存储到数组的指定索引位置上
  3.   arr[2] = 100->将100存储到arr数组的2索引上
  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         int[] arr = new int[3];
  4.         arr[0] = 100;
  5.         arr[1] = 200;
  6.         arr[2] = 300;
  7.     }
  8. }

4.获取元素

  1. 1.注意:
  2.   直接输出数组名,不是获取元素,会把数组在内存中的地址值输出来
  3. 2.格式:
  4.   数组名[索引值]
  5. 3.区别存元素和获取元素
  6.   如果数组名[索引值]在等号右边,代表获取元素
  7.   如果数组名[索引值]在等号左边,代表存储元素
  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         int[] arr = new int[3];
  4.         arr[0] = 100;
  5.         arr[1] = 200;
  6.         arr[2] = 300;
  7.         System.out.println(arr);
  9.         /*
  10.           先将arr数字中0索引的元素获取出来,赋值给等号左边的变量element
  11.          */
  12.         int element = arr[0];
  13.         int element1 = arr[1];
  14.         int element2 = arr[2];
  15.         System.out.println(element);
  16.         System.out.println(element1);
  17.         System.out.println(element2);
  18.     }
  19. }
  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1,2,3,4};
  5.         int[] arr1 = {100,200,300,400};
  6.         System.out.println(arr1[0]);//100
  8.         /*
  9.          先获取arr数组3索引上的元素4
  10.          将4存储到arr1数组的0索引上
  12.          那么arr1数组0索引上的100就被4覆盖了
  13.          */
  14.         arr1[0] = arr[3];
  16.         System.out.println(arr1[0]);//4
  18.     }
  19. }

day04[循环_数组] - 图1

5.遍历数组

  1. 1.概述:将数组中的元素挨个的获取出来
  1. public class Test05 {
  2.     public static void main(String[] args) {
  3.         String[] arr = {"燃灯古佛","如来佛祖","东来佛祖","斗战胜佛","旃檀功德佛","阿弥陀佛"};
  4.         for (int i = 0;i<6;i++){
  5.             System.out.println(arr[i]);
  6.         }
  8.         System.out.println("===================");
  9.         for (int i = 0;i<arr.length;i++){
  10.             System.out.println(arr[i]);
  11.         }
  13.         System.out.println("===================");
  14.         for (int i = 0; i < arr.length; i++) {
  15.             System.out.println(arr[i]);
  16.         }
  17.     }
  18. }

第五章.操作数组时两个常见的问题

1.数组索引越界异常->ArrayIndexOutOfBoundsException

  1. 1.出现的原因:
  2.   我们操作的索引,超出了数组的索引范围
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1,2,3,4,5};
  4.         for (int i = 0; i <= arr.length; i++) {
  5.             System.out.println(arr[i]);
  6.         }
  7.     }
  8. }

day04[循环_数组] - 图2

2.空指针异常->NullPointerException

  1. 1.原因:如果数组为null,然后还操作了数组,就出现了空指针异常
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1,2,3,4};
  4.         int[] arr1 = new int[3];
  5.         int[] arr2 = null;
  6.         System.out.println(arr2.length);
  7.     }
  8. }

day04[循环_数组] - 图3

注意:

1.将来我们开发,不会故意的将一个引用数据类型置成null,如果置成null,也是作为一个初始化来使用,后续一定会为其赋上一个具体的值

2.有的时候,我们写代码时有可能会遇到空指针异常(我们无可奈何的)

  1. 比如:我们要获取一个对象,但是获取出来的对象没有被创建出来,由于没有被创建,获取出来的对象就是null,但是我们并不知道,已操作,出现了空指针异常

以上两个异常:不要故意写,我们要做到,看到这两个异常,知道什么原因即可

第六章.练习

9.1练习

  1. 第一题:需求:求出数组中的元素最大值
  2. 步骤:
  3. 1.定义一个变量max用于拿两个元素之间较大的元素
  4. 2.遍历数组,将每一个元素获取出来
  5. 3.循环比较
  6.   如果max的值小于遍历出来的元素,将较大的元素重新赋值给max
  7. 4.直接输出max
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {4,2,54,67,7};
  4.         //1.定义一个变量max用于拿两个元素之间较大的元素
  5.         int max = arr[0];
  6.         //2.遍历数组,将每一个元素获取出来
  7.         for (int i = 1; i < arr.length; i++) {
  8.             /*3.循环比较
  9.           如果max的值小于遍历出来的元素,将较大的元素重新赋值给max*/
  10.             if (max<arr[i]){
  11.                 max = arr[i];
  12.             }
  13.         }
  14.         //4.直接输出max
  15.         System.out.println(max);
  16.     }
  17. }

9.2练习

  1. 随机产生10个[0,100]之间整数，统计既是3又是5，但不是7的倍数的个数
  2. 步骤:
  3.   1.创建数组,长度为10
  4.   2.创建Random对象,调用10次nextInt(101)
  5.   3.将随机出来的数据,存到数组中
  6.   4.定义一个变量,做统计  count
  7.   5.遍历数组
  8.     在遍历的过程中判断
  9.     判断条件:
  10.      arr[i]%3==0 && arr[i]%5==0 && arr[i]%7!=0
  11.      如果是true,count++
  12.   6.输出count
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         //1.创建数组,长度为10
  4.         int[] arr = new int[10];
  5.         //2.创建Random对象,调用10次nextInt(101)
  6.         Random rd = new Random();
  7.         //3.将随机出来的数据,存到数组中
  8.         for (int i = 0; i < 10; i++) {
  9.             arr[i] = rd.nextInt(101);
  10.         }
  11.         //4.定义一个变量,做统计  count
  12.         int count = 0;
  13.        /* 5.遍历数组
  14.            在遍历的过程中判断
  15.            判断条件:
  16.            arr[i]%3==0 && arr[i]%5==0 && arr[i]%7!=0
  17.            如果是true,count++*/
  18.         for (int i = 0; i < arr.length; i++) {
  19.             if (arr[i]%3==0 && arr[i]%5==0 && arr[i]%7!=0){
  20.                 count++;
  21.             }
  22.         }
  23.         //6.输出count
  24.         System.out.println(count);
  25.     }
  26. }

9.3练习

  1. 用一个数组存储本组学员的姓名，从键盘输入，并遍历显示
  1. 步骤:
  2.   1.定义一个数组 5
  3.   2.创建Scanner对象
  4.   3.调用next()输入姓名存到数组中
  5.   4.遍历数组
  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         //1.定义一个数组 5
  4.         String[] arr = new String[5];
  5.         //2.创建Scanner对象
  6.         Scanner sc = new Scanner(System.in);
  7.         //3.调用next()输入姓名存到数组中
  8.         for (int i = 0; i < arr.length; i++) {
  9.             System.out.println("请你输入第"+(i+1)+"个学生姓名:");
  10.             String name = sc.next();
  11.             arr[i] = name;
  12.         }
  13.         //4.遍历数组
  14.         for (int i = 0; i < arr.length; i++) {
  15.             System.out.println(arr[i]);
  16.         }
  17.     }
  18. }

9.4练习

  1. 需求:
  2.   1.定义一个数组 int[] arr = {1,2,3,4}
  3.   2.遍历数组,输出元素按照[1,2,3,4]
  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1,2,3,4};
  4.         //[1,2,3,4]
  6.         System.out.print("[");
  7.         for (int i = 0; i < arr.length; i++) {
  8.             //判断如果i的值变化到最大索引了,证明要输出的是最后一个元素,最后一个元素输出之后,后面直接跟]
  9.             if (i==arr.length-1){
  10.                 System.out.print(arr[i]+"]");
  11.             }else{
  12.                 System.out.print(arr[i]+",");
  13.             }
  14.         }
  15.         System.out.println();
  16.         System.out.println(Arrays.toString(arr));
  17.     }
  18. }

9.5练习

  1. 键盘录入一个整数,找出整数在数组中存储的位置
  2. 步骤:
  3.   1.创建一个数组,存元素
  4.   2.创建Scanner对象
  5.   3.调用nextInt()键盘录入一个整数
  6.   4.遍历数组,判断如果遍历出来的元素==录入的整数,直接将对应的索引输出
  1. public class Test05 {
  2.     public static void main(String[] args) {
  3.         //1.创建一个数组,存元素
  4.         int[] arr = {11,22,33,44,55};
  5.         //2.创建Scanner对象
  6.         Scanner sc = new Scanner(System.in);
  7.         //3.调用nextInt()键盘录入一个整数
  8.         int data = sc.nextInt();
  9.         //4.遍历数组,判断如果遍历出来的元素==录入的整数,直接将对应的索引输出
  11.         //定义一个变量,表示是否有要查找的数据
  12.         int index = 0;
  13.         for (int i = 0; i < arr.length; i++) {
  14.             if (arr[i]==data){
  15.                 index++;
  16.                 System.out.println(i);
  17.             }
  18.         }
  20.         /*
  21.            判断,index如果还是0,证明for循环中的if语句一次都没走
  22.            if一次都没走,证明数组中根本就不存在要查找的数据
  23.          */
  24.         if (index==0){
  25.             System.out.println(-1);
  26.         }
  27.     }
  28. }

第七章.内存

  1. ===============================================================
  2. 栈(Stack)
  3.   专门运行方法的
  4.   方法的运行会进栈运行->压栈
  5.   方法运行完毕->弹栈
  7. 堆(Heap)
  8.   我们new出来的对象都会在堆内存中出现
  9.   我们每new一次,在堆内存中就会产生一片空间,并为这个空间赋一个地址值
  10.   而且,堆内存中的数据都是有默认值的:
  11.   整数:0
  12.   小数:0.0
  13.   字符:'\u0000'
  14.   布尔:false
  15.   引用:null
  17. 方法区(Method Area)
  18.   我们的代码程序运行之前,会被jvm中的类加载器(ClassLoader)加载到内存中
  19.   方法区就记录着类的信息 和方法的信息
  20.   当方法区中的方法被调用时,方法会从方法区中出来进栈运行
  22. ===============================================================
  24. 本地方法栈(Native Method Stack)
  25.   专门运行native方法的
  26.   本地方法,是C语言写的,C语言没有对我们开源,所以我们看不到方法体
  28. 寄存器(pc register)
  29.   和CPU有关

1.一个数组在内存中如何存储

  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         int[] arr = new int[3];
  4.         System.out.println(arr);//地址值
  5.         System.out.println(arr[1]);//0
  6.         arr[1] = 10;
  7.         System.out.println(arr[1]);//10
  8.     }
  9. }

day04[循环_数组] - 图4

2.两个数组内存图

  1. 创建了两个数组,开辟了两个不同的空间
  2. 改变一个空间的数据,不会 影响到另外一个空间中的数据
  3. public class Test02 {
  4.     public static void main(String[] args) {
  5.         int[] arr1 = new int[3];
  6.         System.out.println(arr1);//地址值
  7.         arr1[1] = 10;
  8.         System.out.println(arr1[1]);//10
  10.         int[] arr2 = new int[3];
  11.         System.out.println(arr2);//地址值
  12.         arr2[1] = 100;
  13.         System.out.println(arr2[1]);//100
  14.     }
  15. }

day04[循环_数组] - 图5

3.两个数组指向同一个空间

  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.         int[] arrA = new int[3];
  4.         System.out.println(arrA);
  5.         arrA[1] = 10;
  7.         int[] arrB = arrA;
  8.         System.out.println(arrB);
  9.         arrB[1] = 100;
  11.         System.out.println(arrA[1]);
  12.         System.out.println(arrB[1]);
  13.     }
  14. }
  17. arrB是arrA给的,由于arrA保存的是地址值,所以arrB的地址值和arrA的地址值是一样的,所以arrB和arrA在内存中指向的是同一片空间,同一个数组,所以改变arrB也会影响到arrA9

day04[循环_数组] - 图6