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编译器在编译时添加(当且仅当程序员没有定义构造方法时参加)
4.6、Static 关键字
静态方法, 静态变量, 静态块(不使用, 也不推荐使用):创建对象之前自动引用 (可以写过程代码 例: for循环 if判断··· )
静态属性 可以用 类名.属性名 调用
静态方法 可以用 类名.方法名 调用
不能修饰类
4.7、运行时异常
java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
5.0 窗体
使用的类:
-
JFrame
-
JPanel
-
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、内存区域
- 堆
- 元数据区
- 栈
- 值栈
- 字符串池
6.2 堆
包含:
1* 对象数据, 普通属性
问题:
1* Java 中是否有指针?
Java中没有指针, 因为不能声明指针类的变量, 但引用类型变量底层封装了指针
2* Java中是按引用传递还是按值传递的(都对)
按引用传递:方法调用完, 是否会改变参数的原始数值(基本型不会改变, 引用型会改变)
按值传递: 基本型拷贝的具体的数值, 引用型拷贝的内存首地址
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));
}
}
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、常见运行时异常及其含义
- NullPointerException 空指针异常: 没有创建,没有堆内存
- NumberFormatException 字符串转换为数字, 出现非数字型 抛出异常
- IndexOutOfBoundsException 下标越界异常(数组越界访问异常)
- ArrayIndexOutOfBoundsException // 数组下标越界异常
- StringIndexOutOfBoundsException // 符串下标越界异常
- ArithmeticException 数学问题异常(算术异常) // 例如 0 不可以做除数
- ClassCastException 类型转换异常(错误) new 的类型 与 想要强转的类型不一致
- IllegalArgumentException 参数错误异常
11.5、常见编译时异常及其含义(更需要记忆相对于运行时异常)
- ParseException 是由类 DataFormat 的 parse 方法抛出的 DataFormat.parse
- SQLException 调用sql包中的每个类的每个方法都会抛出
- ClassNotFoundException 调用Class.forName()方法抛出
- IOException
- FileNotFoundException
11.6、五个关键字(重点)
-
try
代码块: 可能发生异常的代码,也就是业务代码 -
catch
代码块:异常处理的代码
特点: 一个 try 块后可以有多个 catch 块
子类 catch 块 必须在父类 catch 块前面
同等级的 catch 块无先后顺序
作用:记录信息 -
finally
代码块:一般用来释放资源
特点: 作最后的收尾工作
最终一定会执行的代码(并且为最后执行)(除非调用了System.exit方法) -
throw
位置:方法体内
表示:正在向外抛出异常 -
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) 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服务器 “程序只有一份”
特例: 集群 一个节点 一份程序
优点:
维护方便
缺点:
速度受网络带宽等各种情况限制