Java基础 韩顺平老师的课，记的（前6章）部分笔记

https://www.bilibili.com/video/BV1fh411y7R8/?p=110&spm_id_from=333.880.my_history.page.click&vd_source=92305fa48ea41cb7bedb3ab5e056d42d

韩顺平老师在b站课的链接。

 

010，JDK的介绍

 

018，Java开发细节

 6，一个源文件中最多只能有一个public类。其他类的个数不限。

public class test1 {
    public static void main(String[] args){
        System.out.println("hello world");
    }
}
class Dog{

}
class Cat{
    
}

编译后，每一个类都对应一个.class文件

7，如果源文件包含一个public类，则文件名必须按该类名命名！

8，一个源文件中最多只能有一个public类。其他类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法

public class test1 {
    public static void main(String[] args){
        System.out.println("hello world");
    }
}
class Dog{
    public static void main(String[] args){
        System.out.println("dog");
    }
}
class Cat{
    public static void main(String[] args){
        System.out.println("cat");
    }
}

比如指定运行Dog类

 

019，学习方法

 

028，DOS指令

DOS：Disk Operating System 磁盘操作系统。

常用的dos命令

 

 

 

 

1，查看当前目录是有什么   dir 。

比如查看 d盘下的java文件夹里有啥，dir d:\java

 2,切换到其他盘下，cd

比如当前盘是c盘，切换到d盘下，cd /D d:

 3，切换到当前盘的其他目录下，cd ，用相对路径和绝对路径都可以

相对路径是指从根目录开始的目录，比如当前盘是d盘,切换到d盘java文件夹下的jetbra文件夹下，cd d:\java\jetbra

绝对路径是指从当前文件夹开始的路径，比如当前盘是d盘,切换到d盘java文件夹下的jetbra文件夹下，cd ..\..\java\jetbra，..\表示上一级目录，如果是顶级目录，写了也不会报错。

 4，切换到上一级，cd ..

 5，切换到根目录，cd \

 6，查看指定的目录下所有的子级目录，tree 文件路径 

7，清屏 cls  [简记：苍老师]

8，退出DOS，exit

051，自动类型转换

 

 

1，有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。以下代码经过编译后才判断出对错。

int n1 = 10;
float d1 = n1 + 1.1; //错误，1.1默认是double类型，自动类型转换后，计算结果d1是double类型
double d1 = n1 + 1.1; //对
float d1 = n1 + 1.1f; //对

2，当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。

int n2 = 1.1; //错误，1.1是double类型，精度大，n2是int类型，精度小，只能是小转换成大的

3，（byte，short）和 char 之间不会相互自动转换。

byte b1 = 10;//对，原因：当把具体数赋给byte时，先判断该数是否在byte范围内，如果是就可以。
int n2 = 1;
byte b2 = n2;//错误，原因：如果是变量赋值，判断类型

char c1 = b1;//错误，原因：byte不能自动转成char

4，byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型。

byte b2 = 1;
byte b3 = 2;
short s1 = 1;
short s2 =  b2 + s1;//错，b2+s1结果是int
int s2 = b2 + s1;//对
byte b4 = b2 + b3;//错，b2+b3结果是int

5，boolean 不参与转换

boolean pass = true;
int num = pass;//错

6，自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型

byte b4 = 1;
short s3 = 100;
int num1 = 1;
double num2 = 1.1;
double num3 = b4 + s3 + num1 + num2;//对

 

054，强制类型转换

 

1，当进行数据的大小从 大 ------->  小，就需要使用到强制转换

2，强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

int x = (int)(10*3.5+6*1.5);// (int)44.0 -> 44

3，char 类型可以保存 int 的常量值，但不能保存 int 的变量值（自动类型转换讲过），需要强转

char c1 = 100;//对
int m = 100; //对
char c2 = m;//错
char c3 = (char)m; //对

4，byte 和 short 类型在进行运算时，当做 int 类型处理（自动类型转换讲过）

 

085，键盘输入

 案例演示：要求可以从控制台接收用户信息（姓名，年龄，薪水）

import java.util.Scanner;//表示把java.util下的Scanner类导入
public class test1 {
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);//创建Scanner 对象
        System.out.println("请输入名字");
        String name = myScanner.next();//接收用户输入字符串

        System.out.println("请输入年龄");
        int age = myScanner.nextInt();//接收用户输入int

        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble();//接收用户输入double
        System.out.println("名字是：" + name + "年龄是：" + age + "薪水是：" + sal);
    }
}

 运行结果：

 

136，空心金字塔

请编写一个程序，可以接收一个整数，表示层数（totalLevel），打印出空心金字塔。【化繁为简，先死后活】

1，先打印一个矩形

 

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

 运行结果：

 

2，打印半个金字塔

 

public class test1 {
    public static void main(String[] args){
        for(int i = 1; i <= 5; i++) //i 表示层数
        {
            for(int j = 1; j <= i; j++) //控制打印每层的 * 个数，不能超过层数
            {
                System.out.print("*"); //这里不能换行输入*,不用println
            }
            System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
        }
    }
}

 运行结果：

 

3，打印整个金字塔

 

public class test1 {
    public static void main(String[] args){
        for(int i = 1; i <= 5; i++) //i 表示层数
        {
            for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
            {
                System.out.print("*"); //这里不能换行输入*,不用println
            }
            System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
        }
    }
}

运行结果：

 

3，打印整个金字塔（ * 前加空格）

 

public class test1 {
    public static void main(String[] args){
        for(int i = 1; i <= 5; i++) //i 表示层数
        {
            for(int k = 1; k <= 5 - i; k++)//在输出*之前，还有输出 对应空格 = 总层数-当前层
            {
                System.out.print(" ");//这里是一个空格
            }
            for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
            {
                System.out.print("*"); //这里不能换行输入*,不用println
            }
            System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
        }
    }
}

运行结果：

 

4，打印空心的金子塔

 

public class test1 {
    public static void main(String[] args){
        for(int i = 1; i <= 5; i++) //i 表示层数
        {
            for(int k = 1; k <= 5 - i; k++)//在输出*之前，还有输出 对应空格 = 总层数-当前层
            {
                System.out.print(" ");//这里是一个空格
            }
            for(int j = 1; j <= 2 * i - 1; j++) //控制打印每层的 * 个数，不能超过层数
            {
                if(j == 1 || j == 2 * i - 1 || i == 5)//当前行的第一个位置是*，最后一个位置也是*，最后一层全部*
                {
                    System.out.print("*"); //这里不能换行输入*,不用println
                }
                else //其他情况输出空格
                {
                    System.out.print(" ");
                }

            }
            System.out.println("");//每打印完一层的 * 后，就换行，println本身会换行
        }
    }
}

运行结果：

 

先死后活：层数 5 做成变量 int totalLevel = 5;

149，本章作业3

1，输出1-100之间的不能被5整除的数，每5个一行。

难点：每5个一行，使用 int count 统计输出的个数，当 count % 5 = 0 就说明输出了5个。

 

public class test1 {
    public static void main(String[] args) {
        int count = 0;
       for(int i = 1; i <= 100; i++)
       {
           if(i % 5 != 0)
           {
              count++;
              System.out.print(i +"\t");//这里不用换行
              if(count % 5 == 0)//判断每满5个，就输出一个换行
              {
                  System.out.println();
              }
           }
       }
    }
}

 

运行结果：

 

150，本章作业4

1，输出小写的 a-z 以及大写的 Z-A

a的Ascll码是97，对应着字符a，97加1就是98，对应着字符b....，所以用for循环从'a' 到 'z'。'a'是char类型，本质是整数。

public class test1 {
    public static void main(String[] args) {
        for(char c1 = 'a'; c1 <= 'z'; c1++)//'b' = 'a' + 1，c = 'a' + 2
        {
            System.out.print(c1 + " ");
        }
        System.out.println();
        for(char c1 = 'Z'; c1 >= 'A'; c1--)
        {
            System.out.print(c1 + " ");
        }
    }
}

运行结果：

 

152，本章作业6

1，求 1+（1+2）+（1+2+3）+（1+2+3+4）+...+（1+2+3+..+100) 的结果。

观察式子，发现第一项到最后一项有100个，第二项是（1+2），数字在逐渐增加，第二项也对应着其中的最后一个数字2。

public class test1 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1; i <= 100; i++)//i 可以表示是第几项，同时也是当前项的最后一个数
        {
            for(int j = 1; j <= i; j++) //内层对 1到 i 进行循环
            {
                sum += j;
            }
        }
        System.out.println(sum);
    }
}

运行结果：

 

162，数组练习2

1，请求出一个数组 int[] 的最大值 {4,-1,9,10,23}，并得到对应的下标。

思路：（1）假定 max = arr[0] 是最大值，maxIndex = 0，

（2）从下标 1 开始遍历 arr，如果 max < 当前元素，说明 max 不是真正的最大值，我们就 max = 当前元素；maxIndex = 当前元素下标

（3）当我们遍历这个数组 arr 后，max 就是真正的最大值，maxIndex 是最大值对应的下标

public class test1 {
    public static void main(String[] args) {
        int[] arr = {4,-1,9,10,23};
        int max = arr[0]; //假定数组arr第一个元素就是最大值
        int maxIndex = 0;
        for(int i = 1; i < arr.length; i++) //i的最大值是arr.length - 1,从下标 1 开始遍历arr
        {
            if(max < arr[i]) //如果max < 当前元素
            {
                max = arr[i]; //把 max 设置成当前元素
                maxIndex = i;
            }
        }
        System.out.println(max);
        System.out.println(maxIndex);
    }
}

运行结果：

 

163，数组赋值机制(引用赋值）

基本数据类型赋值，赋值方式为值拷贝。n2的变化，不会影响到n1的值。

public class test1 {
    public static void main(String[] args) {
       int n1 = 10;
       int n2 = n1;
       n2 = 80;
       System.out.println("n1 = " + n1);
       System.out.println("n2 = " + n2);
    }
}

运行结果：

 

数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值。arr2变化会影响到arr1。

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

       for(int i = 0; i < arr1.length; i++)
       {
           System.out.print(arr1[i] + " ");
       }
    }
}

运行结果：

 

 

166，数组反转1（通过找规律反转）

1，把数组的元素内容反转

arr = {1,2,3,4,5,6} ----->  arr = {6,5,4,3,2,1}

类似于两个装着不同饮料的杯子，互相交换，需要借助一个空杯子。

规律：

（1），把 arr[0] 和 arr[5] 进行交换，{6,2,3,4,5,1}

（2），把 arr[1] 和 arr[4] 进行交换，{6,5,3,4,2,1}

（3），把 arr[2] 和 arr[3] 进行交换，{6,5,4,3,2,1}

（4），一共要交换 3 次 = arr.length / 2

每次交换时，对应的下标时 arr[i] 和 arr[arr.length - 1 - i]

public class test1 {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,6};
       int temp = 0;
       int len = arr.length;
       for(int i = 0; i < len / 2; i++)
       {
           temp = arr[len-1-i];
           arr[len-1-i] = arr[i];
           arr[i] = temp;
       }
       for(int i = 0; i < len; i++)
       {
           System.out.print(arr[i] + "\t");
       }
    }
}

运行结果：

 

167，数组反转2（使用逆序赋值方式）

思路：

（1），先创建一个新的数组 arr2，大小 arr.length

（2），逆序遍历 arr，将每个元素拷贝到 arr2 的元素中（顺序拷贝）

（3），建议增加一个循环变量 j，用来表示 arr2的元素下标

（4），当 for 循环结束，arr2 就是一个逆序的数组 {6,5,4,3,2,1}

（5），让 arr 指向 arr2 数据空间，此时 arr 原来的数据空间就没有变量引用，会被当做垃圾，销毁

public class test1 {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,6};
       int[] arr2 = new int[arr.length];
       for(int i = arr.length - 1, j = 0; i >= 0; i--, j++)
       {
           arr2[j] = arr[i];
       }
       arr = arr2;//引用赋值，见 163 节笔记
       for(int i = 0; i < arr.length; i++)
       {
           System.out.print(arr[i] + "\t");
       }
    }
}

运行结果：

 

168，数组扩容1

1，实现动态的给数组添加元素效果，实现对数组扩容。

（1），原始数字使用静态分配 int[] arr = {1,2,3}

（2），增加的元素4，直接放在数组的最后 arr = {1,2,3,4}

（3），用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

思路：

（1），定义初始数组 int[] arr = {1,2,3}

（2），定义一个新的数组 int[] arrNew = new int[arr.length+1];

（3），遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组

（4），将 4 赋给 arrNew[arrNew.length - 1] = 4；把 4 赋给 arrNew 最后一个元素

（5），让 arr 指向 arrNew；arr = arrNew；那么，原来 arr 数组就被销毁

（6），创建一个 Scanner 可以接受用户输入

（7），因为用户什么时候退出，不确定，老师使用 do-while + break来控制

 

import java.util.Scanner;
public class test1 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        int[] arr = {1,2,3}; //初始数组
        do {
            int[] arrNew = new int[arr.length + 1];
            for (int i = 0; i < arr.length; i++) {
                arrNew[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addNum = myScanner.nextInt();
            arrNew[arrNew.length - 1] = addNum; //arrNew最后一个元素是下标为arrNew.length-1
            arr = arrNew;
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println("是否继续添加 y/n");
            char key = myScanner.next().charAt(0);
            if(key == 'n') //如果输入n，就结束
            {
                break;
            }
        }while(true);
        System.out.println("你退出了添加....");
    }
}

 

运行结果：

 

170，数组缩减（仿照上个题的思路）

public class test1 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        int[] arr = {1,2,3,4,5}; //初始数组
        do {
            int[] arrNew = new int[arr.length-1];
            for (int i = 0; i < arr.length-1; i++) {
                arrNew[i] = arr[i];
            }
            arr = arrNew;
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println("是否继续缩减 y/n");
            char key = myScanner.next().charAt(0);
            if(key == 'n') //如果输入n，就结束
            {
                break;
            }
            if(arr.length == 1)
            {
                System.out.println("不能再缩减");
                break;
            }
        }while(true);
        System.out.println("你退出了缩减....");
    }
}

运行结果：

 

172，冒泡排序

总结冒泡排序特点（看视频后就能理解了）：

1，我们一共有5个元素

2，一共进行了4轮排序，可以看成是外层循环

3，每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数，第2轮排序，确定第2大的数位置，依次类推

4，当进行比较时，如果前面的数大于后面的数，就交换

5，每轮比较在减少 4->3->2->1

public class test1 {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        int temp = 0; //用于辅助交换的变量
        //将多轮排序使用外层循环包括起来即可
        for(int i = 0; i < arr.length - 1; i++) //外层循环是4次
        {
            for(int j = 0; j < arr.length - 1 - i; j++)//4次比较->3次->2次->1次，每轮比较在减1
            {
                if(arr[j] > arr[j+1])//如果前面的数（大） > 后面的数（小），就交换。本来顺序是 大 小；要从小到大排序，顺序变为 小 大。要看清顺序
                { //如果是从大到小，只改成 < ,其余不变
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("\n==第" + (i+1) + "轮==");
            for(int j = 0; j < arr.length; j++)
            {
                System.out.print(arr[j] + "\t");
            }
        }
    }
}

运行结果：

 

174，查找

1，顺序查找

有一个数列：白眉鹰王，金毛狮王，紫衫狮王，青翼蝠王，从键盘中任意输入一个名称，判断数列中是否包含此名称。要求：如果找到了，就提示找到，并给出下标值。

思路：

（1），定义一个字符串数组

（2），接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出

import java.util.Scanner;
public class test1 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        System.out.println("请输入名字");
        String findName = myScanner.next();
        int index = -1;
       for(int i = 0; i < names.length; i++)//顺序遍历查找
       {
           if(findName.equals(names[i]))//字符串比较 equals，如果输入的名字和当前遍历的数组名字相同
           {
               System.out.println("恭喜你找到 " + findName);
               System.out.println("下标为= " + i);
               index = i; //也可以是其他值，除了设的-1
               break;
           }
       }
       if(index == -1) //如果没有找到，index 用来提示这种情况
       {System.out.println("sorry，没有找到 " + findName);
       }

    }
}

运行结果：

 

175，二维数组入门

二维数组：1，从定义形式上看 int[][] ；

2，可以这样理解，二维数组的每个元素是一维数组，所以如果需要得到每个一维数组的值，还需要再次遍历

3，如果我们要访问第（i+1）个一维数组的第 j+1 个值 arr[i][j]，下标从0开始

4，第2个指向才是真正的存储空间

 

 

 

public class test1 {
    public static void main(String[] args) {
        int[][] arr = {{0,0,0,0,0,0},
                       {0,0,1,0,0,0},
                       {0,2,0,3,0,0},
                       {0,0,0,0,0,0}};
        //二维数组是由4个一维数组构成的
        System.out.println("二维数组的元素个数= " + arr.length); //输出是 4
        System.out.println("第3个一维数组的第4个值= " + arr[2][3]);

        for(int i = 0; i < arr.length; i++)//遍历二维数组的每个元素，相当于行
        {
            //arr[i] 表示二维数组的第 i+1 个元素，比如arr[0]:二维数组的第一个元素
            //arr[i].length 得到对应的每个一维数组的长度
            for(int j = 0; j < arr[i].length; j++)//相当于列
            {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

运行结果：

 

181，杨辉三角

使用二维数组打印一个 10 行杨辉三角（图在网上搜的，可以便于理解杨辉三角的特点）

 特点：1，第一行有1个元素，第n行有n个元素

2，每一行的第一个元素和最后一个元素都是1

3，从第三行开始，对于非第一个元素和最后一个元素的元素的值 arr[i][j] = arr[i-1][j] + arr[i-1][j-1]

public class test1 {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][]; //要求了10行，列数不确定
          for(int i = 0; i < yangHui.length; i++)//遍历yangHui的每个元素，即一维数组
          {
              yangHui[i] = new int[i+1];//给每个一维数组（行）开空间（一维数组又指向了另一个空间，空间可以放[i+1]个数据，如果没有给一维数组new，那么arr[i]就是null,没有任何指向
              for(int j = 0; j < yangHui[i].length; j++)//遍历一维数组
              {
                  if(j == 0 || j == yangHui[i].length - 1)//每一行的第一个元素和最后一个元素都是1
                  {
                      yangHui[i][j] = 1;
                  }
                  else //中间的元素
                  {
                      yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                  }
              }
          }
          //输出杨辉三角
          for(int i = 0; i < yangHui.length; i++)
          {
              for(int j = 0; j < yangHui[i].length; j++)
              {
                  System.out.print(yangHui[i][j] + "\t");
              }
              System.out.println();
          }
    }
}

运行结果：

 

186，本章作业3

1，已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，比如：[10,12,45,90]，添加23后，数组为 [10,12,23,45,90]

思路：本质数组扩容 + 定位

1，我们先确定 添加数应该插入到哪个索引

2，然后扩容

public class test1 {
    public static void main(String[] args) {
        int[] arr = {10,12,45,90};
        int insertNum = 23;
        int index = -1; //index 就是要插入的位置
        //遍历 arr数组，如果发现 insertNum <= arr[i],说明 i 就是要插入的位置
        //使用 index 保留 index = i;
        //如果遍历完后，没有发现 insertNum <= arr[i]，说明 index = arr.length，即添加到 arr的最后
        for(int i = 0; i < arr.length; i++)
        {
            if(insertNum <= arr[i])
            {
                index = i;//设置为要插入的位置下标
                break;//找到位置后，就退出
            }
        }
        if(index == -1)//判断index的值
        {
            index = arr.length;//说明还没有找到要插入的位置，就是插入的数比arr数组最后一个位置的元素大
        }

        //扩容，先创建一个新的数组，大小 arr.length+1，
        // 准备将arr的元素拷贝到arrNew，并且要跳过index位置
        int[] arrNew = new int[arr.length + 1];
        for(int i = 0, j = 0; i < arrNew.length; i++)// i 控制arrNew的下标，j 用来控制arr数组的下标
        {
            if( i != index)//如果插入的位置和当前遍历的下标不相等的话，说明可以把arr的元素拷贝到arrNew
            {
                arrNew[i] = arr[j];
                j++;//拷完后，就开始拷arr数组的下一个位置的元素
            }
            else //相等的话，这个位置就是要插入的数
            {
                arrNew[i] = insertNum;
            }
        }
        arr = arrNew;//让arr指向arrNew，原来的数组，就成为垃圾，被销毁
        System.out.println("======插入后，arr数组的元素情况======");
        for(int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + "\t");
        }
    }
}

运行结果：

 

187，本章作业4

1，随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值，求最大值和最大值的下标，并查找里面是否有 8 

public class test1{
    public static void main(String[] args){
        int[] arr = new int[10];
        for(int i = 0; i < arr.length; i++)
        {
            arr[i] = (int)(Math.random() * 100) + 1; //这个死记住就行
        }
        System.out.println("====arr的元素情况=====");
        for(int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("====arr的元素情况(倒序)=====");
        for(int i = arr.length - 1; i >= 0; i--)
        {
            System.out.print(arr[i] + "\t");
        }
        //求最大值和最大值的下标，平均值
        double sum = arr[0];
        int max = arr[0];
        int maxIndex = 0;
        for(int i = 1; i < arr.length; i++) //i 从1开始的，就是从第2个元素开始的
        {
            sum += arr[i];
            if(max < arr[i]) //求最大值
            {
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("\nmax= " + max + " maxIndex= " + maxIndex);
        System.out.println("\n平均值= " + (sum / arr.length));
        //顺序查找
        int index = -1;
        int findNum = 8;
        for(int i = 0; i < arr.length; i++)
        {
            if(findNum == arr[i])
            {
                System.out.println("找到数" + findNum + " 下标= " + i);
                index = i;
                break;
            }
        }
        if(index == -1)
        {
            System.out.println("没有找到数" + findNum);
        }
    }
}

运行结果：