JavaSE知识总结

1.0 Java基础

1.1、Java是什么

定义: 1) Java是 Sun 公司的 jamesgosling 发明的面向对象的可跨平台的编程语言
\2) solarls 是 Sun 公司的 OS, 09 年被甲骨文公司收购
\3) 机器->汇编->高级->面向对象
\4) 面向对象的高级语言企图用人的世界观来改造计算机的世界观
\5) Java(爪哇) : 岛名

1.2、Java跨平台原理

\1) 平台: 我们把CPU处理器与操作系统的整体叫平台
\2) c语言 “跨平台”
→ win NT 编译器(VS) — winNT程序
.c(源程序) – → liunx 编译器(GCC, ICC) — linux 程序
→ 其他OS编译器 — 其他OS程序
\3) Java 跨平台
→ Windows解释器 — Windows平台运行代码
.Java(源程序)-- .class(中间码) – → Linux解释器 — Linux平台运行代码
→ 其他操作平台解释器 — 其他平台运行代码
\4) 语言的三种分类
\1. 编译执行: 例如: C 优点: 执行速度快 缺点: 无法跨平台
\2. 解释执行: 例如: HTML JavaScript 优点: 可以跨平台 缺点: 执行速度慢
\3. 中间码 + 虚拟机

1.3、JDK

1)JDK(Java Developer’s Kit)
开发Java需要的源文件到中间文件的编译器, 运行Java需要对应的平台的解释器,
Sun把这两个组件放在一起再加上其他组件成为
2)JVM(Java Virtual Machine)
Java虚拟机, 包含: 类加载器, 字节码校验器, Java解释器
3)JRE(Java Runtime Environment)
Java运行时环境, 包含JVM 与 Java 运行支持类库与文件
4)环境变量
操作系统给程序运行提供支持的一些文件路径设置

1.4、开发Java程序

1） 类名与文件名一致并首字母大写, Java 严格区分大小写
2） 常用DOS命令
dir 列出当前文件夹下所有文件与子文件夹
cd 文件夹名 进入文件夹
cd… 返回上级目录
cd\ 进入盘根文件夹
3） Java注释
\1. 单行 //
\2. 多行 //
\3. 文档注释 /
这里是文档注释
作者:mc
功能: 第一个Java演示程序
*/
可通过JDK 提供的javadoc 命令转化为html帮助文档, 控制台进入Java源文件所在目录输入 “javadoc filename.java” 命令转化为html帮助文档,
4） Java打包
先编译为 .class 类文件, 输入 jar crf filename.jar filename1.class filename2.class
最后得到一个 filename.jar 文件

1.5、Java的三个分支

JavaSE – Java Standard Editon
JavaEE – Java Enterprise Edition
JavaME – Java Micro Edition

1.6、Java的优缺点

优点: 无指针, 自动收集, 平台无关, 面向对象, 简单, 健壮, 安全, 多线程等
缺点: 运行速度慢 占用资源多 无指针 垃圾回收线程占用资源 不能实时收集内存

1.7、JVM 与 JIT

JVM: 代码的装入（类加载器的完成）、 代码的校验（字节码校验器） 和代码的执行
Java即时编译: 即 JIT 可以提高Java代码运行效率

2.0 Eclipse使用

2.1、IDE 工具（Integrated Development Environment）

集成开发环境
窗体: Sun AWT / Swing
IBM SWT

2.2、Eclipse

基于插件思想开发 命令 文件名 参数（zhangsan lisi wangwu zhaoliu）
main方法参数 只有在控制台使用 java Test zhangsan lisi wangwu zhaoliu

2.3、部署

2.4、使用 Eclipse

workspace 是运行 Eclipse 的基本单位

2.5、快捷键:

CTRL + M // 放大窗口
ALT + / // 代码提示（万能键）
main // main方法
sysout // 输出（打印到控制台）
CTRL + Shift + S // 自动生成代码
CTRL + Shift + T // 打开类窗口
CTRL + F6 // 打开的多个文件窗口进行切换
CTRL + F11 // 当前窗口运行
CTRL + F7 // 切换窗口
F3 // 查看源代码
CTRL + O // 显示类的类结构

// 打开已经存在的项目文件夹
File->import->General->Existing Projects into Workspace

2.6、保存项目的三种方式:

​ \1. 备份workspace 2. 备份项目 3. 只备份源文件
调试：
1） 监视代码运行的轨迹
2） 查看某个变量在某个时候的数值
3） 关键性名词 ： 断点
快捷键：
​ F5 进入方法
​ F6 单步执行
​ F8 执行到下个断点或者程序结束

变量

3.1、Java数据类型

\1. 基本数据类型:
数值型:
整数型: byte short int long
浮点型: float double
字符型: char
布尔型: boolean
\3. 引用数据类型:
类: class
接口: interface
数组:

3.2、命名规则

变量名不能以数字开头
可以使用 ‘_’, ‘$’ $: 内部类使用,通常不使用
boolean 型变量通常用 is 开头

三个知识点:

String 类 字符串

4.0 类和对象

4.1、类

定义： 类是具有相同属性和行为的一组对象的集合
Java程序组成的基本单位

4.2、对象 （实例）

定义： 把符合某类标准的具体事物称为对象
联系： 类是对象的抽象定义， 对象是类的具体实例
区别： 类是抽象的， 对象是具体的

单态类： 只能创建一个对象的类 单态是一种设计模式

4.3、方法

方法由： 方法声明， 方法实现 而部分组成
方法声明分为 ： 范围类型， 方法名称， 参数列表

1） 返回类型： 可以是任何的返回类型， 无返回值用void表示如果有返回值，
在方法体里必须使用return关键字返回与之匹配的数据类型
2） 方法名称： 符合变量命名规范，首字母小写
3） 参数列表： 可以有0到无数个参数

4.3、包（package）

本质上是文件夹
作用： 1) 避免命名冲突 2) 为封装提供支持 3) 更好的管理类
命名规范： 公司命名的倒置为开头

如果当前类 与 要使用的类不在同一个包里
需要使用import关键字 导入要使用类的包
import packagename.classname

导入类的三种方法： 1) 使用 ALT + /
\2) 使用错误代码解决方案 CTRL + 1
\3) 导入类的快捷键 CTRL + Shift + O // 导入多个类 如果有重名的会程序员主动选择

4.4、如何介绍方法

这个方法是** 类的 其参数为 *** 返回值类型是 **

4.5、构造方法

结构： 方法名与类名相同： 首字母大写
无返回值： 无 void 关键字
创建对象时， 由 JVM 自动调用
作用： 给构造属性赋初值
this 关键字

分类：
\1. 显式构造方法： 可见 0-N 个 程序员定义

 \2. 隐式构造方法： 不可见  无参数   Java编译器在编译时添加(当且仅当程序员没有定义构造方法时参加)
1

4.6、Static 关键字

静态方法， 静态变量， 静态块（不使用, 也不推荐使用）：创建对象之前自动引用 （可以写过程代码 例： for循环 if判断··· ）
静态属性 可以用 类名.属性名 调用
静态方法 可以用 类名.方法名 调用
不能修饰类

4.7、运行时异常

java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常

5.0 窗体

使用的类：

1. JFrame

2. JPanel

3. ImageIcon

类的方法：
JFrame gameUI = new JFrame();
gameUI.setTitle(“Push boxs 1.0 The First Level --By BabyMuu”); // 设置窗体标头
gameUI.setSize(800, 600); // 设置窗体大小
gameUI.setLocation(400, 100); // 设置窗体位置（左上角）
gameUI.setLocationRelativeTo(null); // 窗体居中
gameUI.setVisible(true); // 设置窗体可见

6.0 Java内存管理

JVM 默认最大申请内存 64M

6.1、内存区域

1. 堆
2. 元数据区
3. 栈
4. 值栈
5. 字符串池

6.2 堆

包含：
1* 对象数据, 普通属性

问题：
1* Java 中是否有指针？
Java中没有指针, 因为不能声明指针类的变量, 但引用类型变量底层封装了指针

 2* Java中是按引用传递还是按值传递的（都对）
 按引用传递：方法调用完， 是否会改变参数的原始数值（基本型不会改变， 引用型会改变）
 按值传递：   基本型拷贝的具体的数值， 引用型拷贝的内存首地址
1
2
3

6.3、元数据区

包含：
1* 类结构
2* 静待变量的数值
3* 所有方法代码

6.4、栈

默认内存空间： 1M
包含：
1* 变量的值
引用型： 内存首地址
基本型： 变量值

6.5、对象使用

声明对象： 分配栈内存, 类似于指针类型变量
创建对象： 根据方法区模板, 分配堆内存, 存储具体值

注：
Java 中 值类型 是按照值传递
引用类型 是按照引用传递（本质上是地址传递）

6.6、垃圾回收

如果一块堆内存， 没有任何一个指向它的引用， 则视其为垃圾内存
垃圾回收车（garbage collector）运行时刻：
1* 内存资源不够用
2* 系统资源闲置
3* 利用" System.gc "方法 建议垃圾回收车运行（不一定运行）

在对象内存被回收（释放）时调用
C++ 析构函数
Java 方法重写 finalize（Object类）
Max Finally

6.10、杂项知识点

// C++ 析构函数
// Java 方法重写 finalize

7.0 包和常用类

7.1、常见的包

java.long 默认包 直接可以使用其内部的方法 不用导入
包含的常见类: String System Object
java.util
java.sql
java.text
java.swing
java.awt
java.io
java.net

7.2、包装类

基本数据类型
byte boolean short double float long char int
包装类(long) 包
Byte Boolean Short Double Float Long Character Integer

为什么保留八个基本数据类型:
基本型 只在栈中有一块内存
包装类 栈和堆中分别有一块内存, 或许有更多块内存
效率相较于基本数据类型较低

7.3、日期类

public class TestDate {/** 日期类常用方法*/
public static void main(String[] args) throws ParseException {
Date now = new Date();
now.getTime() // 输出从1970年开始到现在的毫秒数
System.out.println(now); // 输出当前日期
年 月 日 时 分 秒 毫秒
// SimpleDateFormat df = new SimpleDateFormat(“yyyy-MM-dd:HH.mm.ss.SS”);
SimpleDateFormat df = new SimpleDateFormat(“yyyy-MM-dd”);
String str = df.format(now); // 根据 SimpleDateFormat 的参数格式化 Date对象为字符串
System.out.println(str);

 String dateStr = "2001-1-1";
 Date btd;
 
 btd = df.parse(dateStr);     // String 转换成 Date  参数 字符串
 System.out.println(btd);
 
 String str1 = df.format(btd);    // Date 转换成 String  参数 Date对象
 System.out.println(str1);
 
 // 日期计算 
 Calendar calendar = Calendar.getInstance();    // 创建日期对象  通过调用 类.静态方法 创建
 calendar.setTime(btd);               // 设置日期时间 
 calendar.add(Calendar.DATE, 100);  // 向前(后)移动 count 年(月, 周, 日)
 Date newDate = calendar.getTime();         // 通过日期类的方法 返回值 Date 对象
 System.out.println(df.format(newDate));   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

}
}

7.4、字符串

\1. String str1 = new String(“hello”)
在堆中创建内存 并将内存首地址返回给栈
\2. String str1 = “hello”;
在字符串池中查找 是否有相同的字符串
如果有 将已有字符串的内存首地址返回给栈
如果没有 在字符串池中创建内存 并将内存首地址返回给栈
\3. 字符串拼接
StringBuffer sb = new StringBuffer(“hello”);// 变长字符串
sb.append(“world”); // 扩充
System.out.println(sb.toString()); // 编程字符串输出

7.10、杂项知识点

1* // 不推荐使用以下方法
import com.babymuu.Student.cLSName // 导入静态属性
import com.babymuu.Student.sayHello // 导入静态方法
// main函数中 clsName = “hello”
// 可以直接使用 sayHello();
2* StringBuffer 和 StringBuilder 的区别
StringBuffer 是线程安全的
StringBuilder 是线程非安全的 但缺少了上锁开锁的过程导致资源占用减少
3* == 与 equals 的区别:
1- == 比较的是栈值，是否指向同一块内存。
2- equals比较的是指向的两块内存存储的数值是否相等。
// 为true, equals 一定为true；equals 为true, == 不一定为true。
3- 基本型比较使用==比较
引用型用 equals 方法比较

8.0 继承

8.1、OOA OOD OOP

OOA : 面向对象分析方法
OOD : 面向对象设计
OOP : 面向对象编程

8.2、定义

在一个类的基础上定义一个新类是继承

8.3、特点

1* 子类拥有父类的属性和方法
2* 当两个类有多个相同的属性和方法, 抽取父类(减少代码冗余, 实现代码复用)
3* 1- 子类可以有自己新的属性和方法
2- 子类可以重写自己的方法
4* 1- 可以声明父类, 创建子类
2- 1+ 声明的什么类型, 只能调用本类型的属性和方法
2+ 创建的什么类型, 就真正运行的什么类型的方法(方法重写)
3+ 创建的什么类型, 就可以强转为什么方法
5* 父类可以出现的地方, 子类一定可以出现(子类的功能一定是大于父类的)

8.4、方法重写(方法覆盖)

子类与父类具有 相同的方法声明, 不同的方法实现(相同的方法头, 不同的方法体)
子类重写父类地方法, 可以改变访问修饰符, 但只能改为更广的范围
与方法重载的区别:
方法重载大部分在一个类里面
方法重写在子父类之间

8.5、关键字 final

修饰符 最终的， 不变的
修饰类 不能被继承 例如: String 和 八个包装类
修饰方法 不能被重写
修饰变量 定义为常量 final static int AGE = 100;(当把变量修饰为 final 的同时, 还需要用 static 将其修饰)

8.6、关键字 super this

super 表示父类的属性和方法
this 表示本类的属性和方法

8.7、继承中的构造方法

1* 创建子类对象一定会调用父类的构造方法
2* 默认调用父类无参的构造方法(显示或隐式)
3* 只能调用父类存在的构造方法

8.10、杂项知识点

1*
@Override 重写父类的方法
@Deprecated 方法不推荐使用
@SuppressWarnings 忽略警告
2* 常量
1- 常量必须赋初值
2- 常量所有字母需要大写

9.0 封装

9.1、封装定义

隐藏属性方法 与 方法实现细节 的过程

9.2、封装实现

方法, 不提供源文件
包
访问修饰符

9.3、访问修饰符

protected private public default(默认)
public 所有类可以访问
protected 该类及其子类成员可以访问, 同一个包中的可以访问
default 同一个包的可以访问
private 只有当前类可以访问

9.3、实体类 (entity class)

特点:
属性全都是私有的
每个属性对应两个共有的方法 (访问器)
默认顺序
1- 私有方法
2- 共有的构造方法
3- 访问器
4- toString
5- hashCode
6- equals

9.5、访问器

获取私有属性的值
// 取值 类型 get属性名首字母大写()
public int getId() {
return id;
}
设置私有属性的值
// 赋值 void set属性名首字母大写(类型)
public void setId(int id) {
this.id = id;
}

9.6、查看类中的所有属性

@Override public String toString() {
return “hellod [id=” + id + “, name=” + name + “, age=” + age + “, isMen=” + isMen + “, address=” + address
+ “]”;
}

9.7、哈希码

@Override public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((address == null) ? 0 : address.hashCode());
result = prime * result + age;
result = prime * result + id;
result = prime * result + (isMen ? 1231 : 1237);
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

9.8、判断两个对象是否相同

@Override public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Teacher other = (Teacher) obj;
if (address == null) {
if (other.address != null) return false;
} else if (!address.equals(other.address)) return false;
if (age != other.age) return false;
if (id != other.id) return false;
if (isMen != other.isMen) return false;
if (name == null) {
if (other.name != null) return false;
} else if (!name.equals(other.name)) return false;
return true;
}

9.9、名词: “透明的”

10.0 多态

10.1、简介

多态就是多种形态
直接表现: 1-方法重写 2-方法重载

10.2、方法重载

类中的方法具有相同的方法名, 不同的参数列表叫方法重载
参数列表不同指的是: 1-参数个数 2-参数类型
要点:
1- 与参数名无关
2- 与返回类型无关
3- 父子类方法重载 (正常使用很少)

10.3、抽象方法和抽象类

10.3.1、抽象方法

​ 由 abstract 关键字修饰的方法, 只有方法的声明, 没有方法实现的方法
​ public abstract void driverBMW();

10.3.2、抽象类

​ 1- 由 abstract 关键字修饰的类为抽象类
​ 一个抽象类中可以没有抽象方法, 但有抽象方法的类一定是抽象类
​ 2- 子类继承抽象类的三种方法
​ 1 实现父类的所有抽象方法
​ 2* 部分实现父类的抽象方法, 但需要将自己定义为抽象类
​ 3* 不实现父类的抽象方法, 但需要将自己定义为抽象类
​ 3- 抽象类"缺点"
​ 抽象类只能声明, 不能创建
​ 只能创建抽象类的实现类
​ 4- “构造方法和静态方法不能是抽象的”"
​ 5- 使用场景
​ 如果父类中的某个方法不包含任何业务逻辑(空方法, 方法体在系统中并不使用)
​ 或者父类方法的出现就是为了让子类重写, 那么就把这个方法定义为抽象方法, 类定义为抽象,

10.4、接口

1- 接口是一系列方法的声明
2- 接口中的抽象方法 可以省略 abstract 关键字
3- 子类继承抽象类的三种方法
1* 实现父类的所有抽象方法
2* 部分实现父类的抽象方法, 但需要将自己定义为抽象类
3* 不实现父类的抽象方法, 但需要将自己定义为抽象类
4- 接口的特点
1* 接口只能声明, 不能创建, 只能创建接口的实现类
2* 一个类只能继承于一个父类, 但可以实现多个接口
3* 接口也能继承接口, 并且一个接口可以继承多个接口 (Java为单继承语言)
4* 接口里面定义的全为常量, 不能定义变量
public final static boolean ISMAN = false;
5- 特殊接口分类
1- 标识接口(空方法接口) : 不写任何东东
2- 常量接口: 只定义常量, 不定义方法

10.5、面向接口编程

在一个面向对象的系统中, 系统的各种功能是由许许多多的不同对象协作完成的. 在这种情况下, 各个对象内部是如何实现自己的,
对系统设计人员来讲就不那么重要了; 而各个对象之间的协作关系则成为系统设计的关键. 小到不同类之间的通信,
大到各模块之间的交互, 在系统设计之初都是要着重考虑的, 这也是系统设计的主要工作内容. 面向接口编程就是指按照这种思想来编程.

10.6、内部类

1- 需求分析
当一个类仅仅在另一个类的内部使用时， 定义此类为内部类

10.7、匿名内部类

1- 需求分析
匿名内部类可以直接使用外部类私有的属性, 简化代码开发
public class Test { // 匿名内部类实现
private static int minute = 3;
public static void main(String[] args) {
ZhangSan zhangSan = new ZhangSan();
// 匿名内部类实现
zhangSan.goHome(new IBus() {
@Override public void toArrived() {
System.out.println(minute + “mins”);
}
});
}
}

10.10、杂项知识点

一个优秀的系统需要 低耦合: 替换某个组件比较方便(可移植性)
1* 让一个类(文件) 只做一件事情
2* 能声明父类的地方绝不声明子类
3* 能声明接口的地方绝不声明实现类

11.0 异常处理

11.1、什么是异常

程序在编译或运行时出现的错误叫 “异常”

11.2、异常处理的意义或目的

1、 能够使源文件进行编译（使.java文件编译成.class文件）
2、 当程序发生异常之后，使程序可以继续进行

11.3、异常体系结构

​ 0-Throwable
​ 1-Error-0L 2-Exception-0R
​ 3-RuntimeException-2L 4-else(CompileTimeException编译时异常)-2R
​ 5-NullPointException-3.1 7-NullPointException-4.1
​ 6-NumberFormatException-3.2 8-NumberFormatException-4.2
顶层分类
Throwable
大分类
1-Error 由 JVM 抛出 程序员无法处理
样例： 内存溢出， 线程错误， 虚拟机错误
发生Error 程序需要重新启动

2-Exception 由程序抛出 程序员可以处理
样例： NullPointException NumberFormatException

小分类
3-RuntimeException “运行时异常” 可处理可不处理
RuntimeException 及其子类

除 RuntimeException 的其他分支为 “编译时异常” : 必须处理， 否则源程序无法完成编译
是由特定的方法抛出， 如果出现编译时异常处理， 必须是程序调用了特定方法
不但要记住编译时异常名字和含义
更重要的是 其由哪个类的哪个方法抛出
样例： SQLException, ClassNotFoundException

11.4、常见运行时异常及其含义

1. NullPointerException 空指针异常： 没有创建，没有堆内存
2. NumberFormatException 字符串转换为数字， 出现非数字型 抛出异常
3. IndexOutOfBoundsException 下标越界异常（数组越界访问异常）
   1. ArrayIndexOutOfBoundsException // 数组下标越界异常
   2. StringIndexOutOfBoundsException // 符串下标越界异常
4. ArithmeticException 数学问题异常（算术异常） // 例如 0 不可以做除数
5. ClassCastException 类型转换异常（错误） new 的类型 与 想要强转的类型不一致
6. IllegalArgumentException 参数错误异常

11.5、常见编译时异常及其含义（更需要记忆相对于运行时异常）

1. ParseException 是由类 DataFormat 的 parse 方法抛出的 DataFormat.parse
2. SQLException 调用sql包中的每个类的每个方法都会抛出
3. ClassNotFoundException 调用Class.forName()方法抛出
4. IOException
5. FileNotFoundException

11.6、五个关键字(重点)

1. try
   代码块： 可能发生异常的代码，也就是业务代码

2. catch
   代码块：异常处理的代码
   特点： 一个 try 块后可以有多个 catch 块
   子类 catch 块 必须在父类 catch 块前面
   同等级的 catch 块无先后顺序
   作用：记录信息

3. finally
   代码块：一般用来释放资源
   特点： 作最后的收尾工作
   最终一定会执行的代码（并且为最后执行）（除非调用了System.exit方法）

4. throw
   位置：方法体内
   表示：正在向外抛出异常

5. throws
   位置：方法声明的最后面
   特点：一个或多个 可以有多个异常
   表示：调用此方法有"可能"抛出对应异常, 调用方法的客户端需要处理

11.7、三个单词 final finally finalize

final 修饰符 最终的， 不变的
修饰变量 定义为常量
修饰类 不能被继承
修饰方法 不能被重写
通常与 static 关键字 同时使用 保留一份放入方法区内

finally
代码块： 一般用来释放资源
特点： 作最后的收尾工作
最终一定会执行的代码（并且为最后执行）（除非调用了System.exit方法）
finalize 为 Object类中的一个方法
功能： 在收集内存的时候被JVM自动调用

11.8、自定义异常

当系统异常描述不精确的时候使用
一般继承于 Exception

12.0 Object 类

12.1、方法：

​ toString 转换成字符串
​ hascode 哈希码
​ equals 对比两个类的具体内容是否相同
​ finalize 在收集内存的时候被JVM自动调用
​ getClass 返回一个类

12.2、哈希码

@Override public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((address == null) ? 0 : address.hashCode());
result = prime * result + age;
result = prime * result + id;
result = prime * result + (isMen ? 1231 : 1237);
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
将对象用一串数字表示
对象 的 数字表示
哈希码 != 内存地址
equals == true => hascode == true
hascode == true !=> equals == true

12.3、class 类

作用： 封装另外一个类的信息

13.0 集合框架

13.1、集合与数组

数组：
1* 长度不能改变
2* 排放顺序编写
3* 存放同一类型的数据
集合
1* 长度可变
2* 排序自己实现
3* 存放不同类型的数据
将多个元素组成一个单元的对象
将一个元素放入集合 是将元素的首地址放入集合而不是将元素的对象放入集合

13.2、集合框架

提供用于管理对象集合的接口和类

包括：
“接口、 实现、 算法”

13.3、接口体系结构

​

   Collection             Map           
 list       set          SortedMap   
       SortedSet
1
2
3

\1) List 可以直接进入 有序的 元素可以重复 通过下标访问内存地址
\2) Set 可以直接进入 无序的 元素不可重复(后来的将前面覆盖) 无法通过下标找到数据
\3) Map 不可直接进入(需要一个键)存储键值对
说明：
Collection 位于体系结构的顶层
Set接口用于处理 “集”(元素没有具体的位置， 不允许重复)
List接口用于处理"序列"(元素有具体的位置，允许重复)
Map用于处理"键值对" (键不允许重复， 值允许)

13.4、Map

存储的是键值对
13.4.1 HashMap 和 Hashtable 的区别
共同点: 都实现了 Map 的接口
不同点: 1* Hashtable 有 synchronized 关键字修饰 是线程安全的
2* HashMap 允许 null 作为 key 和 value 而 Hashtable 不允许
3* Hashtable 循环遍历特有方法
13.4.2 如何循环遍历 HashMap
{ //两种方法
// 通过 Collection 接口 直接获取值
Collection values = stus.values();
for (Student value : values) {
System.out.println(value);
}
// 通过 keySet 返回 键 的集合
Set keys = stus.keySet();
for (Integer key : keys) {
Student value = stus.get(key);
System.out.println(“key :” + key + " value : " + value);
} }

13.10、杂项知识点

1* ArrayList 就是线性表的顺序存储
2* LinkedList 就是线性表的链式存储 (双向链表)
3* “ArrayList” 和 “Vector” 的区别:
Vector 有 synchronized 关键字修饰, 表示是线程安全的(表示同时只能由一个线程进行操作)
ArrayList 是线程非安全的, 单线程
4* “ArrayList” 和 “LinkedList” 区别：
LinkedList 内部数据结构是双向链表
优点: 如果频繁的对集合内的数据进行新增或删除 推荐使用
ArrayList 内部数据结构是顺序表

5* 排序
方案一、
\1. 让排序的实现类实现 "Comparable"接口
\2. 在主函数中调用 “Collections.sort()” 方法 参数: 要排序的数组
方案二、
\1. 单独一个类实现"Comparator"接口
\2. 在主函数中调用 “Collections.sort()” 方法 参数: 要排序的数组 排序关键字的类

6* Collection 和 Collections 的区别
Collection : 是集合框架的顶层结构
Collections : Java.util 包里的工具类

14.0 awt&swing

1.0 C/S

特点: 每个客户必须安装(部署)一份应用程序, 代码时在本机, 给一个人独享一份代码, 针对特定客户群
优点: 快, 交互性能好
缺点: 升级/更新比较繁琐

2.0 B/S: web应用程序

特点: 程序代码在 Web服务器 “程序只有一份”
特例: 集群 一个节点 一份程序
优点:
维护方便
缺点:
速度受网络带宽等各种情况限制