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开始

复制代码
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);
        }
    }
}

运行结果: