JavaSE知识总结（1）

最新推荐文章于 2022-06-09 21:19:32 发布

深夜书屋

最新推荐文章于 2022-06-09 21:19:32 发布

阅读量683

点赞数 6

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_47804805/article/details/119513148

版权

JavaSE 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

本文详细介绍了Java语言的发展历程、特点、平台分类（JavaSE、JavaEE、JavaME）以及基本语法，包括注释、关键字、数据类型、变量、运算符和流程控制。此外，还讲解了DOS命令的使用，如切换目录、查看目录内容、创建文件夹、删除文件夹等。最后，深入探讨了Java中的环境变量配置、数据存储（进制转换、存储单位）、类型转换以及流程控制结构（如循环和分支结构）。

摘要由CSDN通过智能技术生成

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

Java平台

2、DOS命令

定义：DOS， Disk Operating System 磁盘操作系统

打开方式：

1、开始菜单下输入CMD；
2、win + R输入CMD；
3、在文件夹路径下输入CMD

常见的DOS命令

d： 切换d盘

dir 显示：当前目录下所有内容。

<DIR>表示文件夹 文件显示子节

cd + 文件路径：进入文件夹，可用TAB键补全内容
cd … ：回到上一层目录
cd / ：回到根目录

md 创建文件夹

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
if-else
if-else if-else

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......]