java高级（javaAdv和JavaApi）

豪ㄘ

已于 2024-06-04 18:52:45 修改

阅读量2.2k

点赞数 18

文章标签： java 开发语言

于 2023-12-31 23:21:10 首次发布

本文链接：https://blog.youkuaiyun.com/2301_79880794/article/details/135314432

版权

JavaApi

1.String字符串

String 是一个类，属于引用类型。
Java 程序中一切使用 "" 引起来的内容，都是这个类的实例，称为字符串对象。
字符串定义后是一个常量，值不可更改。字符串实际是一个字符数组。

2. String 类使用时注意

由此可见，如果要频繁更改 String 类型变量的值，不要使用 String 对象操作字符串，效率很低又浪费内存空间。

3.通过构造方法创建字符串

3.1. 常用构造方法

String() ：创建一个空白字符串对象，实际创建一个空字符数组。
String(String str)：创建一个指定的字符串对象，实际是创建一个形参字符串的副本。
String(char[] list)：创建一个指定字符数组的字符串对象。
String(byte[] list)：按默认编码格式创建一个指定字节数组的字符串对象。
String(byte[] list,String charsetName)：按指定的编码格式创建一个指定字节数组的字符串对象。

4.不同方式创建字符串

使用 "" 赋值的形式创建
使用构造方法 String(String str) 创建
使用 + 拼接 "" 和 new 出来的字符串对象

5.字符串总结

在使用字符串时，如果要比较其值是否相同，不要使用 == 判断，因为 == 判断的是内存地址。
所以在比较字符串是否相同时，要使用 String 重写的 equals 方法进行判断。
String 中 equals 方法判断的原理，大致为：将两个字符串保存到字符数组中，再对每个字符逐一比较，如果全部一致则返回。
在使用 equals 方法时，通常要将已知的非空字符串作为调用者。

6.字符串常用方法

常用方法	类型	作用
length()	int	获取字符串的长度
trim()	String	去除字符串首尾的所有空格
toLowerCase()	String	转换字符串为小写
toUpperCase()	String	转换字符串为大写
isEmpty()	boolean	判断是否为一个空字符串
getBytes()	byte[]	按默认编码格式将字符串转换为字节数组
toCharArray()	char[]	将字符串转换为字符数组
equalslgnoreCase(String str)	boolean	忽悠大小写比较指定字符串是否相同
equals(String str)	boolean	判断字符串是否相同
charAt(int index)	char	获取index的位置上的字符串
indexOf(String str)	int	获取str第一次出现的位置，如果没有返回-1
lastindexOf(String str)	int	获取str最后一次出现的位置，如果没有返回-1
contains(字符序列)	boolean	判断指定的字符序列(字符串)是否存在于原字符串中
concat(String str)	String	将str拼接到原字符串末尾
startsWith(String str)	boolean	判断是否以指定字符串开头
endsWith(String str)	boolean	判断是否以指定字符串结尾s
substring(int , index)	String	截取原字符串在(index,数组长度)区间内的字符,(从from截取至to，包含from位置不包含to).
substring(int from , int to)	String	截取原字符串在(from , to)区间内的字符,(cong).
split(String reg)	String[]	按指定字符串或正则表达式切分原字符串，如果指定内容不在末尾，n个指定字符能得到n+1个子串，如果指定内容在末尾，n个指定字符能得到n个子串(不包含末尾的无效字符).
String.valueOf(参数)	String	将一个参数转换为字符串，参数可以是原始类型，也可以任意对象
replace(char oldChar , char newChar)	String	使用newCher替换oldChar

7.可变字符串

String 字符串对象是一个常量，在定义后其值不可改变。
如果使用 String 类的对象，对其频繁更新时，就会不停地创建新的对象，重新引用。
所以如果要执行 1000 次重新赋值的过程，就要创建 1000 个字符串对象，花费很多时间和内存空间，所以效率很低。这时就需要使用可变字符串类。

1、StringBuilder 类

用于表示可变字符串的一个类，是非线程安全的，建议在单线程环境下使用，效率略高于StringBuffer 。

2、StringBuffer 类

用于表示可变字符串的一个类，是线程安全的，建议在多线程环境下使用，效率略低于 StringBuilder 。
StringBuilder 和 StringBuffer 中的方法作用都一致，只不过 StringBuffer 中的方法使用了 synchronized 关键字修饰，表示一个同步方法，在多线程环境下不会出现问题。

3、比较 String StringBuilder StringBuffer 这三个类的区
别

3.1 相同点

这三个类都可以用于表示或操作一个字符串
这三个类中有公共的方法，如 indexOf() 、 charAt() 等、
这三个类都是被 final 修饰的类，不能被继承

3.2 不同点

String 定义的字符串是一个常量，不可变； StringBuilder 和 StringBuffer 定义的字符串是一个变量，可以改变。
String 类中的方法调用后，会创建字符串副本，不会影响原字符串；可变字符串对象调用的方法直接操作原字符串，会影响。
StringBuilder 是非线程安全的， StringBuffer 是线程安全的，其中的方法使用 synchronized 修饰为同步方法。在多线程情景下，需要使用 StringBuffer 。 StringBuilder 效率略高于 StringBuffer 。

4.总结

在程序中，如果要频繁操作某个字符串，一定使用可变字符串类 StringBuilder 或 StringBuffer 创建对象。

8.包装类

Java 是纯面向对象语言，宗旨是将一切事物视为对象处理。
但原始类型不属于对象，不满足面向对象的思想，但原始类型使用时无需创建对象，保存在栈中，效率更改。
为了让原始类型也有对象的类类型，达到 " 万物皆对象 " 的思想，所以就有了包装类的概念。
包装类就是原始类型对应的类类型。包装类通常用于将字符串转换为对应的原始类型。

8.1 常用包装类

包装类	原始类型	将字符串转换为原始类型
Byte	byte	Byte.parseByte(String str)
Short	short	Short.parseShort(String str)
Integer	int	Integer.parseInt(String str)
Long	long	Long.parseLong(String str)
Float	float	Float.parseFloat(String str)
Double	double	Double.parseDouble(String str)
Boolean	boolean	Boolean.parseBoolean(String str)
Character	char	无

8.2 特点

八个原始类型中，除了 int 和 char 之外，其余类型的包装类，都是将首字母改为大写。 int Integer ， char 为 Character 。
除了 Character 类之外，其余类都有至少两个构造方法 : 参数为原始类型或字符串的构造方法。
Character 的构造方法只有一个，参数为 char 变量。除了 Character 类之外，其余类都有静态方法 parse 原始类型 (String str) ，用于将字符串转换为相应的原始类型
数值型的包装类的 parseXXX() 方法，如果不是一个真正的对应类型的数，转换时会抛出NumberFormatException 异常。如 "123abc" 、 "123.456" 都不能使用 Integer.parseInt() 转换
Boolean 类型中的 parseBoolean() 方法，参数如果是 "true" 这个单词，无论大小写，都能转换为真正的 boolean 值的 true ，只要不是 "true" 这个单词，转换结果都为 false除了 Boolean 类之外，其余类都有 MAX_VALUE 和 MIN_VALUE 这两个静态属性，用于获取对应原始类型支持的最大最小范围
所有包装类中都有一个 compareTo( 参数 1, 参数 2) 方法 , 用于比较两个参数，
如果是数值型，参数 1> 参数 2 返回 1 ，参数 1< 参数 2 返回 -1 ，相同返回 0
如果是 Boolean 型，两个参数相同返回 0 ，不同时，如果参数 1 为 true 返回 1 ，否则返回 -1
如果是 Character 型，返回参数 1- 参数 2 的值。
所有包装类中都有 toString() 方法，用于将包装类对象转换为 String 字符串对象

8.3 装箱和拆箱

所有包装类都有一个静态方法 valueOf( 原始类型 ) ，将某个原始类型的数据转换为相应的包装类对
象，这个过程称为装箱。

8.3.1 手动装箱

int i = 123 ; // 定义一个原始类型的数据
Integer aInteger = Integer . valueOf ( i ); // 调用包装类的 valueOf() 方法将原始类型转换为包
所有包装类都有一个原始类型 Value() 方法，用于将包装类对象转换为原始类型，这个过程称为拆箱。

8.3.2 手动拆箱

Integer aInteger = new Integer ( 123 ); // 创建一个包装类对象
int i = aInteger . intValue (); // 调用包装类的 " 原始类型 Value()" 方法将其转换为原始类型
装类对象自动装箱拆箱。在 jdk1.5 之后，加入了自动装箱拆箱的特性，可以直接在原始类型和对应的包装类中互相赋值。

8.3.3 自动装箱

Integer aInteger = 123 ;

8.3.4 自动拆箱

int i = aInteger ;

8.3.5 字符串与原始类型之间的转换

原始类型转换为字符串，拼接一个空字符串
int num=123;
String str=num+"";

8.3.6 String.valueOf( 原始类型参数 );

int num = 123 ;
String str = String . valueOf ( num );
System . out . println ( str . length ());

8.3.7 将原始类型转换为包装类后，调用 toString() 方法

Integer num = 123 ;
String str = num . toString ();

8.3.8 字符串转换为原始类型

使用原始类型对应的包装类，调用其 parseXXX( 字符串 ) 方法
String num = "123" ;
int i = Integer . parseInt ( num );

9. date类（用于表示日期时间的类，位于 java.util 包下）

9.1 构造方法

Date() ：创建当前瞬间的日期对象
Date(long l)：创建指定毫秒数对应的日期对象。( 从 1970.1.1 起经过了的毫秒数 )
Date(int year,int month,int date) ：该构造方法已过时。创建指定年月日的日期对象。(年从1 900年起经过的年数，月用0-11表示1-12月)

9.2 常用方法

getTime() 得到对应Date对象指定的毫秒数。
setTime(long l) 设置毫秒数
after(Date when) 判断调用日期对象是否在when 之后
before(Date when) 判断调用日期对象是否在when 之前

9.3 Calendar 类

用于表示日历的类。包含了很多日历相关的信息。
是一个抽象类，无法直接创建对象，可以通过该类的静态方法 getInstance() 获取该类的实例。

9.4 日历字段

Calendar.YEAR 获取年份
Calendar.MONTH 获取月份(0-11 表示 1-12 月 )
Calendar.DATE 获取日期
Calendar.DAY_OF_WEEK 获取星期(1-7 表示周天到周六 )
Calendar.HOUR_OF_DAY 获取二十四小时制的小时
Calendar.MINUTE 获取分钟
Calendar.SECOND 获取秒
Calendar.DAY_OF_MONTH 本月中的第几天
Calendar.DAY_OF_YEAR 本年中的第几天
Calendar.WEEK_OF_MONTH 本月中的第几周
Calendar.WEEK_OF_YEAR 本年中的第几周

9.5 常用方法

get( 日历字段 ) 获取指定日历字段实际的值
getTime() 获取对应的Date 对象 (Calendar 转换为 Date)
getMaximum( 日历字段 ) 获取指定日历字段支持的最大值。如Calendar.DATE 支持最大值为31
getActualMaximum( 日历字段 ) 获取指定日历字段在实际时间下的最大值。如4 月下 Calendar.DATE 实际最大值为30
getTimeZone() 获取当前日历在实际时间下的时区信息
set( 日历字段 , 值 ) 将指定日历字段设置为指定值
set( 年 , 月 , 日 ) 设置指定的年月日，没有设置的部分沿用当前日期。

10. 异常

当程序没有按程序员的意愿正常执行，中途出错导致程序中断，出现这种情况，就称为异常。

10.1 异常的产生

异常在程序中以对象的形式存在。当代码执行时出现异常，虚拟机会自动创建一个相应的异常对象，如果没有对该异常进行处理，就会导致程序中断。

10.2 异常的分类

异常在程序中以对象的形式存在，所以异常有对应的类。

常见运行时异常	说明	出现的情景
NullPointerException	空指针异常	用空对象null调用方法或属性
ArrayIndexOutOfBoundsException	数组下标越界异常，使用数组时，下标超出范围
ClassCastException	对象转型异常	Dog dog=(Dog)new Person(); (Person类和Dog 类不是继承关系 )
InputMismatchException	输入类型不匹配异常	如需要int类型的数据，输入String类型的数据。
ArithmeticException	算术运算异常	0当分母
IllegalArgumentException	非法参数异常	调用方法的参数不合理

10.3 处理异常Exception

只要处理Exception异常类的子类时，都称为处理异常。处理异常的目的就是为了保证程序正常运行，不要中断。

10.3.1 try-catch-finally语句

try{

// 可能出现异常的代码

} catch ( 异常类异常对象 ){

// 如果出现异常对象，且与 catch 中的异常类匹配，则执行

} catch ( 异常类异常对象 ){ // 后续的 catch 中的异常类型只能与之前的异常类型同级或是父类

// 如果出现异常对象，且与 catch 中的异常类匹配，则执行

} finally {

// 无论程序是否会抛出异常，一定要执行的代码

}

10.3.2 try-catch 注意

执行 try 中的内容时，当某行代码抛出异常后，不再执行 try 中该行代码后续的内容。
无论 try 中是否会抛出异常， finally 中的内容一定执行。通常 finally 用于释放资源。
如果有多个 catch ，需要将异常子类放在最前，异常父类放在最后
try 、 catch 、 finally 都不能单独使用， try 需要配合 catch 或 finally 或 catch 和 finally 一起使用
try 中定义的内容，无法在 try 之外的地方使用
try 中如果有 return ，不影响 finally 的执行，并且 finally 优先于 return 执行

10.3.3 throws 关键字

public class Test {
public void fun () throws InterruptException { // 在定义方法时，声明可能抛出的异常型
// 如果直接写这句话，会报错，因为 sleep() 方法会抛出一个非运行时异常，必处理
Thread . sleep ( 5000 );
}
}

10.3.4 throw 和 throws

throws 表示用于方法声明异常。使用时写在方法的小括号之后。

// 用于声明方法的异常
public void fun () throws Exception {
}

throw 用于手动抛出异常对象。使用时写在 {} 中，通常用于满足某种条件时，强制中断程序。

public void fun (){

// 用于手动抛出一个异常对象

RuntimeException e = new RuntimeException ();
throw e ;
}

10.3.5 自定义异常

可以自定义异常，在满足某种条件下，手动通过 throw 关键字抛出异常，人为中断程序。

10.3.5.1 自定义异常步骤

定义一个类，继承某个异常类。
如果继承的是 RuntimeException ，表示自定义的异常类属于运行时异常，该异常对象可以不用处理。
如果继承的是非 RuntimeException ，表示自定义的异常类属于非运行时异常，该异常对象必须要处理。
[ 可选操作 ] 定义一个无参数的构造方法，调用父类中无参的构造方法，定义一个带字符串参数的构造方法，调用父类带字符串参数的构造方法。

11.数组、集合

11.1 数组的特点

数组中保存的元素都是有序的，可以通过下标快速访问
数组中保存的数据都是同一种类型
数组的长度在定义后，无法改变
数组无法获取其中保存的实际元素数量

11.2 集合

能保存一组数据，可以有序也可以无序
集合的容量可变
集合中可以保存不同类型的数据
可以获取集合中实际的元素数量

11.3 集合框架 ( 集合家族 )

Iterator 接口并不算严格意义上的集合的 " 根 ", 它称为迭代器，用于遍历集合元素的一个工具接口。
所以集合的根接口为： Collection 接口和 Map 接口，位于 java.util 包中。

11.3.1 Collection 接口

核心的两个子接口： Set 和 List 。
这两个接口都可以保存一组数据， Set 接口保存数据时，是无序不重复的 ; List 接口保存数据时，是有序可重复的。

11.3.2 List 接口 ( 有序可重复 )

有序集合，元素可以重复，允许保存 null ，可以通过索引获取对应位置上的元素。
在接口中定义了一些操作元素的方法，如获取元素数量、添加、删除、替换、截取等。

11.3.3 ArrayList 实现类 ( 掌握 )

采用数组实现的集合
可以通过索引访问元素、可以改变集合大小。如果要在其中插入或删除元素时，会影响其余元素。
该集合查询效率高、增删中间元素效率低。
该集合对象中保存的元素，都是引用类型 ( 对象的内存地址 ) 。即使保存了 123 ，其实不是保存的 int类型的 123 ，而是 Integer 类型的 123.

11.4 构造方法

11.4.1 ArrayList()

创建一个无参的 ArrayList 对象。实际是创建了一个空的 Object 数组。在调用添加元素方法时，才会初始化该数组大小为 10 。

11.4.2 ArrayList(int capacity)

创建一个指定容量的 ArrayList 对象，实际是创建一个指定大小的 Object 数组，如果参数为负，会抛出 IllegalArgumentException 异常

11.5 常用方法

add(Object obj) ：添加obj 到集合的末尾。返回值：boolean。
add(int index,Object obj)：添加obj到 index索引上。返回值： void。
get(int index) ：得到指定index索引的元素。返回值： Object。
set(int index,Object obj)：使用obj覆盖 index索引的元素，返回被覆盖的元素。返回值：Object。
size() ：获取集合中的元素数量。返回值： int
isEmpty() ：判断集合是否为空。返回值：boolean。
clear()：清空集合。返回值： void。
remove(Object obj)：删除指定obj对象。返回值： boolean。
remove(int index)：删除指定Index索引的元素，返回被删除的元素。返回值：Object。
contains(Object obj)：判断是否存在obj元素。返回值：boolean。
indexOf(Object obj) ：得到元素obj第一次出现的索引。返回值： int。
lastIndexOf(Object obj)：得到元素obj最后一次出现的位置。返回值： int。
subList(int from,int to)：得到[from,to)区间内的元素。返回值： List。
toArray() ：将集合转换为数组。返回值：Object[]。

11.6 LinkedList 实现类

采用双向链表实现的集合
集合中保存的每个元素也称为节点，除首尾节点外，每个节点即保存了自己的数据，也保存了其前一个和后一个节点的地址
如果在其中进行插入和删除的操作时，不影响其他元素的位置，只需要重新定义新节点的前后节点位置即可。
如果要查询某个节点的索引，需要从头结点或尾结点开始一步步得到目标节点位置，所以中间进行插入和删除的效率高，随机读取的效率低

11,6,1 构造方法：

LinkedList()，创建一个空链表。

11.6.2 常用方法：

由于 LinkedList 实现了 List 接口，所有这里省略 List 接口中常用的方法，如 add(Object obj)，Remove(Object obj) 等。参考 ArrayList 中的方法。
addFirst() 添加头结点
addLast() 添加尾结点
getFirst() 得到头结点
getLast() 得到尾结点
remove() 删除头结点
removeFirst() 删除头结点
removeLast() 删除尾结点
push(Object obj) 添加头结点( 入栈 )
pop() 得到并移除头结点( 出栈 )
peek() 得到头结点
poll() 删除头结点
offer(Object) 添加尾结点

11.7 ArrayList 和 LinkedList 的区别

两者都是 List 接口的实现类，保存的元素有序可重复，允许保存 null ，拥有一些公共的方法，如
size() ， isEmpty() ， subList(int from,int to) 等
ArrayList 采用数组实现，对于随机读取效率更高，通常用于查询； LinkedList 采用双向链表实现，
插入删除不影响其他元素位置，通常用于中间插入删除。

11.8 哈希码的特点

如果两个对象的 hashCode 不同，这两个对象一定不同
如果两个对象的 hashCode 相同，这两个对象不一定相同
如 " 通话 " 和 " 重地 " 这两个字符串的 hashCode 相同，但是两个对象
hashCode 相同，对象不同，称为哈希冲突

11.9 HashSet 实现类

采用哈希表实现
元素不能重复，无序保存，允许保存 null
本质是一个 HashMap 对象，调用 add() 方法，实际调用的也是 HashMap 中的 put() 方法，参数作为
put() 方法的键， new Obejct() 作为 put() 方法的值

11.10 HashSet 添加数据的原理

if( 两个对象 hashCode 相同 && 两个对象 equals 相同 ){ 视为同一对象，不能添加 }
每次向集合中添加元素时，先判断该元素的 hashCode 是否存在，

如果不存在，视为不同对象，直接添加
如果存在，再判断 equals 方法的结果
如果为 false ，视为不同对象，直接添加
如果为 true ，视为同一对象，不能添加

可见不能添加的条件是两个对象的 hashCode 相同并且 equals 结果为 true 。

如果每次都只判断 equals 的话，过程可能会很久，效率不高，
如果每次只判断 hashCode 的话，有可能会有哈希冲突，

所以先判断 hashCode ，再判断 equals ，既能保证效率又能保证添加进去的元素都是不相同的元素。

11.11 equals 方法和 hashCode 的关系

如果两个对象的 equlas 方法比较结果为 true ，在没有重写 equals 方法的前提下， hashcode 相同吗？相同
如果两个对象的 hashCode 不同，在没有重写 equals 方法的前提下， equals 方法比较结果为 ? false
如果两个对象的 hashCode 相同， equals 方法比较结果为 ? 可能为 true 也可能是 false

11.12 构造方法

HashSet() 创建一个默认的集合对象，实际是创建了一个大小为16 ，加载因子为0.75 的 HashMap 对象
HashSet(int capacity) 创建一个指定容量的集合对象，实际是创建了一个指定大小，加载因子为0.75 的 HashMap 对象
HashSet(int capacity,float loadFactor) 创建一个指定容量和指定加载因子的集合对象。

11.13 常用方法

add(Object obj) 添加元素到集合中
size() 得到元素数量
isEmpty() 判断集合是否为空
remove(Object obj) 根据对象删除元素
contains(Object obj) 判断是否存在某个元素
toArray() 将集合转换为Object 数组
clear() 清空集合

11.14 TreeSet 实现类

特殊的 Set 实现类，数据可以有序保存，可以重复，不能添加 null 元素
采用红黑树 ( 自平衡二叉树 ) 实现的集合,

二叉树表示某个节点最多有两个子节点
某个节点右侧的节点值都大于左侧节点值

只能添加同一种类型的对象且实现了 Comparable 接口的对象
实现 Comparable 接口后必须要重写 compareTo 方法
每次调用添加时，参数会自动调用该方法
添加的元素可以自动排序
compareTo 方法的返回值决定了能否添加新元素和新元素的位置

如果返回 0 ，视为每次添加的是同一个对象，不能重复添加
如果返回正数，将新元素添加到现有元素之后
如果返回负数，将新元素添加到现有元素之前

11.15 HashMap 实现类

JDK1.8 之后， HashMap 的数据结构采用 " 数组 + 链表 + 红黑树 " 实现
当没有哈希冲突时，元素保存到数组中
如果哈希冲突，在对应的位置上创建链表，元素保存到链表中
当链表元素数量大于 8 ，转换为红黑树
数据采用 " 键值对 " 的形式保存，键称为 key ，值称为 value ，键不能重复，允许 null ，值没有限制，键和值都是引用类型
在哈希表中，哈希码就是键，保存的数据就是值，可以通过键得到相应的值。

11.15 常用方法

put(Object key,Object Value) 添加一组键值对
get(Object key) 根据键得到值
size() 得到键值对的数量
clear() 清空所有键值对
keyset() 得到所有键的集合
values() 得到所有值的集合
containtsKey(Object key) 判断是否包含某个键
containsValue(Object value) 判断是否包含某个值
remove(Object key) 根据键删除键值对

javaAdv

12 File 文件

Java 中可以将本地硬盘中的文件 ( 文件和目录 ) 以对象的形式表示。
就能通过 Java 代码对本地文件进行读取或操作。

12.1 构造方法

File(String pathName) 根据文件的完整路径创建对象
File(String parent,String name) 根据文件所在的父目录路径和自身文件名创建对象
File(File parent,String name) 根据文件所在父目录文件对象和自身文件夹创建对象

12.2 常用方法

exists()：判断文件是否存在。返回值： boolean。
isFile() ：判断是否为文件。返回值： boolean。
isDirectory()：判断是否为目录。返回值： boolean。
getName()：得到文件名。返回值： String。
getPath() ：得到文件所在相对路径。返回值： String。
getAbsolutePate() ：得到文件所在绝对路径。返回值： String。
getParent() ：得到父目录的名称。返回值： String。
getParentFile()：得到父目录的对象。返回值： File。
lastModified()：得到文件最后一次修改时间对应的毫秒数。返回值： long。
length()：得到文件的所占字节大小。返回值： long。
isHidden()：判断文件是否为隐藏。返回值： boolean。
list() ：得到目录下的第一层子文件名的字符串数组。返回值： String[]。
listFiles() ：得到目录下的第一层子文件的文件数组。返回值： File[]。
delete()：删除某个文件或空目录。返回值： boolean。
mkdir() ：创建一个空目录。返回值： boolean。
renameTo(File newFile)：将原文件命名为新文件(新文件可以指定新位置)。返回值： boolean。

13 I/O流

13.1 流的分类

Java 中将流定义成了类，以对象的形式保存。流有 " 四大家族 " ，是所有流的父类。
InputStream 字节输入流
FileInputStream ObjectInputStream
OutputStream 字节输出流
FileOutputStream ObjectOutputStream
Writer 字符输出流
FileWriter BufferedWriter
Reader 字符输入流
FileReader BuffedredReader

13,1 按方向分类

输入流： InputStream 、 Reader

作用：将硬盘中的数据读取到内存中

输出流： OutputStream 、 Wrtiter

作用：将内存中的数据写入到硬盘中

13.2 按类型分

字节流： InputStream 、 OutputStream

作用：适用于非文本类型，如图片、文件等的读写

字符流： Reader 、 Writer

作用：适用于文本类型，尤值 txt 格式文件的读写

如要将硬盘中某个 txt 文件中的字符读取到程序中，使用 Reader
如要将硬盘中的某个图片读取到程序中，使用 InputStream

13.3 流的四个父类的特点

以上四个类都在 java.io 包下，都是抽象类，不能直接创建其对象，要使用其子类
这四个类都有 close() 方法，用于关闭流对象释放资源
输出流 (OutputStream 和 Write) 都有 flush() 方法，用于将流中的数据到冲刷到硬盘中
在使用输出流对象时，一定要调用 flush() 或 close() 方法后，才能真正将数据写到硬盘中
输入流 (InputStream 和 Reader) 都有 read() 方法读取数据到内存中，输出流都有 write() 方法写入数
据到硬盘中所有的流类中，以 Stream 结尾的，都是字节流，以 Reader 或 Writer 结尾的都是字符流
读取硬盘中的数据时，使用输入流；将数据写入到硬盘中时，使用输出流
读取或写入文本文件时，使用字符流；读取或写入非文本文件时，使用字节流

13.4 FileInputStream 文件字节输入流

按字节读取本地文件，本地文件必须存在

13.4.1 构造方法

FileInputStream(String pathName) 根据文件名创建文件字节输入流对象
FileInputStream(File file) 根据文件对象创建文件字节输入流对象

13,4.2 常用方法

read() 读取一个字节。返回读取到的字节本身。
read(byte[] b) 按字节数组读取。返回读取到的字节数量。读取到的内容保存在了字节数组中
close() 关闭流对象

13.5 FileOutputStream 文件字节输出流

按字节将数据写入到本地文件中，本地文件可以不存在

13.5.1 构造方法

FileOutputStream(String pathName) 根据文件名创建文件字节输出流对象，写入内容时覆盖原内容。
FileOutputStream(String pathName,boolean append) 根据文件名创建文件字节输出流对象，写入内容时追加在原内容之后。
FileOutputStream(File file) 根据文件对象创建文件字节输出流对象，写入内容时覆盖原内容。
FileOutputStream(File file,boolean append) 根据文件对象创建文件字节输出流对象，写入内容时追加在原内容之后。

13.5.2 常用方法

write(int i) 写入一个字节
write(byte[] bytes) 写入一个字节数组
write(byte[] bytes,int off,int len) 写入字节数组中从off 开始的 len 个字节
flush() 将数据冲刷到本地文件中
close() 关闭流对象

13.6 使用 FileInputStream 和 FileOutputStream 读写时的注意事项

（1）在使用 read(byte[] bytes) 方法时，每次都会读取指定数组大小的字节，将读取到的字节保存到数组中，该方法返回读取到的字节数量。如果最后一次读取的字节数不足字节数组大小时，只会用读取到的内容覆盖最前的几个元素。所以会导致读取到的内容多于实际内容。
（2）在使用 write(byte[] bytes) 方法时，会将字节数组中的所有内容写入到输出流中，在最后一次写入时，可能会写入多余的内容。所以在写入时，最好使用 write(byte[] bytes,int off,int len) 方法，表示将字节数组中的元素，从 off 开始，写入 len 个字节。

13.7 FileReader文件字符输入流（按字符读取文件）

13.7.1 构造方法

FileReader(String fileName) 根据文件名创建文件字符输入流对象
FileReader(File file) 根据文件对象创建文件字符输入流对象

13.7.2 常用方法

ready() 判断是否还有下一个字符
read() 读取下一个字符，返回读取到的字符
read(char[]
chars) 按字符数组读取字符，返回读取到的字符数量，读取到的字符保存在了字符数组中
close() 关闭流对象

13.8 FileWriter文件字符输出流（按字符写入）

13.8.1 常用的构造方法

FileWriter(String fileName) 按文件名创建字符输出流对象
FileWriter(String fileName,boolean append) 按文件名创建字符输出流对象，允许追加写入
FileWriter(File file) 按文件对象创建字符输出流对象
FileWriter(File file,boolean append) 按文件对象创建字符输出流对象，允许追加写入

13.8.2 常用方法

write(String str) ：按字符串写入。
write(char[] c)：按字符数组写入。
write(String str,int off,int len)：按字符串写入，从off开始写入 len 个字符。
write(char[] c,int off,int len) ：按字符数组写入，从off开始写入 len 个字符。
flush() ：冲刷流中的数据到硬盘中(必须调用该方法或 close 方法后，才能真正写入)。
close()：关闭流对象。

13.9 BufferedReader 字符缓冲输入流

自带字符数组(缓冲区 ) 的字符输入流。默认字符数组大小为 8192 ，每次最多读取 8192个字符
在读取纯文本文件 (txt 或 md 等 ) 时，首选该类。

13.9.1 构造方法

13.9.1.1 BufferedReader(Reader reader)

创建一个带有缓冲区 ( 字符数组 ) 的字符输入流对象，默认缓冲区大小为 8192 。参数注意是一个 Reader 类型的对象，但 Reader 是一个抽象类，所以要使用其子类，如 FileReader ，然后在 FileReader 中定义要读取的文件信息

13.9.1.2 BufferedReader(Reader reader,int size)

创建一个指定缓冲区 ( 字符数组 ) 大小的字符输入流对象

13.9.2常用方法

ready() 判断是否还有字符
readLine() 读取整行字符
close() 关闭流对象

13.9.3 BufferedWriter 字符缓冲输出流

自带字符数组 ( 缓冲区 ) 的字符输出流。

13.9.4 构造方法

13.9.4.1 BufferedWriter(Writer writer)

创建一个带有缓冲区 ( 字符数组 ) 的字符输出流对象，参数为一个Writer 对象，但 Writer 是一个抽象类，所以要使用其子类，如FileWriter 对象，在 FileWriter 中定义要写入的文件

13.9.4.2 BufferedWriter(Writer writer,int size)

创建一个指定缓冲区 ( 字符数组 ) 大小的字符输出流对象

13.9.5 常用方法

write(String str) 写入一个字符串
newLine() 换行
flush() 将输出流中的字符冲刷到文件中
close() 关闭流对象

13.9.6 ObjectOutputStream 对象字节输出流 ( 序列化 )

序列化：将对象转换为文件的过程
被序列化的对象，必须要实现 Serializable 接口。
这个接口是一个特殊的接口，没有定义方法，只是给这个类打上标记，表示该类可以被序列化。

13.9.6.1 构造方法

13.9.6.1.1 ObjectOutputStream(OutputStream os)

创建一个对象字节输出流对象，参数为一个字节输出
流对象，由于是抽象类，所以要使用其子类，如
FileOutputStream 对象，在其中定义要写入的文件。

13.9.6.2 常用方法

writeObject(Object obj) 将一个对象写入到本地文件中
close() 关闭流对象

13.9.7 ObjectInputStream 对象字节输入流 ( 反序列化 )

反序列化：将文件转换为对象的过程

13.9.7.1 构造方法

13.9.7.1.1 ObjectInputStream(InputStream is)

创建一个对象字节输入流对象，参数为一个字节输入流对
象，由于是抽象类，所以要使用其子类，如
FileInputStream 对象，在其中定义要读取的文件

13.9.7.2 常用方法

readObject()
读取序列化后的文件，返回对象 Object
close()
关闭流对象