[Java知识库]java基础 -- 笔记

JAVA基础

引言： 百川东到海，何时复西归?少壮不努力，老大徒伤悲。

第一章：初始JAVA

程序是什么：

程序一词来自生活，通常指完成某些事情的一种既定方式和过程，可以将程序看成一系列动作执行的描述。

重点：程序就是一系列有序指令的集合！！！

JAVA的产生：

Java是Sun Microsystems于1995年推出的高级编程语言

Java可以做什么 ：

1：开发桌面应用程序 
2：开发面向Internet的应用程序

Java平台的体系结构：

	1.Java SE 面向对象  API  JVM...
	2.Java ME 移动设备  游戏  通信...
	3.Java EE  JSP  EJB服务...

开发三步骤：

1：编写源程序（编写.java）   
2：编译源程序(编译.class)
3：运行

使用记事本开发三步骤：

1：编写源代码以.java为后缀名保存     
2：使用javac命令编译.java文件生成.class文件
3：使用java命令运行.class文件。输出程序结果

JAVA程序的基本结构：

//外层框架
public class HelloWorld{
    //java程序入口程序
    public static void main(String[] args){
        //编写代码
        System.out.println("com.ytzl.chpater01.Hello World");
    }
}
// class：关键字    HelloWorld:类名与文件名完全一致  
//main方法四要素必不可少：public  static void  String[] args 
//main()方法是java程序执行的入口
//{}一一对应缺一不可

//public:公共的  static:静态的 void:空的/没有返回值 String[]:String类型数组

输出语句：

System.out.println("com.ytzl.chpater01.Hello World"); //打印完引号中的信息会自动换行

System.out.print("com.ytzl.chpater01.Hello World"); //打印输出信息后不会自动换行

区别：有ln会自动换行，没有ln不会自动换行

转义符:

\t:制表符
\n:换行符

JAVA程序的注释：

单行注释以//开始
多行注释以/*开始 */结尾   
多行注释的每一行开头可以写多个或者一个*  

JAVA的编码规范：

1:类名使用public 修饰
2：一行只写一条语句
3：{}的使用以及位置
4：代码缩进
    
注意：
    
1：Java对大小写敏感!
2：每一条Java语句必须以分号结束!    
3：注意：不要漏写引号!并且必须是英文的！    

第二章：数据类型 变量 运算符

变量是什么：

表示一个存储数据的基本空间

不同数据存入具有不同内存地址的空间，相互独立     

JAVA常用的数据类型：

整形int :用于存储整数，例如：1天   99岁
字符串String:用于存储字符串，l例如：我的爱好是打游戏
字符型char:用于存储单个字符：例如：男/女   开/关
非整形double:用于存储小数，例如0.6元，3.5小时
布尔boolean:，存储的值只有两个：true  false

如何声明变量以及使用：

先声明后赋值	
String name;   name = "张三"；
边声明边赋值
Sting name ="张三";

常量：

程序中运行中，不允许被修改的量使用final修饰
  例如：  final int age = 19;
优点：安全
只能被赋值一次，通常定义时即对其初始化    

变量名命名规则：

开头：字母   下划线  $符号
其余部分: 数字   字母   下划线  $符号
    
重点:不能使用关键字    

运算符：

算数运算符：+ - * / % 
赋值运算符：=      把=右边的值或表达式结果存储到=左边的变量中
关系运算符：> < >= <= != ==
逻辑运算符：&&：并且   ||：或者  ！：取反  
运算符优先级：!>算数运算符>关系运算符>&&>||    

自动类型转换规则：

1：两种数据类型要兼容        
2：小转大 例如 double类型大于int类型

强制类型转换：

语法：（类型名）（表达式）
例如：int  b = (int)10.2;

分解一个数字个十百千：

int gewei = num % 10; 
int shiwei = num / 10 % 10; 
int baiwei = num / 100 % 10; 
int qianwei = num / 1000;

产生随机数：

一位:int random=(int)(Math.random()*10);

四位:int random=(Math.random() * (9999 - 1000 + 1)) + 1000

Scanner使用：

1:用来获取用户（在控制台）的输入
2:先导入Scanner类所在的包：import java.util.Scanner;
3:创建Scanner类对象： Scanner scanner/input=new Scanner(System.in);
4:使用扫描仪对象来获取数据：
    		scanner.next();--》获取字符串; 
			scanner.nextlnt();--》获取整形变量（整数）;
			scanner.nextDouble();--》获取非整型变量（小数）;
            scanner.next().charAt(0);--》获取单个字符;             

自增自减:++ –

（1）int a=num++; 表示num先赋值给a，在自加1；
（2）int b=++num; 表示num先自加1，在赋值给b；

第三章：选择结构

基本的if选择结构:可以处理单分支的if选择结构

//结果必须是布尔值
if ( 条件 ) { 
        //代码块 
}

if-else选择结构:可以处理两个分支的if选择结构

if ( 条件 ) { 
        //代码块1  
 }else { 
       //代码块2 
}

多重if选择结构:可以处理多个分支的if选择结构

if(条件){
			//代码块1
}else if(条件){
			//代码块2
}else{
			//代码块3
}

嵌套if：可以处理某分支中嵌套if结构的if选择结构

if(条件1) {
    //满足条件一的情况下在判断条件二
      if(条件2) {
            //代码块1
      } else {
            //代码块2
      }
} else {
     //代码块3
}

switch选择结构

switch(表达式){
	case 常量一:
			//代码块1
		break;
	case 常量二:
			//代码块2
		break;
	default:
		//没有找到匹配的值执行的代码
		break;
}
表达式：int char byte 枚举  short String
每个case后不漏写break,记得跳出

switch和多重if区别：

相同点：
    		都是用来处理多分支条件的结构
不同点：  
    		switch:只能处理等值条件判断
            多重if:判断某个连续区间   

异常处理:

Scanner对象的hasNextInt()方法，可以判断用户从键盘输入的字符是否是合法的数字
例如：
	if（scanner.hasNextInt()）{
			int num = scanner.inputInt();
	}else{
			System.out.println("输入不是数字哦");
	}

比较:

    比较int double类型使用==
    比较字符串使用.equals();

选择结构总结；

if选择结构
    
	基本if选择结构： 处理单一或组合条件的情况
	if-else选择结构：处理简单的条件分支情况
	多重if选择结构：处理复杂的条件分支情况
	嵌套if选择结构：用于较为复杂的流程控制
    
switch选择结构
        
	多重分支并且条件判断是等值判断的情况

第四章：循环

while循环：

//符合条件，循环继续执行；否则，循环退出
while ( 循环条件 ) { 
       循环操作
}
示例：循环输出100遍我要好好学习天天向上。
     int i =1;
     while (i<=100){
    	System.out.println("第"+i+"遍：我要好好学习天天向上");
        i++;
     }
特点：先判断，再执行 

程序调试

1：设置断点
2：单步执行
3：观察变量

do while循环

语法：
//先执行一遍循环操作
do {
    
		循环操作
            
} while ( 循环条件 );//分号必须有
//符合条件，循环继续执行；否则，循环退出

特点：先执行，再判断

do while 和while区别

1：语法不同 
略
       
2：执行顺序不同
    while 是先判断再执行循环操作，do while则刚好相反

3:当初始条件不满足循环条件的时候
    while 循环一次都不会执行
   do while 循环不管任何情况都至少执行一次

for循环

语法：
	for(参数初始化;循环条件;更新循环变量){
        循环操作
    }
示例：循环输出100以内偶数之和
    //定义总和
   	 int sum = 0;
        for (int i = 0; i <=100; i++) {
            if(i%2==0){
                sum=sum+i;
            }
        }
    System.out.println("100以内所有偶数和"+sum);
for循环执行顺序：参数初始化-->循环条件-->循环操作-->更新循环变量
for循环书写顺序：参数初始化-->循环条件-->更新循环变量-->循环操作 
    
注意： 代码规范：格式对齐、代码的缩进    

break使用：

break：改变程序控制流
当用于do-while、while、for等循环结构中时，可跳出循环而执行循环后面的语句
示例：
        //使用循环进行累加，从1到10
        //判断累加值是否大于20
        //如果大于20，则跳出循环，并打印当前值
        //定义累加值初始变量
        int number =0;
        for (int i = 1; i <=10; i++) {
            //累加值
            number=number+i;
        	//如果大于20,打印当前值,跳出循环
            if(number>20){
                //打印当前值
                System.out.println(i);
                //!!!:跳出循环而执行循环后面的语句
                break;
            }
        }
 	System.out.println("程序结束);

continue使用：

continue ：只能用在循环结构中
作用：跳过循环体中剩余的语句而执行下一次循环
	通常与条件语句一起使用，加速循环
示例：求1~10之间的所有偶数和（使用continue）
实现思路：
    	使用循环进行累加，循环的范围是从1至10
		判断当前数是否为偶数	
		如果为奇数跳过，执行下一个循环。如果为偶数，进行累加    
	int sum = 0; // 定义一个变量，进行累加
		for (int i = 1; i <= 10; i++) {
            //判断是否偶数,一个数%2==1的时候这个数就是奇数,==0的整个
			if (i % 2 == 1) {
                //！！！继续下一次循环
				continue;// 如果i为奇数,结束本次循环，不累加，进行下一次循环
			}
			sum = sum + i;
		}
	System.out.print("1--10之间的偶数和是:" + sum);

对比break和continue：

使用场合：
	break可用于switch结构和循环结构中
	continue一般只用于循环结构中
作用（循环结构中）：
	break语句用于终止循环，程序跳转到循环体外的下一条语句
	continue用于跳出本次循环，进入下一次循环 
    
扩展：oop面向对象用到：	
	return：结束当前方法的执行并退出，返回到调用该方法的语句处

循环结构总结:

无论哪一种循环结构，都有4个必不可少的部分：
	重点！！！:初始部分、循环条件、循环体、迭代部分
	
三种循环的区别:
        区别1：语法
            略
        区别2：执行顺序 
            while 循环：先判断，再执行
            do-while循环：先执行，再判断
            for循环：先判断，再执行
        区别3：适用情况
            循环次数确定的情况，通常选用for循环
            循环次数不确定，通常选用while或do-while循环

重点！！！:三种循环的特点:

            while循环的特点是先判断后执行

            do-while循环的特点:
                先执行，再判断
                循环操作至少执行一次

            for循环结构与跳转语句:
                for循环结构
                    确定循环次数
                    特点：先判断，再执行
		
跳出循环的语句
		break：循环结构中遇到break语句，将会跳出其所在的循环，执行该循环结构后的第一条语句
		continue：结束本次循环，进入下一次循环的条件判断

第五章：数组

为什么需要数组：

题目：计算全班（30人）的平均分

int stu1 = 95;
int stu2 = 89;
int stu3 = 79;
int stu4 = 64;
int stu5 = 76;
int stu6 = 88;
……
avg = (stu1+stu2+stu3+stu4+stu5…+stu30)/30;

弊端：
	1:声明30个变量太繁琐
	2:且不利于数据处理(计算)

什么是数组

数组是一个变量，用来存储一组相同数据类型的数据
	
	声明一个变量就是在内存空间划出一块合适的空间

	声明一个数组就是在内存空间划出一串连续的空间

数组基本要素：

标识符：数组的名称，用于区分不同的数组
数组元素：向数组中存放的数据
元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问
元素类型：数组元素的数据类型  

注意:数组长度固定不变，避免数组越界

如何使用数组：

//例如:定义一个存储分数的数组
//使用数组四步走:
        //第一步：声明数组
        int[] score;

        //第二步：分配空间
        score=new int[5];

        //第三步：赋值
        score[0]=80;
		
        //第四步：处理数组
        score[0]=score[0]*10;  

声明数组：

声明数组: 告诉计算机数据类型是什么
示例:int[ ] JavaScore;   //Java成绩

语法:	数据类型    数组名[ ] ; 
	 数据类型[ ]  数组名 ; 
	 
注意:声明数组时不能规定数组长度          

分配空间:

分配空间: 告诉计算机分配几个连续的空间
	JavaScore = new int[30]; 

语法:声明数组并分配空间
	数据类型[ ]  数组名   =   new   数据类型[大小]  ;             	
示例：
	int[] JavaScore = new int[30];

数组赋值：

赋值：向分配的空间里放入数据
	JavaScore[0] = 89;
	JavaScore[1] = 79;
	JavaScore[2] = 76;
	……
	太麻烦！能不能一起赋值？
	
方法1: 边声明边赋值
	int[ ] JavaScore = {89, 79, 76};
	int[ ] JavaScore = new int[ ]{89, 79, 76};
注意：不能指定数组长度          

方法2：动态地从键盘录入信息并赋值	
	int[] JavaScore=new int[5];
	Scanner input = new Scanner(System.in);
	for(int i = 0; i < JavaScore.length; i ++){
    	 score[i] = input.nextInt();
	}

处理数据:

对数据进行处理：计算5位学生的javaScore平均分
方式一：
	int [ ] JavaScore = {60, 80, 90, 70, 85};
	double avg;
	avg = (JavaScore[0] + JavaScore[1] + JavaScore[2] + JavaScore[3] + JavaScore[4])/5;  
  

方式二:
	int [ ] JavaScore = {60, 80, 90, 70, 85};
	int sum = 0;
	double avg;
	for(int i = 0; i < JavaScore.length; i++){
  	   sum = sum + JavaScore[i];
    }
	avg = sum / JavaScore.length; 

注释：
1:访问数组成员：使用“标识符[下标]”
2:数组的length属性
3:JavaScore[i]:访问成员

提问使用数组求10个学生的平均分:

	Scanner scanner = new Scanner(System.in);
        //定义存储java成绩数组
        int[] JavaScore=new int[10];
        //定义java成绩数组的总和	
        int sum=0;
        for (int i = 0; i < JavaScore.length; i++) {
            System.out.println("请输入第"+(i+1)+"个学生Java成绩:");
            JavaScore[i]=scanner.nextInt();
            sum =sum+JavaScore[i];
            //简写：sum+= JavaScore[i];
        }
        System.out.println("30个学生的java平均分是："+(sum/JavaScore.length));

数组升序排序:

题目：循环录入5位学员成绩，进行升序排列后输出结果
提示：
	使用java.util.Arrays类
	注意导包：java.util下的
	Arrays类的sort()方法：对数组进行升序排列
public class ScoreSort {
	public static void main(String[] args) {
		int[] scores = new int[5];	//成绩数组
		Scanner input = new Scanner(System.in);
		System.out.println("请输入5位学员的成绩：");
		//循环录入学生成绩并存储在数组中
		for(int i = 0; i < scores.length; i++){
			scores[i] = input.nextInt();
		}
		//数组中的元素被重新排列
		Arrays.sort(scores);	
		System.out.print("学员成绩按升序排列：");
		//循环输出数组中的信息
		for(int i = 0; i < scores.length; i++){
			System.out.print(scores[i] + " ");
		}
	}
}

使用Arrays类的各种方法:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lGlqj79m-1632835337892)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1616557031352.png)]

public class Arrays_Study {
    public static void main(String[] args) {
        //返回值：boolean 方法名称:equals(array1,array2)
        //作用：比较数组array1和array2是否相等
        System.out.println("---------equals(array1,array2)方法:----------");
        int[] arr1={10,50,90,80,60};
        int[] arr2={10,50,90,80,60};
        int[] arr3={20,40,90};
        //判断arr1与arr2的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr2));
        //判断arr1与arr3的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr3));

        //方法名称： sort(array)
        //作用：对数组array的元素进行升序排列
        System.out.println("\n---------sort(array)方法:----------");
        int[] JavaScores ={90,50,100,60,30,70};
        //对数组进行升序排列
        Arrays.sort(JavaScores);
        System.out.println("Java成绩升序排列后：");
        for (int i = 0; i <JavaScores.length ; i++) {
            System.out.print(JavaScores[i]+"\t");
        }

        System.out.println();
        //返回值：String 方法名称：toString(array)
        //作用:将数组array转换成一个字符串
        System.out.println("\n---------toString(array)方法:----------");
        int[] SqlScores = {70,80,50,40,60,20};
        //对数组进行升序排列
        Arrays.sort(SqlScores);
        //将SqlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(SqlScores));

        //方法名称：fill(array,val)
        //作用：把数组array所有元素都赋值为value
        System.out.println("\n---------fill(array,val)方法:----------");
        int[] HtmlScores = {70,50,90,40,30,100};
        Arrays.fill(HtmlScores,60);
        //将HtmlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(HtmlScores));

        //方法名称：copyOf(array,length)
        //作用：把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
        System.out.println("\n---------copyOf(array,length)方法:----------");
        int[] arr11={10,90,80,70,60};
        int[] arr22=Arrays.copyOf(arr11,6);
        System.out.println(Arrays.toString(arr22));
        int[] arr33=Arrays.copyOf(arr11,3);
        System.out.println(Arrays.toString(arr33));
        //将arr11复制成长度为5的新数组arr44
        int[] arr44=Arrays.copyOf(arr11,5);
        System.out.println(Arrays.toString(arr44));

        //返回值：int 方法名称：binarySearch(array, val)
        //作用：查询值val在数组array中的下标
        //（要求数组中元素已经按升序排列，如果没有找到，则返回一个负整数）
        System.out.println("\n---------binarySearch(array, val)方法:----------");
        int[] MathScores ={60,70,40,20,80,100};
        Arrays.sort(MathScores);
        int index = Arrays.binarySearch(MathScores,99);
        System.out.println(index);
        int indexTwo = Arrays.binarySearch(MathScores,20);
        System.out.println(indexTwo);
    }
}

求数组最大值：

题目:从键盘输入五位学生的成绩，求考试成绩最高分	
示例：    
	public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //定义存储5个学生的成绩数组
		int[] scores = new int[5];
        //记录最大值
		int max = 0;	
		System.out.println("请输入5位学员的成绩：")
		for(int i = 0; i < scores.length; i++){
			scores[i] = input.nextInt();
		}
		//假设第一个元素为最大的成绩
		max = scores[0];
        //从第一个成绩开始比较
		for(int i = 1; i < scores.length; i++){
            //循环判断
			if(scores[i] > max){
				max = scores[i];
			}
		}
		System.out.println("考试成绩最高分为：" + max);
	}

数组插入数据：

public static void main(String[] args){
		int[] list = new int[6];
		list[0] = 99;
		list[1] = 85;
		list[2] = 82;
		list[3] = 63;
		list[4] = 60;
		//将最后一个元素空出
		//保存新增成绩将插入的位置
		int index = list.length;
		System.out.println(index);
		System.out.println("请输入新增成绩： ");
		Scanner input = new Scanner(System.in);
		int num = input.nextInt();
		//找到新元素的要插入的位置
		for(int i = 0; i < list.length; i++){
			if(num > list[i]){
				index = i;
				break;
			}
		}
		//元素后移
		for(int j = list.length-1; j > index; j--){
			list[j] = list[j-1];
		}
		list[index] = num;
		System.out.println("插入成绩的下标是："+index);
		System.out.println("插入后的成绩信息是： ");
		for (int k = 0; k < list.length; k++) {
			System.out.print(list[k] + "\t");
		}

}

数组降序排序:

实现思路：
  1:先使用arrays类的sort方法进行升序排列
  2:再使用for循环降序排列
  int[] numbers = {9,41,52,1,8,90,60};
  Arrays.sort(numbers);
  			
  //从最后一个下标的输入开始  小于第一个下标   递减
  for (int i = numbers.length-1; i >=0 ; i--) {
            System.out.println(numbers[i]);
  }       

二维数组：

语法：
	<数据类型>  [ ][ ]  数组名;  或者  <数据类型>  数组名 [ ][ ];
示例：
	int [ ][ ] scores;   //定义二维数组
	scores=new int[5][50];  //分配内存空间
	或者
	int [ ][ ] scores = new int[5][50];

注意：定义二维数组时，要定义最大维数
	二维数组本质上仍是一个一维数组，只是它的每个元素又是一个一维数组

二维数组例图：int[][] s =new int[3] [5];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TBaRhMAh-1632835337896)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1616987360084.png)]

二维数组定义:

定义并赋值
写法一
	int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};

写法二
	int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

写法三
    int[][] scores ={{4},{5,78,18,13,78},{45,788}};

第六章：循环进阶

什么是二重循环：

一个循环体内又包含另一个完整的循环结构 

外层循环变量变化一次，内层循环变量要变化一遍

利用二重循环实现九九乘法表:

for (int i = 1; i <=9; i++) {
            for (int j = 1; j<=i; j++) {
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println("");
}

什么是冒泡排序?

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它通过将相邻元素进行比较和交换，逐步将一个无序序列排列为一个有序序列。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法实现原理？

冒泡排序算法的运作如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

核心思想：两层比较

冒泡排序速记口诀（升序）

N 个数字来排队
两两相比小靠前
外层循环 N-1
内层循环 N-1-I

每次比较相邻两数
小的交换到前面
每轮结束后最大的数交换到最后

冒泡排序代码示例：

public static void main(String[] args) {
        int[] scores = {16, 25, 9, 90, 23};
        for (int i = 0; i < scores.length - 1; i++) {
            for (int j = 0; j < scores.length - 1 - i; j++) {
                if (scores[j] > scores[j + 1]) {
                    // 交换元素
                    int temp = scores[j];
                    scores[j] = scores[j + 1];
                    scores[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡排序后：");
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
   
    	/*for (int score : scores) {
            System.out.println(score);
        }*/
    
}

嵌套/双层循环中的continue和break详解

大部分直到在一层循环中continue和break的作用，其作用为：
		continue：跳过这次循环，直接开始下一次循环
        break：直接结束循环
        
但在嵌套循环中，却不清楚这两的作用范围：
	1:continue在嵌套循环中：
			内层的continue直接跳过了其之下的内层代码，直接开始了下一次的内层循环
	2:break在嵌套循环中：
   			 break使得内层循环直接提取结束，直接就开始了下一次的外循环
   		 
嵌套循环中的break和continue都只对一层循环起作用，用在内层循环时，只对内层循环其作用，对外层循环无影响。   		 

																																						作者：花花

for (int j = 0; j < scores.length - 1 - i; j++) {
if (scores[j] > scores[j + 1]) {
// 交换元素
int temp = scores[j];
scores[j] = scores[j + 1];
scores[j + 1] = temp;
}
}
}
System.out.println(“冒泡排序后：”);
for (int i = 0; i < scores.length; i++) {
System.out.println(scores[i]);
}

	/*for (int score : scores) {
        System.out.println(score);
    }*/

}

##### 嵌套/双层循环中的continue和break详解

大部分直到在一层循环中continue和break的作用，其作用为：
continue：跳过这次循环，直接开始下一次循环
break：直接结束循环

但在嵌套循环中，却不清楚这两的作用范围：
1:continue在嵌套循环中：
内层的continue直接跳过了其之下的内层代码，直接开始了下一次的内层循环
2:break在嵌套循环中：
break使得内层循环直接提取结束，直接就开始了下一次的外循环

嵌套循环中的break和continue都只对一层循环起作用，用在内层循环时，只对内层循环其作用，对外层循环无影响。

作者：花花																																			

?