java基础知识02

1.7Random：产生随机数

1.导包 import java.util.random 2.创建Random类型的引用 Random ran=new Random(); 3.使用功能 ran.nextInt()随机产生int范围内的整数 ran.nextInt(整数n) 随机[0，n]整数 ran.nextDouble()[0.0,1.0)随机产生double范围的小数

公式总结：随机整数： [0,n] ran.nextInt(整数n) [0,n] ran.nextInt(n+1) [min,max) ran.nextInt(max-min)+min ran.nextInt(max)->[0,max) ran.nextInt(max)+min->[min,max+min) ran.nextInt(max-min)+min->[0,max-min)+min -->[min,max) [min,max] ran.nextInt(max-min+1)+min 注意：伪随机数

import java.util.Random;
public class Class012_Random{
    //程序的入口
    public static void main(String[] args){
        //1.导包
        //2.创建Random类型的引用
        Random  ran = new Random();
        //3.使用功能
        int num = ran.nextInt();
        System.out.println(num);

2.运算符

算术运算符＋ - ＊／％＋＋ --

赋值运算符＝比较运算符|关系 > < >= <= == != 逻辑运算符& | ! ^ && || 位运算符条件运算符　? :

操作数：运算符左右两边的数据表达式：运算符连接操作数作数整体称为表达式语句：语句以；结束

一元运算符｜单目运算符：操作数只有一个　＋-（正负号）二元运算符｜双目运算符：操作数只有两个＋ - ＊／三元运算符｜三目运算符：操作数有三个条件运算符

2.1算数运算符

＋ - ＊／％＋＋ -- ＋：１正号２加法运算３字符串的连接符当＋左右两边一旦出现＂＂字符串，＋就作为字符串连接符，把左右两边的数据拼接成为一个字符串　-：１负号２减法运算

％取余数｜取余｜模以当第一个操作数＜第二个操作数，结构为第一个操作数

public class Class013_Operator{
    //程序的入口
    public static void main(String[] args){
        int i = +3;
        System.out.println(i);
        
        System.out.println("i = "+i); //"i = 3"
        
        System.out.println("hello"+'a'+1); //"helloa"+1="helloa1"
        System.out.println('a'+1+"hello"); //98+"hello"  = "98hello"
        System.out.println("hello"+true); //"hellotrue"
        
        
    }
    
}

2.2一元运算符

++ 自增 : 自身+1 a++==> a=a+1

--自减 : 自身-1 a-- ==> a=a-1

规律 :

只操作自己 : ++放在操作数的前面后面都是自身+1 --放在操作数的前面后面都是自身-1

影响其他结果 : (赋值,表达式,输出){前算后换}

++--放在操作数前面,先+1|-1,再去运算 ++--放在操作数后面,先去运算,再进行+1|-1

public class Class014_Operator{
    //main方法 
    public static void main(String[] args){
        System.out.println("方法");
        
        int i = 1;
        //只操作自己 
        System.out.println(i);
        i++;
        ++i;
        System.out.println(i); //3
        
        //影响其他结果
        int j = i++;
        System.out.println(i);  //4
        System.out.println(j);  //3
        
        j = --i;
        System.out.println(i);  //3
        System.out.println(j);  //3
        
        System.out.println(i++);  //3
        System.out.println(i);  //4
        
        j = i++ + 2; 
        System.out.println(i);  //5
        System.out.println(j);  //6
        
        j = i++ + ++i + i++ + i++ + ++i;
        System.out.println(i);  //10
        System.out.println(j);  //37 
        
        //练习
        int k=20;
        j=8;
        int totle = k++ + j-- + --j + ++k + k++ + j++ + k-- + --k + j++;
        System.out.println("k="+k+",j="+j+",totle="+totle);   //
    }
    
}

2.3赋值运算符

基础赋值运算符 =是java中唯一一个自右向左运算的符号优先级最低

扩展赋值运算符（算数运算符+基础赋值运算符） += a=a+10;==>a+=10; -= *= /= %=

优点：执行效率快自动做强制类型转换

注意：编译器件编译器会自动把可以实现的位置优先成为扩展赋值运算符

public class Class015_Operator{
    //main方法 
    public static void main(String[] args){
        int zhang = 98;
        int wang = 100;
        
        int result = 0;
        
        result+=zhang;//result = result+zhang; 
        result+=wang;//result = result+wang;
        
        
        short  s = 100;
        //s = s + 1;
        //s++;
        s+=1;
        System.out.println(s);
        
        
    }
    
}

2.4比较运算符|关系运算符

> < >= <= byte,short,int,long,float,double,char

== != 基本，引用

结果都为boolean类型

public class Class016_Operator{
    //main方法 
    public static void main(String[] args){
        int a = 1;
        
        boolean flag = a>0;
        System.out.println(flag);
        
        String s1 = "zhangsan";
        String s2 = "zhangsan";
        
        System.out.println(s1==s2);
        System.out.println(s1!=s2);
        
        //练习  对下面代码进行注释
        double d=10/3; 
        a=10/3;
        System.out.println(a==d);    //true
        System.out.println(a);    //3.0
        System.out.println(d);    //3.0
        
        d=10/3.0;  
        a=10/3;
        System.out.println(a==d);    //false
        System.out.println(a);    //3.0
        System.out.println(d);    //3.33333333333333
        
        System.out.println("hello"!="hello"); //false
    }
    
}

2.5逻辑运算符

& 与两个都为真true，结果才为true，一个为false就是false

| 或一个为true就是true,两个都为false才是false

！非取反！true-->false ！false-->true

^异或相同为false，不同为true

短路：如果左边的操作数的值能够决定最终表达式的结果，第二个操作数不会执行 && : 两个都为真true,结果才为true,一个为false就是false || : 一个为true就是true,两个都为false才是false

注意：操作数必须boolean，值为boolean的表达式建议使用短路运算符

blic class Class017_Operator{
    //main方法 
    public static void main(String[] args){
        System.out.println("-----------------&-----------------");
        System.out.println(true&true);  //true
        System.out.println(true&false);  //false
        System.out.println(false&false);  //false
        System.out.println(false&true); //false
        
        System.out.println("-----------------|---------------");
        System.out.println(true|true);  //true
        System.out.println(true|false);  //true
        System.out.println(false|false);  //false
        System.out.println(false|true); //true
        
        System.out.println("-----------------!---------------");
        System.out.println(!true);  //false
        System.out.println(!false);  //true
        
        System.out.println("-----------------^---------------");
        System.out.println(true^true);  //false
        System.out.println(true^false);  //true
        System.out.println(false^false);  //false
        System.out.println(false^true); //true
        
        System.out.println("-----------------&&`-----------------");
        System.out.println(true&&true);  //true
        System.out.println(true&&false);  //false
        System.out.println(false&&false);  //false
        System.out.println(false&&true); //false
        System.out.println("-----------------& 与 &&-----------------");
        //System.out.println(false&5/0==0);  // java.lang.ArithmeticException: / by zero
        System.out.println(false&&5/0==0);  //false
        
        System.out.println("=============练习=================");
        int a=10;
        int b=9;
        System.out.println(a>b & ++b>a);  //false
        System.out.println("a="+a+",b="+b);  //a=10,b=10
        System.out.println(a<b | b<a);    //false
        System.out.println(!(a>b ^ a>9)); //false
        System.out.println(10>5 & 10/0==0); //报错
        System.out.println(10<5 && 10/0==0); //false

2.6条件运算符

条件表达式？值1：值2；

条件表达式：值为boolean类型的表达式

执行流程： 1.计算条件表达式，得到boolean结果 2.为false，结果为值2

public class Class018_Operator{
    //main方法 
    public static void main(String[] args){
        String s = false ? "值1" : "值2";
        System.out.println(s);
        
        int a = 5;
        String s2 = a>0? "a>0" : "a<=0";
        boolean flag = a>0? true : false;
        System.out.println(flag);
        System.out.println(a>0);
        
        int b = 7;
        //求2个数最大的值
        int max = a>b?a:b;
        System.out.println(max);
        
        //求2个数值最大的变量
        String name = a>b? "a" : "b";
        
        //判断a是否为偶数
        System.out.println(a%2==0?"偶数":"奇数");
        
        //求3个变量中最大的值、
        max= 0;
        int c = 14;
        //1)
        max = a > b ? a : b;
        max = max>c ? max : c;
        System.out.println(max);
        
        max= 0;
        //2)
        max = a>b && a>c ? a : (b>c ? b : c);
        System.out.println(max);
    }
    
}

2.7位运算符

把操作数转为二进制，然后根据运算符的规则运算，最终得到的结果转为十进制

&：同一位的两个数，两个都为1才是1，一个为0就是0 | ：同一位的两个数，一个都为1才是1，两个为0就是0 ^ : 同一位的两个数，相同为0不同为1

注意：以上三个左右两边为boolean类型数据就作为逻辑运算符存在

位运算符

右移==>8>>2 把第一个操作数转为二进制，向右移动第二个操作数个位数，移出的位数直接忽略不计，剩余的转为十进制

左移==>8<<2 把第一个操作数转为二进制，向左移动第二个操作数个位数，空位补0，结果转为十进制

总结规律：右移：/2的次方 8>>3==>8/2^3 左移：* 2的次方 8<<3==>8 * 2^3

注意：建议使用位移运算符代替乘除，效率高

System.out.println(3&2);  //2
        System.out.println(3|2);  //3
        System.out.println(3^2);  //1
        
        System.out.println(8>>2);  //2
        System.out.println(8<<1);  //16
        
        
        int a = 5;
        int b = 10;
        boolean x =a < b  ?( a++ * 2 > b || a > b ):( a < b);
        System.out.println(x);  //false
        System.out.println(a);  //6
        System.out.println(b);  //10
        System.out.println(false && true || true);  //true
        System.out.println(true || true && false);  //true

2.8运算优先级

运算优先级：单目算数位关系，逻辑三目后赋值。

public class Class020_Operator{
    //main方法 
    public static void main(String[] args){
        int a = 5;
        int b = 10;
        boolean x = a < b ? a++ * 2 > b || a > b : a < b;
        System.out.println(x);  //F
        System.out.println(a);  //6
        System.out.println(b);  //10
        //&&比||优先级高
        System.out.println(false && true || true);  //T
        System.out.println(true || true && false);  //T
        
        //赋值运算符 : 自右向左执行
        //x=y=z=10;
        
        //条件运算符具有自右向左的结合性
        boolean w = true?true:false?false:false;
        boolean y = true?true:(false?false:false);  //自由向左结合  T
        boolean z = (true?true:false)?false:false;  //自左向右结合  F
        System.out.println(w); 
        System.out.println(y); 
        System.out.println(z); 
    }
    
}

必备番外：流程控制语句

顺序结构：默认从上到下从左到右选择结构：满足条件执行相应的代码 if..else switch 循环结构：重复执行一段代码（控制执行次数） for while do..while

if 单选择|单分支： if（boolean表达式）{ 语句体 } 执行流程： 1.boolean表达式，得到boolean结果 2.如果结果为true，执行{}中的语句体 3.如果结果为false，直接跳过if结构

双选择|双分支： if（boolean表达式）{ 语句体1； }else{ 语句体2； } 执行流程： 1.boolean表达式，得到boolean结果 2.如果接过为true，执行{}中的语句体1 3.如果结果为false，执行else后的语句体2 多选择|多分支： if（boolean表达式）{ 语句体1； }else if (boolean表达式2){ 语句体2； }else if(boolean表达式3){ 语句体3； }········ else{ 语句体n； } 执行流程： 1.boolean表达式1，得到boolean结果，如果结果为true，执行{}中的语句体1 2.如果结果为false，执行boolean表达式2，如果结果为true，执行{}中的语句体2 3.如果结果为false，执行boolean表达式2，如果结果为true，执行{}中的语句体3 4.如果以上都不满足，执行else后的语句体n；\

注意：一个if..else为一个结果，只能执行一个语句体。如果{}中的语句体只有一句，前后的{}可以省略

if语句与条件运算符区别： 1.条件运算符肯定有结果，但是if结果不一定能有结果 2.条件运算符结果智能为值1|值2，if语句体可以存在多条指定语句 3.if结果功能更加强大，但是条件运算符符结构简单，效率高推荐简单的使用条件运算符，复杂的使用if

public class Class021_If{
    
    public static void main(String[] args){
        System.out.println("if之前");
        //单选泽
        if(false){
            System.out.println("满足条件");
        }
        System.out.println("if之后");
        
        //双选泽
        int i=1;
        if(i>0){
            System.out.println("i>0");
        }else{
            if(i==0){
                System.out.println("i=0");
            }else{
                System.out.println("i<0");
            }
        }
        
        //多选泽
        if(i>0) 
            System.out.println("i>0");
        else if(i==0) 
            System.out.println("i=0");
        else 
            System.out.println("i<0");  
        
    }
    
}

if语句小练习

public class Class022_Practice{
    public static void main(String[] args){
        System.out.println("--------------一----------------");
        /*
            一.两个随机数 判断两个数是否相等
        */
        Random random=new Random;
        int a=random.nextInt();
        int b=random.nextInt();
        System.out.println(a==b);
        
        System.out.println("--------------二----------------");
        /*
            二.获取两个随机数中的最大 要求:分别用if语句,用三目运算符实现
        */
        if(a>b){
            System.out.println("max="+a);
        }else{
            System.out.println("max="+b);
        }
        String s1=a>b?a:b;
        
        System.out.println("--------------三----------------");
        /*
            三.获取三个随机数中的最大值 要求:使用if语句嵌套
        */
        int c=random.nextInt();
        if(a>b&&a>c){
            System.out.println("max="+a);
        }else if(b>c){
            System.out.println("max="+b);
        }else{
            System.out.println("max="+c);
        }
        
        System.out.println("--------------四----------------");
        /*
            四.键盘输入小明的一门成绩,显示该成绩对应的奖励
                100         爸爸给你买个iphone18promax        x=100
                [90,100)    爸爸给你买个iphone18              x>=90 & x<100
                [60,90)     别灰心,爸爸给你买各种学习资料        x>=60 & x<90
                (0,60)      买学习资料,上补习班,各种爱的教育,如果下次还不及格,小心皮鞭沾凉水  x>0 & x<60
                0           我看你是快了!!!!                  x=0
                
                注意:java中不支持这种格式90<=x<=100
                    要写成: x>=90 & x<100
        */
        Scanner sc =new Scanner(System.in);
        //获取用户数据
        int d1=nextInt();
        if(d1==100){
            System.out.println("爸爸给你买个iphone18promax")
        }else if(d1>=9&&d1<100){
            System.out.println("爸爸给你买个iphone18");
        }else if(d1>=60&&d1<90){
            System.out.println("别灰心,爸爸给你买各种学习资料");
        }else if(d1>0&&d1<60){
            System.out.println("买学习资料,上补习班,各种爱的教育,如果下次还不及格,小心皮鞭沾凉水");
        }else if(d1==0){
            System.out.println("我看你是快了!!!!");
        }

if 区间判断定值判断

switch定值判断

    语法：
        switch(条件){
            case 值1:
                语句体1;
                break;
            case 值2:
                语句体2;
                break;
            .....
            default: 
                语句体n;
                break;
        }

条件：变量，表达式数据类型：byte short int char 枚举（jdk1.5） String（jdk1.7） case： case跟定值，要与条件的结果判断，条件的结果与case后的定值相等就指定对应的语句体 break：结束当前switch语句，防止case穿透 default：相当于else，可以定义可以不定义位置可以定义在switch语句中的任意位置

public class Class023_Switch{
    public static void main(String[] args){
        String flag = "紫灯";
        
        switch(flag){
            case "绿灯":
                System.out.println("绿灯行..");
                break;
            case "红灯":
                System.out.println("红灯停..");
                break;
            case "黄灯":
                System.out.println("黄灯等一等..");
                break;  
            default :  
                System.out.println("别捣乱..");
                break;  
        }
        /*
        
        //case穿透
        switch(flag){
            case "绿灯":
                System.out.println("绿灯行..");
            case "红灯":
                System.out.println("红灯停..");
            case "黄灯":
                System.out.println("黄灯等一等..");
                break;
            default :  
                System.out.println("别捣乱..");    
        }
        */
        
        //测试char
        char ch = 'a';
        switch(ch){
            case 'a':
                System.out.println("aaa..");
                break;  
            case 'b':
                System.out.println("bbb..");
                break;              
        }
        
        //思考 : 
        boolean  b = false;
        //通过switch语句对b进行判断
        String s=String.valueOf(b);//第一个方法
        String s2=""+b;//第二个方法
        String s3=b?"true":"false";//第三个方法（三目运算符）
        String s4=Boolean.toString(b);//第四个方法
        switch(s){
            case"false":
                System.out.println("false");
                break;
            case"true":
                System.out.println("true");
                break;
            default:
                System.out.println("搞什么飞机啊！！");
                break;

3.0循环结构

循环结构：让一些代码重复执行多次 for while do..while 可以相互转化

3.1for循环

for（条件初始化；条件判断；条件变化）{ 重复执行的代码块； } 条件初始化：声明一个变量i，并且第一次赋值条件判断：值为boolean类型的判断结果，控制循环的结束条件变化：i自身值的改变

执行流程： 1.条件初始化 i=1 2.条件判断：判断是否结果，为false，循环结束，为true，执行本次循环体语句 i<5 3.条件变化 i++ 重复执行2，3步骤

注意： 1.在循环语句中可以使用条件变量i 2.在for循环中的条件变量i作用域只在当前循环 3.如果循环体语句只有一句，前后的{}可以省略

public class Class024_For{
    public static void main(String[] args){
        //输出优极限口号 : 
        /*
        System.out.println("极限就业,挑战极限!!!!");
        for(int i=1;i<=100;i++){
            System.out.println("极限就业,挑战极限!!!!"+i);
        }
        //打印1~10之间的整数
        //1)重复输出打印  2)输出内容有规律 确定变化区间[1,10],确定变化规律 每次+1
        for(int i=1;i<=10;i++ ){
            System.out.println(i);
        }
        //求1~10之间的整数和
        //1.重复求和   2.对1~10之间的整数 
        int sum = 0; //记录和 
        for(int i=1;i<=10;i++){
            //sum = sum+i;
            sum+=i;
        }
        System.out.println(sum);
        
        
        //15~20之间整数和
        //重复求和   [15,20]
        sum = 0; 
        for(int i=15;i<=20;i++)
            sum+=i;
        
        System.out.println(sum);
    }
}

3.2While条件循环

语法：条件初始化； while（条件判断）{ 循环体；条件循环； }

循环之间可以相互转换在使用while循环时候，注意条件的声明位置，条件变化的位置 while循环适合使用在条件不用声明就已经存在|条件变化不需要手动控制，这种情况适合使用whlie循环 for循环适合用在确定循环次数，确定条件变化区间，适合使用for循环

public class Class026_while {
    public static void main(String[] args) {
        //for
        for(int i=1;i<=10;i++){
            System.out.println(i);
        }
        //while
        int i=1;
        while(i<=10){
            System.out.println(i);
            i++;
        }
        
        //1~100之间整数和
        i=1;
        int sum = 0;
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println(sum);
        System.out.println(i);

3.3 do..while循环

语法：条件初始化； do{ 循环体语句；条件变化； }while（条件判断）；

区别： while：先判断，满足条件要求再执行每一次循环 do..while：先执行一次，然后再判断条件决定下一次是否执行，无论是否满足条件，都至少执行一次

public class Class027_DoWhile {
    public static void main(String[] args) {
        /*
        while(false){
            System.out.println("while...false");
        }
        */
        
        do{
            System.out.println("do...while...false");
        }while(false);
        
        //求100之间整数和
        int i=1;
        int sum = 0;
        //while实现
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println(sum);
        
        
        System.out.println(i);
        
        //转为do..while实现
        int j = 1;
        sum = 0;  //sum归零
        do{
            sum+=j;
            j++;
            
        }while(j<=100);
        System.out.println(sum);
        System.out.println(j);
    }
}

3.4 break和continue

break作用：终止，结束应用场景：switch，循环 continue：作用：结束本次循环，直接进入到下一次循环应用场景：循环中

public class Class029_BreakContinue {
    public static void main(String[] args) {
        //输出1~10之间的整数,如果遇到3或者3的倍数跳过
        for(int i=1;i<=10;i++){
            if(i%3==0){
                continue;
            }
            System.out.println(i);
        }
        
        //找到100,300之间前五个能被5整数的数据
        int count = 0;
        for(int i=100;i<=300;i++){
            if(i%5==0){
                System.out.println(i);
                count++;
                //循环结束的条件
                if(count==5){
                    break;
                }
            }
        }
        System.out.println(".....");
        
        //练习题
        //A: 输出除了4和6以外的1~10之间的数
        int i2=0;
        for(int i=1;i<=10;i++){
            if(i!=4&&i!=6){
                System.out.println(i);
            }
        }
        
        for(int i=1;i<=10;i++){
            if(i==4&&i==6){
                continue;
            }
            System.out.println(i);
        }

3.5 循环嵌套

for（条件初始化；条件判断；条件变化）{ //循环体语句 for(条件初始化；条件判断；条件变化){ 循环体语句 } //循环体语句 } 外层循环执行一次，内存循环执行一轮（从开始到不满足循环条件结束）

public class Class030_NestedLoop {
    public static void main(String[] args) {
        /*
            * * * * * 
            * * * * * 
            * * * * * 
            * * * * * 
            * * * * * 
        */
        //单层循环
        int count = 0; //计数器
        for(int i=1;i<=25;i++){
            System.out.print("* ");
            count++;
            if(count==5){
                System.out.println();
                count=0; //计数器归零
            }
        }
        
        System.out.println();
        System.out.println();
        System.out.println();
        
        //双重循环
        //外层循环控制行i    内层循环控制列 j
        for(int i=1;i<=5;i++){
            for(int j=1;j<=5;j++){
                System.out.print("* ");
            }
            System.out.println();  //换行
        }
        System.out.println();
        System.out.println();
        System.out.println();
        /*
            * * * * * 
            *       * 
            *       * 
            *       * 
            * * * * * 
        */
        for(int i=1;i<=5;i++){
            for(int j=1;j<=5;j++){
                if(i==1 || i==5 || j==1 || j==5){
                    System.out.print("* ");
                }else{
                    System.out.print("  ");
                }
            }
            System.out.println();  //换行
        }
        
        System.out.println();
        System.out.println();
        System.out.println();
        /*
            * * * * * * *
            * * * * * * *
            * * * * * * *
            * * * * * * *
            * * * * * * *
            * * * * * * *
        */
        for(int i=1;i<=6;i++){
            for(int j=1;j<=7;j++){
                System.out.print("* ");
            }
            System.out.println();  //换行
        }
        System.out.println();
        System.out.println();
        System.out.println();
        
        /*
            * * * * * * *
            *           *
            *           *
            *           *
            *           *
            * * * * * * *
        */
        for(int i=1;i<=6;i++){
            for(int j=1;j<=7;j++){
                if(i==1 || i==6 || j==1 || j==7){
                    System.out.print("* ");
                }else{
                    System.out.print("  ");
                }
                
            }
            System.out.println();  //换行
        }
        System.out.println();
        System.out.println();
        System.out.println();
        
        /*
            *                   1
            * *                 2
            * * *               3
            * * * *             4
            * * * * *           5
        */
        for(int i=1;i<=7;i++){
            for(int j=1;j<=i;j++){
                System.out.print("* ");
            }
            System.out.println();  //换行
        }
        System.out.println();
        System.out.println();
        System.out.println();
        
        /*
            *                   1
            * *                 2
            *   *               3
            *     *             4
            * * * * *           5
        */
        for(int i=1;i<=7;i++){
            for(int j=1;j<=i;j++){
                if(i==7 || j==1 || j==i){
                    System.out.print("* ");
                }else{
    System.out.print("  ");
    }
    }
    System.out.println();  //换行
    }
    System.out.println();
    System.out.println();
    System.out.println();

    //九九乘法表
    for(int i=1;i<=9;i++){
    for(int j=1;j<=i;j++){
    System.out.print(j+"*"+i+"="+i*j+"\t");
    }
    System.out.println();  //换行
    }
    for(int i=1;i<=9;i++){
    for(int j=1;j<=i;j++){
    System.out.print(j+"*"+i+"="+i*j+"\t");
    }
    }
    }
}

多重循环嵌套下break与continue的使用 break与continue默认针对最内层循环如果想要break与continue针对多重循环嵌套下的某一层循环，可以使用带标签的break与continue

步骤： 1.每一层设置标签 2.使用break与continue的时候==>break|continue标签名；

public class Class031_BreakContinue {
    public static void main(String[] args) {
        
        one:
        for(int i=1;i<=5;i++){
            two:
            for(int j=1;j<=5;j++){
                if(j==3){
                    break one;
                }
                System.out.print("i="+i+" ==> j="+j+"\t");
            }
            System.out.println();
        }
        
    }
}

posted @ 2022-03-07 08:43 柯ke 阅读(72) 评论(0) 收藏举报

刷新页面返回顶部

柯ke