diff --git "a/14 \345\256\213\345\256\217\346\211\254/20221203\345\205\263\344\272\216if\350\257\255\345\217\245\345\222\214switch\345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\347\254\224\350\256\260.md" "b/14 \345\256\213\345\256\217\346\211\254/20221203\345\205\263\344\272\216if\350\257\255\345\217\245\345\222\214switch\345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f68f176ae724cf319ef44785c296132feb59a4d2
--- /dev/null
+++ "b/14 \345\256\213\345\256\217\346\211\254/20221203\345\205\263\344\272\216if\350\257\255\345\217\245\345\222\214switch\345\210\206\346\224\257\347\273\223\346\236\204\347\232\204\347\254\224\350\256\260.md"	
@@ -0,0 +1,150 @@
+## 流程控制语句
+
+- ##### 分支结构（if，switch）
+
+- ##### 循环结构（for,while,do...while）
+
+### 分支结构
+
+- #### if语句
+
+  1. 格式
+
+     ```java
+     //格式1    判断是否满足条件，满足则执行语句体，不满足则不执行语句体，继续执行后面的语句
+     if (关系表达式) {
+     	语句体；
+     }
+     
+     //格式2    判断是否满足条件，满足则执行语句体1，不满足则执行语句体2，继续执行后面的语句
+     if (关系表达式) {
+         语句体1；
+     } else {
+         语句体2；
+     }
+     
+     //格式3    判断是否满足表达式1，满足则执行语句体1，不满足则判断是否满足表达式2，满足则执行语句体2，不满足继续往下判断，最后若不满足任何一个表达式则执行语句体n+1
+     if (关系表达式1) {
+         语句体1;	
+     } else if (关系表达式2) {
+         语句体2;	
+     } 
+     …
+     else {
+         语句体n+1;
+     }
+     ```
+
+  2. 示例
+
+     ```java
+     //格式1示例：判断年龄是否18，18则可以上网吧
+     public class IfDemo {
+     	public static void main(String[] args) {
+     		System.out.println("开始");
+             
+     		// 如果年龄大于18岁, 就可以上网吧
+     		int age = 17;
+     		
+     		if(age >= 18){
+     			// int a = 10;
+     			System.out.println("可以上网吧");
+     		}
+     			
+     		System.out.println("结束");
+     	}
+     }
+     
+     //格式2示例：判断奇偶数
+     public class Demo2If {
+     	public static void main(String[] args) {
+     		// 程序判断一个数, 是奇数还是偶数
+     		int num = 9;
+     		
+     		if(num % 2 == 0){
+     			System.out.println("偶数");
+     		}else{
+     			System.out.println("奇数");
+     		}
+     	}
+     }
+     
+     //格式3示例：判断成绩再哪个范围，90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油！
+     public class Demo3If {
+     	public static void main(String[] args){
+     		int score = 65;
+     		if(score >= 90 && score <= 100){
+     			System.out.println("优秀");
+     		}else if (score >= 80 && score <= 89){
+     			System.out.println("良好");
+     		}else if (score >= 70 && score <= 79){
+     			System.out.println("中等");
+     		}else if (score >= 60 && score <= 69){
+     			System.out.println("及格");
+     		}else if (score >= 0 && score <= 59){
+     			System.out.println("请努力加油");
+     		}else{
+     			System.out.println("成绩有误!");
+     		}
+     	}
+     }
+     ```
+
+- #### switch语句
+
+  1. 格式
+
+     ```java
+     switch (表达式) {
+     	case 1:
+     		语句体1;
+     		break;
+     	case 2:
+     		语句体2;
+     		break;
+     	...
+     	default:
+     		语句体n+1;
+     		break;
+     }
+     ```
+
+  2. 示例
+
+     ```java
+     public static void main(String[] args){
+     // 1. 键盘录入星期数据，使用变量接收
+     	Scanner sc = new Scanner(System.in);
+     	System.out.println("请输入");
+     	int week = sc.nextInt();
+     	// 2. 多情况判断，采用switch语句实现
+     	switch(week){
+     	// 3. 在不同的case中，输出对应的减肥计划
+     		case 1:
+     			System.out.println("跑步");
+     			break;
+             case 2:
+     			System.out.println("游泳");
+     			break;
+     		case 3:
+     			System.out.println("慢走");
+     			break;
+     		case 4:
+     			System.out.println("动感单车");
+     			break;
+             case 5:
+                 System.out.println("拳击");
+                 break;
+             case 6:
+                 System.out.println("爬山");
+                 break;
+     		case 7:
+                 System.out.println("好好吃一顿");
+                 break;
+     		default:
+                 System.out.println("您的输入有误");
+                 break;
+     		}
+     	}
+     }
+     ```
\ No newline at end of file
diff --git "a/14 \345\256\213\345\256\217\346\211\254/20221206\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md" "b/14 \345\256\213\345\256\217\346\211\254/20221206\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..df2c9266252b0262565aa448135d6b47c2ed4b5a
--- /dev/null
+++ "b/14 \345\256\213\345\256\217\346\211\254/20221206\345\205\263\344\272\216for\345\276\252\347\216\257\343\200\201while\345\276\252\347\216\257\345\222\214do...while\347\232\204\347\254\224\350\256\260.md"	
@@ -0,0 +1,152 @@
+## for循环
+
+- 格式
+
+  ```java
+  for (初始化语句;条件判断语句;条件控制语句){
+  	循环语句体;
+  }
+  //初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+  //条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+  //循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+  //条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出1-5和5-1的数据
+  public class ForTest01 {
+  	public static void main(String[] args) {
+  		//需求：输出数据1-5
+  		for(int i=1; i<=5; i++) {
+  			System.out.println(i);
+  		}
+  		System.out.println("--------");
+  		//需求：输出数据5-1
+  		for(int i=5; i>=1; i--) {
+  			System.out.println(i);
+  		}
+  	}
+  }
+  
+  //需求：输出1-100之间的偶数和
+  public class ForTest01 {
+  	public static void main(String[] args) {
+          int num = 0;  //定义变量接收数据和
+          for(int i = 1; i <= 100; i++){   //循环
+              if(i % 2 == 0){              //if语句判断是否为偶数
+                  num += i;                //是偶数就加起来
+              }
+          }
+          System.out.print("1-100之间的偶数和为：" + num);  //输出值
+      }
+  }
+  
+  //需求：输出所有的水仙花数，每行输出两个
+  public class S1 {
+      public static void main(String[] args) {
+          int a = 0;  //接收水仙花数输出次数
+          for (int i = 100; i <= 1000; i++){
+              int ge = i % 10;            //求出个位上的值
+              int shi = i / 10 % 10;      //求出十位上的值
+              int bai = i / 100 % 10;     //求出百位上的值
+              if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
+                  System.out.print(i + " ");  //输出水仙花数
+                  a++;                        //每输出一次a+1
+                  if (a % 2 == 0){            //每当输出两次就换行
+                      System.out.println();
+                  }
+              }
+          }
+      }
+  }
+  ```
+
+- 注意：
+
+  println：是输出后换行
+
+  print：输出后不换行
+
+## while循环
+
+- 格式
+
+  ```java
+  初始化语句;
+  while (条件判断语句){
+      循环语句体;
+      条件控制语句;
+  }
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出5次"HelloWorld"
+  public class WhileDemo {
+  	public static void main(String[] args) {
+  	//for循环实现
+  	for(int i=1; i<=5; i++) {
+  		System.out.println("HelloWorld");
+  	}
+  	System.out.println("--------");
+  	//while循环实现
+  	int j = 1;
+  	while(j<=5) {
+  		System.out.println("HelloWorld");
+  		j++;
+  		}
+  	}
+  }
+  
+  //需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
+  public class S1 {
+      public static void main(String[] args) {
+          int ci = 0; //定义计数器，计算折叠几次，初始值为0
+          double zhi = 0.1;  //定义纸张厚度
+          int shan = 8844430;  //定义珠穆朗玛峰高度
+          while (shan >= zhi){
+              zhi *= 2;
+              ci++;
+          }
+          System.out.println("纸张需要折" + ci + "次才能和珠穆朗玛峰一样高");
+      }
+  }
+  ```
+
+## do...while循环
+
+- 格式
+
+  ```java
+  初始化语句;
+  do {
+      循环语句体;
+      条件控制语句;
+  }while(条件判断语句);
+  ```
+
+- 案例
+
+  ```java
+  //需求：在控制台输出5次"HelloWorld"
+  public class DoWhileDemo {
+  	public static void main(String[] args) {
+  		//for循环实现
+  		for(int i=1; i<=5; i++) {
+  			System.out.println("HelloWorld");
+      	}
+  		System.out.println("--------");
+  		//do...while循环实现
+  		int j = 1;
+  		do {
+  			System.out.println("HelloWorld");
+  			j++;
+  		}while(j<=5);
+  	}
+  }
+  ```
+
+  
\ No newline at end of file
diff --git "a/14 \345\256\213\345\256\217\346\211\254/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md" "b/14 \345\256\213\345\256\217\346\211\254/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..df5201d0d735d60b1567a7ebac144b3938d4913b
--- /dev/null
+++ "b/14 \345\256\213\345\256\217\346\211\254/20221208\345\205\263\344\272\216\351\232\217\346\234\272\346\225\260\344\270\216\346\225\260\347\273\204\347\232\204\347\254\224\350\256\260\345\222\214\344\275\234\344\270\232.md"	
@@ -0,0 +1,310 @@
+## 跳转循环
+
+- 跳转控制语句（break）：跳出循环，结束循环
+
+- 跳转控制语句（continue）：跳过本次循环，继续下次循环
+
+- 示例
+
+  ```java
+  public class S1 {
+  	/*
+  		break : 终止循环体内容的执行
+  		注意：使用是基于条件控制的
+  		break语句只能在循环和switch中进行使用.
+  		需求: 模拟20岁工作到80岁, 60岁退休.
+  	*/
+  	public static void main(String[] args){
+  		for(int i = 20; i <= 80; i++){
+  			if(i == 60){
+  				break; // 结束整个循环
+  			}
+  			System.out.println(i + "岁正在上班");
+  		}
+  	}
+  }
+  
+  
+  public class S1 {
+  	/*
+  		continue : 跳过某次循环体内容的执行
+  		注意：使用是基于条件控制, 在循环内部使用.
+  		需求: 模拟电梯上行的过程 1-24层, 4层不停.
+  	*/
+  	public static void main(String[] args){
+  		for(int i = 1; i <= 24; i++){
+  			if(i == 4){
+  				continue;
+  			}
+  			System.out.println(i + "层到了~");
+  		}
+  	}
+  }
+  ```
+
+## 随机数
+
+- 使用步骤
+
+  1. 导入Random包：import java.util.Random;
+
+  2. 创建对象：Random r = new Random();
+
+  3. 产生随机数：int num = r.nextInt(10);【10代表的时随机数的范围为0到9，即不包括所输入的数】
+
+  4. 示例
+
+     ```java
+     import java.util.Random;
+     public class S1 {
+     	/*
+     		Random : 产生随机数
+     		1. 导包 : import java.util.Random;
+     		导包的动作必须出现在类定义的上面
+     		2. 创建对象 : Random r = new Random();
+     		上面这个格式里面，r 是变量名，可以变，其他的都不允许变
+     		3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包
+     		括0,不包括10
+     		上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变
+     		需求: 产生随机数1-10之间的
+     	*/
+     	public static void main(String[] args){
+     	// 2. 创建对象
+     		Random r = new Random();
+     		for(int i = 1; i <= 10; i++){
+     		// 3. 获取随机数
+     			int num = r.nextInt(10) + 1; // 1-10
+     			System.out.println(num);
+     		}
+     	}
+     }
+     ```
+
+## 数组
+
+- 格式
+
+  ```java
+  //第一种格式：数据类型 [] 数组名
+  //示例
+  int[] arr;
+  double[] arr;
+  char[] arr;
+  
+  //第二种格式：数据类型 数组名 []
+  //示例
+  int arr[];
+  double arr[];
+  char arr[];
+  ```
+
+- 数组的动态初始化
+
+  1. 定义：数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+  2. 格式
+
+     ```java
+     //数据类型[] 数组名 = new 数据类型[数组长度];
+     int[] arr = new int[3];
+     //等号左边{int:数组的数据类型、[]:代表这是一个数组、arr:代表数组的名称}
+     //等号右边{new:为数组开辟内存空间、int:数组的数据类型、[]:代表这是一个数组、3:代表数组的长度}
+     ```
+
+  3. 示例
+
+     ```java
+     package com.itheima.array;
+     public class S1 {
+         /*
+             数组的动态初始化:
+                             在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
+             动态初始化格式:
+                             数据类型[] 数组名 = new 数据类型[数组的长度];
+             注意:
+                             打印数组变量的时候, 会打印出数组的内存地址
+             [I@10f87f48 :
+                             @ : 分隔符
+                             [ : 当前的空间是一个数组类型
+                             I : 当前数组容器中所存储的数据类型
+                             10f87f48 : 十六进制内存地址
+                                     0 1 2 3 4 5 6 7 8 9 a b c d e f
+          */
+         public static void main(String[] args) {
+             // 数据类型[] 数组名 = new 数据类型[数组的长度];
+             // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
+             int[] arr = new int[5];
+             // [I@10f87f48
+             System.out.println(arr);
+             byte[] bArr = new byte[3];
+             // [B@b4c966a
+             System.out.println(bArr);
+         }
+     }
+     ```
+  
+- 数组的静态初始化
+
+  1. 定义：在创建数组时，直接将元素确定
+
+  2. 格式
+  
+     ```java
+     //完整格式
+     	数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+     //简化
+         数据类型[] 数组名 = {元素1,元素2,...}
+     ```
+  
+  3. 示例
+  
+     ```java
+     package com.itheima.array2;
+     public class Demo1Array {
+         /*
+             数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
+     
+             完整格式:
+                         数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+             简化格式:
+                         数据类型[] 数组名 = {数据1,数据2,数据3...};
+          */
+         public static void main(String[] args) {
+             // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+             int[] arr = new int[]{11,22,33};
+             System.out.println(arr[0]);
+             System.out.println(arr[1]);
+             System.out.println(arr[2]);
+             // 数据类型[] 数组名 = {数据1,数据2,数据3...};
+             int[] arr2 = {44,55,66};
+             System.out.println(arr2);
+             System.out.println(arr2[0]);
+             System.out.println(arr2[1]);
+             System.out.println(arr2[2]);
+         }
+     }
+     ```
+  
+- 数组元素访问
+
+  1. 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 
+
+     ```java
+     //格式
+     数组名[索引];
+     ```
+
+  2. 示例
+
+     ```java
+     package com.itheima.array;
+     public class Demo3ArrayIndex {
+         /*
+             数组动态初始化:
+                     初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
+             数组的元素访问格式:
+                     数组名[索引]
+                     索引: 数组中数据的编号方式, 编号从0开始
+                     作用: 访问数组容器中的空间位置
+             注意:
+                     数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
+          */
+         public static void main(String[] args) {
+             int[] arr = new int[3];         // 0 1 2
+             System.out.println(arr);        // 数组的内存地址  [I@10f87f48
+             // 数组名[索引]  访问数组容器中的空间位置
+             System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
+             System.out.println(arr[1]);
+             System.out.println(arr[2]);
+             System.out.println("--------------");
+             // 数组名[索引]
+             arr[0] = 11;
+             arr[1] = 22;
+             arr[2] = 33;
+             System.out.println(arr[0]);
+             System.out.println(arr[1]);
+             System.out.println(arr[2]);
+         }
+     }
+     ```
+
+## 作业
+
+1. 猜大小
+
+   ```java
+   import java.util.Random;
+   import java.util.Scanner;
+   public class 猜大小 {
+       public static void main(String[] args) {
+           Random ran = new Random();
+           Scanner sc = new Scanner(System.in);
+           Scanner tb = new Scanner(System.in);
+           int rnum =ran.nextInt(90)+10;
+           int cishu = 0;
+           while(true){
+               System.out.println("请输入您所猜的数：");
+               int snum = sc.nextInt();
+               if (snum > rnum){
+                   System.out.println("猜大了！");
+                   cishu++;
+               }else if (snum < rnum){
+                   System.out.println("猜小了！");
+                   cishu++;
+               }else{
+                   System.out.println("恭喜您，猜对了！");
+                   cishu++;
+                   break;
+               }
+               if (cishu == 3){
+                   System.out.println("您已经猜错三次，请问是否投币继续（是Y/否N）");
+                   char sftb = tb.next().charAt(0);
+                   if (sftb == 89) {
+                       System.out.println("感谢您的投币，请继续！");
+                   }else if(sftb == 78){
+                       System.out.println("感谢您的参与，欢迎下次再来！");
+                       break;
+                   }else{
+                       System.out.println("输入出错，请下次再来！");
+                       break;
+                   }
+               }
+           }
+           System.out.println("您一共猜了" + cishu + "次");
+       }
+   }
+   ```
+
+2. 数组
+
+   ```java
+   import java.util.Arrays;
+   import java.util.Random;
+   public class x {
+       public static void main(String[] args) {
+           Random r = new Random();
+           int[] arr = new int[10];
+           for (int i = 0;i<arr.length;i++){
+               arr[i] = r.nextInt(41)+10;
+           }
+           System.out.println("打乱前："+Arrays.toString(arr));
+           for (int i = 0; i<arr.length;i++){
+               int a = r.nextInt(arr.length);
+               int b = r.nextInt(arr.length);
+               int t = arr[a];
+               arr[a] = arr[b];
+               arr[b] = t;
+           }
+           System.out.println("打乱后："+Arrays.toString(arr));
+           int max = arr[0];
+           for (int i = 1; i<arr.length;i++){
+               if (arr[i]>max){
+                   max = arr[i];
+               }
+           }
+           System.out.println("最大值为："+max);
+       }
+   }
+   ```
+
+   
\ No newline at end of file
diff --git "a/14 \345\256\213\345\256\217\346\211\254/20221209\345\205\263\344\272\216\346\225\260\347\273\204\351\201\215\345\216\206\347\232\204\347\254\224\350\256\260\344\270\216\344\275\234\344\270\232.md" "b/14 \345\256\213\345\256\217\346\211\254/20221209\345\205\263\344\272\216\346\225\260\347\273\204\351\201\215\345\216\206\347\232\204\347\254\224\350\256\260\344\270\216\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d5b4a846db10c6f9820a8098dd5cc031b1b20e22
--- /dev/null
+++ "b/14 \345\256\213\345\256\217\346\211\254/20221209\345\205\263\344\272\216\346\225\260\347\273\204\351\201\215\345\216\206\347\232\204\347\254\224\350\256\260\344\270\216\344\275\234\344\270\232.md"	
@@ -0,0 +1,182 @@
+## 数组操作两个常见问题
+
+1. ### 索引越界异常
+
+   - 出现原因
+
+     ```java
+     //数组的长度为3，索引范围为0-2，没有索引为3的值，因此程序运行后会抛出ArrayIndexOutOfBoundsException 数组越界异常
+     //此时将错误的索引改到正确的索引范围即可解决
+     public class ArrayDemo {
+         public static void main(String[] args) {
+             int[] arr = new int[3];
+             System.out.println(arr[3]);
+         }
+     }
+     ```
+
+2. ### 空指针异常
+
+   - 出现原因
+
+     ```java
+     //arr = null 这行代码意味着变量arr将不会保存数组的内存地址，即不允许再操作数组，因此运行时会抛出 NullPointerException 空指针异常
+     //此时给数组一个真正的堆存空间引用即可
+     public class ArrayDemo {
+         public static void main(String[] args) {
+             int[] arr = new int[3];
+             //把null赋值给数组
+             arr = null;
+             System.out.println(arr[0]);
+         }
+     }
+     ```
+
+## 数组遍历
+
+- 定义：就是将数组中的每个元素分别获取出来，遍历时数组操作中的基石
+
+- 示例
+
+  ```java
+  //每一个都输出一边，但如果数组元素非常多用这种写法就会很麻烦
+  public class ArrayTest01 {
+  	public static void main(String[] args) {
+  		int[] arr = { 1, 2, 3, 4, 5 };
+  		System.out.println(arr[0]);
+  		System.out.println(arr[1]);
+  		System.out.println(arr[2]);
+  		System.out.println(arr[3]);
+  		System.out.println(arr[4]);
+  	}
+  }
+  //循环写法，数组的索引时0到lenght-1，可以作为循环的条件出现
+  public class ArrayTest01 {
+      public static void main(String[] args) {
+          //定义数组
+          int[] arr = {11, 22, 33, 44, 55};
+  
+          //使用通用的遍历格式
+          for(int x=0; x<arr.length; x++) {
+              System.out.println(arr[x]);
+          }
+      }
+  }
+  ```
+
+- 遍历例题
+
+  ```java
+  //需求：最大值获取：从数组的所有元素中找出最大值
+  import java.util.Random;
+  import java.util.Scanner;
+  public class 数组遍历获取最大值 {
+      public static void main(String[] args) {
+          //随机数组获取最大值
+          Random ran = new Random();  
+          int[] arr = new int[5];
+          System.out.print("随机数组为：");
+          for (int i = 0;i < arr.length;i++){
+              arr[i] = ran.nextInt(90)+10;
+          }
+          for (int a = 0;a < arr.length;a++){
+              System.out.print(arr[a] + " ");
+          }
+          int max = arr[0];
+          for (int i = 1;i < arr.length;i++){
+              if (arr[i] > max){
+                  max = arr[i];
+              }
+          }
+          System.out.println();
+          System.out.println("数组中最大数为：" + max);
+          /*
+              //已知数组获取最大值
+              int[] arr = {12,45,98,73,60};
+              int max = arr[0];
+              for (int a = 0;a < arr.length;a++){
+                 System.out.print(arr[a] + " ");
+              }
+              for(int i = 1;i < arr.length;i++){
+                  if (arr[i] > max){
+                      max = arr[i];
+                  }
+              }
+              System.out.println();
+              System.out.println("最大值为" + max);
+          */
+      }
+  }
+  
+  //需求：键盘录入5个整数，存储到数组中，并对数组求和
+  import java.util.Scanner;
+  public class 求数组和 {
+      public static void main(String[] args) {
+          Scanner sc = new Scanner(System.in);
+          int sum = 0;
+          int[] arr = new int[5];
+          for (int i = 0;i < arr.length; i++){
+              System.out.println("请输入第" + (i+1) + "个整数：");
+              arr[i] = sc.nextInt();
+          }
+          for (int i = 0; i < arr.length;i++){
+              sum += arr[i];
+          }
+          System.out.println("所有数的和为：" + sum);
+      }
+  }
+  
+  //需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索	   引，并在控制台输出找到的索引值。
+  import java.util.Scanner;
+  public class 查找索引 {
+      public static void main(String[] args) {
+          int[] arr = {19,28,37,46,50};
+          System.out.print("数组中的数有：");
+          for (int a = 0;a < arr.length;a++){
+              System.out.print(arr[a] + " ");
+          }
+          Scanner sc = new Scanner(System.in);
+          System.out.println();
+          System.out.println("请输入你要查找的元素：");
+          int num = sc.nextInt();
+          int index = -1;
+          for (int i = 0;i < arr.length;i++){
+              if (num == arr[i]){
+                  index = i;
+                  break;
+              }
+          }
+          System.out.println(index);
+      }
+  }
+  
+  //需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。
+  import java.util.Scanner;
+  public class 平均分 {
+      public static void main(String[] args) {
+          Scanner sc = new Scanner(System.in);
+          int sum = 0;
+          int[] arr = new int[6];
+          for (int i = 0;i < arr.length; i++){
+              System.out.println("请输入第" + (i+1) + "位评委的打分：");
+              arr[i] = sc.nextInt();
+          }
+          for (int i = 0;i < arr.length;i++){
+              sum += arr[i];
+          }
+          int max = arr[0];
+          int min = arr[0];
+          for (int i = 1;i < arr.length;i++){
+              if (max < arr[i]){
+                  max = arr[i];
+              }
+              if (min > arr[i]){
+                  min = arr[i];
+              }
+          }
+          System.out.println("该选手平均分为：" + (sum - max - min)/4.0 + "分");
+      }
+  }
+  ```
+
+  
\ No newline at end of file