From 430a1c54a29c6d2bf17f0b406ab1924d6f1926a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E5=BF=B5=E5=BF=B5?= <2324752546@qq.com>
Date: Mon, 5 Dec 2022 20:17:03 +0800
Subject: [PATCH 1/4] =?UTF-8?q?=E7=AC=AC=E4=BA=94=E6=AC=A1=E6=8F=90?=
 =?UTF-8?q?=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...47\345\210\266\350\257\255\345\217\245.md" | 339 ++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 "47 \346\235\216\345\277\265\345\277\265/20221205 Java\346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245.md"

diff --git "a/47 \346\235\216\345\277\265\345\277\265/20221205 Java\346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245.md" "b/47 \346\235\216\345\277\265\345\277\265/20221205 Java\346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245.md"
new file mode 100644
index 0000000..e0fa454
--- /dev/null
+++ "b/47 \346\235\216\345\277\265\345\277\265/20221205 Java\346\265\201\347\250\213\346\216\247\345\210\266\350\257\255\345\217\245.md"	
@@ -0,0 +1,339 @@
+# 笔记：
+
+## 一、if语句格式：
+
+### 格式1：
+
+```
+if (关系表达式) {
+    语句体;	
+}
+```
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体
+
+③如果关系表达式的值为false就不执行语句体
+
+④继续执行后面的语句内容
+
+示例：
+
+```java
+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：
+
+```
+格式：
+if (关系表达式) {
+    语句体1;	
+} else {
+    语句体2;	
+}
+```
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体1
+
+③如果关系表达式的值为false就执行语句体2
+
+④继续执行后面的语句内容
+
+示例：奇偶数
+
+​	任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+```java
+public class Demo2If {
+	public static void main(String[] args) {
+		// 程序判断一个数, 是奇数还是偶数
+		int num = 9;
+		
+		if(num % 2 == 0){
+			System.out.println("偶数");
+		}else{
+			System.out.println("奇数");
+		}
+	}
+}
+```
+
+### 格式3(理解)：
+
+```
+格式：
+if (关系表达式1) {
+    语句体1;	
+} else if (关系表达式2) {
+    语句体2;	
+} 
+…
+else {
+    语句体n+1;
+}
+```
+
+执行流程：
+
+①首先计算关系表达式1的值
+
+②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+④…
+
+⑤如果没有任何关系表达式为true，就执行语句体n+1。
+
+示例：
+
+​	定义一个在0~100之间的变量a, 90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油
+
+```java
+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.分支语句switch语句：
+
+格式：
+
+```java
+switch (表达式) {
+	case 1:
+		语句体1;
+		break;
+	case 2:
+		语句体2;
+		break;
+	...
+	default:
+		语句体n+1;
+		break;
+}
+
+```
+
+执行流程： 
+
+1、首先计算出表达式的值 
+
+2、其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结 束。 
+
+3、最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+### 2.switch语句case穿透
+
+概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透 
+
+需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日 
+
+示例代码：
+
+```java
+public static void main(String[] args){
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入星期数:");
+		int week = sc.nextInt();
+		switch(week){
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+			case 5:
+				System.out.println("工作日");
+				break;
+			case 6:
+			case 7:
+				System.out.println("休息日");
+				break;
+			default:
+				System.out.println("您的输入有误");
+				break;
+		}
+	}
+}
+```
+
+# 三、for循环：
+
+#### 循环：
+
+循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环 体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循 环，否则循环将一直执行下去，形 成死循环。
+
+#### 格式：
+
+```java
+for (初始化语句;条件判断语句;条件控制语句) {
+	循环体语句;
+}
+
+```
+
+#### 格式解释：
+
+初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样 
+
+条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去 
+
+循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情 
+
+条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+#### 执行流程：
+
+①执行初始化语句 
+
+②执行条件判断语句，看其结果是true还是false 
+
+​		如果是false，循环结束 
+
+​		如果是true，继续执行 
+
+③执行循环体语句 
+
+④执行条件控制语句 
+
+⑤回到②继续
+
+#### 案例：
+
+输出数据1-5和5-1
+
+需求：在控制台输出1-5和5-1的数据 
+
+示例代码：
+
+```java
+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-5数据和
+
+需求：求1-5之间的数据和，并把求和结果在控制台输出 
+
+示例代码：
+
+```java
+public class ForTest02 {
+	public static void main(String[] args) {
+		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+		int sum = 0;
+		//从1开始到5结束的数据，使用循环结构完成
+		for(int i=1; i<=5; i++) {
+			//将反复进行的事情写入循环结构内部
+				// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
+			sum += i;
+			/*
+				sum += i; sum = sum + i;
+				第一次：sum = sum + i = 0 + 1 = 1;
+				第二次：sum = sum + i = 1 + 2 = 3;
+				第三次：sum = sum + i = 3 + 3 = 6;
+				第四次：sum = sum + i = 6 + 4 = 10;
+				第五次：sum = sum + i = 10 + 5 = 15;
+			*/
+		}
+		//当循环执行完毕时，将最终数据打印出来
+		System.out.println("1-5之间的数据和是：" + sum);
+	}
+}
+```
+
+本题要点： 
+
+​		今后遇到的需求中，如果带有求和二字，请立即联想到求和变量 
+
+​		求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+
+# 作业：
+
+```java
+public class a1202 {
+    public static void main(String[] args) {
+        double money = 0;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("选择您要乘坐的出租车：");
+        String car = sc.next();
+        System.out.println("您要去往的目的地距离：");
+        double jl = sc.nextDouble();
+        switch (car){
+            case"夏利":
+                if (jl > 3){
+                    money = (jl - 3)*2.1+3;
+                }else {
+                    money = 3;
+                }
+                break;
+            case "富康":
+                if (jl > 3){
+                    money = (jl - 3)*2.4+4;
+                }else {
+                    money = 4;
+                }
+                break;
+            case "桑塔纳":
+                if (jl > 3){
+                    money = (jl - 3)*2.7+5;
+                }else {
+                    money = 5;
+                }
+                break;
+        }
+        System.out.println("你所乘坐的是：" + car + "   你所行驶的公里数：" + jl + "  你需要支付的费用：" + money );
+        }
+    }
+
+```
+
-- 
Gitee


From e3c0cee6b9b9344968f02afaae0eff4a67a53728 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E5=BF=B5=E5=BF=B5?= <2324752546@qq.com>
Date: Wed, 7 Dec 2022 20:58:43 +0800
Subject: [PATCH 2/4] =?UTF-8?q?=E7=AC=AC=E5=85=AD=E6=AC=A1=E6=8F=90?=
 =?UTF-8?q?=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...022 1206 Java\345\276\252\347\216\257 .md" | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 "47 \346\235\216\345\277\265\345\277\265/2022 1206 Java\345\276\252\347\216\257 .md"

diff --git "a/47 \346\235\216\345\277\265\345\277\265/2022 1206 Java\345\276\252\347\216\257 .md" "b/47 \346\235\216\345\277\265\345\277\265/2022 1206 Java\345\276\252\347\216\257 .md"
new file mode 100644
index 0000000..e077997
--- /dev/null
+++ "b/47 \346\235\216\345\277\265\345\277\265/2022 1206 Java\345\276\252\347\216\257 .md"	
@@ -0,0 +1,49 @@
+# 笔记：
+
+### 1.while循环：
+
+~~~ Java
+while(条件){
+  循环体；
+}
+~~~
+
+（循环体内要有改变条件的机会）
+
+解释来说就是先判断条件是否满足，是则进入循环，否则进行后续语句。
+
+### 2.do...while循环：
+
+~~~ java 
+do
+{
+ <循环体语句>;
+}while(循环条件);
+~~~
+
+
+
+ 与while循环不同的是do-while循环是先进入循环，后判断条件
+
+使用do-while循环进行计算时最好先保存原始的值，后面可能会有用
+
+### 3.在不同的场景使用不同的循环：
+
+1.如果循环必须执行一次，用do-while
+
+2.其他情况用while
+
+### 4.死循环：
+
+~~~ Java
+for死循环格式 :
+for(;;){
+}
+while死循环格式 :
+while(true){
+}
+do..while死循环格式 :
+do{
+}while(true);
+~~~
+
-- 
Gitee


From bc3b9343e0339ef0014656cdd93fd78e61ab2bb9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E5=BF=B5=E5=BF=B5?= <2324752546@qq.com>
Date: Fri, 9 Dec 2022 10:37:01 +0800
Subject: [PATCH 3/4] =?UTF-8?q?=E7=AC=AC=E4=B8=83=E6=AC=A1=E6=8F=90?=
 =?UTF-8?q?=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../20221208 \346\225\260\347\273\204.md"     | 506 ++++++++++++++++++
 1 file changed, 506 insertions(+)
 create mode 100644 "47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md"

diff --git "a/47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md" "b/47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md"
new file mode 100644
index 0000000..fb05ea7
--- /dev/null
+++ "b/47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md"	
@@ -0,0 +1,506 @@
+# 笔记：
+
+### 1.1 数组介绍
+
+ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
+
+### 1.2 数组的定义格式
+
+#### 1.2.1 第一种格式
+
+ 数据类型[] 数组名
+
+ 示例：
+
+```Java
+int[] arr;        
+double[] arr;      
+char[] arr;
+```
+
+#### 1.2.2 第二种格式
+
+ 数据类型 数组名[]
+
+ 示例：
+
+```Java
+int arr[];
+double arr[];
+char arr[];
+```
+
+### 1.3 数组的动态初始化
+
+#### 1.3.1 什么是动态初始化
+
+ 数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+#### 1.3.2 动态初始化格式
+
+```Java
+数据类型[] 数组名 = new 数据类型[数组长度];
+int[] arr = new int[3];
+```
+
+#### 1.3.3 动态初始化格式详解
+
+- 等号左边：
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - arr:代表数组的名称
+- 等号右边：
+  - new:为数组开辟内存空间
+  - int:数组的数据类型
+  - []:代表这是一个数组
+  - 5:代表数组的长度
+
+**代码 :**
+
+```Java
+package com.itheima.array;
+
+public class Demo2Array {
+    /*
+        数组的动态初始化:
+                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
+
+        动态初始化格式:
+                        数据类型[] 数组名 = 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.4 数组元素访问
+
+#### 1.4.1 什么是索引
+
+ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
+
+#### 1.4.2访问数组元素格式
+
+```
+数组名[索引];
+```
+
+#### 1.4.3示例代码
+
+```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.5 内存分配
+
+#### 1.5.1 内存概述
+
+ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。
+
+ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
+
+ 必须放进内存中才能运行，运行完毕后会清空内存。
+
+ Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
+
+#### 1.5.2 java中的内存分配
+
+- 目前我们只需要记住两个内存，分别是：栈内存和堆内存
+
+| 区域名称   | 作用                                                       |
+| ---------- | ---------------------------------------------------------- |
+| 寄存器     | 给CPU使用，和我们开发无关。                                |
+| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关。          |
+| 方法区     | 存储可以运行的class文件。                                  |
+| 堆内存     | 存储对象或者数组，new来创建的，都存储在堆内存。            |
+| 方法栈     | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 |
+
+###  1.9 数组的静态初始化
+
+#### 1.9.1 什么是静态初始化
+
+ 在创建数组时，直接将元素确定
+
+#### 1.9.2 静态初始化格式
+
+- 完整版格式
+
+  ```
+  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+  ```
+
+- 简化版格式
+
+  ```Java
+  数据类型[] 数组名 = {元素1,元素2,...};
+  ```
+
+#### 1.9.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.10 数组操作的两个常见问题
+
+#### 1.10.1 索引越界异常
+
+- 出现原因
+
+  ```java
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+          System.out.println(arr[3]);
+      }
+  }
+  ```
+
+  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+
+  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+- 解决方案
+
+  将错误的索引修改为正确的索引范围即可！
+
+#### 1.10.2 空指针异常
+
+- 出现原因
+
+  ```java
+  public class ArrayDemo {
+      public static void main(String[] args) {
+          int[] arr = new int[3];
+  
+          //把null赋值给数组
+          arr = null;
+          System.out.println(arr[0]);
+      }
+  }
+  ```
+
+  
+
+  arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+- 解决方案
+
+  给数组一个真正的堆内存空间引用即可！
+
+### 1.11 数组遍历
+
+- 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
+
+  ```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 ，可以作为循环的条件出现。
+
+  ```java
+  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]);
+          }
+      }
+  }
+  ```
+
+### 1.12 数组获取最大值
+
+- 最大值获取：从数组的所有元素中找出最大值。
+
+- 实现思路：
+
+  - 定义变量，保存数组0索引上的元素
+  - 遍历数组，获取出数组中的每个元素
+  - 将遍历到的元素和保存数组0索引上值的变量进行比较
+  - 如果数组元素的值大于了变量的值，变量记录住新的值
+  - 数组循环遍历结束，变量保存的就是数组中的最大值
+
+- 代码实现：
+
+  ```java
+  package com.itheima.test;
+  
+  import java.util.Scanner;
+  
+  public class Test2Array {
+      /*
+          需求: 从数组中查找最大值
+  
+                  int[] arr = {12,45,98,73,60};
+  
+          实现步骤:
+                  1. 假设数组中的第一个元素为最大值
+                  2. 遍历数组, 获取每一个元素, 准备进行比较
+                  3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
+                  4. 循环结束后, 打印最大值.
+       */
+      public static void main(String[] args) {
+          int[] arr = {12,45,98,73,60};
+          // 1. 假设数组中的第一个元素为最大值
+          int max = arr[0];
+          // 2. 遍历数组, 获取每一个元素, 准备进行比较
+          for(int i = 1; i < arr.length; i++){
+              // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
+              if(arr[i] > max){
+                  max = arr[i];
+              }
+          }
+          //  4. 循环结束后, 打印最大值.
+          System.out.println("max:" + max);
+      }
+  }
+  ```
+
+### 1.13 数组元素求和
+
+- 需求：键盘录入5个整数，存储到数组中，并对数组求和
+
+- 思路： 1.创建键盘录入对象，准备键盘录入 2.定义一个求和变量，准备记录累加后的结果 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值 4.将键盘录入的数值存储到数组中 5.遍历数组，取出每一个元素，并求和 6.输出总和
+
+- 代码实现：
+
+  ```java
+  package com.itheima.test;
+  
+  import java.util.Scanner;
+  
+  public class Test3Array {
+      /*
+          需求：键盘录入5个整数，存储到数组中，并对数组求和
+  
+          思路：
+              1.创建键盘录入对象，准备键盘录入
+              2.定义一个求和变量，准备记录累加后的结果
+              3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+              4.将键盘录入的数值存储到数组中
+              5.遍历数组，取出每一个元素，并求和
+              6.输出总和
+       */
+      public static void main(String[] args) {
+          // 1.创建键盘录入对象，准备键盘录入
+          Scanner sc = new Scanner(System.in);
+          // 2.定义一个求和变量，准备记录累加后的结果
+          int sum = 0;
+          // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
+          int[] arr = new int[5];
+          // 4.将键盘录入的数值存储到数组中
+          for(int i = 0; i < arr.length; i++){
+              System.out.println("请输入第" + (i+1) + "个整数:");
+              //arr[i] = 10;
+              arr[i] = sc.nextInt();
+          }
+  
+          // 5.遍历数组，取出每一个元素，并求和
+          for (int i = 0; i < arr.length; i++) {
+              sum += arr[i];
+          }
+  
+          // 6.输出总和
+          System.out.println("sum:" + sum);
+  
+      }
+  }
+  ```
+
+### 1.14 数组基本查找【应用】
+
+- 需求： 已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控 制台输出找到的索引值。
+
+- 思路： 1.定义一个数组，用静态初始化完成数组元素的初始化 2.键盘录入要查找的数据，用一个变量接收 3.定义一个索引变量，初始值为-1 4.遍历数组，获取到数组中的每一个元素 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环 6.输出索引变量
+
+- 代码实现：
+
+  ```java
+  public static void main(String[] args) {
+          // 1.定义一个数组，用静态初始化完成数组元素的初始化
+          int[] arr = {19, 28, 37, 46, 50};
+          // 2.键盘录入要查找的数据，用一个变量接收
+          Scanner sc = new Scanner(System.in);
+          System.out.println("请输入您要查找的元素:");
+          int num = sc.nextInt();
+          // 3.定义一个索引变量，初始值为-1
+          // 假设要查找的数据, 在数组中就是不存在的
+          int index = -1;
+          // 4.遍历数组，获取到数组中的每一个元素
+          for (int i = 0; i < arr.length; i++) {
+              // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
+              if(num == arr[i]){
+                  // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
+                  index = i;
+                  break;
+              }
+          }
+          //  6.输出索引变量
+          System.out.println(index);
+      }
+  }
+  ```
+
+  # 作业：
+
+  ### 1.
+
+  ~~~ Java
+  public class guess {
+      public static void main(String[] args) {
+          Random r = new Random();
+          Scanner sc = new Scanner(System.in);
+          int randomNum = r.nextInt(100)+1;
+          while (true){
+              System.out.println("请输入您猜的数字");
+              int num = sc.nextInt();
+              if(num>randomNum){
+                  System.out.println("猜大了");
+              }else if (num<randomNum) {
+                  System.out.println("猜小了");
+              }else {
+                  System.out.println("恭喜你猜对了");
+                  break;
+              }
+          }
+          System.out.println("感谢您的使用");
+      }
+  }
+  
+  ~~~
+
+   
+
+### 2.
+
+~~~ Java
+public class max {
+    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 c = arr[a];
+            arr[a]=arr[b];
+            arr[b]=c;
+        }
+        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);
+    }
+}
+   
+~~~
+
-- 
Gitee


From fef27a2c507dc8eabe4281afc4f0756c3e0939df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E5=BF=B5=E5=BF=B5?= <2324752546@qq.com>
Date: Mon, 12 Dec 2022 20:22:28 +0800
Subject: [PATCH 4/4] =?UTF-8?q?=E4=BD=9C=E4=B8=9A=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../20221208 \346\225\260\347\273\2041.md"    |   0
 .../20221209 \346\225\260\347\273\2042.md"    | 186 ++++++++++++++++++
 2 files changed, 186 insertions(+)
 rename "47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md" => "47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\2041.md" (100%)
 create mode 100644 "47 \346\235\216\345\277\265\345\277\265/20221209 \346\225\260\347\273\2042.md"

diff --git "a/47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md" "b/47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\2041.md"
similarity index 100%
rename from "47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\204.md"
rename to "47 \346\235\216\345\277\265\345\277\265/20221208 \346\225\260\347\273\2041.md"
diff --git "a/47 \346\235\216\345\277\265\345\277\265/20221209 \346\225\260\347\273\2042.md" "b/47 \346\235\216\345\277\265\345\277\265/20221209 \346\225\260\347\273\2042.md"
new file mode 100644
index 0000000..75ebf9c
--- /dev/null
+++ "b/47 \346\235\216\345\277\265\345\277\265/20221209 \346\225\260\347\273\2042.md"	
@@ -0,0 +1,186 @@
+# 笔记：
+
+## 1.随机数：Random
+
+**1.1 概述**
+
+大家都看过电视上面抽奖的画面吧，主持人一声令下，大屏幕的数据开始滚动，随机选择一个号码，所以Random用于产生一个随机数。
+
+**1.2 使用步骤(和 Scanner 类似)**
+
+导包
+import java.util.Random;
+
+创建对象
+
+Random r = new Random();
+
+获取随机数
+int number = r.nextInt(10);
+
+产生的数据在 0 到 10 之间，包括 0，不包括 10。
+
+括号里面的 10 是可以变化的，如果是 100，就是 0-100 之间的数据。
+
+## 2.遍历数组：
+
+**2.1第一种方法（传统方法）**
+
+~~~ Java
+int a[]={1,2,3,4,5};
+for(int i=0;i<a.length;i++){
+System.out.println(a[i]);
+}
+1
+2
+3
+4
+~~~
+
+**2.2第二种方法（非传统方法）**
+
+~~~ Java
+int a[]= {1,2,3,4,5};
+for(int i:a){
+System.out.println(i);
+}
+1
+2
+3
+4
+~~~
+
+***注意：其中i的数据类型要和数组a的数组类型保持一致。***
+
+**2.3第三种方法（利用Arrays类中的toString()方法）**
+
+~~~ Java
+int a[]= {1,2,3,4,5};
+System.out.println(Arrays.toString(a));
+~~~
+
+## 3.数组最值问题：
+
+**求最大值：**
+先设置一个变量max，假设数组【0】号最大，并且存放在max中，然后与数组中的其他元素每一个都比较一下，若比max大，则将arr【i】赋值给max，以此类推得到最大值
+**求最小值：**
+设置一个变量min，假设数组假设数组【0】号最小，并且存放在min中，然后与数组中的其他元素每一个都比较一下，若比min还小，则将arr【i】赋值给min，以此类推得到最小值
+
+## 4.数组求和：
+
+看到数组求和就要想到**+=**（加等）
+
+~~~ java
+public static void main(String[] args) {
+
+    //定义一个静态初始化
+    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    
+    //再定义一个数据用来接收最后的和
+    int sum = 0;
+    //for循环遍历每个数组中的元素
+    for (int x = 0; x < arr.length; x++) {
+        //+=运算符求出结果
+        sum += x;
+    }
+    //打印最终结果
+    System.out.println(sum);
+   }
+ }
+
+~~~
+
+
+
+## 5.数组取平均值：
+
+一般情况下对数组计算均值，可以采用对数组求和，再除以数组长度。
+
+实现代码：
+
+~~~ Java
+public double doubleArrAverage(double[] arr) {
+		double sum = 0;
+		for(int i = 0;i < arr.length; i++) {
+			sum += arr[i];
+		}
+		return sum / arr.length;
+	}
+~~~
+
+但其中存在最大问题就是数组求和，如果数组内元素值较大或者数组元素非常多，很有可能出现内存溢出。解决这种问题，一种方法是采用每个元素除以数组长度，再对结果求和。
+
+实现代码：
+
+~~~ Java
+public double doubleArrage(double[] arr) {
+		double result = 0;
+		for(int i = 0;i < arr.length; i++) {
+			result += arr[i] / arr.length;
+		}
+		return result;
+	}
+~~~
+
+另一种方法是，假定数组长度是动态的，当存在一个元素时，均值ave即为当前数组值arr[0]。当加入第二个个元素，第二个元素减去均值ave，得到的差值除以数组长度，再与均值ave相加，即可得到数组均值。以此类推，直到数组所有元素参与计算，也就完成了整个数组均值计算。
+
+实现代码：
+
+~~~ Java
+public double doubleArrage(double[] arr) {
+		double result = arr[0];
+		for(int i = 1;i < arr.length; i++) {
+			double temp = arr[i];
+			result += (temp - result) / (i + 1);
+		}
+		return result;
+	}
+~~~
+
+
+
+# 作业：
+
+```java
+import java.util.Random;
+
+public class zuoye2 {
+        public static void main(String[] args) {
+//        闽大举行选美比赛，男生参赛，10个女生当评委，
+//        定义一个数组，存放评分，用随机数模拟打分的过程，
+//        用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】
+            Random r = new Random();
+            int[] girl = new int[10];
+            //把随机数放入数组
+            for (int i = 0; i < girl.length; i++) {
+                girl[i] = r.nextInt(100) + 1;
+            }
+            //遍历数组
+            for (int i = 0; i < girl.length; i++) {
+                System.out.println(girl[i]);
+            }
+            //找到最大值
+            int max = girl[0];
+            for (int i = 1; i < girl.length; i++) {
+                if(girl[i] > max){
+                    max=girl[i];
+                }
+            }
+            //找到最小值
+            int min = girl[0];
+            for (int i = 1; i < girl.length; i++) {
+                if(girl[i] < min){
+                    min=girl[i];
+                }
+            }
+            //求和
+            int sum = girl[0];
+            for (int i = 1; i < girl.length; i++) {
+                sum += girl[i];
+            }
+            //取平均
+            int pj = (sum - max - min) / (girl.length - 2);
+            System.out.println("评委打分的平均值为" + pj + "分");
+        }
+    }
+```
\ No newline at end of file
-- 
Gitee