day04.循环_数组

课前回顾:
  1.Scanner:键盘录入
    a.导包:import java.util.Scanner
    b.创建对象:
      Scanner 对象名 = new Scanner(System.in)
    c.调用方法:
      nextInt()录入int型整数
      next()录入字符串,遇到空格或者回车就结束录入
      nextLine()录入字符串,遇到回车就结束录入
  2.switch语句:
    a.格式:
      switch(变量){
          case 目标值1:
              执行语句1;
              break;
          case 目标值2:
              执行语句2;
              break;
          case 目标值3:
              执行语句3;
              break;
              ...
          default:
              执行语句n;
              break;
      }
    b.执行流程:
      挨个匹配case后面的目标值,哪个case配上了,就走哪个case对应的执行语句,break结束switch,如果以上所有的case都没匹配上,就走default对应的执行语句n

3.if
  a.格式1:
    if(boolean表达式){
        执行语句
    }
    先走if后面的判断,如果是true,就走if后面大括号中的内容,否则就不走
  b.格式2:
    if(boolean表达式){
        执行语句1
    }else{
        执行语句2
    }
    先走if后面的判断,如果是true,就走if后面大括号中的内容,否则就走else后的执行语句
  c.格式3:
    if(boolean表达式){
        执行语句1
    }else if(boolean表达式){
        执行语句2
    }...else{
        执行语句n
    }

    从上到下挨个判断,哪个if为true,就走哪个if对应的执行语句,如果以上所有的if都是false,就走else对应的执行语句n

今日重点:
  1.会for,while,do...while循环的格式以及执行流程
  2.会死循环,嵌套循环
  3.会数组的定义,存,取,遍历

第一章.循环语句

1.for 循环

1.格式:
  for(初始化变量;比较;步进表达式){
      循环语句
  }
2.执行流程:
  a.初始化变量
  b.比较,如果是true,走循环语句
  c.走步进表达式(初始化的这个变量的值发生变化),再比较,如果还是true,继续走循环语句
  d.继续走步进表达式,再比较,直到比较为false,循环结束

public class Demo01For {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println("我爱java");
        }
    }
}

1.1 练习

for循环:求1-3之间的数据和,并把求和结果输出到控制台上
1+2+3-> 两两相加,得到一个结果,再和后面一个数相加

步骤:
  1.定义一个变量,来接收两个数的和 -> sum
  2.利用循环,将1-3的数表示出来
  3.在循环体中,进行加法运算,将结果赋值给sum
  4.输出sum

public class Demo02For {
    public static void main(String[] args) {
        //1.定义一个变量,来接收两个数的和 -> sum
        int sum = 0;
        //2.利用循环,将1-3的数表示出来
        for (int i = 1;i<=3;i++){
        //3.在循环体中,进行加法运算,将结果赋值给sum
            sum+=i;//sum = sum+i;
        }
        //4.输出sum
        System.out.println("sum = " + sum);
    }
}

1.2 练习

需求:求出1-100的偶数和

public class Demo03For {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum+=i;
            }
        }
        System.out.println("sum = " + sum);
    }
}

1.3 练习

统计一下1-100之间的偶数个数
步骤:
  1.定义一个变量统计偶数个数: count
  2.利用循环将1-100的数表示出来
  3.如果是偶数,count++;
  4.输出count

public class Demo04For {
    public static void main(String[] args) {
        //1.定义一个变量统计偶数个数: count
        int count = 0;
        //2.利用循环将1-100的数表示出来
        for (int i = 1;i<=100;i++){
        //3.如果是偶数,count++;
            if (i%2==0){
                count++;
            }
        }
        //4.输出count
        System.out.println("偶数个数 = " + count);
    }
}

快捷键:次数.fori

2.while 循环

1.格式:
  初始化变量;
  while(比较){
      循环语句
      步进表达式
  }
2.执行流程:
  a.初始化变量
  b.比较,如果是true,走循环语句
  c.走步进表达式(初始化的这个变量的值发生变化),再比较,如果还是true,继续走循环语句
  d.继续走步进表达式,再比较,直到比较为false,循环结束

public class Demo01While {
    public static void main(String[] args) {
        int i = 1;
        while(i<=10){
            System.out.println("我爱钱");
            i++;
        }
    }
}

public class Demo02While {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;//用于接收两个数的和
        while (i <= 100) {
            sum += i;
            i++;
        }
        System.out.println(sum);
    }
}

public class Demo03While {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;//用于接收两个数的和
        while (i <= 100) {
            if (i % 2 == 0) {
                sum += i;
            }
            i++;
        }
        System.out.println(sum);
    }
}

public class Demo04While {
    public static void main(String[] args) {
        int i = 1;
        int count = 0;//用于统计偶数个数
        while (i <= 100) {
            if (i % 2 == 0) {
                count++;
            }
            i++;
        }
        System.out.println(count);
    }
}

1.1while 练习

需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?27
步骤:
  1.定义一个count,接收对折的次数
  2.定义一个变量,表示山峰的高度 -> mountain
  3.定义一个变量,表示纸的厚度
  4.判断如果纸的厚度小于山峰的高度,就对折,然后统计对折次数
  5.输出count

public class Demo05While {
    public static void main(String[] args) {
        //1.定义一个count,接收对折的次数
        int count = 0;
        //2.定义一个变量,表示山峰的高度 -> mountain
        int mountain = 8844430;
        //3.定义一个变量,表示纸的厚度
        double paper = 0.1;
        //4.判断如果纸的厚度小于山峰的高度,就对折,然后统计对折次数
        while(paper<mountain){
            paper*=2;//paper = paper*2;
            count++;
        }
        //5.输出count
        System.out.println("count = " + count);
    }
}

3.do...while 循环(了解)

1.格式:
  初始化变量;
  do{
      循环语句
      步进表达式
  }while(比较);
2.执行流程:
  a.先初始化变量
  b.走循环语句,走步进表达式
  c.比较,如果是true,继续循环,走步进表达式
  d.再比较,直到比较为false,循环结束
3.特点:
  至少执行一次

public class Demo06DoWhile {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("我爱钱");
            i++;
        }while (i<=10);
    }
}

4.循环的区别

1.for循环中初始化的变量,出了for循环使用不了了
2.while循环中的初始化变量,出了while还能使用
3.do...while至少执行一次

5.循环控制关键字

1.break:
  a.在switch中代表结束switch语句
  b.在循环中代表结束循环
2.continue:
  a.结束当前本次循环,自动进入下一次循环

public class Demo01BreakAndContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i==3){
                //break;//结束循环
                continue;//结束本次循环,自动进入下一次循环
            }
            System.out.println("我爱money"+i);
        }
    }
}

6.死循环

1.条件:比较条件永远成立,导致循环结束不了了,一直循环

public class Demo02DieLoop {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 10;){
            count++;
            System.out.println("我爱money"+count);
        }

        /*while(true){
            count++;
            System.out.println("我爱money"+count);
        }*/
    }
}

7.嵌套循环

1.概述:循环体中嵌套一个循环
2.执行流程:
  先走外层循环,再走内层循环,内层循环就一直循环,直到内层循环结束了,外层循环再进入下一次循环,直到外层循环都结束了,整体结束

public class Demo03ForInFor {
    public static void main(String[] args) {
        for (int fen = 0; fen < 60; fen++) {
            for (int miao = 0; miao < 60; miao++) {
                System.out.println(fen+"分"+miao+"秒");
            }
        }
    }
}

练习:打印矩形

public class Demo04ForInFor {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

练习:打印直角三角形

*
* *
* * *
* * * *
* * * * *

public class Demo05ForInFor {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

第二章.Random 随机数

学习方式和 Scanner 一毛一样

1.概述:java自带的类
2.作用:在指定的范围内随机一个数
3.使用:
  a.导包:import java.util.Random
  b.创建对象:
    Random 对象名 = new Random()
  c.调用方法:
    对象名.nextInt() -> 在int的取值范围随机一个数
    对象名.nextInt(int bound) -> 在0-(bound-1)之间随机一个数

4.指定范围:
  1-10之间随机一个整数: nextInt(10)+1 -> (0-9)+1 -> 0-9的数整体都加1 -> 1-10
  1-100之间随机一个整数: nextInt(100)+1 -> (0-99)+1 -> 1-100
  100-999之间随机一个整数: nextInt(900)+100 -> (0-899)+100 -> 100-999

public class Demo01Random {
    public static void main(String[] args) {
        Random rd = new Random();
        int data = rd.nextInt();
        System.out.println("data = " + data);
        System.out.println("==================");
        int data2 = rd.nextInt(10);
        System.out.println("data2 = " + data2);
        System.out.println("==================");
        int data3 = rd.nextInt(100) + 1;
        System.out.println("data3 = " + data3);
    }
}

练习:完成一个猜数字小游戏
步骤:
 1.创建Scanner对象,调用nextInt,录入一个整数,代表猜的数 scNumber
 2.创建Random对象,调用nextInt,随机一个数,代表被猜的数  rdNumber
 3.比较scNumber和rdNumber,如果scNumber大于rdNumber,输出"猜大了"
 4.如果scNumber小于rdNumber,输出"猜小了"
 5.如果相等,输出"猜对了"

public class Demo02Random {
    public static void main(String[] args) {
        //1.创建Scanner对象,调用nextInt,录入一个整数,代表猜的数 scNumber
        Scanner sc = new Scanner(System.in);
        //2.创建Random对象,调用nextInt,随机一个数,代表被猜的数  rdNumber
        Random rd = new Random();
        int rdNumber = rd.nextInt(100) + 1;
        while(true){
            int scNumber = sc.nextInt();
            //3.比较scNumber和rdNumber,如果scNumber大于rdNumber,输出"猜大了"
            if (scNumber>rdNumber){
                System.out.println("猜大了");
            }else if (scNumber<rdNumber){
                //4.如果scNumber小于rdNumber,输出"猜小了"
                System.out.println("猜小了");
            }else{
                //5.如果相等,输出"猜对了"
                System.out.println("猜对了");
                break;
            }
        }
    }
}

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

1.概述:是一个容器,属于引用数据类型
2.作用:一次存储多个数据
3.特点:
  a.存储的数据可以是基本类型,也可以是引用类型
  b.定长(长度是多少,最多能存多少个数据)
4.定义:
  a.动态初始化:
    数据类型[] 数组名 = new 数据类型[长度]
    数据类型 数组名[] = new 数据类型[长度]

    等号左边的数据类型:规定了数组中能存什么类型的数据
    []:代表数组的意思
    数组名:给数组取的名字
    new:代表的是创建
    等号右边的数据类型:和等号左边的类型要保持一致
    [长度]:规定了数组的长度,最多能存多少个数据
  b.静态初始化:
    数据类型[] 数组名 = new 数据类型[]{元素1,元素2...} -> 不推荐
    数据类型 数组名[] = new 数据类型[]{元素1,元素2...} -> 不推荐

  c.简化静态初始化:
    数据类型[] 数组名 = {元素1,元素2...}

public class Demo01Array {
    public static void main(String[] args) {
        //动态初始化
        int[] arr1 = new int[5];
        String[] arr2 = new String[3];

        //简化静态初始化
        int[] arr3 = {1,2,3,4,5};
        String[] arr4 = {"努尔哈赤","皇太极","顺治","康熙","雍正","乾隆","嘉庆","道光","咸丰","同治","光绪","宣统"};
    }
}

8 种基本类型外加一个 String,用动态初始化定义一遍,用静态初始化定义一遍

第四章.操作数组

1.获取数组的长度

1.格式:
  数组名.length
2.注意:
  length不是一个方法,所以不要带小括号,它是数组的一个属性

public class Demo02Array {
    public static void main(String[] args) {
        int[] arr = {1,3,2,4,4,4,5,5,54,4,566,7,67,7};
        System.out.println(arr.length);
    }
}

2.索引

1.索引:
  元素在数组中存储的位置(编号,下标)

2.特点:
  a.索引是唯一的
  b.索引都是从0开始,最大索引(数组长度-1)

3.注意:
  操作数组中的元素,不管是存,还是取,都必须要通过索引来操作

3.存储元素

1.格式:
  数组名[索引值] = 值  -> 将值存放到数组中指定的索引位置上

public class Demo03Array {
    public static void main(String[] args) {
        String[] arr = new String[5];
        arr[0] = "喜洋洋与灰太狼";
        arr[1] = "海绵宝宝";
        arr[2] = "花园宝宝";
        arr[3] = "百变小樱";
        arr[4] = "熊出没";
        System.out.println("==================");

        int[] arr2 = new int[3];
        Scanner sc = new Scanner(System.in);
       /* int data1 = sc.nextInt();
        arr2[0] = data1;
        int data2 = sc.nextInt();
        arr2[1] = data2;
        int data3 = sc.nextInt();
        arr2[2] = data3;*/


        //arr2[0] = sc.nextInt();
        //arr2[1] = sc.nextInt();
        //arr2[2] = sc.nextInt();
        for (int i = 0; i < arr2.length; i++){
            arr2[i] = sc.nextInt();
        }

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

        int[] arr3 = new int[5];
        Random rd = new Random();
        for (int i = 0; i < arr3.length; i++){
            arr3[i] = rd.nextInt(100) + 1;
        }

        //获取
        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);
        System.out.println(arr3[3]);
        System.out.println(arr3[4]);
    }
}

4.获取元素

1.格式:
  数组名[索引值]
2.注意:
  a.不要直接输出数组名来获取元素,因为直接输出数组名拿到的是地址值
  b.数组中的元素如果没有赋具体的值,直接输出来是有默认值
    整数: 0
    小数: 0.0
    字符: '\u0000'-> 空白字符
    布尔: false
    引用: null
3.地址值:引用数据类型在内存中的唯一标识,为的是能在内存中找到这个数据

public class Demo04Array {
    public static void main(String[] args) {
        String[] arr1 = new String[3];
        arr1[0] = "张无忌";
        arr1[1] = "张翠山";
        arr1[2] = "张三丰";

        System.out.println(arr1);//地址值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

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

        int[] arr2 = new int[3];
        System.out.println(arr2[0]);//默认值
        System.out.println(arr2[1]);//默认值
        System.out.println(arr2[2]);//默认值
    }
}

arr2[0] = arr1[0]  -> 将arr1数组0索引上的元素赋值到arr2数组的0索引上

public class Demo05Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};

        int[] arr2 = new int[3];

        /*
          将arr1数组0索引上的元素放到arr2数组的0索引上
         */
        arr2[0] = arr1[0];
        //将arr1数组1索引上的元素放到arr2数组的1索引上
        arr2[1] = arr1[1];
        //将arr1数组2索引上的元素放到arr2数组的2索引上
        arr2[2] = arr1[2];

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

5.遍历数组

1.概述:循环将数组中的元素获取出来

public class Demo06Array {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

快捷键:数组名.fori

6.操作数组时容易出现的问题

6.1.数组索引越界异常_ArrayIndexOutOfBoundsException

1.出现的原因:
  操作的索引超出了数组索引范围

public class Demo07Array {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //System.out.println(arr[5]);
        System.out.println(arr[-5]);
    }
}

6.2.空指针异常_NullPointerException

1.出现的原因:
  引用类型为null,然后再操作

public class Demo08Array {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        arr = null;
        System.out.println(arr.length);
    }
}

以上两个问题,不用特意去练习,出现之后知道啥原因即可

第五章.数组练习

1.练习

获取数组最大值

步骤:
  1.定义数组,随便存点元素
  2.定义max,用于接收两个元素之间的较大值
  3.遍历数组,在遍历的过程中判断,如果max小于遍历出来的元素,证明遍历出来的元素比max大
  4.将遍历出来的值赋值给max
  5.最后输出max

public class Demo01ArrayTest {
    public static void main(String[] args) {
        //1.定义数组,随便存点元素
        int[] arr = {5,4,5,6,5,4,7};
        //2.定义max,用于接收两个元素之间的较大值
        int max = arr[0];
        //3.遍历数组,在遍历的过程中判断,如果max小于遍历出来的元素,证明遍历出来的元素比max大
        for (int i = 1; i < arr.length; i++) {
        //4.将遍历出来的值赋值给max
            if (max < arr[i]){
                max = arr[i];
            }
        }
        //5.最后输出max
        System.out.println("max = " + max);
    }
}

2.练习

随机产生10个[0,100]之间整数，统计既是3又是5，但不是7的倍数的个数
步骤:
  1.定义一个变量count用来统计个数
  2.定义一个数组,用来存储随机出来的10个数
  3.创建Random对象
  4.循环随机10个整数存储到数组中
  5.遍历数组,如果符合条件,count++
  6.输出count

public class Demo02ArrayTest {
    public static void main(String[] args) {
        //1.定义一个变量count用来统计个数
        int count=  0;
        //2.定义一个数组,用来存储随机出来的10个数
        int[] arr = new int[10];
        //3.创建Random对象
        Random r = new Random();
        //4.循环随机10个整数存储到数组中
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(101);
        }
        //5.遍历数组,如果符合条件,count++
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%3==0 && arr[i]%5==0 && arr[i]%7!=0){
                count++;
            }
        }
        //6.输出count
        System.out.println("count = " + count);
    }
}

3.练习

用一个数组存储本组学员的姓名，从键盘输入，并遍历显示

自己写

4.练习

需求:
  1.定义一个数组 int[] arr = {1,2,3,4}
  2.遍历数组,输出元素按照[1,2,3,4]

public class Demo03ArrayTest {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}

扩展练习:用字符串拼接形式来输出,最后将拼接好的字符串输出

public class Demo04ArrayTest {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //定义一个字符串
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i== arr.length-1){
                str += arr[i]+"]";
            }else {
                str += arr[i]+",";
            }
        }

        System.out.println(str);
    }
}

5.练习

键盘录入一个整数,找出整数在数组中存储的索引位置
步骤:
  1.定义数组,存储一些数据
  2.创建Scanner对象,键盘录入一个整数
  3.遍历数组,判断元素是否和录入的整数相等,如果相等,直接输出对应的索引

public class Demo05ArrayTest {
    public static void main(String[] args) {
        //1.定义数组,存储一些数据
        int[] arr = {11,22,33,44,55,66,77,88};
        //2.创建Scanner对象,键盘录入一个整数
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        //3.遍历数组,判断元素是否和录入的整数相等,如果相等,直接输出对应的索引
        for (int i = 0; i < arr.length; i++) {
            if (data==arr[i]){
                System.out.println(i);
            }
        }
    }
}

问题升级:如果找不到输出-1

public class Demo05ArrayTest {
    public static void main(String[] args) {
        //1.定义数组,存储一些数据
        int[] arr = {11,22,33,44,55,66,77,88};
        //2.创建Scanner对象,键盘录入一个整数
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();

        //定义一个flag,代表的是是否找到了这个数据
        int flag = 0;

        //3.遍历数组,判断元素是否和录入的整数相等,如果相等,直接输出对应的索引
        for (int i = 0; i < arr.length; i++) {
            if (data==arr[i]){
                System.out.println(i);
                flag++;
            }
        }

        //4.出了循环,相当于找完了,如果flag仍然为0,证明在循环的过程中没有相等的,证明数组中没有
        if (flag==0){
            System.out.println(-1);
        }
    }
}