java基础知识点总结思维导图
需积分: 5 112 浏览量
2024-03-16
18:34:07
上传
评论
收藏 385KB PDF 举报
java
基
础知
识
点
总
结
java
基
础
（
都
需
要
掌握
）
1
、
java
语⾔
的
简
单
介
绍
JDK(java
开
发
⼯
具
)> JRE(java
运
⾏
环
境
) >JVM(Java
虚
拟
机
)
配
置
环
境
变
量
JAVA_HOME
HelloWorld
案
例
idea
安
装
进
⾏
配
置
快
捷
键
注
释
、
标
识
符
、
关
键
字
驼
峰
命名
法
2
、
变
量
基
本
数据
类
型 四
类
⼋
种
boolean
byte
short
int Integer
long
float
double
char Character
引
⽤
数据
类
型
类
、
数
组
、
枚
举
引
⽤
数据
类
型
是
地址
值
，
基
本
数据
类
型
是
具
体
的
值
String String s = "abc";
数
组
存
储
⼀
组
相
同
数据
类
型
的
容
器
定
⻓
固
定
数据
类
型
索
引
，
从
0
开
始
⼀
维
数
组
初
始
化
语
法
new new int[3]
{} {1,23}
⼆
维
数
组
初
始
化
语
法
new [1][2]
⾏
、
列
{{},{}}
数
组
异常
空
指
针
：
NullPointerException
某
个
引
⽤
数据
类
型
为
null
，
取
null
值
/
调
⽤
属
性
或
者
⽅
法
/
访
问
元
素
...
等
数
组
越
界
：
ArrayIndexOutOfBoundsException
访
问
了
不
存
在
的
索
引
数
组
⽅
法
Arrays.toString(
数
组
)
将
数
组
转
换
成
String
类
型
输
出
的
,
⽅
便
地
输
出
数
组
3
、
运
算符
算
数
运
算符
+ - * / %
++ --
关
系
运
算符
返
回
值
是
boolean
可
以
⽤
在
任
意
数据
类
型
之
间
⽐
较
!= ==
基
本
数据
类
型
⽐
较
值
引
⽤
数据
类
型
⽐
较
的
地址
值
逻辑运
算符
& |
！
&& ||
&
遇
false
则
false
|
遇
true
则
true
|| &&
短
路
效
果
提
升
效
率
当
左
边
的
结
果
已
经
可
以
决
定
整
个
表
达
式
的
结
果时
，
就
不
⽤
再
继续
执
⾏
右
边
的
表
达
式
了
赋
值
运
算符
=
强
制
类
型
转
化
，
隐
式
类
型
转
化
+= -= /= %= *= =
sum += i; sum =
（
int
）（
sum + i
）
;
其
他
运
算符
三
元
运
算符
boolean
表
达
式
? true
值
:false
值
;
4
、
循
环
for
基
本格
式
for(
初
始
化
值
;
循
环
终
⽌
条
件
;
循
环
后
的
操
作
)
｛
循
环
体
｝
执
⾏
流
程
嵌
套
循
环
外
层
循
环
执
⾏
⼀
次
，
⾥
层
循
环
全
部
执
⾏
完
增
强
for
while
基
本格
式
执
⾏
流
程
do while(
了
解
)
基
本格
式
执
⾏
流
程
⾄
少
执
⾏
⼀
次
循
环
体
控
制
语
句
break
跳
出
整
个
for
循
环
continue
结
束
当
前
循
环
，
继续
下
次
for
循
环
，
即
不
执
⾏
打
印
语
句
5
、
流
程
控
制
语
句
if
格
式
if
if else
if else if ....
else
格
式
3
和
多
个
if
的
区
别
格
式
3:
是
分
⽀
流
程
，
最
终
只
会
进
⼊
⼀个
if
。
多
个
if:
是
只
要
满
⾜
条
件
就
能
进
⼊
if
，不
存
在
互
斥
。
switch(
了
解
)
格
式
执
⾏
流
程
break
穿
透
如
果
没
有
break
，
会产
⽣
case
穿
透
现
象
：⼀个
case
被
匹
配
成
功
，
后
⾯
的
case
就
不
匹
配
了
，
但
是
会
执
⾏
⾥
⾯
的
代
码
缺
点
：
只
能
等
值
匹
配
，
⽐
较
单
⼀，不
能
写
&&
等
复
杂
逻辑
优
点
：
如
果是
等
值
匹
配
，
性
能
、
效
率
⽐
if
⾼
⼀
点
6
、
⽅
法
格
式
参
数
和
返
回
值
return
所
有
分
⽀
都
必
须
要
有
return
修
饰
符
重
载
⾯
向
对
象
1
、
基
本
概
念
⾯
向
对
象
和
⾯
向
过
程
类
与
对
象
局
部
变
量
和
成
员变
量
范
围
如
何
创
建
对
象
如
何
调
⽤
属
性
和
⽅
法
构
造
⽅
法
形
参
实
参
2
、
封
装
Encapsulation
核
⼼思
想
是
隐
藏
细
节
意
思
是
将
代
码
通过
函
数
的
形式
将
⼀
些代
码
细
节
包
装
起
来
，
防
⽌
外
部
代
码的
随
机
访
问
，
要访
问
这
些
数据
就
必
须
通过
调
⽤
函
数
来
完
成
。
封
装
(
把
代
码
放
⼊
⽅
法
）
get/set
好处
提
⾼
了代
码的
阅
读
性
提
⾼
了代
码的
可
维
护
性
3
、
继
承
inheritance
概
念
当
出
现
X
是
⼀
种
y
的
时
候
，
x
就
可
以
继
承
y
⽐
如
⿊
熊
怪
是
⼀
种
妖
怪
两个
类
之
间
通过
extends
关
键
字
来
描
述
⽗
⼦
关
系
⼦
类
便
可
拥
有
⽗
类
的
⾮
私
有
成
员
，
⽅
法
、
属
性
解
决
问题
提
⾼
了代
码
复
⽤
性
代
码的
维
护
性
更
⾼
简
化
代
码的
开
发
⼦
类
对
⽗
类
进
⾏
了
扩
展
⽅
法
重
写
⼦
类
对
⽗
类
中
提
供
的
⽅
法
进
⾏
重
新
定
义
⼦
⽗
类
（
接
⼝
实
现
）
出
现
了
⼀
摸
⼀
样
的
⽅
法
，
升
级
或
者
改
造
⽗
类
的
⽅
法
this super
this
代
表
本
类
对
象
super
代
表
⽗
类
对
象
4
、
多
态
polymorphism
概
念
同
⼀个
对
象
拥
有
多
种
形态
⽐
如
猫
它
是
⼀
只
猫
，
还
是
动
物
⽤
⽗
类
的
类
型
来
接收
⼦
类
的
对
象
不
能
调
⽤
⼦
类
特
有
⽅
法
，
可
以
通过
强
转
（
向
下
转
型
）
好处
扩
展
性强
，
解
决
了代
码
复
⽤
，
降
低
类
型
耦
合
度
耦
合
==
对
外
部
的
依
赖
扩
展
性
变
强
了
，
⽅
法
的
参
数
⽤
⼀个
变
量
接收
所
有
的
⼦
类
对
象
把
不
同
的
数据
类
型
进
⾏
统
⼀，
让
程
序
具
有
超
强
的
可
扩
展
性
不
理
解
的
时
候
多
敲
！！！！！！！！！！！！！！！！！！！！！！
实
战
1
、
Maven
安
装
本
地
仓
库
setting.xml
2
、
Json
json
解
析
fastjson
框架
JSONObject
extends JSON
implements Map<String, Object>
Java
对
象
与
JSON
之
间
的相
互
转
换
序
列化
&
反
序
列化
反
序
列化
：
json
字
符
串
转
化
成
java
对
象
序
列化
：
java
转
成
别
的
就
叫
序
列化
，
将对
象
的
状
态
信
息
转
换
为
可
以
存
储
或
传
输
的
形式
的
过
程
字
符
串
转
对
象
/map/
接
⼝
parseObject
JSONObject.parseObject
(json,
你
要
转
的
类
/
接
⼝
/map.class)
对
象
转
字
符
串
toJSONString
JSONObject.toJSONString
（
对
象
）
map
转
字
符
串
toJSONString
JSONObject.toJSONString (map
集
合
)
字
符
串
数
组
转
成
List<
类
/map...>
集
合
parseArray
JSONObject.parseArray
(json,
你
要
转
的
类
/
接
⼝
/map.class)
数据
类
型
对
象
表
示
为
键
值
对
，
数据
由
逗
号
分
隔
，
花
括
号
保
存对
象
，
⽅
括
号
保
存
数
组
‼
对
象
：
{"name" : "
张
三
"}
字
符
串
：
"abc", "123"
数
字
：
1 , 1.21
数
组
：
[1,2,3]
boolean
：
true
，
false
null
：
null
3
、
Properties
properties
⽂
件
：
项
⽬
当
中
⽐
较
常
⻅
的
配
置
⽂
件
特点
：
以
键
值
对
的
形式
保
存
数据
作
⽤
：
通过
将
系统
配
置
定
义
在
properties
⽂
件
的
形式
来
实
现
代
码
解
耦
。
IO
流
和
File
File
操
作
⽂
件
或
⽂
件
夹
可
以
实
现
对
⽂
件
的
⼀
些
操
作
创
建
删
除
等
FileInputStream
（
读
）
FileOutputStream
（
写
）
——
底
层
调
⽤
了
file
类
，
所
以也
能
创
建
⽂
件
IO
流
修
改⽂
件
内
容
，
也
可
以
⽤
来
⽂
件
内
容
的
传
输
Properties
的
⽗
类
实
现
了
map
接
⼝
可
以
⽤
map
的
⼀
些
⽅
法
load
读
取
加
载输
⼊
流
store
写⼊
配
置
⽂
件
输
出
流
prop.setProperty("id","1");
4
、
xml
xml
：
Extensible Markup Language
扩
展
性
标
记语⾔
与
html
的
区
别
：
html
超
⽂
本
，
是
浏
览
器
展
示
数据
的
⼀
种
⽅
式
xml
是
⼀
种
数据
交互
格
式
，
是
作为
数据
载
体
⽽
出
现
的
，
前
后
端
数据
交
流
的
⽅
式
xml
被
代
替
的
原
因
：
格
式
⽐
较
复
杂
、
⽐
较
笨
重
占
⽤
带
宽
xml
的
解
析
不
⽅
便
dom
树
的
结
构
⼀
层层
解
析
如
果
dom
结
构
不⼀
样
那
么
遍
历
会
有
问题
解
析
dom4j
解
析
技
术
基
于
Java
的
库
来
解
析
XML
⽂
档
5
、
Excel
通过
Poi
操
作
Excel
⼗
分
⽅
便
将
⼀个
Excel
抽
象
为
⼀个
Workbook
sheets
对
象
中保
存
了
excel
中
所
有
的
数据
⼀个
表
单
⻚
抽
象
为
Sheet
，
表
单
中
的
⼀
⾏
抽
象
为
Row
，
⼀
⾏
中
的
⼀个
单
元
格
可
以
抽
象
为
Cell
使
⽤
WorkbookFactory
类
的
create()
⽅
法
解
析
出
excel
所
有
数据
Workbook sheets = WorkbookFactory.create(fis);
1
、
输
⼊
流
加
载
excel
⽂
件
2
、
使
⽤
POI
解
析
excel
3
、
获
取
指
定
sheet
4
、
获
取
制
定
row/
⾏
5
、
获
取
指
定
cell/
单
元
格
列
6
、
获
取
cell
中
的
内
容
HSSFWorkbook
对
应
的
是
97-03
格
式
(.xls)
XSSFWorkbook
对
应
的
是
07
格
式
的
(.xlsx)
。
api
API
⽂
档
使
⽤
String
StringBuilder
和
StringBuffer
可
以
改
变
的
字
符
串
StringBuilder
是
可
以
改
变
的
字
符
串
.
都
在
原
来
的
基
础
上
进
⾏
操
作
.
所
以
不
会产
⽣
内
存
浪
费
.
StringBuffer
和
StringBuilder
基
本
上⼀
模
⼀
样
区
别
是
StringBuffer
线
程
安
全
StringBuilder
线
程
不
安
全
.
常
⽤
API
字
符
串
⽐
较
equals
⽐
较
⚠
equals
顺
序
如
果
⽤
type.equals(Chrome)
可
能
会
空
指
针错
误
因
为
type
是
string
引
⽤
数据
类
型
，
就
有
可
能
会传
null
进
来
所
以
如
果是
null.equals(Chrome)
会
报
空
指
针
；
反
之
，
如
果是
"chrome".equals(null)
这
样是
不
会
报
空
指
针
的
equals
和
==
的
区
别
==
是
运
算符
⽐
较
基
本
数据
类
型
⽐
较
的
是
值
⽐
较
引
⽤
数据
类
型
⽐
较
的
是
地址
值
equals
是
⼀个
⽅
法
Object
中
的
equals
⽤
的
是
==
（
⽐
较
地址
值
）
重
写
之
后
的
equals
⽅
法
⼀
般
⽐
较
内
容
❗
我
们
在
判
断
两个
字
符
串
是
否
⼀
致
的
时
候
⼀
定
要
⽤
equals
这
样
就
是
很
稳
定
的
判
断
内
容
是
否
⼀
样
因
为
字
符
串
String
也
重
写
了
equals
⽅
法
，
判
断
两
个
字
符
串
的
内
容
是
否
⼀
致
equalsIgnoreCase
忽
略
⼤
⼩
写
应
⽤
：
项
⽬
get/post
请
求
/
验
证
码
compareTo
按
字
典
顺
序
⽐
较
两个
字
符
串
如
果
参
数
字
符
串
等
于
此
字
符
串
，
则
返
回
值
0
如
果
此
字
符
串
按
字
典
顺
序
⼩
于
字
符
串
参
数
则
返
回
⼀个
⼩
于
0
的
值
；
如
果
此
字
符
串
按
字
典
顺
序
⼤
于
字
符
串
参
数
则
返
回
⼀个
⼤
于
0
的
值
。
compareToIgnoreCase
replace
字
符
串
替
换
replace(
原
始
待
替
换
字
符
串
部
分
,
替
换
⽬
标
部
分
)
应
⽤
：
参
数
化
替
换
其
他
数据
类
型
和
String
的
转
换
把
其
他
数据
类
型
转
换
成
字
符
串
类
型
最
简
单
的
⽅
式
——>
任何
数据
类
型
+
字
符
串
(
空
字
符
串
)"" —
都
是
字
符
串
String.valueOf(
其
他
数据
类
型
)
把
字
符
串
转
成
其
他
数据
类
型
基
本
数据
类
型
对
应
的
引
⽤
数据
类
型
.parse
引
⽤
数据
类
型
()
Double.parseDouble()
Integer.parseInt()
int i = Integer.parseInt("123");
把
字
符
串
转
成
⼀个
新
的
字
符
数
组
toCharArray
把
数
组
转
成
String
类
型
输
出
Arrays.toString(
数
组
)
substring
字
符
串
截
取
substring(beginIndex,endIndex)
包
含
beginIndex
不
包
含
endIndex
substring(beginIndex)
从
beginIndex
截
取
到
末
尾
split
字
符
串
拆
分
⚠
【
⾯
试
题
⽬
】
split(String regex)
切割
应
⽤
：
为了传
⼀个
内
容
，
⽤
特
殊
字
符
拼
在
⼀
起
，
然
后
使
⽤
时
再切割
此
⽅
法
返
回
的
数
组
包
含
此
字
符
串
的
⼦字
符
串
charAt
返
回
指
定
索
引
处
的
字
符
indexOf()
返
回
索
引
contains
底
层
⽤
的
indexOf
lastIndexOf
最
后
⼀
次
出
现
时
的
索
引
拼
接
字
符
串
的
拼
接
不
是
在
原
字
符
串
的
内
存
空
间
上
修
改
，
⽽
是
新
new
出
来
⼀个
字
符
串
⽐
较
concat
和
+
号
的
效
率
，
concat
更
⾼
isEmpty
判
空
当
字
符
串为
null
的
时
候
不
能
访
问
⚠
否
则
会
报
错
空
指
针
NullPointerException
length
字
符
串
⻓
度
trim
去
掉
左
右
空
格
toUpperCase
、
toLowerCase
转
⼤
⼩
写
startsWith
、
endWith
以
指
定字
符
串
开
头
或
结
尾
2
、
接
⼝
interface
定
义
implements
实
现
特点
只
能
有
抽
象
⽅
法
、
不
能
被
创
建
对
象
、
实
现
类
必
须
重
写
所
有
抽
象
⽅
法
。
可
以
多
实
现
可
以
多
继
承
抽
象
类
⽗
类
和
普
通
类
的
区
别
不
能
创
建
对
象
，
可
以
有
抽
象
⽅
法
容
器
属
于
Collection<<Iterable
List
这
种
容
器
和
数
组
差
不
多
,
优
势
是
不
定
⻓
.
随
便
加
.
有
序
，
有
索
引
，
可
重
复
实
现
类
ArrayList
基
于
动
态
数
组
的
数据
结
构
LinkedList
是
基
于
链
表
结
构
arraylist
和
linklist
的
区
别
对
于
随
机
访
问
的
get
⽅
法
查
询
元
素
，
ArrayList
要
优于
LinkedList
，
因
为
LinkedList
循
环
链
表
寻
找
元
素
。
对
于
新
增
和
删
除
操
作
add
和
remove
，
LinkedList
⽐
较
⾼
效
，
因
为
ArrayList
要
移
动
数据
。
ArrayList
使
⽤
在
查
询
⽐
较
多
，
但
是
插
⼊
和
删
除
⽐
较
少
的
情
况
，
⽽
LinkedList
⽤
在
查
询
⽐
较
少
⽽
插
⼊删
除
⽐
较
多
的
情
况
List
遍
历
for
循
环
；
增
强
for
；
迭
代
器
常
⽤
操
作
1. add(obj)
添
加元
素
2. get(i)
查
看
第
i
个
元
素
3. size()
查
看
列
表
中
的
数据
个
数
9. toArray()
集
合
转
化
成
数
组
toArray()
⽅
法
内
如
果
没
有
参
数
，
返
回
的
是
object
类
型
数
组
如
果
要
为
string
类
型
，
则
需
要
加
：
new String[list.size()]
4. isEmpty()
判
断
是
否
是
空
列
表
5. indexOf(xxx)
查
看
xxx
元
素
在
列
表
中
的
位
置
6. lastIndexOf(xxx)
查
看
xxx
元
素
在
列
表
中
最
后
⼀
次
出
现
的
位
置
7. contains(xxx)
判
断
列
表
中
是
否
包
含
了
xxx
，
列
表
中
包
含
指
定
元
素
，
则
返
回
true
，
否
则
返
回
false
8. subList(start. end)
从
列
表
中
start
开
始
截
取
,
截
取
到
end
但
不
包
括
end
10. remove(obj)
删
除
某
个
元
素
11. remove(i)
删
除
某
个
位
置
的
元
素
19
Set
28
Map
键
值
对
，
键
不
能
重
复
，
双
列
集
合
迭
代
器
迭
代
器
是
⽤
来
⼲
嘛
的
?
遍
历
数据
集
合
的
.
它存
在
的
意
义
就
是
可
以
让
不
同
的
数据
类
型
拥
有
相
同
的
遍
历
⽅
式
.
List, Set, Map.
完
全
不
同
的
三
种
数据
类
型
.
但
是
都
可
以使
⽤
Iterator.
⽅
法
：
next()
——
会
⾃
动
帮
我
们
获
取
到元
素
.
并
且
指
针
指
向
下⼀个
元
素
hasnext()
——
判
断
有
没
有
下⼀个
元
素
，
因
为
集
合
如
果
拿
空
了会
报
错
testng
testng.xml
管
理⽤
例信
息
，
XML
结
构
从
上
往
下
执
⾏
⽤
例
testng
，
这
些
测
试
框架
都
⽀
持我
们
去
定
义
测
试
套
件
，
达
到
管
理
我
们
测
试
⽤
例代
码的
作
⽤
，
同
时
这
些
测
试
框架
提
供
的
⼀
些丰
富
注
解
不
仅
能
很
⽅
便
的
控
制
测
试
⽤
例
的
执
⾏
顺
序
来
控
制
整
个
测
试
流
程
，
还
能
为
各
种
测
试
场
景
的
实
现
提
供
⽀撑
。
30
注
解
23
数据
驱
动
多
线
程
测
试
1
、
使
⽤
注
解
实
现
多
线
程
测
试
@Test(invocationCount = 10,threadPoolSize = 3)
这
⾥
就
是
，
定
义了
三个
线
程
，
来
执
⾏
这
个
⽅
法
10
次
2
、
使
⽤
xml
配
置
⽂
件
实
现
多
线
程
并
发
测
试
<suite name="thread" parallel="methods"
thread-count="3">
属
性
thread-count
允
许
你为
当
前
的
执
⾏
指
定
可
以
运
⾏
的
线
程
数
量
。
thread-count
属
性
表
示
并
发
的
线
程
数
，
默
认
是
5
parallel ——
让
测
试
⽅
法
运
⾏
在
不
同
的
线
程
中
，
要
与
thread-count
⼀
起
使
⽤
parallel="tests"
同
⼀个
test
标
签
下
的
⽤
例
，
运
⾏
在
同
⼀
线
程
中
；
不
同
test
标
签
的
下
的
⽤
例
，
运
⾏
在
不
同
线
程
中
。
parallel="classes"
表
示
以
class
维
度
进
⾏
并
发
执
⾏
⽤
例
，
即
同
⼀个
class
标
签
下
的
⽤
例
，
运
⾏
在
同
⼀
线
程
中
；
不
同
class
标
签
的
下
的
⽤
例
，
运
⾏
在
不
同
线
程
中
。
parallel="methods“
同
⼀个
method
标
签
下
的
⽤
例
，
运
⾏
在
同
⼀
线
程
中
；
不
同
method
标
签
的
下
的
⽤
例
，
运
⾏
在
不
同
线
程
中
。
parallel="instances“
instance
代
表
⼀个
测
试
实
例
，
要
使
⽤
@Factory
注
解
才
⽣
效
，
效
果
和
methods
⼀
样
。
设
置
parallel='instances'
，不
同
测
试
实
例
，
运
⾏
在
不
同
线
程
中
。
parallel = false
false
是
默
认
值
，
代
表
不
使
⽤
多
线
程
并
发
执
⾏
对
于使
⽤
了
数据
驱
动
@DataProvider
注
解
的
情
况
，
如
果
实
现
测
试
数据
维
度
的
并
发
，
需
要
在
@DataProvider
注
解
下
增
加
属
性
parallel =true
。
资源评论
