【个人笔记】JavaSE 基础
2017-01-08 19:40
309 查看
注意的隐藏**：
1.就近匹配原则
2.java采用的是 Unicode 字符集
3.表达式数据结果的类型自动提升
4.注意 短语与（短路或） 的巧用
5. HashMap 类对象中允许出现一对 null 键 null 值
6.集合中不能存放基本数据类型，而只能存放引用数据类型
7.描述文件路径可使用 / 或 \\
一、开发入门
1.Java是否只有编译过程，无所谓的链接，直接生成目标字节码文件？
2. path ：系统程序默认的寻找目录
classpath ：Java 类文件默认找寻路径
set path=%path%;[your path];
javac.exe ：java 编译工具
java.exe ： java 字节码文件运行工具
javac.exe 编译 --> java.exe {JVM启动，类加载，解释执行}
jar.exe ：打包工具
javadoc.exe ：文档制作工具
二、JAVA编程基础
1.Java 代码的基本格式
[修饰符] class [类名]{
[程序代码];
}
2.标识符的组成
所有大小写字母、数字、_ 、$
3.常量
整型：0b(0B)111001010、0134、12398、0x(0X)7F
默认为 int 类型
浮点型：0.7f(F) 、0.8d(D) 、5.022e+23f (e 表示以10为底的指数)
默认为 double 类型
字符：'a' '$' '\u0000'
特殊：'\r' 回车符
'\n' 换行符
'\t' 制表符
'\b' 退格符
'\'' '\"' '\\'
4.变量
4.1 数据类型
基本数据类型
整型 byte(8) short(16) int(32) long(64)
浮点型 float(32) double(64)
字符型 char(16)
布尔型 boolean
引用数据类型
类 class
接口 interface
数组
枚举 enum
注解 annotation
4.2 数据类型强转时发生"高位数据丢失"
4.3 在定义时，不可同时为多个变量赋值，如：
int x=y=z=5; 【错】
5. 运算符
5.1 在使用 -=、+=、*=、/=、%= 等运算时，强制类型转换会自动完成
5.2 & 与 && 的使用（| 与 || 的使用），后者为短路与（短路或），在使用的过程中，一旦左侧的结果能确定整个表达式的结果，则短路与（短路或）不进行右边的运算。（正常与 & 会进行两边的运算）
b>0 && z++>1;
x==0 || y++>0;
5.3 位运算符
& 按位与、| 按位或、~ 取反、^ 按位异或、<< 左移、>> 右移、>>> 无符号右移
6.选择结构语句
if(Expression){
...;
}
if(Expression){
...;
}else{
...;
}
三目运算符 Expression ? Expression_1 : Expression_2;
if(Expression){
...;
}else if{
...;
}
...else{
...;
}
switch(Expression){
case [Expression]:
...;
break;
case [Expression]:
...;
break;
....
default:
...;
break;
}
注：如果多个case条件后面使用的执行语句是一样的，则该执行语句只需书写一次即可。（在case后使用表达式时不会出现该情况）
*Code : Test_Switch.java
7.循环结构语句
while(Expression){
...;
}
do{
...;
}while(Expression);
for(初始化表达式 ; 循环条件 ; 操作表达式){
...;
}
8.跳转语句
8.1 break
· 跳出当前循环层
· 跳出到指定循环层
*Code : Test_break.java
8.2 continue 的使用与break相似
*Code : Test_continue.java
9.方法
修饰符 返回值类型 方法名([参数类型 参数名1 , 参数类型 参数名2 , ...]){
执行语句
...
return 返回值;
}
9.1 重载：1.方法名相同 2.参数个数或参数类型不同
10.数组
10.1 一维数组
动态初始化
类型[] 数组名 = new 类型[长度];
静态初始化
类型[] 数组名 = new 类型[]{元素,元素,...};
类型[] 数组名 = {元素,元素,...};
注意：不可写成 int[] x = new int[4]{1,2,3,4};
10.2 多维数组
int[][] arr = new int[3][4];
int[][] arr = new int[3][];
int[][] arr = {{1,2,3},{4,5,6},{7,8}};
*Code : Test_Array.java
三、面向对象
1.特性
封装性：将对象的属性和行为封装起来，不需要让外界知道细节
继承性：通过继承，可以在无需重新编写原有类的情况下对原有类的功能进行扩展
多态性：指的是一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为
2.类与对象
类名 对象名称 = new 类名();
对象引用.对象成员
2.1 this 关键字
· 可用于调用对象本身的属性和方法
· 可在构造方法中调用其他构造方法，且必须位于第一行、只能调用一次
this([参数1 , 参数2 , ...]);
不能在两个构造方法中使用this相互调用
*Code : Test_extends : Animal.java Dog.java Test.java
3.垃圾回收
可使用 System.gc(); 方法来通知Java虚拟机立即进行垃圾回收
当一个对象在内存中被释放时，他的 finalize(); 方法会被调用
public void finalize(){
...;
}
*Code : Test_finalize.java
4. static 关键字
4.1 静态（成员）变量
在内存中只有一份，能够被一个类的所有实例对象所共享
· JVM 会初始化其值
类名.变量名 或 对象名.变量名
4.2 静态（成员）方法
不实例化对象即可使用该方法
类名.方法名();
4.3 静态代码块
在类加载时执行的代码块，类只加载一次，故代码块只执行一次
static{
...;
}
5. 内部类
5.1 成员内部类
· 在成员内部类中可以访问外部类的所有成员
class Outer{
private int num = 4;
class Inner{
System.out.println("num = " + num);
//同 System.out.println("num = " + Outer.this.num);
}
}
· 不允许定义静态成员
· 通过外部类访问内部类（在其他类中实例化某个类的内部类）（外部类也会被实例化）
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
如： Outer.Inner inner = new Outer().new Inner();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.2 静态内部类
· 使用 static 关键字来修饰该内部类
· 在静态内部类中只能访问外部类的静态成员，不能调用外部费静态成员变量
· 可以定义静态成员
· 在其他类中实例化该内部类（可以在不实例化外部类的情况下实例化内部类）
外部类名.内部类名 变量名 = new 外部类名.内部类名();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.3 方法内部类
· 指在成员方法中定义的类，它只能在当前方法中被使用
· 方法内部类也可以访问外部类的成员变量
5.4 匿名内部类
· 格式
在需要该匿名内部类实例化对象的位置使用以下格式实例化对象
new 父类(参数列表)[或 父接口](){
//匿名内部类中需要实现的方法等
}
注：该类是匿名的，故称为匿名内部类
*Code : test_anonymousinnerclass : Animal.java & Test.java
6.Java 的文档注释
· 以 /** 开头，以 */ 结束
参数：@author ：程序的作者
@version ：程序的开发版本号
@param ：方法定义的参数以及参数对应的说明
@return ：方法的返回值代表的意义
· 生成文档的命令
如：javadoc -d . -author -version Test.java
-d 表示指定输出文档存放的目录
-author 表示文档中需包含作者信息
-version 表示文档中需包含版本信息
7.继承
· 关键字 ： extends
· 单继承，多层继承
· 重写：子类中存在与父类中相同方法名、参数列表、返回值类型相同的方法
8.super 关键字
· 可使用 super 关键字访问父类中的成员变量和成员方法
super.成员变量
super.成员方法([参数1,参与2,...]);
· 可使用 super 关键字调用父类的构造方法，且该语句必须位于子类构造函数第一行，只能有一句
super([参数1,参数2,...]);
*Code : Test_extends : Animal.java Dog.java Test.java
9.final 关键字
· final 修饰类 --> 不能被继承，且该类中所有的方法自动被 final 修饰，
· final 修饰方法 --> 不能被重写
· final 修饰变量（成员变量和局部变量） --> 常量，且只能被赋值一次，JVM不会默认对其进行初始化
10.抽象类和接口
10.1 抽象类 abstract
· 抽象类中存在构造方法
· 抽象类中未必有抽象方法
10.2 接口 interface
· 接口是特殊的抽象类，存在的所有方法都是抽象方法
· 方法默认使用 public abstract 修饰，变量默认使用 public static final 修饰（该变量只能在声明时初始化）
· 类使用 implements 实现某些接口，接口使用 extends 继承某些接口（使用逗号隔开多个接口）
· 继承和实现接口同时存在时，extends 必须位于 implements 之前
· 抽象类可以只实现接口的部分方法，但普通类必须实现接口所有抽象方法
10.2.1 匿名内部类
new 父类(参数列表)
11.多态
· 父类变量可引用子类对象
· 使用 instanceof 来判断某个类是否是另一个类（或接口）的实例或其子类实例，返回一个boolean值
[对象或对象的引用变量] instanceof [类或接口]
12.Object 类
· 是所有类的父类
· 方法
.toString(); //输出对象的基本信息
.getClass().getName(); //获得所属类的类名
.hashCode(); //返回该对象的哈希值，int类型值
13.异常 Exception
· 所有的 Error 和 Exception 都继承自 java.lang.Throwable 类
java.lang.Throwable
Error -IOError
-AWTError
Exception
-RuntimeException（可不使用 catch 捕获）
-ArithmeticException
-ClassCastException
-其他子类（必须使用 catch 捕获）（重点学习该类异常）
· 常用方法
String getMessage(); //返回此 throwable 的详细信息字符串
void printStackTrace(); //将此 throwable 及其追踪输出到标准输出流
void printStackTrace(); //将此 throwable 及其追踪输出到指定的输出流
13.1 try...catch 和 finally
· 格式
try{
//程序代码块
}catch(ExceptionType(Exception类及其子类) e){
//对 ExceptionType 的处理
}finally{
//无论是否有捕获到异常都要执行的程序代码块
}
注：finally{} 块当不使用时可被省略
finally{} 代码块有一种情况下不会被执行，那就是在 try{}catch{} 中执行了 System.exit(0); 语句，该语句表示退出当前的 java 虚拟机，Java 虚拟机停止了任何代码块都不会执行。
13.2 throws 关键字
· 该关键字用于声明某方法可能会发生的异常
· 被该关键字修饰的方法使用时必须使用 try{}catch{} 捕获异常，或在使用该方法的方法声明同样可能抛出的异常
· 如果程序中的异常没有被处理，程序就会非正常终止
· 格式
修饰符 返回值类型 方法名([参数列表]) throws ExceptionType_1 [,ExceptionType_2[,...]]{}
注：ExceptionType 表示可能抛出的异常类或其父类
13.3 throw 关键字
在程序的代码块中使用，用于抛出一个异常实例对象
· 格式
throw ExceptionType(Exception 类或其子类) e;
13.4 异常的分类
· checked 异常（编译时异常）
Exception 类中除了 RuntimeException 类及其子类外都是编译时异常
· 使用 try{}catch{} 捕获并处理
· 在调用该方法的方法声明处使用 throws 关键字声明抛出异常
· unchecked 异常（运行时异常）
java 编译器不会对其进行检查，一般由逻辑错误引起的
· 自定义异常
用户自定义的异常，继承自 Exception 类或其子类
在定义时可使用 Exception 的无参构造函数或有参构造函数
*Code : test_exception : DivideByMinusException.java & Test.java
13.5 包
常用于对 .java 文件进行集中管理，没有显式地声明 package 语句，则处于默认包下
· package 关键字
用于声明某个类属于哪个包
package 包名;
· import 关键字
使用该关键字可在程序中一次导入某个指定包下的类，这样就不必在每次使用该类时都要输入完整的类名了
import 包名.类名; //导入某个包下的某个类
import 包名.*; //导入某个包下的所有类
13.6 其他
13.6.1 编译 .java 文件
javac -d . Example.java
-d 指定生成的 .class 文件存放位置
13.6.2 给 java 程序打包
jar -cvf helloworld.jar cn
-c 代表创建归档文件
-v 在标准输出中生成详细输出
-f 指定归档文件名
jar -xvf helloworld.jar
将 jar 包里的文件和文件夹解压到当前文件夹下
java -jar helloworld.jar
执行 jar 文件
· 生成的 .jar 包里的 MANIFEST.MF 文件就是用来指定 jar 包主类的文件
在该文件里添加 "Main-Class:[完整的类名]"
13.6.3 访问控制权限
从小到大：private < default < protected < public
private : 被修饰的类成员只能被该类的其他成员访问
default : 当一个类或类的成员不使用任何修饰符修饰时，则默认为 default ，只能被本包的其他类访问
protected : 被修饰的类的成员既能被同一包下的其他类访问，也能被不同包下的子类访问
public : 被修饰的类或类的成员能被所有其他类访问，不论访问类与被访问类是否在同一包下
四、多线程
实现多段程序交替运行
1.线程的创建
1.1 继承 java.lang.Thread 类，并重写 run() 方法
1.1.1 Thread 类的常用方法
.run(); //使用当前进程执行 run();
.start(); //开启一个新的线程，并使用该线程执行 run();
1.2 实现 java.lang.Runnable 接口，并实现 run() 方法
通过 Thread(Runnable target); 构造方法来创建一个线程对象
· 实现了当使用多线程去处理同一资源时，把线程同程序代码、有效数据有效分离（即使用同一 Runnable 实例化对象去创建多个线程，可实现在多线程下使用同一对象资源）
2.Thread 类的常用方法
.setName(String name); //设置该线程的 name ；也可以使用构造方法 Thread(Runnable,String); 来设置
.currentThread(); //获取当前线程对象
3.后台线程
· 新创建的线程默认是前台线程
· 对Java程序来说，只要还有一个前台线程在运行，这个进程就不会结束；如果一个进程中只有后台线程运行，这个进程就会结束
3.1 常用方法（Thread 对象）
.setDaemon(boolean b); //将一个线程设置成后台线程，该方法只能在 .start(); 方法调用前调用，否则会引发 IllegalThreadStateException 异常
.isDaemon(); //判断该线程是否为后台线程
4.线程的生命周期及状态转换
4.1 线程的周期
新建状态（new）：仅为线程对象分配了内存资源
就绪状态（Runnable）：线程对象调用了 .start(); 方法
运行状态（Running）：获得 CPU 的使用权
阻塞状态（Blocked）：
· 当线程获取某个对象的同步锁时，该锁被其他线程所持有
· 当线程调用了一个阻塞式的 IO 同步方法
· 当线程调用了某个对象的 .wait(); 方法时
· 当线程调用了 Thread.sleep(); 方法时时
· 当线程调用了另一个线程的 .join(); 方法时
死亡状态（Terminated）：
· 当线程中的 run(); 方法执行完毕时
· 当线程执行过程中出现一个未捕获的异常（Exception）或错误（Error）
· 注：线程进入死亡状态，但是该线程对象仍是一个Thread对象，在没有被垃圾回收器回收之前仍可以和引用其他对象一样引用它。
4.2 线程的调度
4.2.1 调度模型
· 分时调度模型
为所有线程轮流分配一个 CPU 使用权的时间片
· 抢占式调度模型（默认）
优先级高的线程优先占用 CPU；对于相同优先级的线程，则随机选择一个线程使其占用 CPU
4.2.2 线程的优先级
· 可使用 1~10 来表示，数字越大优先级越高，超出范围会报错
static int MAX_PRIORITY； //表示线程的最高优先级，相当于 10
static int MIN_PRIORITY; //表示线程的最低优先级，相当于 1
static int NORM_PRIORITY; //表示线程的普通优先级，相当于 5
· 常用方法（Thread 类实例化对象）
void setPriority(int newPriority); //设置该线程的优先级
int getPriority(); //获得该线程的优先级
· 注：不同操作系统对优先级的支持是不一样的，不能很好地和 java 中线程优先级一一对应，因此，在设计多线程应用程序时，其功能的实现一定不能依赖于线程的优先级，而只能把线程优先级作为一种提高程序效率的手段
4.2.3 线程休眠（继续占有同步锁）
“运行状态” --> “阻塞状态” -（休眠时间结束）-> “就绪状态”
使‘运行状态’的线程进入‘阻塞状态’一段时间（线程暂停执行一段时间），休眠时间结束后，回到‘就绪状态’
public static native void sleep(long millis) throws InterruptedException; //休眠方法，默认单位为 ms
· 使用方法
Thread.currentThread().sleep(); 与 Thread.sleep(); 相同，该方法为静态方法，作用于执行该代码的‘当前进程’
4.2.4 线程让步（放弃同步锁）
“运行状态” --> “就绪状态”-（CPU第二次调度...第三次...）-> “运行状态”或“就绪状态”
使当前线程让出 CPU 使用权，并进入‘就绪状态’，让系统的调度器在具有与当前线程相同优先级或更高优先级且处于‘就绪状态’的线程之间重新调度一次
public static native void yield(); //线程让步方法，静态方法，执行该代码的当前进程
· 使用方法
Thead.yield();
*Code : test_thread : MyThread.java & Test_Yield.java
4.2.5 线程插队（抢占同步锁）
“运行状态” --> “阻塞状态” -（插队的线程执行结束）->“就绪状态”
当在某个线程中调用‘某一线程’的 .join(); 方法时，调用的线程将被阻塞，直到插队线程（‘某一线程’）执行结束
public final void join() throws InterruptedException;
· 使用方法（Thread 类或其子类的实例化对象）
.join();
*Code : test_thread : MyThread.java & Test_Join.java
4.3 多线程同步
· 利用锁对象的唯一性来确保代码访问共享资源时不出现‘意外’，锁对象的标志位默认为 1，被占用后置为 0
· 锁对象不能在 run(); 方法中创建
· 被 synchronized 修饰的代码块或方法在某一时刻只允许一个线程访问
4.3.1 同步代码块
synchronized(lock){ //lock 是一个锁对象，可以是任意类型
//操作共享资源代码块
}
*Code : test_thread : Test_Synchronized_1.java
4.3.2 同步方法
synchronized 返回值类型 方法名([参数列表]){
//共享资源代码块
}
· 注：
非静态同步方法的锁对象是调用该方法的对象，即 this 指向的对象，实现 run(); 方法的类的实例化对象。
静态同步方法的锁对象是该类方法所在的 java.lang.Class 对象 “类名.class"
*Code : test_thread : Test_Synchronized.java
4.3.3 死锁
JVM没有检测死锁和处理死锁的措施。
4.4 多线程通信
· 用于解决当多个线程同时操作同一存储空间而引发的‘意外’问题（数据的存储结果超乎意料）
4.4.1 常用的同步锁对象（任意类型）的方法，该方法定义在 Object 类中（存在一个‘同步锁等待队列’，该队列存放线程对象）
.wati(); //使调用该方法的当前线程‘放弃同步锁’进入等待，直到其他线程‘获得该同步锁’并调用同步锁的 notify(); 方法或 notifyAll(); 方法唤醒该线程
.notify(); //唤醒此同步锁上等待的第一个调用 wait(); 方法的线程
.notifyAll(); //唤醒此同步锁上等待的所有调用 wait(); 方法的线程
*注： public final void wait() throws InterruptedException;
public final native void notify();
public final native void notifyAll();
*Code : test_thread : Test_Wait_Notify.java
五、Java API
1. String 类和 StringBuffer 类（java.lang）
1.1 String 类（常量，一旦创建，其内容和长度都是不可改变的，只能创建（生成）新的字符串）
1.1.1 初始化
String str = "[字符串]";
String str = new String();
String str = new String(char[] value);
String str = new String(String value);
String str = new String(char[] value,int beg,int end);
1.1.2 常用操作
boolean equalsIgnoreCase(String another); //比较两个字符串（忽略大小写）
int indexOf(int ch); //返回该字符第一次出现的位置
boolean isEmpty(); //当且仅当字符串长度为 0 时返回 true
boolean contains(CharSequance cs); //判断此字符串中时候包含指定的字符串序列
String replace(CharSequence oldstr,CharSequence newstr); //返回一个新的字符串，它是通过用 newstr 替换此字符串中出现的所有的 oldstr 得到的
String[] split(String regex); //根据参数 regex 将原来的字符串分割成若干个子字符串
String trim(); //返回一个新字符串，它除去了原字符串首尾的空格
String substring(int beginIndex); //返回一个新的字符串，同包含字符串中索引 beginIndex 后的所有字符串（包含开始索引的字符）
String substring(int beginIndx,int endIndex); //返回一个新的字符串，它包含此字符串中从索引 beginIndex 到索引 endIndex 之间的所有字符（包含开始索引的字符，不包括结束索引的字符）
· 其他：
int lastIndexOf(int ch);
char charAt(int index);
boolean startsWith(String prefix); //判断此字符串是否以指定的字符串开始
boolean endsWith(String suffix);
int length(); //返回此字符串的长度
boolean equals(Object anObject); //将此字符串与指定的字符串比较
String toUpperCase(); //使用默认语言环境的规则将 String 中的所有字符串都转换为大写
String toLowerCase();
String valueOf(int i); //返回 int 参数的字符串表示形式，静态方法
char[] toCharArray(); //将此字符串转换为一个字符数组
* Code : test_javaapi : Test_String.java
1.1.3 注意
在 JVM 中，相同内容的字符串常量在内存中只存在一份（引用地址相同），而在运行时产生的相同内容的字符串在内存中的引用地址不同
1.2 StringBuffer 类（也称字符串缓冲区，其内容和长度都是可以改变的）
1.2.1 初始化
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(String str);
StringBuffer sb = new StringBuffer(CharSequence cs);
StringBuffer sb = new StringBuffer(int capacity); //设定容量，容量不足时会自动改变
1.2.2 常用方法（StringBuffer 对象）
StringBuffer append(String str); //添加字符串到 StringBuffer 对象中
StringBuffer insert(int offset,String str); //在指定（从头开始）偏移量 offset 位置插入字符串 str
StringBuffer deleteCharAt(int index); //删除字符串中指定索引位置的字符
StringBuffer delete(int start,int end); //删除 StringBuffer 对象中指定范围的字符或字符串序列（包含开始索引字符，不包含结束做引字符）
StringBuffer replace(int start,int end,String s); //替换指定范围内的字符串为另一字符串（包含开始索引字符，不包含结束索引字符）
void setCharAt(int index,char ch); //替换指定索引位置的字符
String toString(); //返回 StringBuffer 缓冲区中的字符串
StringBuffer reverse(); //将缓冲区中的字符串反转
*Code : test_javaapi : Test_StringBuffer.java
1.3 两者的比较
· String 类表示的字符串是常量
· String 类覆盖了 Object 类的 equals(); 方法，而 StringBuffer 类没有覆盖该方法
· String 类对象之间可以用操作符 '+' 进行连接，而 StringBuffer 类对象之间不能，会编译错误
2. System 类和 Runtime 类
2.1 System 类
· static void exit(int status);
该方法用于终止当前正在运行的 java 虚拟机，其中参数 status 表示状态码，若状态非 0，则表示异常终止
· static long gc();
运行垃圾回收器，并对垃圾进行回收
· static long currentTimeMillis();
返回以毫秒为单位的当前时间，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，一般成为时间戳
· staitc void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
从 src 引用的指定源数组复制到 dest 引用的数组，复制从指定的位置（srcPos 与 destPos 表示起始位置）开始的一定长度的数据
· static Properties getProperties();
取得当前系统的全部属性，该方法会返回一个 Properties 类对象，属性以键值对的形式存在
*Code : test_javaapi : Test_System.java
2.2 Runtime 类
该类用于表示虚拟机运行时的状态，它用于封装 JVM 虚拟机进程，采用单例模式进行设计，故不可以直接实例化
· 获得 Runtime 类实例对象
Runtime runtime = Runtime.getRuntime();
· 常用方法（Runtime 类对象）
.availableProcessors(); //获得当前虚拟机可使用的处理器个数
.freeMemory(); //获得当前虚拟机的空闲内存大小（字节）
.maxMemory(); //获得当前虚拟机最大可用内存空间大小（字节）
public Process exec(String command) throws IOException; //执行一个 dos 命令，同“运行”
该方法返回一个 Process 类对象，调用该对象的 .destroy(); 方法可以关闭该进程
*Code : test_javaapi : Test_Random.java
3. Math 类和 Random 类
3.1 java.util.Math 类
· 常用方法
Math.abs(int num); //求一个数的绝对值
Math.ceils(double num); //求大于某个数的最小整数（double）
Math.floor(double num); //求小于某个数的最大整数（double）
Math.round(double num); //求一个数四舍五入的结果（long）
Math.max(num_1,num_2); //求两个数中的最大值
Math.min(num_1,num_2); //求两个数中的最小值
Math.random(); //返回一个值（0.0 <= x <1.0）
*Code : test_javaapi : Test_Math.java
3.2 java.util.Random 类（伪随机数生成器）
· 创建伪随机数生成器
Random random = new Random(); //随机使用一个种子（当前时间戳）创建伪随机数生成器
Random random = new Random(long seed); //使用给定的种子来创建伪随机数生成器
· 注：种子相同产生的随机序列相同
· 常用方法
boolean nextBoolean(); //产生一个随机的 boolean 值
double nextDouble(); //产生一个 [0,1) 之间的 double 值
float nextFloat(); //产生一个 [0,1) 之间的 float 值
int nextInt(); //产生一个随机的有符号的 int 值
int nextLong(); //产生一个随机的有符号的 long 值
*Code : test_javaapi : Test_Random.java
4.包装类
4.1 基本数据类型对应的包装类
· byte --> Byte
· char -->Character
· int --> Integer
· Integer 类的常用静态方法
public static String toBinaryString(int i); //将一个整型数值转换为二进制值字符串
public static String toHexString(int i); //将一个整型数值转换为十六进制值字符串
public static String toOctalString(int i); //将一个整型数值转换为八进制值字符串
public static int parseInt(String s); //将一个整型数据字符串识别为整型数值
· Integer 类对象的常用方法
.intValue(); //将 Integer 类型的值以 int 类型值返回
· short --> Short
· long --> Long
· float --> FLoat
· double --> Double
· boolean --> Boolean
4.2 注意
· 所有的包装类都重写了 Object 类中的 .toString(); 方法，该方法以字符串的形式返回被包装的基本数据类型的值
· 除了 Character 类外，其他包装类都有 valueOf(String s); 方法（静态方法），该方法会根据传入的 String 类型参数返回一个适合的包装类对象，该字符串不能为 null 且是可以被解析的，否则即使通过编译也会发生运行时错误
· 除了 Character 类外，其他包装类都有 parseXXX(String s); 方法（静态方法），用法及规则同上
· ‘装箱’与‘拆箱’
装箱：指的是把 基本数据类型值 --> 包装类对象
拆箱：指的是把 包装类对象 --> 基本数据类型值
注：JDK 5.0 之后支持自动装箱与自动拆箱技术，基本数据类型值也可以和包装类对象直接使用操作符进行运算
*Code : test_javaapi : Test_PackingClass.java
5. Date 类、Calendar 类与 DateFormat 类
5.1 java.util.Date 类
· 初始化
Date date = new Date(); //创建一个当前时间的 Date 对象
Date date = new Date(long millisecond); //根据一个时间戳创建 Date 对象
· 该类对象以默认格式输出日期和时间
5.2 java.util.Calendar 类（抽象类）
· 用于完成时间和日期字段的操作，可以通过特定的方法设置和读取日期的特定部分，该类是一个抽象类，不可以直接实例化
· 获得一个 Calendar 类实例化对象
Calendar calendar = Calendar.getInstance(); //创建一个代表默认时区内当前时间的 Calendar 对象
· Calendar 类对象的常用方法
public final void setTime(Date date); //传入一个 Date 类对象来设置 Calendar 类对象的值
public final Date getTime(); //获得 Calendar 类对象对应的 Date 类对象
public int get(int field); //返回指定日历字段的值
如： Calendar.YEAR、Calendar.MONTH、Calendar.DATE、Calendar.HOUR、Calendar.MINUTE、Calendar.SECOND
注：Calendar.MONTH 代表的月字段的值范围为 [0,11]
Calendar 类对象中字段的修改会发生进位
· Calendar 类的两种模式
- lenient 模式（日历字段模式）（默认模式）
该模式下允许字段超出其取值范围，当输出时间时会自动标准化时间
- non-lenient 模式
该模式下的日期和时间只接受规定范围内的数值
*Code : test_javaapi : Test_Calendar.java
5.3 java.text.DateFormat 类（抽象类）
该类用于将一个日期格式化为字符串或将一个特定格式显示的日期字符串转换成一个 Date 对象
· 获得 DateFormat 类对象
public final static getDateFormat(); //用于创建默认语言环境和格式化风格的日期格式化器
public final static getDateFormat(int style); //用于创建默认语言环境和指定格式化的日期格式器
public final static getDateTimeFormat(); //用于创建默认语言环境和格式化风格的日期/时间格式器
public final static getDateTimeFormat(int dateStyle,int timeStyle); //用于创建默认语言环境和指定格式化风格的日期/时间格式器
· 常用方法（DateFormat 类对象）
public final String format(Date date); //将一个 Date 类对象格式化为日期/时间字符串
public Date parse(String source) throws ParseException; //将给定字符串解析成一个 Date 类对象，字符串必须符合格式要求，否则会抛出异常
· 给定的四种格式化风格
DateFormat.FULL； //表示完整格式，如 2017年1月6日 星期五 下午07时38分27秒 CST
DateFormat.LONG; //表示长格式，如 2017年1月6日 下午07时38分27秒
（默认）DateFormat.MEDIUM; //表示普通格式，如 2017-1-6 19:38:27
DateFormat.SHORT; //表示短格式，如 17-1-6 下午7:38
*Code : test_javaapi : Test_DateFormat.java
5.4 java.text.SimpleDateFormat 类（DateFormat 类的子类）（自定义日期/时间格式化器）
可以使用 new 来实例化对象，它的构造方法介绍一个格式字符串参数，表示日期格式模板
· 实例化 SimpleDateFormat 类
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(); //默认以短格式为模板
SimoleDateFormat simpleDateFormat = new SimpleDateFormat(String pattern);
· 占位符
yyyy - 年
MM - 月（数字）
dd - 日
HH - 时
mm - 分
ss - 秒
*Code : test_javaapi : Test_SimpleDateFormat.java
六、集合类
1.集合的分类
Collection : List : 元素有序，可重复（ArrayList , LinkedList , Vector）
Set : 元素无序，不可重复（HashSet , TreeSet）
Map : 用于存储包含键（key）、值（value）映射关系的值
包含一个存放 key 的 Set 视图（key 具有唯一性）和一个存放 value 的 Collection 视图
2. Collection 接口
2.1 该接口的方法
boolean add(Object o); //添加一个元素
boolean addAll(Collection c); //把另一个集合中的元素添加到该集合中
void clear(); //清空该集合中的所有元素
boolean remove(Object o); //删除该集合中指定的元素
boolean removeAll(Collection c); //删除该集合中存在的另一集合中的元素
boolean isEmpty(); //判断该集合是否为空
boolean contains(Object o); //判断该集合是否包含某个元素
boolean containsAll(Collection c); //判断该集合中是否包含另一集合中的所有元素
Iterator iterator(); //获得该集合的迭代器
int size(); //获得该集合的中元素的个数
2.2 List 接口
2.2.1 接口常用方法
void add(int index,Object element); //将 element 插入到 List 集合的 index 处
boolean addAll(int index,Collection c); //将另一个集合中的所有元素插入到 List 集合的 index 处
Object get(int index); //获得 List 集合中 Index 处的元素
Object remove(int index); //删除 List 集合中 index 处的元素
Object set(int index,Object element); //将 List 集合中 index 处元素替换为 element 元素，并将替换后的元素返回
int indexOf(Object o); //返回 o 元素在 List 集合中第一次出现的位置
int lastIndexOf(Object o); //返回 o 元素在 List 集合中最后一次出现的位置
List subList(int fromIndex,int toIndex); //返回一个子集合，该子集合包含源集合中从 fromIndex （包含）到 toIndex （不包含）之间的所有元素
2.2.2 java.util.ArrayList 类（该集合是线程不安全的，即其方法不具有同步锁特征）
该类内部封装了一个长度可变的数组对象。
· 特点：查找访问元素方便快捷，但不适合做大量的增删操作
2.2.3 java.util.LinkedList 类
该类内部维护了一个双向循环链表，使用引用的方式来记住前一个元素和后一个元素。
· 特点：对元素的增删操作有很高的效率
· 常用方法（LinkedList 类对象）
void add(int index,E element); //在此集合中指定的位置插入 element
void addFirst(Object o); //在集合的开头位置插入 o
void addLast(Object o); //在集合的结尾位置插入 o
Object getFirst(); //返回该集合的第一个元素
Object getLast(); //返回该集合的最后一个元素
Object removeFirst(); //移除并返回该集合的第一个元素
Object removeLast(); //移除并返回该集合的最后一个元素
2.2.4 java.util.Iterator 接口（只能从第一个元素遍历到最后一个元素）（仅可正向迭代）
该接口主要用于遍历 Collection 中的元素，故也称为 迭代器
· 常用方法（实现 Iterator 接口的类实例化对象）
boolean hasNext(); //判断集合中是否存在下一个元素
Object next(); //获得下一个元素
· 如果想要通过 .next(); 方法得到特定的元素类型，需进行强制类型转换
· 若在迭代过程中，使用集合的 .remove(); 操作，则可能引发 ConcurrentModificationException 异常，原因是集合删除元素可能导致迭代器预期的迭代次数发生改变，导致迭代器的结果不准确。解决办法是在执行 .remove(); 操作后不再使用该迭代器，或使用迭代器本身的 .remove(); 方法来移除元素（该方法导致的迭代次数变化对 Iterator 来说是可预知的）。
·
2.2.5 foreach 循环（增强的 for 循环）
只能对元素进行访问，不能修改（仅是对临时变量引用的修改）
· 格式
for(容器中元素类型 临时变量 : 容器变量){
//执行语句
}
2.2.6 ListIterator 接口（Iterator 接口的子类）（可正向迭代，可反向迭代）
· 只能用于遍历 List 集合
· 特有方法
void add(Object o); //将指定的元素插入列表
boolean hasPrevious(); //判断当前指针元素所指向的元素是否存在前一个元素
Object previous(); //返回前一个元素
void remove(); //从列表中移除当前迭代器指针所指向的元素
· 获得 ListIterator 对象
ListIterator listIterator = list.listIterator(); //默认指针指向第一个元素
ListIterator listIterator = list.listIterator(int index); //指针指向 index 位置的元素
2.2.7 Enumeration 接口（只可正向遍历）
· 该接口用于遍历 Vector 集合（该集合是线程安全的，即其方法具有同步锁特征）
· Vector 类的用法与 ArrayList 相同
· 获得 Enumeration 对象
Enumeration en = ( Vector 集合的实例化对象).elements();
· 该接口的常用方法
boolean hasMoreElements(); //判断是否存在下一个元素
Object nextElement(); //获得下一个元素
*Code : test_collection_map : Test_List.java
2.3 Set 接口
2.3.1 java.util.HashSet 类（无序）
· 特点：具有良好的存取和查找性能
· 该集合添加元素的流程
先调用元素的 .hashCode(); 方法来确定元素的存储位置；若该位置上已存在元素，则调用元素的 .equals(); 方法来判断是否为同一元素，若结果为 true ，则表示元素重复，丢弃该元素，若结果为 false，则替换原位置上的元素。
· 一般要求对存入元素的类的下列方法进行重写
public int hashCode();
public boolean equals(Object obj);
2.3.2 java.util.TreeSet 类（有序）（采用平衡的二叉树原理）
· 存入该集合的类必须实现 java.lang.Comparable 接口，实现 public int compareTo(Object obj); 方法；或在定义该集合时传入一个适合的比较器（即该类实现了 Comparator 接口，实现该接口中的 public int compare(Object obj1,Object obj2); 方法）。
*Code : test_collection_map : Test_Set.java
3. Map 接口
3.1 该接口的常用方法
void put(Object key,Object value); //将指定的 value 与此映射的指定的 key 关联
Object get(Object key); //返回指定 key 所映射的 value ，若不存在则返回 null
boolean containsKey(Object key); //若存在该 key ，则返回 true
boolean containsValue(Object value); //若存在该 value，则返回 true
Set keySet(); //返回一个包含左右 key 的 Set 视图
Conllection<V> values(); //返回此映射中包含的所有的 value 的 Collection 视图
Set<Map.Entry<K,V>> entrySet(); //返回一个包含所有 key 和 value 的 Set 视图
3.2 java.util.HashMap 类（默认对 key 进行排序）
· key 相同则 value 会发生覆盖
· Map.Entry 类是 Map 接口内部类
· 元素取出顺序与存入顺序不同
· 该集合中允许出现一对 null 键 null 值
3.3 java.util.LinkedHashMap 类（是 HashMap 类的子类）
· 该类内部维护一个双向链表，使元素的迭代顺序与存入的顺序相同
3.4 java.util.TreeMap 类（对 key 排序，采用平衡的二叉树原理）
· 要求 key 元素类实现 Comparable 接口或传入一个实现 Comparator 接口的比较器
· 遍历方法同 HashMap 类
3.5 java.util.Properties 类（Hashtable 类的子类）（用于存储配置项）
· HashMap 与 Hashtable 的区别在于后者是线程安全的且读取较慢
· Properties 类主要用于存储字符串类型的 key 和 value
· 常用方法（Properties 类对象）
public synchronized Object setProperty(String key,String value); //用于添加或修改键值
public String getProperty(String key); //获得 key 所对应的 value，找不到 key 则返回 null
public String getProperty(String key,String defaultValue); //获得 key 所对应的 value，若找不到 key 则返回 defaultValue
*Code : test_collection_map : Test_Map.java
4.泛型（JDK 5.0 新特性）
· parameterized type 即参数化类型（泛型），限定方法操作的数据类型，避免了在程序中进行强制类型转换
· 使用方法
在定义集合类时，使用 "<参数化类型>" 的方式指定该类中方法操作的数据类型
如： ArrayList<String> list = new ArrayList<String>();
· 自定义泛型
在类定义时，类名后添加 "<Type_1 [ , Type_2[ , ...]]>" 以声明参数类型
*Code ： test_collection_map : Test_ParameterizedType.java
5. java.util.Collections 集合操作工具类
5.1 排序操作
public static <T> boolean addAll(Collection<? super T> c,T... elements); //将所有指定元素添加到指定的 Collection 集合中
public static void reverse(List<?> list); //反转 List 类对象中的元素顺序
public static void shuffle(List<?> list); //随机排序 List 类对象中的元素（洗牌）
public static void sort(List list); //对 List 类对象中的所有元素按自然顺序排序
public static void sort(List list,Comparator c); //使用给定的比较器对 List 类对象中的所有元素进行排序
public static void swap(List list,int i,int j); //将指定 List 类对象中的 i 索引元素和 j 索引元素进行交换
5.2 查找、替换操作
public static int binarySearch(List list,Object key); //使用二分法搜索指定的 key 对象在 List 类对象中的索引，该 List 类对象必须是有序的
public static Object max(Collection c); //根据元素的自然顺序返回 List 类对象中最大的元素
public static Object min(Collection c); //根据元素的自然顺序返回 List 类对象中最小的元素
public static boolean replaceAll(List list,Object oldVal,Object newVal); //把 List 类对象中所有的 oldVal 替换成 newVal
6. java.util.Arrays 数组操作工具类
· 常用方法
public static void sort(int[] arr); //该方法有多个重载，对数组进行排序
public static int binarySearch(Object[] arr,Object key); //该方法有多个重载，使用二分法在排序过的数组中进行查找并返回索引
public static int[] copyOfRange(int[] original,int from,int to); //拷贝源数组中指定范围内的元素，超出范围内的以‘默认值’填充，包括 from 索引元素，不包括 to 索引元素
public static void fill(Object[] arr,Object value); //以 value 来填充该数组
public static String toString(Object[] arr); //返回此数组的字符串表现形式，该方法不是对 Object 类中 .toString(); 方法的重写
七、IO
1. IO流 ： 字节流 ： 字节输入流、字节输出流
字符流 ： 字符输入流、字符输出流
2.字节流
2.1 java.io.InputStream 抽象类
· 子类
FileInputStream
BufferedInputStream ： 装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public int read() throws IOException; //从输入流读取一个字节（8位），转换为0~255的整数，并返回该证整数（EOF 值为 -1）
public int read(byte[] b) throws IOException; //从输入流读取若干字节，保存到 b 数组中，并返回成功读取的字节数
public int read(byte[] b,int off,int len) throws IOException; //从输入流的起始位置 off 开始读取 len 个字节数保存到 b 数组中，并返回成功读取的字节数
public void close() throws IOException; //关闭此输入流并释放与该流关联的所有系统资源
· 初始化
FileInputStream fileInputStream = new FileInputStream(String filename) throws FileNotFoundException;
BufferedInputstream bis = new BufferedInputStream(InputStream in); //装饰类
2.2 java.io.OutputStream 抽象类
· 子类
FileOutputStream
BufferedOutputStream ： 装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public void write(int b) throws IOException; //向输出流写入一个字节
public void write(byte[] b) throws IOException; //把 b 数组中的所有字节写入输出流
public void write(byte[] b,int off,int len) throws IOException; //把 b 数组中从偏移量 off 的位置开始的 len 个字节写入输出流
public void flush() throws IOException; //刷新此输出流并强制把缓冲区中的数据写入到目标设备
public void close() throws IOException; //关闭此输出流并释放与此流相关的所有系统资源
· 初始化
FileOutputStream fileOutputStream = new FileOutputStream(String name) throws FileNotFoundException;
FileOutputStream fileOutputStrema = new FileOutputStream(String name,boolean append) throws FileNotFountException; // append 参数表示是否以‘追加’方式写入数据
BufferedOutputStream bos = new BufferedOutputStream(OutputStream out); //装饰类
*Code : test_io : Test_Input_Output_Stream.java & Test_Byte_FileCopy.java & Test_Byte_Buffered.java
3.字符流
3.1 java.io.Reader 抽象类
· 子类
FileReader
BufferedReader ：装饰类，内部定义了一个大小为 8192 的字节数组
LineNumberReader ：BufferedReader 的直接子类
· 常用方法
public int read() throws IOException; //读取一个字符，返回该字符的整型值（该方法有多个重载）
· BufferedReader 的特有方法
public String readLine() throws IOException; //读取一行（返回的结果中不包括 换行符）
· LineNumberReader 的特有方法
public void setLineNumber(int lineNumer); //设置起始行号（并非从该行开始读）
· 初始化
FileReader fileReader = new FileReader(String fileName) throws FileNotFoundException;
BufferedReader br = new BufferedReader(Reader r);
LineNumberReader lr = new LineNumberReader(Reader r);
3.2 java.io.Writer 抽象类
· 子类
FileWriter
BufferedWriter ：装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public void write(int ch) throws IOException; //写入一个字符（该方法有多个重载）
public void writer(String str) throws IOException; //写入一个字符串
public Writer append(CharSequence csq) throws IOException; //以附加方式写入字符串
· BufferedWriter 的特有方法
public void newLine() throws IOException; //写入一个换行符
· 初始化
FileWriter fileWriter = new FileWriter(String fileName) throws IOException;
FileWriter fileWriter = new FileWriter(String fileName,boolean append) throws IOException;
BufferedWriter bw = new BufferedWriter(Writer w);
*Code : test_io : Test_Reader_Writer.java & Test_Buffered_Reader_Writer.java & Test_LineNumberReader.java
4.转换流
· 只能针对操作文本文件的字节流进行转换，若操作的是图片文件，则可能会因为转换为字符流而造成数据丢失
4.1 java.io.InputStreamReader 类（Reader 类的子类）
· 将字节输入流转换为字符输入流
4.2 java.io.OutputStreamWriter 类（Writer 类的子类）
· 将字节输出流转换为字符输出流
*Code : test_io : Test_ConvertClass.java
5.其他 IO 流
5.1 java.io.ObjectInputStream 类 & java.io.ObjectOutputStream 类
· 该类只能一次读写（尚且不知道原因），若想一次性写入多个对象可将所有对象存放在一个 List 中，一次写入
· 要写入流的对象必须实现 java.io.Serializable 接口
· 初始化
ObjectInputStream ois = new ObjectInputStream(InputStream in) throws IOException;
ObjectOutputStream oos = new ObjectOutputStream(OutputStream out) throws IOException;
· ObjectInputStream 类 常用方法
public final Object readObject() throws IOException,ClassNotFountException; //从流中读取一个对象
· ObjectOutputStream 类 常用方法
public final void writeObject(Object obj) throws IOException; //往流中写入一个对象
*Code : test_io : Test_Object_Input_Output_Stream.java
5.2 java.io.DataInputStream 类 & java.io.DataOutputStream 类
· 该类主要用于存储基本数据类型
· 使用时数据的类型读取顺序要与写入顺序相同，才能保证最终数据的正确性
· 初始化
DataInputStream dis = new DataInputStream(InputStream in);
DataOutputStream dos = new DataOutputStream(OutputStream out);
· DataInputStream 类 常用方法
public final int readInt() throws IOException;
public final String readUTF() throws IOException;
public final boolean readBoolean() throws IOException;
public final char readChar() throws IOException;
· DataOutputStream 类 常用方法
public final void writeInt(int i) throws IOException;
public final void writeUTF(String str) throws IOException;
public final void writeBoolean(boolean v) throws IOException;
public final void writeChar(char c) throws IOException;
*Code : test_io : Test_Data_Stream.java
5.3 java.io.PrintStream 类（打印流）（与 DataOutputStream 类相似）
· 该类主要用于该基本数据类型或引用数据类型的对象格式化成字符串后再输出（调用对象的 .toString(); 方法）
· 初始化
PrintStream ps = new PrintStream(OutputStream out);
· 常用方法
public void print(String str); //打印一个字符串（该方法有多个重载）
public void println(Object obj); //调用该对象的 .toString(); 方法，并将结果写入流（该方法有多个重载）
*Code : test_io : Test_PrintStream.java
5.4 标准输入输出流
· 标准流
输入流 System.in : InputStream
输出流 System.out : PrintStream
错误流 System.err : PrintStream
· 重定向标准流（System 类的静态方法）
输入流 public static void setIn(InputStream in);
输出流 public static void setOut(PrintStream out);
错误流 public static void setErr(PrintStream err);
*Code : test_io : Test_System_In_Out_Err.java
5.5 java.io.PipedInputStream 类 & java.io.PipedOutputStream 类（管道流，一般用于线程间通信）
· PipedInputStream 类 用于从管道读取数据到程序中
PipedOutputStream 类 用于从程序写数据到管道中
· 初始化
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
· 常用方法（PipedInputStream 类对象或 PipedOutputStream 类对象）
public void connect(PipedOutputStream src) throws IOException; // PipedInputStream 类对象的方法和，连接输出管道
public synchronized void connect(PipedInputStream snk) throws IOException; // PipedOutputStream 类对象的方法，用于连接输入管道
*Code : test_io : Test_PipedStream.java
5.6 java.io.ByteArrayInputStream 类 & java.io.ByteArrayOutputStream 类（字节数组缓冲区）
· ByteArrayInputStream 类只能从一个 Byte[] 数组中读取数据
· ByteArrayOutputStream 类会在创建实例化时创建一个 Byte[] 数组的缓冲区，该缓冲区会根据存入数据的多少而自动变化，因此可以减少写数据的次数。（如果读取的文件非常大，就不能使用这个类，否则会造成 内存溢出 ）
· 初始化
ByteArrayInputStream bis = new ByteArrayInputStream(Byte[] arr);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
· ByteArrayInputStream 类对象的常用方法
public synchronized int read(); //读取一个字节，返回整型形式数据
· ByteArrayOutputStream 类对象的常用方法
public synchronized void write(int b); //写入一个字节
public synchronized byte[] toByteArray(); //将缓冲区中的所有数据转换为一个 byte[] 数组
*Code : test_io : Test_ByteArrayStream.java
5.7 java.io.CharArrayReader 类 & java.io.CharArrayWriter 类（字符数组缓冲区）
· 用法与 字节数组缓冲区 大致相同
· CharArrayReader 类只能从一个 char[] 数组中读取数据
· 初始化
CharArrayReader car = new CharArrayReader(char[] chs);
CharArrayWriter caw = new CharArrayWriter();
· CharArrayReader 类对象的常用方法
public int read() throws IOException; //读取一个字符，返回整型形式数据
· CharArrayWriter 类对象的常用方法
public void write(int c); //写入一个字符
public char[] toCharArray(); //将缓冲区中的所有数据转换为一个 char[] 数组
*Code : test_io : Test_CharArray_Reader_Writer.java
5.8 java.io.SequenceInputStream 类（输入合并流）
· 该类用于将多个输入流合并成一个输入流，读取数据时会依次从第一个流读到最后一个流
· 初始化
SequenceInputStream sis = new SequenceInputStream(InputStream in1,InputStream in2); //将两个流合并
SequenceInputStream sis = new SequenceInputStream(Enumeration<? extends InputStream> e); //将多个流合并
· 常用方法（SequenceInputStream 类对象）
public int read(byte[] b) throws IOException; //读取数据到一个 byte[] 数组中，并返回读取的字节数，当读到文件尾时返回 -1
public void close() throws IOException; //关闭所有流
· 合并多个流时可将所有流添加到一个 Vector 类对象里，并使用 SequenceInputStream 第二个构造方法
*Code : test_io : Test_SequenceInputStream.java
1.就近匹配原则
2.java采用的是 Unicode 字符集
3.表达式数据结果的类型自动提升
4.注意 短语与（短路或） 的巧用
5. HashMap 类对象中允许出现一对 null 键 null 值
6.集合中不能存放基本数据类型，而只能存放引用数据类型
7.描述文件路径可使用 / 或 \\
一、开发入门
1.Java是否只有编译过程，无所谓的链接，直接生成目标字节码文件？
2. path ：系统程序默认的寻找目录
classpath ：Java 类文件默认找寻路径
set path=%path%;[your path];
javac.exe ：java 编译工具
java.exe ： java 字节码文件运行工具
javac.exe 编译 --> java.exe {JVM启动，类加载，解释执行}
jar.exe ：打包工具
javadoc.exe ：文档制作工具
二、JAVA编程基础
1.Java 代码的基本格式
[修饰符] class [类名]{
[程序代码];
}
2.标识符的组成
所有大小写字母、数字、_ 、$
3.常量
整型：0b(0B)111001010、0134、12398、0x(0X)7F
默认为 int 类型
浮点型：0.7f(F) 、0.8d(D) 、5.022e+23f (e 表示以10为底的指数)
默认为 double 类型
字符：'a' '$' '\u0000'
特殊：'\r' 回车符
'\n' 换行符
'\t' 制表符
'\b' 退格符
'\'' '\"' '\\'
4.变量
4.1 数据类型
基本数据类型
整型 byte(8) short(16) int(32) long(64)
浮点型 float(32) double(64)
字符型 char(16)
布尔型 boolean
引用数据类型
类 class
接口 interface
数组
枚举 enum
注解 annotation
4.2 数据类型强转时发生"高位数据丢失"
4.3 在定义时，不可同时为多个变量赋值，如：
int x=y=z=5; 【错】
5. 运算符
5.1 在使用 -=、+=、*=、/=、%= 等运算时，强制类型转换会自动完成
5.2 & 与 && 的使用（| 与 || 的使用），后者为短路与（短路或），在使用的过程中，一旦左侧的结果能确定整个表达式的结果，则短路与（短路或）不进行右边的运算。（正常与 & 会进行两边的运算）
b>0 && z++>1;
x==0 || y++>0;
5.3 位运算符
& 按位与、| 按位或、~ 取反、^ 按位异或、<< 左移、>> 右移、>>> 无符号右移
6.选择结构语句
if(Expression){
...;
}
if(Expression){
...;
}else{
...;
}
三目运算符 Expression ? Expression_1 : Expression_2;
if(Expression){
...;
}else if{
...;
}
...else{
...;
}
switch(Expression){
case [Expression]:
...;
break;
case [Expression]:
...;
break;
....
default:
...;
break;
}
注：如果多个case条件后面使用的执行语句是一样的，则该执行语句只需书写一次即可。（在case后使用表达式时不会出现该情况）
*Code : Test_Switch.java
7.循环结构语句
while(Expression){
...;
}
do{
...;
}while(Expression);
for(初始化表达式 ; 循环条件 ; 操作表达式){
...;
}
8.跳转语句
8.1 break
· 跳出当前循环层
· 跳出到指定循环层
*Code : Test_break.java
8.2 continue 的使用与break相似
*Code : Test_continue.java
9.方法
修饰符 返回值类型 方法名([参数类型 参数名1 , 参数类型 参数名2 , ...]){
执行语句
...
return 返回值;
}
9.1 重载：1.方法名相同 2.参数个数或参数类型不同
10.数组
10.1 一维数组
动态初始化
类型[] 数组名 = new 类型[长度];
静态初始化
类型[] 数组名 = new 类型[]{元素,元素,...};
类型[] 数组名 = {元素,元素,...};
注意：不可写成 int[] x = new int[4]{1,2,3,4};
10.2 多维数组
int[][] arr = new int[3][4];
int[][] arr = new int[3][];
int[][] arr = {{1,2,3},{4,5,6},{7,8}};
*Code : Test_Array.java
三、面向对象
1.特性
封装性：将对象的属性和行为封装起来，不需要让外界知道细节
继承性：通过继承，可以在无需重新编写原有类的情况下对原有类的功能进行扩展
多态性：指的是一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为
2.类与对象
类名 对象名称 = new 类名();
对象引用.对象成员
2.1 this 关键字
· 可用于调用对象本身的属性和方法
· 可在构造方法中调用其他构造方法，且必须位于第一行、只能调用一次
this([参数1 , 参数2 , ...]);
不能在两个构造方法中使用this相互调用
*Code : Test_extends : Animal.java Dog.java Test.java
3.垃圾回收
可使用 System.gc(); 方法来通知Java虚拟机立即进行垃圾回收
当一个对象在内存中被释放时，他的 finalize(); 方法会被调用
public void finalize(){
...;
}
*Code : Test_finalize.java
4. static 关键字
4.1 静态（成员）变量
在内存中只有一份，能够被一个类的所有实例对象所共享
· JVM 会初始化其值
类名.变量名 或 对象名.变量名
4.2 静态（成员）方法
不实例化对象即可使用该方法
类名.方法名();
4.3 静态代码块
在类加载时执行的代码块，类只加载一次，故代码块只执行一次
static{
...;
}
5. 内部类
5.1 成员内部类
· 在成员内部类中可以访问外部类的所有成员
class Outer{
private int num = 4;
class Inner{
System.out.println("num = " + num);
//同 System.out.println("num = " + Outer.this.num);
}
}
· 不允许定义静态成员
· 通过外部类访问内部类（在其他类中实例化某个类的内部类）（外部类也会被实例化）
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
如： Outer.Inner inner = new Outer().new Inner();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.2 静态内部类
· 使用 static 关键字来修饰该内部类
· 在静态内部类中只能访问外部类的静态成员，不能调用外部费静态成员变量
· 可以定义静态成员
· 在其他类中实例化该内部类（可以在不实例化外部类的情况下实例化内部类）
外部类名.内部类名 变量名 = new 外部类名.内部类名();
*Code : Outer_Inner.Outer.java & Outer_Inner.Test.java
5.3 方法内部类
· 指在成员方法中定义的类，它只能在当前方法中被使用
· 方法内部类也可以访问外部类的成员变量
5.4 匿名内部类
· 格式
在需要该匿名内部类实例化对象的位置使用以下格式实例化对象
new 父类(参数列表)[或 父接口](){
//匿名内部类中需要实现的方法等
}
注：该类是匿名的，故称为匿名内部类
*Code : test_anonymousinnerclass : Animal.java & Test.java
6.Java 的文档注释
· 以 /** 开头，以 */ 结束
参数：@author ：程序的作者
@version ：程序的开发版本号
@param ：方法定义的参数以及参数对应的说明
@return ：方法的返回值代表的意义
· 生成文档的命令
如：javadoc -d . -author -version Test.java
-d 表示指定输出文档存放的目录
-author 表示文档中需包含作者信息
-version 表示文档中需包含版本信息
7.继承
· 关键字 ： extends
· 单继承，多层继承
· 重写：子类中存在与父类中相同方法名、参数列表、返回值类型相同的方法
8.super 关键字
· 可使用 super 关键字访问父类中的成员变量和成员方法
super.成员变量
super.成员方法([参数1,参与2,...]);
· 可使用 super 关键字调用父类的构造方法，且该语句必须位于子类构造函数第一行，只能有一句
super([参数1,参数2,...]);
*Code : Test_extends : Animal.java Dog.java Test.java
9.final 关键字
· final 修饰类 --> 不能被继承，且该类中所有的方法自动被 final 修饰，
· final 修饰方法 --> 不能被重写
· final 修饰变量（成员变量和局部变量） --> 常量，且只能被赋值一次，JVM不会默认对其进行初始化
10.抽象类和接口
10.1 抽象类 abstract
· 抽象类中存在构造方法
· 抽象类中未必有抽象方法
10.2 接口 interface
· 接口是特殊的抽象类，存在的所有方法都是抽象方法
· 方法默认使用 public abstract 修饰，变量默认使用 public static final 修饰（该变量只能在声明时初始化）
· 类使用 implements 实现某些接口，接口使用 extends 继承某些接口（使用逗号隔开多个接口）
· 继承和实现接口同时存在时，extends 必须位于 implements 之前
· 抽象类可以只实现接口的部分方法，但普通类必须实现接口所有抽象方法
10.2.1 匿名内部类
new 父类(参数列表)
11.多态
· 父类变量可引用子类对象
· 使用 instanceof 来判断某个类是否是另一个类（或接口）的实例或其子类实例，返回一个boolean值
[对象或对象的引用变量] instanceof [类或接口]
12.Object 类
· 是所有类的父类
· 方法
.toString(); //输出对象的基本信息
.getClass().getName(); //获得所属类的类名
.hashCode(); //返回该对象的哈希值，int类型值
13.异常 Exception
· 所有的 Error 和 Exception 都继承自 java.lang.Throwable 类
java.lang.Throwable
Error -IOError
-AWTError
Exception
-RuntimeException（可不使用 catch 捕获）
-ArithmeticException
-ClassCastException
-其他子类（必须使用 catch 捕获）（重点学习该类异常）
· 常用方法
String getMessage(); //返回此 throwable 的详细信息字符串
void printStackTrace(); //将此 throwable 及其追踪输出到标准输出流
void printStackTrace(); //将此 throwable 及其追踪输出到指定的输出流
13.1 try...catch 和 finally
· 格式
try{
//程序代码块
}catch(ExceptionType(Exception类及其子类) e){
//对 ExceptionType 的处理
}finally{
//无论是否有捕获到异常都要执行的程序代码块
}
注：finally{} 块当不使用时可被省略
finally{} 代码块有一种情况下不会被执行，那就是在 try{}catch{} 中执行了 System.exit(0); 语句，该语句表示退出当前的 java 虚拟机，Java 虚拟机停止了任何代码块都不会执行。
13.2 throws 关键字
· 该关键字用于声明某方法可能会发生的异常
· 被该关键字修饰的方法使用时必须使用 try{}catch{} 捕获异常，或在使用该方法的方法声明同样可能抛出的异常
· 如果程序中的异常没有被处理，程序就会非正常终止
· 格式
修饰符 返回值类型 方法名([参数列表]) throws ExceptionType_1 [,ExceptionType_2[,...]]{}
注：ExceptionType 表示可能抛出的异常类或其父类
13.3 throw 关键字
在程序的代码块中使用，用于抛出一个异常实例对象
· 格式
throw ExceptionType(Exception 类或其子类) e;
13.4 异常的分类
· checked 异常（编译时异常）
Exception 类中除了 RuntimeException 类及其子类外都是编译时异常
· 使用 try{}catch{} 捕获并处理
· 在调用该方法的方法声明处使用 throws 关键字声明抛出异常
· unchecked 异常（运行时异常）
java 编译器不会对其进行检查，一般由逻辑错误引起的
· 自定义异常
用户自定义的异常，继承自 Exception 类或其子类
在定义时可使用 Exception 的无参构造函数或有参构造函数
*Code : test_exception : DivideByMinusException.java & Test.java
13.5 包
常用于对 .java 文件进行集中管理，没有显式地声明 package 语句，则处于默认包下
· package 关键字
用于声明某个类属于哪个包
package 包名;
· import 关键字
使用该关键字可在程序中一次导入某个指定包下的类，这样就不必在每次使用该类时都要输入完整的类名了
import 包名.类名; //导入某个包下的某个类
import 包名.*; //导入某个包下的所有类
13.6 其他
13.6.1 编译 .java 文件
javac -d . Example.java
-d 指定生成的 .class 文件存放位置
13.6.2 给 java 程序打包
jar -cvf helloworld.jar cn
-c 代表创建归档文件
-v 在标准输出中生成详细输出
-f 指定归档文件名
jar -xvf helloworld.jar
将 jar 包里的文件和文件夹解压到当前文件夹下
java -jar helloworld.jar
执行 jar 文件
· 生成的 .jar 包里的 MANIFEST.MF 文件就是用来指定 jar 包主类的文件
在该文件里添加 "Main-Class:[完整的类名]"
13.6.3 访问控制权限
从小到大：private < default < protected < public
private : 被修饰的类成员只能被该类的其他成员访问
default : 当一个类或类的成员不使用任何修饰符修饰时，则默认为 default ，只能被本包的其他类访问
protected : 被修饰的类的成员既能被同一包下的其他类访问，也能被不同包下的子类访问
public : 被修饰的类或类的成员能被所有其他类访问，不论访问类与被访问类是否在同一包下
四、多线程
实现多段程序交替运行
1.线程的创建
1.1 继承 java.lang.Thread 类，并重写 run() 方法
1.1.1 Thread 类的常用方法
.run(); //使用当前进程执行 run();
.start(); //开启一个新的线程，并使用该线程执行 run();
1.2 实现 java.lang.Runnable 接口，并实现 run() 方法
通过 Thread(Runnable target); 构造方法来创建一个线程对象
· 实现了当使用多线程去处理同一资源时，把线程同程序代码、有效数据有效分离（即使用同一 Runnable 实例化对象去创建多个线程，可实现在多线程下使用同一对象资源）
2.Thread 类的常用方法
.setName(String name); //设置该线程的 name ；也可以使用构造方法 Thread(Runnable,String); 来设置
.currentThread(); //获取当前线程对象
3.后台线程
· 新创建的线程默认是前台线程
· 对Java程序来说，只要还有一个前台线程在运行，这个进程就不会结束；如果一个进程中只有后台线程运行，这个进程就会结束
3.1 常用方法（Thread 对象）
.setDaemon(boolean b); //将一个线程设置成后台线程，该方法只能在 .start(); 方法调用前调用，否则会引发 IllegalThreadStateException 异常
.isDaemon(); //判断该线程是否为后台线程
4.线程的生命周期及状态转换
4.1 线程的周期
新建状态（new）：仅为线程对象分配了内存资源
就绪状态（Runnable）：线程对象调用了 .start(); 方法
运行状态（Running）：获得 CPU 的使用权
阻塞状态（Blocked）：
· 当线程获取某个对象的同步锁时，该锁被其他线程所持有
· 当线程调用了一个阻塞式的 IO 同步方法
· 当线程调用了某个对象的 .wait(); 方法时
· 当线程调用了 Thread.sleep(); 方法时时
· 当线程调用了另一个线程的 .join(); 方法时
死亡状态（Terminated）：
· 当线程中的 run(); 方法执行完毕时
· 当线程执行过程中出现一个未捕获的异常（Exception）或错误（Error）
· 注：线程进入死亡状态，但是该线程对象仍是一个Thread对象，在没有被垃圾回收器回收之前仍可以和引用其他对象一样引用它。
4.2 线程的调度
4.2.1 调度模型
· 分时调度模型
为所有线程轮流分配一个 CPU 使用权的时间片
· 抢占式调度模型（默认）
优先级高的线程优先占用 CPU；对于相同优先级的线程，则随机选择一个线程使其占用 CPU
4.2.2 线程的优先级
· 可使用 1~10 来表示，数字越大优先级越高，超出范围会报错
static int MAX_PRIORITY； //表示线程的最高优先级，相当于 10
static int MIN_PRIORITY; //表示线程的最低优先级，相当于 1
static int NORM_PRIORITY; //表示线程的普通优先级，相当于 5
· 常用方法（Thread 类实例化对象）
void setPriority(int newPriority); //设置该线程的优先级
int getPriority(); //获得该线程的优先级
· 注：不同操作系统对优先级的支持是不一样的，不能很好地和 java 中线程优先级一一对应，因此，在设计多线程应用程序时，其功能的实现一定不能依赖于线程的优先级，而只能把线程优先级作为一种提高程序效率的手段
4.2.3 线程休眠（继续占有同步锁）
“运行状态” --> “阻塞状态” -（休眠时间结束）-> “就绪状态”
使‘运行状态’的线程进入‘阻塞状态’一段时间（线程暂停执行一段时间），休眠时间结束后，回到‘就绪状态’
public static native void sleep(long millis) throws InterruptedException; //休眠方法，默认单位为 ms
· 使用方法
Thread.currentThread().sleep(); 与 Thread.sleep(); 相同，该方法为静态方法，作用于执行该代码的‘当前进程’
4.2.4 线程让步（放弃同步锁）
“运行状态” --> “就绪状态”-（CPU第二次调度...第三次...）-> “运行状态”或“就绪状态”
使当前线程让出 CPU 使用权，并进入‘就绪状态’，让系统的调度器在具有与当前线程相同优先级或更高优先级且处于‘就绪状态’的线程之间重新调度一次
public static native void yield(); //线程让步方法，静态方法，执行该代码的当前进程
· 使用方法
Thead.yield();
*Code : test_thread : MyThread.java & Test_Yield.java
4.2.5 线程插队（抢占同步锁）
“运行状态” --> “阻塞状态” -（插队的线程执行结束）->“就绪状态”
当在某个线程中调用‘某一线程’的 .join(); 方法时，调用的线程将被阻塞，直到插队线程（‘某一线程’）执行结束
public final void join() throws InterruptedException;
· 使用方法（Thread 类或其子类的实例化对象）
.join();
*Code : test_thread : MyThread.java & Test_Join.java
4.3 多线程同步
· 利用锁对象的唯一性来确保代码访问共享资源时不出现‘意外’，锁对象的标志位默认为 1，被占用后置为 0
· 锁对象不能在 run(); 方法中创建
· 被 synchronized 修饰的代码块或方法在某一时刻只允许一个线程访问
4.3.1 同步代码块
synchronized(lock){ //lock 是一个锁对象，可以是任意类型
//操作共享资源代码块
}
*Code : test_thread : Test_Synchronized_1.java
4.3.2 同步方法
synchronized 返回值类型 方法名([参数列表]){
//共享资源代码块
}
· 注：
非静态同步方法的锁对象是调用该方法的对象，即 this 指向的对象，实现 run(); 方法的类的实例化对象。
静态同步方法的锁对象是该类方法所在的 java.lang.Class 对象 “类名.class"
*Code : test_thread : Test_Synchronized.java
4.3.3 死锁
JVM没有检测死锁和处理死锁的措施。
4.4 多线程通信
· 用于解决当多个线程同时操作同一存储空间而引发的‘意外’问题（数据的存储结果超乎意料）
4.4.1 常用的同步锁对象（任意类型）的方法，该方法定义在 Object 类中（存在一个‘同步锁等待队列’，该队列存放线程对象）
.wati(); //使调用该方法的当前线程‘放弃同步锁’进入等待，直到其他线程‘获得该同步锁’并调用同步锁的 notify(); 方法或 notifyAll(); 方法唤醒该线程
.notify(); //唤醒此同步锁上等待的第一个调用 wait(); 方法的线程
.notifyAll(); //唤醒此同步锁上等待的所有调用 wait(); 方法的线程
*注： public final void wait() throws InterruptedException;
public final native void notify();
public final native void notifyAll();
*Code : test_thread : Test_Wait_Notify.java
五、Java API
1. String 类和 StringBuffer 类（java.lang）
1.1 String 类（常量，一旦创建，其内容和长度都是不可改变的，只能创建（生成）新的字符串）
1.1.1 初始化
String str = "[字符串]";
String str = new String();
String str = new String(char[] value);
String str = new String(String value);
String str = new String(char[] value,int beg,int end);
1.1.2 常用操作
boolean equalsIgnoreCase(String another); //比较两个字符串（忽略大小写）
int indexOf(int ch); //返回该字符第一次出现的位置
boolean isEmpty(); //当且仅当字符串长度为 0 时返回 true
boolean contains(CharSequance cs); //判断此字符串中时候包含指定的字符串序列
String replace(CharSequence oldstr,CharSequence newstr); //返回一个新的字符串，它是通过用 newstr 替换此字符串中出现的所有的 oldstr 得到的
String[] split(String regex); //根据参数 regex 将原来的字符串分割成若干个子字符串
String trim(); //返回一个新字符串，它除去了原字符串首尾的空格
String substring(int beginIndex); //返回一个新的字符串，同包含字符串中索引 beginIndex 后的所有字符串（包含开始索引的字符）
String substring(int beginIndx,int endIndex); //返回一个新的字符串，它包含此字符串中从索引 beginIndex 到索引 endIndex 之间的所有字符（包含开始索引的字符，不包括结束索引的字符）
· 其他：
int lastIndexOf(int ch);
char charAt(int index);
boolean startsWith(String prefix); //判断此字符串是否以指定的字符串开始
boolean endsWith(String suffix);
int length(); //返回此字符串的长度
boolean equals(Object anObject); //将此字符串与指定的字符串比较
String toUpperCase(); //使用默认语言环境的规则将 String 中的所有字符串都转换为大写
String toLowerCase();
String valueOf(int i); //返回 int 参数的字符串表示形式，静态方法
char[] toCharArray(); //将此字符串转换为一个字符数组
* Code : test_javaapi : Test_String.java
1.1.3 注意
在 JVM 中，相同内容的字符串常量在内存中只存在一份（引用地址相同），而在运行时产生的相同内容的字符串在内存中的引用地址不同
1.2 StringBuffer 类（也称字符串缓冲区，其内容和长度都是可以改变的）
1.2.1 初始化
StringBuffer sb = new StringBuffer();
StringBuffer sb = new StringBuffer(String str);
StringBuffer sb = new StringBuffer(CharSequence cs);
StringBuffer sb = new StringBuffer(int capacity); //设定容量，容量不足时会自动改变
1.2.2 常用方法（StringBuffer 对象）
StringBuffer append(String str); //添加字符串到 StringBuffer 对象中
StringBuffer insert(int offset,String str); //在指定（从头开始）偏移量 offset 位置插入字符串 str
StringBuffer deleteCharAt(int index); //删除字符串中指定索引位置的字符
StringBuffer delete(int start,int end); //删除 StringBuffer 对象中指定范围的字符或字符串序列（包含开始索引字符，不包含结束做引字符）
StringBuffer replace(int start,int end,String s); //替换指定范围内的字符串为另一字符串（包含开始索引字符，不包含结束索引字符）
void setCharAt(int index,char ch); //替换指定索引位置的字符
String toString(); //返回 StringBuffer 缓冲区中的字符串
StringBuffer reverse(); //将缓冲区中的字符串反转
*Code : test_javaapi : Test_StringBuffer.java
1.3 两者的比较
· String 类表示的字符串是常量
· String 类覆盖了 Object 类的 equals(); 方法，而 StringBuffer 类没有覆盖该方法
· String 类对象之间可以用操作符 '+' 进行连接，而 StringBuffer 类对象之间不能，会编译错误
2. System 类和 Runtime 类
2.1 System 类
· static void exit(int status);
该方法用于终止当前正在运行的 java 虚拟机，其中参数 status 表示状态码，若状态非 0，则表示异常终止
· static long gc();
运行垃圾回收器，并对垃圾进行回收
· static long currentTimeMillis();
返回以毫秒为单位的当前时间，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，一般成为时间戳
· staitc void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
从 src 引用的指定源数组复制到 dest 引用的数组，复制从指定的位置（srcPos 与 destPos 表示起始位置）开始的一定长度的数据
· static Properties getProperties();
取得当前系统的全部属性，该方法会返回一个 Properties 类对象，属性以键值对的形式存在
*Code : test_javaapi : Test_System.java
2.2 Runtime 类
该类用于表示虚拟机运行时的状态，它用于封装 JVM 虚拟机进程，采用单例模式进行设计，故不可以直接实例化
· 获得 Runtime 类实例对象
Runtime runtime = Runtime.getRuntime();
· 常用方法（Runtime 类对象）
.availableProcessors(); //获得当前虚拟机可使用的处理器个数
.freeMemory(); //获得当前虚拟机的空闲内存大小（字节）
.maxMemory(); //获得当前虚拟机最大可用内存空间大小（字节）
public Process exec(String command) throws IOException; //执行一个 dos 命令，同“运行”
该方法返回一个 Process 类对象，调用该对象的 .destroy(); 方法可以关闭该进程
*Code : test_javaapi : Test_Random.java
3. Math 类和 Random 类
3.1 java.util.Math 类
· 常用方法
Math.abs(int num); //求一个数的绝对值
Math.ceils(double num); //求大于某个数的最小整数（double）
Math.floor(double num); //求小于某个数的最大整数（double）
Math.round(double num); //求一个数四舍五入的结果（long）
Math.max(num_1,num_2); //求两个数中的最大值
Math.min(num_1,num_2); //求两个数中的最小值
Math.random(); //返回一个值（0.0 <= x <1.0）
*Code : test_javaapi : Test_Math.java
3.2 java.util.Random 类（伪随机数生成器）
· 创建伪随机数生成器
Random random = new Random(); //随机使用一个种子（当前时间戳）创建伪随机数生成器
Random random = new Random(long seed); //使用给定的种子来创建伪随机数生成器
· 注：种子相同产生的随机序列相同
· 常用方法
boolean nextBoolean(); //产生一个随机的 boolean 值
double nextDouble(); //产生一个 [0,1) 之间的 double 值
float nextFloat(); //产生一个 [0,1) 之间的 float 值
int nextInt(); //产生一个随机的有符号的 int 值
int nextLong(); //产生一个随机的有符号的 long 值
*Code : test_javaapi : Test_Random.java
4.包装类
4.1 基本数据类型对应的包装类
· byte --> Byte
· char -->Character
· int --> Integer
· Integer 类的常用静态方法
public static String toBinaryString(int i); //将一个整型数值转换为二进制值字符串
public static String toHexString(int i); //将一个整型数值转换为十六进制值字符串
public static String toOctalString(int i); //将一个整型数值转换为八进制值字符串
public static int parseInt(String s); //将一个整型数据字符串识别为整型数值
· Integer 类对象的常用方法
.intValue(); //将 Integer 类型的值以 int 类型值返回
· short --> Short
· long --> Long
· float --> FLoat
· double --> Double
· boolean --> Boolean
4.2 注意
· 所有的包装类都重写了 Object 类中的 .toString(); 方法，该方法以字符串的形式返回被包装的基本数据类型的值
· 除了 Character 类外，其他包装类都有 valueOf(String s); 方法（静态方法），该方法会根据传入的 String 类型参数返回一个适合的包装类对象，该字符串不能为 null 且是可以被解析的，否则即使通过编译也会发生运行时错误
· 除了 Character 类外，其他包装类都有 parseXXX(String s); 方法（静态方法），用法及规则同上
· ‘装箱’与‘拆箱’
装箱：指的是把 基本数据类型值 --> 包装类对象
拆箱：指的是把 包装类对象 --> 基本数据类型值
注：JDK 5.0 之后支持自动装箱与自动拆箱技术，基本数据类型值也可以和包装类对象直接使用操作符进行运算
*Code : test_javaapi : Test_PackingClass.java
5. Date 类、Calendar 类与 DateFormat 类
5.1 java.util.Date 类
· 初始化
Date date = new Date(); //创建一个当前时间的 Date 对象
Date date = new Date(long millisecond); //根据一个时间戳创建 Date 对象
· 该类对象以默认格式输出日期和时间
5.2 java.util.Calendar 类（抽象类）
· 用于完成时间和日期字段的操作，可以通过特定的方法设置和读取日期的特定部分，该类是一个抽象类，不可以直接实例化
· 获得一个 Calendar 类实例化对象
Calendar calendar = Calendar.getInstance(); //创建一个代表默认时区内当前时间的 Calendar 对象
· Calendar 类对象的常用方法
public final void setTime(Date date); //传入一个 Date 类对象来设置 Calendar 类对象的值
public final Date getTime(); //获得 Calendar 类对象对应的 Date 类对象
public int get(int field); //返回指定日历字段的值
如： Calendar.YEAR、Calendar.MONTH、Calendar.DATE、Calendar.HOUR、Calendar.MINUTE、Calendar.SECOND
注：Calendar.MONTH 代表的月字段的值范围为 [0,11]
Calendar 类对象中字段的修改会发生进位
· Calendar 类的两种模式
- lenient 模式（日历字段模式）（默认模式）
该模式下允许字段超出其取值范围，当输出时间时会自动标准化时间
- non-lenient 模式
该模式下的日期和时间只接受规定范围内的数值
*Code : test_javaapi : Test_Calendar.java
5.3 java.text.DateFormat 类（抽象类）
该类用于将一个日期格式化为字符串或将一个特定格式显示的日期字符串转换成一个 Date 对象
· 获得 DateFormat 类对象
public final static getDateFormat(); //用于创建默认语言环境和格式化风格的日期格式化器
public final static getDateFormat(int style); //用于创建默认语言环境和指定格式化的日期格式器
public final static getDateTimeFormat(); //用于创建默认语言环境和格式化风格的日期/时间格式器
public final static getDateTimeFormat(int dateStyle,int timeStyle); //用于创建默认语言环境和指定格式化风格的日期/时间格式器
· 常用方法（DateFormat 类对象）
public final String format(Date date); //将一个 Date 类对象格式化为日期/时间字符串
public Date parse(String source) throws ParseException; //将给定字符串解析成一个 Date 类对象，字符串必须符合格式要求，否则会抛出异常
· 给定的四种格式化风格
DateFormat.FULL； //表示完整格式，如 2017年1月6日 星期五 下午07时38分27秒 CST
DateFormat.LONG; //表示长格式，如 2017年1月6日 下午07时38分27秒
（默认）DateFormat.MEDIUM; //表示普通格式，如 2017-1-6 19:38:27
DateFormat.SHORT; //表示短格式，如 17-1-6 下午7:38
*Code : test_javaapi : Test_DateFormat.java
5.4 java.text.SimpleDateFormat 类（DateFormat 类的子类）（自定义日期/时间格式化器）
可以使用 new 来实例化对象，它的构造方法介绍一个格式字符串参数，表示日期格式模板
· 实例化 SimpleDateFormat 类
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(); //默认以短格式为模板
SimoleDateFormat simpleDateFormat = new SimpleDateFormat(String pattern);
· 占位符
yyyy - 年
MM - 月（数字）
dd - 日
HH - 时
mm - 分
ss - 秒
*Code : test_javaapi : Test_SimpleDateFormat.java
六、集合类
1.集合的分类
Collection : List : 元素有序，可重复（ArrayList , LinkedList , Vector）
Set : 元素无序，不可重复（HashSet , TreeSet）
Map : 用于存储包含键（key）、值（value）映射关系的值
包含一个存放 key 的 Set 视图（key 具有唯一性）和一个存放 value 的 Collection 视图
2. Collection 接口
2.1 该接口的方法
boolean add(Object o); //添加一个元素
boolean addAll(Collection c); //把另一个集合中的元素添加到该集合中
void clear(); //清空该集合中的所有元素
boolean remove(Object o); //删除该集合中指定的元素
boolean removeAll(Collection c); //删除该集合中存在的另一集合中的元素
boolean isEmpty(); //判断该集合是否为空
boolean contains(Object o); //判断该集合是否包含某个元素
boolean containsAll(Collection c); //判断该集合中是否包含另一集合中的所有元素
Iterator iterator(); //获得该集合的迭代器
int size(); //获得该集合的中元素的个数
2.2 List 接口
2.2.1 接口常用方法
void add(int index,Object element); //将 element 插入到 List 集合的 index 处
boolean addAll(int index,Collection c); //将另一个集合中的所有元素插入到 List 集合的 index 处
Object get(int index); //获得 List 集合中 Index 处的元素
Object remove(int index); //删除 List 集合中 index 处的元素
Object set(int index,Object element); //将 List 集合中 index 处元素替换为 element 元素，并将替换后的元素返回
int indexOf(Object o); //返回 o 元素在 List 集合中第一次出现的位置
int lastIndexOf(Object o); //返回 o 元素在 List 集合中最后一次出现的位置
List subList(int fromIndex,int toIndex); //返回一个子集合，该子集合包含源集合中从 fromIndex （包含）到 toIndex （不包含）之间的所有元素
2.2.2 java.util.ArrayList 类（该集合是线程不安全的，即其方法不具有同步锁特征）
该类内部封装了一个长度可变的数组对象。
· 特点：查找访问元素方便快捷，但不适合做大量的增删操作
2.2.3 java.util.LinkedList 类
该类内部维护了一个双向循环链表，使用引用的方式来记住前一个元素和后一个元素。
· 特点：对元素的增删操作有很高的效率
· 常用方法（LinkedList 类对象）
void add(int index,E element); //在此集合中指定的位置插入 element
void addFirst(Object o); //在集合的开头位置插入 o
void addLast(Object o); //在集合的结尾位置插入 o
Object getFirst(); //返回该集合的第一个元素
Object getLast(); //返回该集合的最后一个元素
Object removeFirst(); //移除并返回该集合的第一个元素
Object removeLast(); //移除并返回该集合的最后一个元素
2.2.4 java.util.Iterator 接口（只能从第一个元素遍历到最后一个元素）（仅可正向迭代）
该接口主要用于遍历 Collection 中的元素，故也称为 迭代器
· 常用方法（实现 Iterator 接口的类实例化对象）
boolean hasNext(); //判断集合中是否存在下一个元素
Object next(); //获得下一个元素
· 如果想要通过 .next(); 方法得到特定的元素类型，需进行强制类型转换
· 若在迭代过程中，使用集合的 .remove(); 操作，则可能引发 ConcurrentModificationException 异常，原因是集合删除元素可能导致迭代器预期的迭代次数发生改变，导致迭代器的结果不准确。解决办法是在执行 .remove(); 操作后不再使用该迭代器，或使用迭代器本身的 .remove(); 方法来移除元素（该方法导致的迭代次数变化对 Iterator 来说是可预知的）。
·
2.2.5 foreach 循环（增强的 for 循环）
只能对元素进行访问，不能修改（仅是对临时变量引用的修改）
· 格式
for(容器中元素类型 临时变量 : 容器变量){
//执行语句
}
2.2.6 ListIterator 接口（Iterator 接口的子类）（可正向迭代，可反向迭代）
· 只能用于遍历 List 集合
· 特有方法
void add(Object o); //将指定的元素插入列表
boolean hasPrevious(); //判断当前指针元素所指向的元素是否存在前一个元素
Object previous(); //返回前一个元素
void remove(); //从列表中移除当前迭代器指针所指向的元素
· 获得 ListIterator 对象
ListIterator listIterator = list.listIterator(); //默认指针指向第一个元素
ListIterator listIterator = list.listIterator(int index); //指针指向 index 位置的元素
2.2.7 Enumeration 接口（只可正向遍历）
· 该接口用于遍历 Vector 集合（该集合是线程安全的，即其方法具有同步锁特征）
· Vector 类的用法与 ArrayList 相同
· 获得 Enumeration 对象
Enumeration en = ( Vector 集合的实例化对象).elements();
· 该接口的常用方法
boolean hasMoreElements(); //判断是否存在下一个元素
Object nextElement(); //获得下一个元素
*Code : test_collection_map : Test_List.java
2.3 Set 接口
2.3.1 java.util.HashSet 类（无序）
· 特点：具有良好的存取和查找性能
· 该集合添加元素的流程
先调用元素的 .hashCode(); 方法来确定元素的存储位置；若该位置上已存在元素，则调用元素的 .equals(); 方法来判断是否为同一元素，若结果为 true ，则表示元素重复，丢弃该元素，若结果为 false，则替换原位置上的元素。
· 一般要求对存入元素的类的下列方法进行重写
public int hashCode();
public boolean equals(Object obj);
2.3.2 java.util.TreeSet 类（有序）（采用平衡的二叉树原理）
· 存入该集合的类必须实现 java.lang.Comparable 接口，实现 public int compareTo(Object obj); 方法；或在定义该集合时传入一个适合的比较器（即该类实现了 Comparator 接口，实现该接口中的 public int compare(Object obj1,Object obj2); 方法）。
*Code : test_collection_map : Test_Set.java
3. Map 接口
3.1 该接口的常用方法
void put(Object key,Object value); //将指定的 value 与此映射的指定的 key 关联
Object get(Object key); //返回指定 key 所映射的 value ，若不存在则返回 null
boolean containsKey(Object key); //若存在该 key ，则返回 true
boolean containsValue(Object value); //若存在该 value，则返回 true
Set keySet(); //返回一个包含左右 key 的 Set 视图
Conllection<V> values(); //返回此映射中包含的所有的 value 的 Collection 视图
Set<Map.Entry<K,V>> entrySet(); //返回一个包含所有 key 和 value 的 Set 视图
3.2 java.util.HashMap 类（默认对 key 进行排序）
· key 相同则 value 会发生覆盖
· Map.Entry 类是 Map 接口内部类
· 元素取出顺序与存入顺序不同
· 该集合中允许出现一对 null 键 null 值
3.3 java.util.LinkedHashMap 类（是 HashMap 类的子类）
· 该类内部维护一个双向链表，使元素的迭代顺序与存入的顺序相同
3.4 java.util.TreeMap 类（对 key 排序，采用平衡的二叉树原理）
· 要求 key 元素类实现 Comparable 接口或传入一个实现 Comparator 接口的比较器
· 遍历方法同 HashMap 类
3.5 java.util.Properties 类（Hashtable 类的子类）（用于存储配置项）
· HashMap 与 Hashtable 的区别在于后者是线程安全的且读取较慢
· Properties 类主要用于存储字符串类型的 key 和 value
· 常用方法（Properties 类对象）
public synchronized Object setProperty(String key,String value); //用于添加或修改键值
public String getProperty(String key); //获得 key 所对应的 value，找不到 key 则返回 null
public String getProperty(String key,String defaultValue); //获得 key 所对应的 value，若找不到 key 则返回 defaultValue
*Code : test_collection_map : Test_Map.java
4.泛型（JDK 5.0 新特性）
· parameterized type 即参数化类型（泛型），限定方法操作的数据类型，避免了在程序中进行强制类型转换
· 使用方法
在定义集合类时，使用 "<参数化类型>" 的方式指定该类中方法操作的数据类型
如： ArrayList<String> list = new ArrayList<String>();
· 自定义泛型
在类定义时，类名后添加 "<Type_1 [ , Type_2[ , ...]]>" 以声明参数类型
*Code ： test_collection_map : Test_ParameterizedType.java
5. java.util.Collections 集合操作工具类
5.1 排序操作
public static <T> boolean addAll(Collection<? super T> c,T... elements); //将所有指定元素添加到指定的 Collection 集合中
public static void reverse(List<?> list); //反转 List 类对象中的元素顺序
public static void shuffle(List<?> list); //随机排序 List 类对象中的元素（洗牌）
public static void sort(List list); //对 List 类对象中的所有元素按自然顺序排序
public static void sort(List list,Comparator c); //使用给定的比较器对 List 类对象中的所有元素进行排序
public static void swap(List list,int i,int j); //将指定 List 类对象中的 i 索引元素和 j 索引元素进行交换
5.2 查找、替换操作
public static int binarySearch(List list,Object key); //使用二分法搜索指定的 key 对象在 List 类对象中的索引，该 List 类对象必须是有序的
public static Object max(Collection c); //根据元素的自然顺序返回 List 类对象中最大的元素
public static Object min(Collection c); //根据元素的自然顺序返回 List 类对象中最小的元素
public static boolean replaceAll(List list,Object oldVal,Object newVal); //把 List 类对象中所有的 oldVal 替换成 newVal
6. java.util.Arrays 数组操作工具类
· 常用方法
public static void sort(int[] arr); //该方法有多个重载，对数组进行排序
public static int binarySearch(Object[] arr,Object key); //该方法有多个重载，使用二分法在排序过的数组中进行查找并返回索引
public static int[] copyOfRange(int[] original,int from,int to); //拷贝源数组中指定范围内的元素，超出范围内的以‘默认值’填充，包括 from 索引元素，不包括 to 索引元素
public static void fill(Object[] arr,Object value); //以 value 来填充该数组
public static String toString(Object[] arr); //返回此数组的字符串表现形式，该方法不是对 Object 类中 .toString(); 方法的重写
七、IO
1. IO流 ： 字节流 ： 字节输入流、字节输出流
字符流 ： 字符输入流、字符输出流
2.字节流
2.1 java.io.InputStream 抽象类
· 子类
FileInputStream
BufferedInputStream ： 装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public int read() throws IOException; //从输入流读取一个字节（8位），转换为0~255的整数，并返回该证整数（EOF 值为 -1）
public int read(byte[] b) throws IOException; //从输入流读取若干字节，保存到 b 数组中，并返回成功读取的字节数
public int read(byte[] b,int off,int len) throws IOException; //从输入流的起始位置 off 开始读取 len 个字节数保存到 b 数组中，并返回成功读取的字节数
public void close() throws IOException; //关闭此输入流并释放与该流关联的所有系统资源
· 初始化
FileInputStream fileInputStream = new FileInputStream(String filename) throws FileNotFoundException;
BufferedInputstream bis = new BufferedInputStream(InputStream in); //装饰类
2.2 java.io.OutputStream 抽象类
· 子类
FileOutputStream
BufferedOutputStream ： 装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public void write(int b) throws IOException; //向输出流写入一个字节
public void write(byte[] b) throws IOException; //把 b 数组中的所有字节写入输出流
public void write(byte[] b,int off,int len) throws IOException; //把 b 数组中从偏移量 off 的位置开始的 len 个字节写入输出流
public void flush() throws IOException; //刷新此输出流并强制把缓冲区中的数据写入到目标设备
public void close() throws IOException; //关闭此输出流并释放与此流相关的所有系统资源
· 初始化
FileOutputStream fileOutputStream = new FileOutputStream(String name) throws FileNotFoundException;
FileOutputStream fileOutputStrema = new FileOutputStream(String name,boolean append) throws FileNotFountException; // append 参数表示是否以‘追加’方式写入数据
BufferedOutputStream bos = new BufferedOutputStream(OutputStream out); //装饰类
*Code : test_io : Test_Input_Output_Stream.java & Test_Byte_FileCopy.java & Test_Byte_Buffered.java
3.字符流
3.1 java.io.Reader 抽象类
· 子类
FileReader
BufferedReader ：装饰类，内部定义了一个大小为 8192 的字节数组
LineNumberReader ：BufferedReader 的直接子类
· 常用方法
public int read() throws IOException; //读取一个字符，返回该字符的整型值（该方法有多个重载）
· BufferedReader 的特有方法
public String readLine() throws IOException; //读取一行（返回的结果中不包括 换行符）
· LineNumberReader 的特有方法
public void setLineNumber(int lineNumer); //设置起始行号（并非从该行开始读）
· 初始化
FileReader fileReader = new FileReader(String fileName) throws FileNotFoundException;
BufferedReader br = new BufferedReader(Reader r);
LineNumberReader lr = new LineNumberReader(Reader r);
3.2 java.io.Writer 抽象类
· 子类
FileWriter
BufferedWriter ：装饰类，内部定义了一个大小为 8192 的字节数组
· 常用方法
public void write(int ch) throws IOException; //写入一个字符（该方法有多个重载）
public void writer(String str) throws IOException; //写入一个字符串
public Writer append(CharSequence csq) throws IOException; //以附加方式写入字符串
· BufferedWriter 的特有方法
public void newLine() throws IOException; //写入一个换行符
· 初始化
FileWriter fileWriter = new FileWriter(String fileName) throws IOException;
FileWriter fileWriter = new FileWriter(String fileName,boolean append) throws IOException;
BufferedWriter bw = new BufferedWriter(Writer w);
*Code : test_io : Test_Reader_Writer.java & Test_Buffered_Reader_Writer.java & Test_LineNumberReader.java
4.转换流
· 只能针对操作文本文件的字节流进行转换，若操作的是图片文件，则可能会因为转换为字符流而造成数据丢失
4.1 java.io.InputStreamReader 类（Reader 类的子类）
· 将字节输入流转换为字符输入流
4.2 java.io.OutputStreamWriter 类（Writer 类的子类）
· 将字节输出流转换为字符输出流
*Code : test_io : Test_ConvertClass.java
5.其他 IO 流
5.1 java.io.ObjectInputStream 类 & java.io.ObjectOutputStream 类
· 该类只能一次读写（尚且不知道原因），若想一次性写入多个对象可将所有对象存放在一个 List 中，一次写入
· 要写入流的对象必须实现 java.io.Serializable 接口
· 初始化
ObjectInputStream ois = new ObjectInputStream(InputStream in) throws IOException;
ObjectOutputStream oos = new ObjectOutputStream(OutputStream out) throws IOException;
· ObjectInputStream 类 常用方法
public final Object readObject() throws IOException,ClassNotFountException; //从流中读取一个对象
· ObjectOutputStream 类 常用方法
public final void writeObject(Object obj) throws IOException; //往流中写入一个对象
*Code : test_io : Test_Object_Input_Output_Stream.java
5.2 java.io.DataInputStream 类 & java.io.DataOutputStream 类
· 该类主要用于存储基本数据类型
· 使用时数据的类型读取顺序要与写入顺序相同，才能保证最终数据的正确性
· 初始化
DataInputStream dis = new DataInputStream(InputStream in);
DataOutputStream dos = new DataOutputStream(OutputStream out);
· DataInputStream 类 常用方法
public final int readInt() throws IOException;
public final String readUTF() throws IOException;
public final boolean readBoolean() throws IOException;
public final char readChar() throws IOException;
· DataOutputStream 类 常用方法
public final void writeInt(int i) throws IOException;
public final void writeUTF(String str) throws IOException;
public final void writeBoolean(boolean v) throws IOException;
public final void writeChar(char c) throws IOException;
*Code : test_io : Test_Data_Stream.java
5.3 java.io.PrintStream 类（打印流）（与 DataOutputStream 类相似）
· 该类主要用于该基本数据类型或引用数据类型的对象格式化成字符串后再输出（调用对象的 .toString(); 方法）
· 初始化
PrintStream ps = new PrintStream(OutputStream out);
· 常用方法
public void print(String str); //打印一个字符串（该方法有多个重载）
public void println(Object obj); //调用该对象的 .toString(); 方法，并将结果写入流（该方法有多个重载）
*Code : test_io : Test_PrintStream.java
5.4 标准输入输出流
· 标准流
输入流 System.in : InputStream
输出流 System.out : PrintStream
错误流 System.err : PrintStream
· 重定向标准流（System 类的静态方法）
输入流 public static void setIn(InputStream in);
输出流 public static void setOut(PrintStream out);
错误流 public static void setErr(PrintStream err);
*Code : test_io : Test_System_In_Out_Err.java
5.5 java.io.PipedInputStream 类 & java.io.PipedOutputStream 类（管道流，一般用于线程间通信）
· PipedInputStream 类 用于从管道读取数据到程序中
PipedOutputStream 类 用于从程序写数据到管道中
· 初始化
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
· 常用方法（PipedInputStream 类对象或 PipedOutputStream 类对象）
public void connect(PipedOutputStream src) throws IOException; // PipedInputStream 类对象的方法和，连接输出管道
public synchronized void connect(PipedInputStream snk) throws IOException; // PipedOutputStream 类对象的方法，用于连接输入管道
*Code : test_io : Test_PipedStream.java
5.6 java.io.ByteArrayInputStream 类 & java.io.ByteArrayOutputStream 类（字节数组缓冲区）
· ByteArrayInputStream 类只能从一个 Byte[] 数组中读取数据
· ByteArrayOutputStream 类会在创建实例化时创建一个 Byte[] 数组的缓冲区，该缓冲区会根据存入数据的多少而自动变化，因此可以减少写数据的次数。（如果读取的文件非常大，就不能使用这个类，否则会造成 内存溢出 ）
· 初始化
ByteArrayInputStream bis = new ByteArrayInputStream(Byte[] arr);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
· ByteArrayInputStream 类对象的常用方法
public synchronized int read(); //读取一个字节，返回整型形式数据
· ByteArrayOutputStream 类对象的常用方法
public synchronized void write(int b); //写入一个字节
public synchronized byte[] toByteArray(); //将缓冲区中的所有数据转换为一个 byte[] 数组
*Code : test_io : Test_ByteArrayStream.java
5.7 java.io.CharArrayReader 类 & java.io.CharArrayWriter 类（字符数组缓冲区）
· 用法与 字节数组缓冲区 大致相同
· CharArrayReader 类只能从一个 char[] 数组中读取数据
· 初始化
CharArrayReader car = new CharArrayReader(char[] chs);
CharArrayWriter caw = new CharArrayWriter();
· CharArrayReader 类对象的常用方法
public int read() throws IOException; //读取一个字符，返回整型形式数据
· CharArrayWriter 类对象的常用方法
public void write(int c); //写入一个字符
public char[] toCharArray(); //将缓冲区中的所有数据转换为一个 char[] 数组
*Code : test_io : Test_CharArray_Reader_Writer.java
5.8 java.io.SequenceInputStream 类（输入合并流）
· 该类用于将多个输入流合并成一个输入流，读取数据时会依次从第一个流读到最后一个流
· 初始化
SequenceInputStream sis = new SequenceInputStream(InputStream in1,InputStream in2); //将两个流合并
SequenceInputStream sis = new SequenceInputStream(Enumeration<? extends InputStream> e); //将多个流合并
· 常用方法（SequenceInputStream 类对象）
public int read(byte[] b) throws IOException; //读取数据到一个 byte[] 数组中，并返回读取的字节数，当读到文件尾时返回 -1
public void close() throws IOException; //关闭所有流
· 合并多个流时可将所有流添加到一个 Vector 类对象里，并使用 SequenceInputStream 第二个构造方法
*Code : test_io : Test_SequenceInputStream.java
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 个人笔记。Java基础几个知识点说明
- CSS基础（五） 个人笔记
- 黑马程序员----【javaSE基础】个人总结--代码块
- python基础学习笔记（个人学习时记录的笔记，不全的地方请大家指正）
- JavaScript基础（补充） 个人笔记
- JavaSE基础学习笔记-提高篇-JDK1.5新特性
- JavaSE基础笔记十二
- javase基础入门复习笔记四
- C\C++ 程序员从零开始学习Android - 个人学习笔记（九） - java基础 - 异常
- 个人笔记 java基础数据类型
- Python学习的个人笔记（基础语法）
- Javase基础之IO流笔记
- 关于linuxcast网站课程中MYSQL安装配置基础课程的个人笔记
- 黑马程序员：iOS基础——个人笔记（三）
- 网络技术基础概念和个人笔记总结（1）
- 黑马程序员----【JavaSE基础】视频第一天复习笔记
- java基础（个人学习笔记，不断修改更新中）
- Javase基础笔记---异常部分
- javascript基础（二） 个人笔记
- python个人笔记（一）基础语法