JavaSE知识总结（1）
（由思维导图转换，格式会有些错误，内容混乱，若有错误的地方，请大家帮忙改正）
Java基础
1、语言发展史
计算机语言介绍
定义：计算机编程语言就是人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能
发展史
第一代：机器语言（相当于人类的原始阶段）
第二代：汇编语言（相当于人类的手工业阶段）
第三代：高级语言（相当于人类的工业阶段）
? C、C++、JAVA、PYTHON
越来越接近人的思维，使用越来越方便
Java语言
特点
1、高级语言
2、Java之父
? 詹姆斯高斯林；于1996年发布JDK1.0版本
3、完全面向对象
? Java语言支持封装、继承、多态，面向对象编程，以达到高内聚、低耦合的标准。
4、支持分布式
Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段
5、健壮型
健壮型：Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。
强类型机制
异常处理
垃圾回收机制
6、安全：反射机制
安全：Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。
7、跨平台：
跨平台：对.class后缀的文件名进行编译后可以在任何支持jvm的平台上运行（一处编译到处执行）
JVM：Java虚拟机，是运行所有Java程序的假想计算机，是Java程序的运行环境之一，编写的Java代码都将运行中JVM上。
JRE：是Java程序的运行时环境，包含JV M和运行时所需要的核心类库。
JDK：是Java程序开发工具包，包含JRE和开发人员使用工具。
Java可以运行在所有平台上吗？
答：不可以，必须要支持JVM
? JDK = JRE + 开发工具集
? JRE = JVM + Java SE标准类库
版本
| 发行版本 | 发行时间 | 备注 |
| :----------: | :------------: | :----------------------------------------------------------: |
| oak | 1990年代初开发 | 小家电的编程语言，来解决诸如电视机、电话、闹钟、烤面包机等家用电器的控制和通讯问题 |
| Java | 1995.05.23 | Sun公司在Sun world会议上正式发布Java和HotJava浏览器 |
| Java 1.0 | 1996.01.23 | Sun公司发布了Java的第一个开发工具包 |
| Java 1.1 | 1997.02.19 | |
| Java 1.2 | 1998.12.08 | 拆分成：J2SE（标准版）、J2EE（企业版）、J2ME（小型版） |
| Java 1.3 | 2000.05.08 | |
| Java1.4 | 2004.02.06 | |
| **Java 5.0** | 2004.09.30 | ①版本号从1.4直接更新至5.0；②平台更名为JavaSE、JavaEE、JavaME |
| Java 6.0 | 2006.12.11 | 2009.04.20 Oracle宣布收购SUN公司 |
| Java 7.0 | 2011.07.02 | |
| **Java 8.0** | 2014.03.18 | **LTS版本** |
| Java 9.0 | 2017.09.22 | ①每半年更新一次；②Java 9.0开始不再支持windows 32位系统 |
| Java 10.0 | 2018.03.21 | |
| Java 11.0 | 2018.09.25 | ①JDK安装包取消独立JRE安装包;②**LTS版本** |
| Java 12.0 | 2019.03.19 | |
| Java 13.0 | 2019.9.18 | |
| java16.0 | 2021.3 | 最新版本 |
归类:
? Java1.0-Java1.4
? Java5.0-Java7.0
? java8.0（LST）
? LST为长期使用版本
? java9.0-java13.0
? java16.0
? java17.0（LST）正在开发
Java平台
Java EE企业版
JavaEE（Java Platform, Enterprise Edition企业版）：是为开发企业环境下的应用程序提供的一套解决方案，主要针对于Web应用程序开发。
JavaSE标准版
JavaSE（Java Platform, Standard Edition标准版）：允许您在桌面和服务器上开发和部署Java应用程序。Java提供了丰富的用户界面、性能、多功能性、可移植性和当今应用程序所需的安全性。
JavaME小型版
JavaME（Java Platform, Micro Edition 小型版）：为互联网上的嵌入式和移动设备上运行的应用提供了一个健壮、灵活的环境：微控制器、传感器、网关、移动电话、个人数字助理（PDA）、电视机顶盒、打印机等等。JavaME包括灵活的用户界面、健壮的安全性、内置的网络协议，以及支持动态下载的网络和离线应用程序。基于JavaME的应用程序在许多设备上都是可移植的，但是利用了每个设备的本机功能。
概括
Java EE包含JavaSE， JavaSE 包含JavaME
2、DOS命令
定义：DOS， Disk Operating System 磁盘操作系统
打开方式：
? 1、开始菜单下输入CMD；
? 2、win + R输入CMD；
? 3、在文件夹路径下输入CMD
常见的DOS命令
d： 切换d盘
dir 显示：当前目录下所有内容。
? <DIR>表示文件夹 文件显示子节
cd
-
cd + 文件路径：进入文件夹，可用TAB键补全内容
-
cd … ：回到上一层目录
-
cd / ：回到根目录
md 创建文件夹
rd
? rd 空目录名：删除文件夹，不能删除非空目录，且不经过回收站直接删除，谨慎使用！
? rd /S 非空目录名：删除目录以及下面的子目录和文件，带询问
? rd /S/Q 非空目录名：删除目录以及下面的子目录和文件，不带询问
del 删除文件，不经过回收站直接删除，谨慎使用！
? del 文件名.扩展名
? del 目标目录\文件名.扩展名
*可一次性删除多个文件，表示任意不表示.
? del *.* 删除所有文件并询问
? del/Q *.* 删除所有文件不询问
echo 文件内容 > 文件的名字 会创建文件将文件内容放入文件名内
键盘的上下键：可查找历史命令
cls 清理CMD屏幕
copy a.txt p.txt 将a文件复制给p
exit 退出DOS窗口
3、配置环境变量
[配置环境变量](https://blog.csdn.net/qq_47804805/article/details/119152891?spm=1001.2014.3001.5501):
? 详情请到"https://blog.csdn.net/qq_47804805/article/details/119152891"
4、基本语法
4.1注释
注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
? 单行注释//
? 多行注释/* */
? 文档注释/** */
4.2关键字与标识符
关键字
? 定义：在Java中有特别含义的单词（字符串）
? 特点：全部是小写字母
保留字
? 定义：现在还没有特别的含义，但是以后可能会用到
? const和goto是保留字
标识符
? 定义：Java对类名、方法名、变量名、包名等命名时采用的字符序列。（在Java中凡是需要自己命名的位置都是标识符）
命名规则（必须遵循）
字母、数字、下划线_ 、美元$符号组成;
数字不能开头;
严格区分大小写;
不能是Java中的关键字或保留字.
命名规范（约定成俗）
见名知意;
对类名进行命名时，要求每一个单词的首字母都是大写（大驼峰式）;
对方法、变量命名时，要求首字母需要小写，从第二个单词开始首字母大写（小驼峰式）;
对包名进行命名时，所有的单词字母都必须小写，每个单词之词使用点（.）分割，如xxx.yyy.zzz;
对常量进行命名时，要求所有的字母都大写，如PI。若是有多个单词组成，单词与单词之间需要用下划线分开.
4.3输出语句
换行输出语句：输出内容，完毕后进行换行，如System.out.println(输出内容);
直接输出语句：输出内容，完毕后不做任何处理，如System.out.print(输出内容);
注意：
- 换行输出语句，括号内可以什么都不写，只做换行处理；
- 直接输出语句，括号内什么都不写的话，编译时会报错；
- 不能同时输出多个数据，但可以使用“+”把多个数据拼接起来，变成为一个数据进行输出。
4.4数据类型
基本数据类型
整型
- ? byte 占用1字节，-128~127
- ? short 占用2字节， -32768~32767
- ? int 占用4字节，-2147483648~2147483647
- ? long 占用8字节，-2的63次方到2的63次方-1
浮点型
- ? float 占用4字节
- ? double 占用8字节
字符型
char：表示单个字符
- 占用2字节
- 字符时用一对单引号‘ ’包裹的，并且只能是一个字符
布尔型
- true：真
- false：假
- 占用1字节
总结：基本数据类型分为四类八种，byte short int long float double char boolean
引用数据类型：
? 引用数据类型：不是基本数据类型就是引用数据数据类型
? 如String：字符串类型
? 引用数据类型的默认值都是null
4.5常量与变量
常量
? 常量：在程序执行的过程中，其值不可以发生改变的量。
自定义常量：通过final关键字定义
字面值常量
- ? 字符串常量
- ? 整数常量
- ? 浮点常量
- ? 字符常量
- ? 布尔常量
- ? 空常量null
注意：
? 1、字符常量的单引号里面只有一个字符；
? 2、空常量不可以直接在输出语句中打印
变量
? 变量：在程序执行的过程中，其值可以发生改变的量，且Java是强类型语言，需要声明变量、指明类型。
变量的声明
? 数据类型 变量名
变量的赋值
? 变量名 = 值 值必须对应数据类型
变量的实质
? 在同一个方法内，不能声明相同的名字的变量
变量的作用：
? 用来存储数据，代表内存的一块存储区域，并且这块内存中的值是可以改变的。
变量使用的注意事项
1.先声明后使用，如果没有声明，会报“找不到符号”错误
2.在使用之前必须初始化，如果没有初始化，会报“未初始化”错误
3.变量有作用域，作用域为变量直接所属的{}范围内，如果超过作用域，也会报“找不到符号”错误，如int的范围为为-2147483648~2147483647，若变量定义超出这个范围则报错
4.在同一个作用域中不能重名。即同一个{}内，不能同时声明两个同名变量
4.6存储数据
进制
? 计算机中只有二进制。那么做计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。
进制分类
- 二进制：逢二进一，以0b或0B开头
- 八进制：逢八进一，以0开头
- 十进制: 逢十进一，没有开头的表示十进制
- 十六进制：逢十六进一，以0x或0X开头
进制转换
-
十进制转二进制
? 除2取余法
-
二进制转十进制
? 让二进制每一位上的数乘以次幂值并相加
-
二进制转八进制
? 三位一分法
-
二进制转十六进制
? 四位一分法
存储单位
- 位（bit）
- 子节（Byte）
- KB
- MB
- GB
- TB
除了1byte = 8bit, 其它的进制转换都是1024
二进制数据存储
整数存储
整型类型：
- byte
- short
- int
- long
符号位：最高位为0是正数，1为负数
原码：十进制数转为二进制数，此二进制为原码
反码：正数的反码不变；负数的符号为不变，其余位取反，即0变1、1变0
补码：正数不变，负数反码+1
注意：
? 计算机在存储数据时以补码形式存储
小数存储
浮点类型
- folat ： 4字节 32B
- double：8字节 64B，浮点类型默认是double类型
存储分3个部分
- 符号位：0表示正， 1为负
- 指数位：用于存储科学计数法中的指数数据，并且要加上偏移量（float偏移127， double偏移量为1023）
- 尾数位
可以使用科学计数法表示：e的多少次方等于10的多少次方
弊端
- 浮点类型无法表示精确小数
- BigDecimal可以解决
字符存储
编码表
-
ASCLL：美国标准信息交换码
- 记住字符0是48，字符A是65，字符a是97
-
Unicode统一码
记住几个常用的，如字符0的编码为48，字符A的编码为65，字符a的编码为97- Java采用的是Unicode编码
转义字符
- 换行\n等价于回车
- 制表符\t相当于tab键
- 退格\b相当于delete后删一个
- 回到开头\r
- 表示一个双引号\”
- 在字符串插入一个“\”：\\
4.7基本数据类型转换
可以转换的类型有（从上往下依次由小到大排列）
- byte：1
- short：2
- char：2
- int：4
- long：8
- float：4
- double：8
自动类型提升
自动类型提升 ： 低数据类型转高数据类型
- 将一个小的数据类型的值赋值给一个大的数据类型
- 多个数据类型做运算，统一转为运算中最高的数据类型
强制类型转换
强制类型转换：高数据类型转低数据类型
低精度类型 变量名 = （低精度类型）高精度类型
特殊的数据类型转换：String
任意数据类型的数据与String类型进行“+”运算时，结果一定是String类型
4.8运算符
运算符定义：是一种特殊的符号，用来表示数据的运算、赋值和比较等。
表达式：用运算符连接起来的式子。
运算符的分类
按照功能分类
算术运算符
-
+、-、*、/、%、++、- -
+ 有三种作用：1、正号，2、加号，3、连接符（从左到右，若时碰上字符串则变成拼接）。 - 有两种作用：1、负号，2、减号。 / 除法时要注意：整数相除时不保留小数，想要保留小数则需要浮点类型。 % 取余数 ++有两种，一种是前++（先加1再运算），另一种是后++（先运算后加1）。——的用法也一样。
只要是byte、short、char这三种类型做运算，结果都会转成int类型，注意会报错
赋值运算符
- =、+=、-=、*=、/=、%=
- 注意：赋值运算符不会改变原有数据特性，如byte b= 10；b += 30是等于40；而b = b + 30会报错
关系运算符
- <、>、<=、>=、!=、==
逻辑运算符
- &（与）、｜（或）、！（非）、^（异或）、&&（短路与）、｜｜（短路或）。逻辑运算符操作的是布尔类型的表达式
&&短路与：左边错了右边不用看；
｜｜短路或：左边对了右边不用看。
条件运算符(三元运算符)
- 条件表达式？表达式1 ：表达式2，若表达式为真，执行表达式1，否则执行表达式2
位运算符
-
&、｜、～、^、<<、>>、>>>
&与：对两个进制数每一位进行与操作，true为1否则为0，最后计算进制结果。
｜或：对两个进制数每一位进行或操作，true为1否则为0，最后计算进制结果。
<<左移：往左边移一位，对于二进制来说就是乘以2的几次方，右移>>相当于除以2的几次方。注意：（当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位。）
>>>无符号右移：往右移动后，左边空出来的位直接补0，不看符号位。正数时和右移一样，负数时右边移出去几位，左边补几个0，结果变为正数注意：位运算符的运算过程都是基于补码运算，我们还需要转换成原码后才能得出结果
按照操作个数分类
一元运算符
- ++、–、！
二元运算符
- +、-、*、/、%、>等
三元运算符
- 条件运算符
4.9流程控制
从键盘输入数据
//1、准备一个键盘扫描器（可先导Scanner包或直接使用包名+类名）
import java.until.Scanner; //(放在类的上方)
Scanner input = new Scanner(System.in);
//2、给出键盘输入提示语句(可省略)
System.out.print(“请输入数据:”);
//3、对象调用方法接收数据；对象名.方法名()
int num = input.nextInt(); //获取一个整数
获取整数：input.nextInt
获取其它数据类型：input.nextDouble(); // (next数据类型)
-
没有关于char类型的输入方法，但可以用String的方法chartAt提取char
-
next和nextLine一起使用时有冲突：
next遇到空格、tab、回车则结束；
nextLine遇到回车则结束。
若是next在前，nextLine在后，next回车后将会发生程序结束，跳出nextLine，解决方法：在添加一句nextline用来接收回车。
顺序结构
? 顺序结构：从上而下顺序执行每一行代码
分支结构（选择结构）
? 分支结构（选择结构）：根据条件选择执行不同的代码
if分支
if(关系表达式1){
语句体1;
}else if (关系表达式2){
语句体2；
}else{
语句体3;
}
// 其中else可省略，变成了if-else if结构
if分支可多重嵌套
在if的语句块中，或者是在else语句块中，
又包含了另外一个条件判断（可以是单分支、双分支、多分支）
执行的特点：
（1）如果是嵌套在if语句块中的
只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的
只有当外部的if条件不满足，进入else后，才会去判断内部的条件
执行流程：
1、首先判断条件表达式看其结果是true还是false；
2、如果是true就执行方法体；
3、如果是false就执行其它语句（if单分支：则不执行）
switch选择（switch - case）
? switch一般与break结合使用
switch(表达式){
case 1:
语句块1；
break；
case 2:
语句块2；
break；
…
default:
语句块n+1；
break；
}
/*
（1）入口
①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；
②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里。
（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿
（3）出口
①自然出口：遇到了switch的结束"}"；
②中断出口：遇到了break等。
*/
编写时候需要注意:
1、
在switch中，若是case的后面不写break将会出现穿透现象（即会一直向下运行直到遇到break或者整个switch语句结束，switch语句执行终止。）；2、switch(表达式)的值的类型，只能是：4种基本数据类型（byte、short、int、char）和两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）；2、case后面必须是常量值，而且不能重复
if和switch使用区别：
if语句的条件可以是一个范围或者特定值，switch语句的条件一般是特定的值，不适合表示范围。
循环结构：
? 循环结构：重复执行某一些代码
for循环
表达式
for(初始化语句 ; 循环条件语句 ; 迭代语句){
循环语句体;
}
注意：
（1）for(;;)中的两个；是不能多也不能少；
（2）循环条件必须是boolean类型；
（3）如果循环条件语句省略的话，就默认为循环条件成立，进入死循环；如果迭代语句省略并且循环语句体中没有使变量发生变化的话，导致变量不会改变，进入死循环。
执行流程
第一步：执行初始化语句，完成循环变量的初始化；
第二步：执行循环条件语句，看循环条件语句的值是true，还是false；
如果是true，执行第三步；
如果是false，循环语句中止，循环不再执行。
第三步：执行循环体语句
第四步：执行迭代语句，针对循环变量重新赋值
第五步：根据循环变量的新值，重新从第二步开始再执行一遍
while循环
while表达式
格式：
while (循环条件语句①) {
循环体语句②；
}
注意：while(循环条件)中循环条件必须是boolean类型
死循环
//死循环
while(true){
循环体语句;//如果此时循环体中没有跳出循环的语句，也是死循环
}
do,while()表达式
表达式：
do {
循环体语句；
} while (循环条件语句)；
?
注意：
（1）while(循环条件)中循环条件必须是boolean类型；
（2）do{}while(); 中while的后面有一个分号";"
（3）do...while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
- do…while至少执行一次代码
循环使用变量需要注意：
1、如果记录的是总体的变量，需要将变量定义值循环外部；
2、如果记录的是单个个体变化，需要将变量定义在循环内部。
三种循环语句的相异处
1、从循环次数的角度区分
① do...while循环至少执行一次循环体语句；
② for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句。
2、从循环变量的生命周期角度分析
① for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；
② while和do...while循环的循环变量因为在外面声明的，所以while和do...while结束后可以被继续使用的。
3、如何选择
-- 遍历有明显的循环次数（范围）的需求，选择for循环；
-- 遍历没有明显的循环次数（范围）的需求，循环while循环；
-- 如果循环体语句块至少执行一次，可以考虑使用do...while循环；
-- 本质上：三种循环之间是可以互相转换的，都能实现循环的功能；
4、共同之处（都具备四要素）
- 循环变量的初始化表达式
- 循环条件
- 循环变量的修改的迭代表达式
- 循环体语句块
5、都可以嵌套循环，总的循环次数=外循环次数 * 内循环次数。三种循环也可以任意互相嵌套（不建议用while进行嵌套循环）
关键字：break；continue；return
break（跳出语句）
作用：结束循环
只能用在循环或者switch中
continue
作用：结束本次循环，进入下一次循环
只能用在循环内
return
return（结束方法）：在方法中任意使用 (面向对象会展开)
break、continue使用注意：
如果没有标签，结束的是break、continue所在层的循环；如果有标签，结束的是标签所在层的循环。
如何声明标识符？～～标识符命名遵循命名规范和命名规则
4.10数组
基本概念
定义：数组就是多个相同类型的数据按照一定的顺序排列的集合，并使用一个名字命名，然后用编号区分这些数据。（数组就是一个存储数据的容器）
数组的组成
? 数组的组成：数组名、下标（脚标、索引）、元素、数组的长度
特点
- 数组的长度一旦确定将不能修改
- 存储的元素为相同的数据类型，可以说基本数据类型或者说引用数组类型
- 有索引，在创建数组的同时会在内存中开辟一整块连续的空间
- 存取元素的速度快（因为可以通过下标，直接定位到任意一个元素）
基本使用
数组的声明与初始化
? 数组在使用之前需要先进行声明并初始化
数组的声明
1、元素的数据类型[] 数组的名称;(推荐使用)
2、元素的数据类型 数组的名称[];
初始化数组
-
静态初始化
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...}; 或 数据类型[] 数组名; 数组名 = new 数据类型[]{元素1,元素2,元素3...};
简化方式：
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写
* 先给定所有元素，由系统决定数组的长度
-
动态初始化
格式：数据类型[] 数组名字 = new 数据类型[长度]; 或 数据类型[] 数组名字; 数组名字 = new 数据类型[长度];先确定数组的长度，后期再给元素赋值（创建时系统会给出元素的默认值）
-
数组元素的默认值
发生（动态初始化时） 数据类型[] 数组名字 = new 数据类型[长度]; 在动态初始化时只确定了数组的长度，系统将会自动分配默认值给数组。
-
//数组的默认值
byte int short 默认值为0
long 默认值为0L也可以是0
float 0.0f/0.0
double 0.0
boolean false
char \u0000 空
访问数组元素
概念理解
-
索引
每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。 -
索引范围：[ 0, 数组的长度-1]
使用
- 查找元素：数组名[索引]，即可查找指定索引位置的元素
- 给指定元素赋值：数组名[索引] = 值，表示为数组中指定索引位置的元素赋值
获取数组的长度
? 获取数组的长度：数组名.length，返回一个int类型。
? 注意：区分长度和索引的范围，最大索引应该是数组的长度-1
遍历数组
数组遍历格式
-
普通for循环
格式：public static void main(String[] args) { int[] arr = {11, 22, 33, 44, 55}; //打印输出数组的长度 System.out.println("数组长度："+arr.length);//数组长度为5 //数组遍历（正序）： System.out.println("数组遍历："); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } //数组遍历（逆序）： System.out.println("数组逆序遍历："); for (int i = arr.length-1; i >=0 ; i--) { System.out.println(arr[i]); } } -
增强for循环
格式：for(数据元素类型 变量名：数组名 ){ //变量名：数据内的元素 System.out.println( 变量名); } -
判断是否需要使用下标，即可选择遍历
数组内存图
基础概念：类的加载是按需加载；在类加载时开辟内存空间
-
方法区：类的信息、方法的信息、变量的信息
-
虚拟机栈：java方法执行的信息，局部变量
-
本地方法栈：C/C++
-
堆
? 对象
? 数组
-
程序计数器：用于记录计算机下一条指令的地址，CPU的一部分
数组高级用法
数据统计（求和、均值、统计元素个数等）
思路：遍历数组，挨个累加或判断每一个元素
查找最值及其位置
思路：
1、先假设第一个元素为最大(maxNum)/最小(minNum)并用变量index记录最值位置；
2、用maxNum/minNum与后面的每一个元素比较；
3、用index时刻记录目前的最值的索引值
查找指定元素第一次出现的位置
顺序查找
思路：用想要查的value去和数组的每一个元素进行比较，如有相等则直接返回（直接返回就是记录第一次出现位置）。
查找次数（迭代次数）：n-1，n是数组长度
二分查找（折半查找）
在一个从小到大排列的数组中查找某一元素：
? 元素与中间下标元素进行比较，如果查找元素比中间下标元素大，则选择右边否则左边，这是第一次查找；第二次开始查找的位置=第一次的中间下标 + 1 （如果-1则说明是第一步左边），找第二次查找的中间下标与查找元素进行比较，等于则找到、大于则在右边，小于则左边。依次循环，直到找到、下角标越界或者数组循环结束为止。
使用二分查找的前提要求：将数组中的元素按照大小顺序排序
算法
概念(了解)：
了解：
算法（Algorithm）是指解题方案的准确而完整的描述，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。
算法复杂度是指算法在编写成可执行程序后，运行时所需要的资源，资源包括时间资源和内存资源，因此算法复杂度分为时间复杂度和空间复杂度。
时间复杂度是指执行算法所需要的计算工作量。
空间复杂度是指执行这个算法所需要的内存空间。
算法的优劣：通常用算法的时间复杂度和空间复杂度来衡量。
十大经典算法：交换排序分为冒泡排序、快速排序；插入排序分为简单插入排序、希尔排序；选择排序分为简单选择排序、堆排序；归并排序分为二路归并排序、多路归并排序；还有基数排序、桶排序、基数排序。
冒泡排序
思路：
依次比较相邻的两个数，将小的数放到前面，大的数放到后面。即第一趟，首先比较第1个和第2个元素，将小的数放到前面，大的数放到后面。然后比较第2个和第3个元素，将小的数放到前面，大的数放到后面。如此继续，直到比较最后两个数，将小的数放到前面，大的数放到后面。
重复第一趟步骤，直至全部排序完成。
总的来说：冒泡排序就是比较两个相邻的元素，将值大的元素，最终最大值出现在最后位置。
直接选择排序
思路：每一次排序都是为了寻找数组内的最小值下标，找到最小值下标后，再与指定位置进行交换。
折半插入排序
思落：先利用二分查找，找出插入元素的合适位置，然后整个数据移动，腾出"合适的位置"，放入要插入的元素。
快速排序
思路：①选出一个数作为中间值，其它数都与中间值进行比较，②如果比它小则放到中间值的左边区域，如果比它大则放在中间值的右边区域。这是一次循环
重复上述步骤②，直到各个分区只剩下一个数。
具体：选择数组的第一个数做中间值，从后往前找比它小的数，对它进行数据交换，小的数就在左边位置，在从前往后找比它大的数，在进行数据交换。
概念比较混乱，还需要读者从去网上查找资料
数组反转
思路1：借助一个新数组
定义一个同样长度的数组，将数组倒序（数组遍历类似）插入到新数组中
思路2：首尾对应位置交换（推荐）
定义一个中间变量，变成了三个元素的交换，其中循环的次数=交换的次数=数组的长度/2
数组扩容
思路：1、新建一个数组，可以是原来数组的2倍或1.5倍；（此处借用了后面集合的底层思想）2、将原来数组的数组放入到新数组中；3、将新数组的地址值赋值给原有数组的引用（原来数组名）
- 1、如果新增的元素个数确定，那么可以增加指定长度，如果新增元素个数不确定，那么可以扩容为原来的1.5倍、2倍等。
2、数组扩容太多会造成浪费，太少会导致频繁扩容降低效率，必须要结合实际
数组元素的插入、复制和删除
元素复制
System.arraycopy(arr, srcPos,newArr, destPos, arr.length)。
其中arr是原数组，srcPos是原数组开始复制的元素位置，newArr是要复制到的数组，destPos是复制到新数组的开始位置；length指要复制元素的个数
- System.arraycopy(arr, srcPos,newArr, destPos, arr.length)
元素插入
- 在末端插入：直接赋值
- 非末端插入：先将数组元素复制后，进行扩容，再从插入元素位置到最后一个元素往后移，最后进行元素插入，赋值给原数组引用
元素删除
- 思路：把要删除位置之后的每个元素都向前移动，再将多余出来的位置变成数组的默认值或者结合实际情况进行更改
二维数组与一维数组的不同之处
二维数组基本概念：二维数组本质上就是元素为一维数组的一个数组，二维数组也称为二维表
二维数组的声明
元素的数据类型[][] 二维数组的名称;//推荐
元素的数据类型 二维数组名[][];//不推荐
元素的数据类型[] 二维数组名[];//不推荐
? 数组名[下标1][下标2]；下标1:指一维数组的下标，下标2：一维数组的下标
二维数组的初始化
静态初始化
如果是静态初始化，右边new 数据类型[][]中不能写数字，因为行数和列数，由{}的元素个数决定。
//1.先声明，再静态初始化
元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
//2.声明并同时静态初始化
元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
//3.声明并同时静态初始化的简化写法
元素的数据类型[][] 二维数组的名称 = {
{元素1，元素2，元素3 。。。},
{第二行的值列表},
...
{第n行的值列表}
};
?
动态初始化
//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
//此时创建完数组，行数、列数确定，而且元素也都有默认值
//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;
注意：
? 1、若是二维中的一维长度没有定义，则默认为null；
? 2、静态初始化赋值也遵守一维数组静态初始化的规则
一维数组和二维数组的地址值不一样
地址值是由：数据类型@哈希值，三部分组成，则二维数组输出 ]]@哈希值，一维数组输入 ]@哈希值
遍历：循环嵌套
格式：
//有下标的遍历二维数组
for(int i=0; i<二维数组名.length; i++){
for(int j=0; j<二维数组名[i].length; j++){
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
?
//增强for循环：
for (数据类型[] ele : 二维数组名){
for(数据类型 e : ele){
System.out.print(e + "\t");
}
System.out.println();
}
?
(Arrays.deepToString(数组名)); //展示二维数组,仅仅适用于展示
?
内存图
后期补上
数组的相关工具类
Java提供了现成的工具类，方便实现数组的相关操作。
java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：
- static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
- static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
- static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
- static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
- static void fill(int[] a, int val) ：用val填充整个a数组
- static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val
- static void sort(int[] a) ：将a数组按照从小到大进行排序
- static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
- static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3......]
关于数组操作的常见异常
数组越界异常（不存在的索引）：ArrayIndexOutOfBoundsException
数组空指针异常（还未分配元素的内存空间）：NullPointerException
?