Java基础笔记(一)

主要是mooc陈良育老师的课程，这是第一部分课程的内容，强烈推荐，让我发现不少存在的知识漏洞，下面是笔记。

Java类基础知识

Class（类）

1.main函数

简写psvm

2.类

1. Java文件必须以.java作为拓展名
2. 一个Java文件只能有一个public class
3. public class的名字必须和文件名字一样
4. 大小写都要完全一致
5. 一个文件可以有多个class，但是只有一个是public。
6. 不提倡一个文件里面放多个类，内部类除外
7. System.out.print输出
8. System.out.println换行输出
9. 类是Java中的最基础逻辑单位
   Java所有的内容都是需要放在类的范围中
   内容不允许游离在类意外
   换言之，Java项目就是由一个个类组成的
10. 类的构成：成员变量/属性,成员方法/函数

3.Main函数

1. 一个class最多只能有一个main函数。类可以没有main函数，没有main函数的类就不能主动执行，但可以被动执行(被别人调用)
2. 程序的入口都是main函数,这点和C/C++一致。有一点不同的是Java要求所有程序必须放在类对象中，即所有的代码都要放在class的所辖范围内.
3. main函数的形参和前缀修饰符public，static，void等都不能省略，是固定写法。可简单记忆为PSVM。
4. 严格意义上说，main函数不属于这个类的所拥有函数。
5. 只是因为Java要求所有的内容都必须放置在class的范围内，所以main函数寄居在某一个class中。
6. main函数是一个Java程序的总入口。
7. main函数也无法被其他方法/类所调用
8. 一个Java程序可以调用多个其他的Java class
9. String[] args是main函数的形参，即在main函数中可以使用这些args的值

基本类型和运算符

基本类型

1. boolean：只有true或者false两种值
2. byte：字节1byte=8bits 存储有符号的，以二进制补码表示的整数 范围为-128到127，默认值为0，byte类型用在大型数组中可以显著节约空间，主要代替小整数，因为byte变量占用的空间只有int类型的四分之一,byte在二进制文件读写中使用较多（转换文件编码，文件流操作等）
3. short：16位，2个字节，有符号的以二进制补码表示的整数，范围从-2^15到215-1，默认值为1
4. int: 32位，4个字节，有符号的以二进制补码表示，范围从-2^31-231-1
5. long: 64位,8个字节，有符号的以二进制补码表示,范围从-2^63-263-1，默认值为0L
6. float: 单精度，32位，4个字节，定义是末尾可加f
7. double: 双精度，64位，8个字节,定义是末尾可加d
8. float和double都不能用来表示很精确的数字.
9. char是一个单一的16位Unicode字符，最小值为\u0000（即为0），最大值是\uffff(即为65535);char数据类型可以存储任何字符

运算符

1. +，-，*，/，%
2. 逻辑运算符 &&,||,!
3. 比较运算符!=,>,>=,<,<=,==
4. 移位运算符>>,<<等
5. 不用背诵运算符优先级，用括号隔开

选择结构

1. if(布尔表达式) 单种case
2. if(布尔表达式)···else
3. 多重选择结构switch表达式

循环结构

1. while
2. do— while
3. for
4. break
5. continue

自定义函数

1. 函数必须放在类的范围内
2. 修饰词(public或者static)返回值(int或者void),函数名(形参列表){函数体}
3. 通常情况下，我们都建议方法是public
4. 函数可以调用其他函数
5. 递归函数调用，需要注意终止性。
6. 同一个类中，函数名称可以相同，即重载函数overload，但是函数参数的个数或者类型必须有所不同
7. 不能以返回值来区分同名的函数
8. 函数的重载是函数名相同，形参列表必须不同

面向对象

1. 对象=属性+方法
2. 对象的规范=属性定义+方法定义
3. 对象是一个变量
4. 类就是类型，是规范是定义，从万千对象中抽取共性
5. 类规定了对象应该有的属性内容和方法
6. 对象是类的具体实现，是活生生的
7. Oriented Object是对OP的一种改进
8. 计算机的发展和社会发展也是相似之处，更强调方法的执行主体，增加类型的重用部分
9. 变量定义的变迁：更加功能强大
10. 基本类型=》结构体=》多种变量+方法
11. 类可以继承：子类可以继承父类所有内容(不能直接访问private成员)
12. 结构体只能全包含，不能控制包含的力度
13. 面向对象语言主要特点: 识认性，类别性，多态性，继承性

Java类和对象

1. 最简单的类class A{}
2. 对象A obj = new A();
3. 类是定义，是规范
4. 对象是实例，是类的一个实现，是一个具体的东西
5. 对象交换和普通类型交换的不同，对象的赋值是Reference赋值，而基本类是直接值拷贝
6. 产生一个对象，new，反射克隆

构造函数

1. 在对象产生时就给成员变量赋值
2. 构造函数的名称和类名是一致的，且没有返回值
3. Java有构造函数，但是没有析构函数(销毁对象)
4. 每个变量都是有生命周期的，它只能存储在离它最近的大括号内
5. 当变量被创建时，变量将占据内存；当变量消亡时，系统将回收内存
6. Java具有内存自动回收机制的，当变量退出其生命周期，JVM会自动回收所分配的对象的内存
7. 对象回收效率依赖于垃圾回收器GC，其回收算法关系到性能好坏，是JVM的研究热点
8. 每个Java类都必须有构造函数
9. 如果没有显式定义构造函数，Java编译器自动为该类产生一个空的无形参构造函数，编译器就不会越俎代庖了。
10. 每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super(),除非子类的构造函数第一句话是super，而且super语句必须放在第一条
11. 一个类可以有多个构造函数，只要形参列表不相同
12. 在new对象的时候，根据实参的不同，自动挑选相应的构造函数。如果实参形参匹配不上，将会报错。

信息隐藏

1. 面向对象的一个法则:类的成员属性，是私有的private，类的方法是公有public的，通过方法修改成员属性的值
2. 类成员是私有private的
3. get和set方法是公有public的，统称为getter和setter
4. 外界对类成员的操作只能通过get和set方法
5. 可以用IDE快速生成
6. this负责指向本类中的成员变量，this相当于infohiding2

继承

1. 面向对象编程语言和面向过程的编程语言最突出的特点就是变量类型的继承
2. 更符合大自然规律：父亲有的，儿子就有
3. 面向过程的编程语言没有继承，导致出现很多类型重复定义
4. 物以类聚，世间万物皆对象，对象也可以分成若干类别。
5. 类别内的对象属性和方法都具有一定的共同点。
6. 将共同点提取出来，即形成了父类/基类/超类，Parent class/Base class/Super class
7. 而其他类则自动成为子类/派生类，Child class/Derived class
8. 子类继承父类所有的属性和方法，但不能直接访问private成员
9. 根据信息隐藏原则：子类会继承父类所有的方法，可以直接使用
10. 子类也会继承父类的父类的所有属性和方法，但不能直接访问private成员
11. 单根继承原则：每个类只能继承一个类
12. 如果不屑extends，Java类都默认继承java.lang.Object类
13. java所有类从Object开始，构建出一个类型继承树
14. Object类里面默认就有clone，equals，finalize，getClass，hashCode，toString等方法
15. 每个Java类都必须有构造函数
16. 如果没有显式定义狗洗澡函数，Java编译器自动为该类产生一个空的无形参构造函数。
17. 每个子类的构造函数第一句话，都默认调用父类的无形参构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条，不会出现连续两条super语句

抽象类和接口

1. 类：属性(0或多个)+方法(0或多个)
2. 一个完整的类：所有的方法都有实现(方法体)
3. 类可以没有方法，但是有方法就肯定要有实现，这才是一个完整的类
4. 一个完整的类才可以被实例化，被new出来
5. 如果一个类暂时有方法未实现，需要被定义为抽象类，abstract class
6. 抽象类的组成：成员变量，个数不限；具体方法，方法有实现，个数不限；抽象方法，加abstract关键字，个数不限
7. 抽象类也是类，一个类如果继承于抽象类，就不能继承于其他类
8. 子类可以继承于抽象类，但是一定要实现父类们所有abstract的方法。如果不能完全实现，那么子类也必须被定义为抽象类。
9. 只有实现父类们的所有抽象方法，才变成完整类
10. 如果类的所有方法都没有实现，那么这个类就算是接口interface。
11. 类只可以继承一个类，但是可以实现多个接口，继承和实现可以同时
12. 接口不算类，或者说是特殊的类
13. 接口设计是为了弥补单根设计的不足。
14. 接口可以继承多个接口，没有实现的方法将会叠加
15. 类可以实现接口，就必须实现所有未实现的方法。如果没有全部实现，那么只能成为一个抽象类
16. 接口里可以定义变量，但是一般是常量

转型，多态和契约设计

1. 变量支持互相转化，比如int a=（int） 3.5；
2. 类型可以相互转型，但是只限制于有继承关系的类
3. 子类可以转换成父类，而父类不可以转为子类
4. 子类继承父亲所有的财产，子类可以变成父类，即向上转型，向下转型则是不允许的。
5. 父类转为子类有一种情况例外，就是这个父类本身就是从子类转化过来的。比如new的是子类
6. 类型转换，带来的作用就是多态。
7. 子类继承父类的所有方法，但子类可以重新定义一个名字、参数和父类一样的方法，这种行为就是重写(覆写，覆盖，overwrite/override,not overload)
8. 子类的方法的优先级高于父类的。
9. 多态的作用，以统一的接口来操作某一类中不同的对象的动态行为，对象之间的解耦

契约设计

1. Java编程设计遵循契约精神
2. 契约： 规定规范了对象应该包含的行为方法
3. 接口定义了方法的名称、参数和返回值，规范了派生类的行为
4. 基于接口，理用转型和多态，不影响真正方法的调用，成功地将调用类和被调用类解耦decoupling

static

1. Java中的关键字
2. 可以用在变量，方法，类，匿名代码块
3. 静态变量，类共有成员
4. static变量只依赖于类存在，通过类即可访问，不依赖于对象实例存在。
5. 所有的对象实例共享存储在一个共同的空间(栈)
6. static方法无需通过对象来引用，而通过类名可以直接引用
7. 在静态方法中，只能使用静态变量，不能使用非静态变量。
8. 静态方法静止引用非静态方法。
9. 关于static修饰类，内部类使用较少
10. static块，旨在类第一次被加载时调用，换句话说，在程序运行期间，这段代码只运行一次。执行顺序：static块>匿名块>构造函数.

单例模式 getInstance()

1. 单例模式，又名单态模式
2. 限定某一个类在整个程序运行过程中，只能保留一个实例对象在内存空间
3. 单例模式是GoF的23种设计模式中经典的一种属于创建型模式类型
4. 设计模式：在软件开发过程中，经过验证的，用于解决在特定环境下的重复出现的，特定问题的解决方案。
5. 设计模式起源于建筑领域。
6. 单例模式：保证一个类有且只有一个对象，采用static来共享对象实例，采用private构造函数，防止外界new操作。

final

1. Java的final关键字同样可以用来修饰类方法字段
2. final的类不能被继承
3. 父类中如果有final的方法，子类不能改写此方法
4. final的变量，不能被再次赋值。如果是基本型别的变量，不能修改其值，如果是对象实例，那么不能修改其指针，但是可以修改对象内部的值。

常量设计和常量池

1. 常量：一种不会修改的变量，java没有constant关键字，用final，不会修改，只读，只要一份，static，方便访问public
2. java中的常量使用public static final，建议常量名字全大写，以连字符相连
3. 接口内定义的变量默认为常量，public interface
4. Java为很多基本类型的包装类/字符串都建立常量池
5. 常量池：相同的值只存储一份，节省内存，共享访问
6. 基本类型的包装类：Boolean，Byte，Short，Integer，Long，Charaacter，Float，Double。其中Boolean：true，false，Byte：-128_{127,Character:0}127,short,Int,Long:-128~127
7. Float,Double:没有缓存(常量池)
8. 比如Integer i1=i2=127，则i1==i2，而i1=i2=128，则i1！=i2
9. Java为常量字符串建立了常量池缓存机制
10. 节约内存，提高共享访问
11. 基本类型的包装类和字符串有两种创建方式
12. 常量式字面量赋值创建，放在栈内存
13. new对象进行创建，放在堆内存
14. 这两种创建方式导致创建的对象存放的位置不同。故直接==为false
15. 栈内存读取速度快但容量小，堆内存读取速度慢但容量大

不可变对象和字符串

1. 不可变对象(Immutable Object)
2. 一旦创建，这个对象不能被更改，其内在的成员变量的值就不能修改了，八个基本类型的包装类S听，BigInteger，BigDecimal
3. 可变对象(Mutable Object)普通对象
4. 不可变对象也是传指针，指针指向可以改变。
5. 由于不可变，临时变量指向新内存，外部实参的指针不改动。
6. 如何创建不可变对象：immutable对象是不可改变的，有改变，请clone/new一个对象进行修改，所有的属性都是final和private的，不提供setter方法，类是final的，或者所有的方法都是final，类中包含mutable对象，那么返回拷贝需要深度clone
7. 不可变对象的优点：只读，线程安全，并发读，提高性能，可以重复使用
8. 缺点：制造垃圾，浪费空间
9. String定义有两种=“”或new，内容比较使用equals，是否指向同一个对象采用指针比较==
10. 字符串假发由于String不可此u该，效率差，使用StringBuffer/StringBuilder类的append方法进行修改
11. StringBuffer/StringBuilder的对象都是可变对象
12. StringBuffer(同步，线程安全，修改快速),StringBuilder（不同步，线程不安全，修改更快）
13. 函数参数是基本类型，则为传值的。
14. 速度，StringBuilder，Stringbuffer，String

package，import

1. 所有Java类都是放置在同一个目录下面的，因此类之间的相互调用无需显式声明调用。同一个目录下，两个类的名字不能相同，文件过多，查找和修改都不易，且容易出错。
2. Java支持多个目录放置Java，并且通过package/import/classpath/jar等机制配合使用，可以支持跨目录放置和调用Java类
3. package包，和C++中的namespace类似
4. 引用类的时候，必须采用全称引用，程序正文可以使用短名称。
5. import必须放在package之后，类定义之前
6. 多个import顺序无关
7. 可以用*来引入一个目录下的所有类
8. import尽量精确，不推荐用*，以免新增的同名程序会使得老程序报错

Java访问权限

1. Java访问权限有四种：private，default，protected，public
2. 使用范围：四种都可以用来修饰成员变量，成员方法，构造函数
3. private仅允许同一个类访问
4. default允许同一个类同一个包访问
5. protected允许同一个类，同一个包，不同包的子类
6. public允许同一个类，同一个包，不同包的子类，不同包的非子类

JavaDoc

1. 利用注解自动生成接口文档

数字相关类

1. Java数字类，short，int，long，float，double，biginteger，bigdecimal，random，math
2. random，nextInt（）返回一个随机int，nextInt（int a）返回[0,a)之间的随机int，nextDouble()返回一个[0.0,1.0]之间的double，ints()方法批量返回随机数数组
3. Math.random（）返回一个[0.0,1.0]之间double

字符串相关类

1. String：java中使用频率最高的类，是一个不可变对象，加减操作性能差
2. replace支持正则表示式
3. StringBuffer，StringBuilder可变字符串
4. 前者同步性能好，后者不同步，性能更好。
5. 方法一样，区别在同步，append/insert/delete/replace/substring
6. length字符串实际大小，capacity所占用空间大小
7. 如有大量append，事先预估大小，再调用相应的构造函数
8. StringBuffer，Builder是一个可变空间，而String是一个定长数组，所以是不可变的。

时间相关类

1. 时间类：java.util.Date-getTime().java.sql.Date（和数据库对应的时间类）,Calendar是目前程序中最常用的，但是是抽象类。Calendar gc=Calendar.getInstance();Calendar gc=new GregorianCalendar();简单工厂模式。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
2. Calendar线程不安全，java.time包,线程安全，主要包括LocalDate，LocalTime，LocalDateTime：LocalDate+LocalTime，Instant：时间戳

格式化相关类

1. Format，NumberFormat数字格式化，MessageFormat，字符串格式化，DateFormat日期，日期格式化。
2. DateFormatter时间格式化，线程安全，SimpleDateFormat线程不安全

Java异常分类

1. 异常：程序不正常的行为或者状态。
2. 异常处理：程序返回到安全状态，允许用户保存结果，并以适当方式关闭程序。
3. Throwable是Java所有异常(错误)的祖先类
4. 异常分为Error，Exception.Error是系统内部错误或者资源耗尽
5. Exception分为IOException，Runtime Exception，RuntimeException是程序自身的错误，非RuntimeException是外界相关的错误。
6. 另外一种分类方法是Unchecked Exception，包括Error子类和RuntimeException子类
7. 非RuntimeException的Exception的子类异常，checked exception
8. 编译器会检查程序是否为checked exception配置了处理，如果没有处理，会报错。

Java异常处理

1. 异常处理，try-catch-finally：一种保护代码正常运行的机制。
2. 异常结构：-try···catch，trycatchfinally，try finally
3. 异常处理：一个方法被覆盖，覆盖它的方法必须抛出相同的异常，或者异常的子类。
4. 如果父类的方法抛出多个异常，那么重写的子类方法必须抛出那些异常的子集，也就是不能抛出新的异常。
5. 自定义异常

数组

1. 数据是一个存放多个数据的容器，数据是同一种类型，所有的数据都是线性规则排列的，可通过位置索引来快速定位访问数据，需明确容器长度
2. JCF，容器：能够存放数据的空间结构，数组/列表散列集，树
3. 容器框架：对外的接口，接口的实现，算法
4. 容器框架优点：提高数据存放效率，避免重复劳动，C++的STL，Java里面的JCF
5. Vector，Stack，Hashtable，Enumeration，泛型设计，基于设计模式
6. Java Collection Framework，列表，散列，映射
7. Java的集合接口是Collection，add，contains，remove，size，iterator迭代器，如hasNext，next，remove
8. JCF主要的数据结构实现类：列表(List,ArrayList,LinkedList),集合(Set,HashSet,TreeSet,LinkedHashSet),映射(Map,HashMap,TreeMap,LinkedHashMap),主要算法类:Arrays:对数组进行查找和排序等操作,Collections:对Collection及其子类进行排序和查找操作。
9. 列表List，ArrayList以数组实现的列表，不支持同步，利用索引可以快速定位，不适合插入删除，适合查询。ArrayList会自动扩充容器大小的50%
10. LinkedList:以双向链表实现的列表，不支持同步，可被当作堆栈、队列和双端队列进行操作，顺序访问高效，随机访问较差，中间插入和删除高效，适用于经常变化的数据。
11. Vector同步，和ArrayList类似，可变数组实现的列表，Vector同步，适合在多线程下使用，原先不属于JCF框架，属于Javga最早的数据结构，性能不好，在非同步情况下，优先采用ArrayList
12. 集合Set，确定性，互异性，无序性。Java中的集合接口Set：HashSet(基于散列函数的集合，无序，不支持同步)，TreeSet(基于树结构的集合，可排序的，不支持同步)，LinkedHashSet(基于散列函数和双向链表的集合，可排序，支持同步)
13. HashSet是基于HashMap实现的，可以容纳null元素，可支持同步，但是需要设置，入Set s=Collections.synchronizedSet(new HashSet(…));
14. retainAll计算两个集合交集
15. LinkedHashSet，继承HashSet，也是基于HashMap实现的，可以容纳null元素，不支持同步，Set s=Collections。synchronizedSet(new LinkedHashSet(…));方法与HashSet基本一致，通过一个双向链表维护插入顺序。
16. TreeSet基于TreeMap实现的，不可以容纳null元素，不支持同步，如果想要同步可以通过SortedSet s=Collections。synchronizedSortedSet(new TreeSet(…))；
17. 相同与不同：HashSet，LinkedHashSet，TreeSet的元素都只能是对象，HashSet和LinkedHashSet判定元素重复的原则，判定两个元素的hashCode返回值是否相同，若不同，返回false，若HashCode相同，判定equals方法，若不同，返回false，返回true。hashCode和equals方法是所有类都有的，因为Object类有。
18. Treeset判定元素重复的原则：需要元素继承自Comparable接口，比较两个元素的compareTo方法
19. equals(),hashCode(),toString(),如果第一个相同，那么这三个都是相同的。
20. CompareTo方法必须进行定义才能用到TreeSet

Map映射

1. Map映射：Hashtable(同步，慢，数据量小)，HashMap（不支持同步，快，数据量大），Properties(同步，文件形式，数据量小)
2. Hashtable:K-V对，K和V都不允许为null，同步，多线程安全，无序的，适合小数据量，主要方法clear，contains，containsValue，containsKey，put，remove，size；Entry，map，Enumeration遍历，Enumeration是只读的。
3. HashMap：K-V对，K和V都允许为null，不同步，多线程不安全，Map m=Collections.synchronizedMap(new HashMap(…));无序的，主要方法类似。
4. LinkedHashMap:基于双向链表的维持插入顺序的HashMap，
5. TreeMap基于红黑树的Map，可以根据key的自然排序或者compareTo方法进行排序输出
6. Properties：继承于Hashtable，可以将K-V对保存在文件中，适用于数据量小的配置文件，继承自Hashtable的方法，从文件中加载的load方法，写入到文件中的store方法，获取属性getProperty，设置属性setProperty。

JCF工具类

1. Arrays: 处理对象是数组，排序：对数组排序，sort/parralelSort；查找：从数组中查找一个元素binarySearch；批量拷贝：从原数组批量赋值元素到目标数组，copyOf；批量赋值：对数组进行批量赋值，fill。等价性比较：判定两个数组内容是否相同：equals。
2. 包装器类：处理对象是Collection及其子类，排序：对List进行排序，sort。搜索： 从List中搜索元素，binarySearch，批量赋值，对List批量赋值，fill。最大最小：查找集合中最大最小值，max，min；反序：将List反序排列，reverse。

对象比较：

1. 对象实现Comparable接口需要修改对象类，Arrays和Collections在进行对象sort时自动调用该方法，新建Comparator适合于对象类不可更改的情况。
2. 新建Comparator适合于对象类不可更改的情况，compare方法，>返回1，==返回0，<返回-1，Comparator比较器将作为参数提交给工具类的sort方法。

Java文件基本操作

1. 文件系统是由OS管理的
2. 文件系统和Java进程是平行的，是两套系统
3. 文件系统是由文件夹和文件递归组合而成
4. 文件目录分隔符，Linux/Uninx用/隔开，windows用、隔开，涉及转义则\\
5. 文件包括文件里面的内容和文件基本属性
6. 文件基本属性： 名称大小，扩展名修改时间等
7. File类：File类与OS无关，但会受到OS的权限限制，常用方法，createNewFile，delete，exists，getAbsolutePath，getName，getParent，getPath，mkdir等
8. File不涉及具体文件内容，只涉及属性
9. NIO包：Path，Files，DirectoryStream，FileVisitor，FileSystem是对File的补充，主要涉及文件的复制与移动，文件相对路径，递归遍历目录，递归删除目录。支持正则表达式

JavaIO包

1. 文件系统和Java是两套系统
2. Java读写文件，只能以数据流的形式进行读写
3. Java.io包中：节点类：直接对文件进行读写，包装类：转化类：字节/字符/数据类型的转化类。装饰类：装饰节点类
4. 字节：byte，8bit，最基础的存储单位
5. 字符：a，10000，我，书写概念
6. 数据类型：3，5.25，abcdef
7. 文件以字节保存，因此程序将变量保存到文件需要转化
8. 节点类：直接操作文件夹类，InputStream，OutputStream，FileInputStream，FileOutputStream；Reader，Writer字符，FileReader，FileWriter，其中Input表输入流，out表输出流
9. 字节类以Stream结尾，字符类以er为结尾
10. 转换类:字符到字节之间的转化，InputStreamReader：文件读取时字节，转化为Java能理解的字符，OutputStreamWriter：java将字符转化为字节输入到文件中
11. 装饰类：装饰节点类
12. DataInputStream，DataOutputStream：封装数据流
13. BufferedInputStream，BufferOutputStream：缓存字节流(访问速度快，因为硬盘访问比较慢)
14. BufferdReader，BufferedWriter：缓存字符流

文本文件读写

1. 文件类型：一般文本文件(若干行字符构成的文件)，如txt等；一般二进制文件，如数据文件dat；带特殊格式的文本文件，如xml等；带特殊格式二进制文件，如doc，ppt等
2. 文件是数据的一个容器（口袋）
3. 文件可以存放大量的数据
4. 文件很大，注定Java只能以流形式依次处理
5. 从Java角度理解：输出：数据从Java到文件中，写操作；输入：数据从文件到Java，读操作；
6. 文本文件读写：输出文本字符到文件中，从文件中读取文本字符串
7. 写文件，先创建文件，写入数据，关闭文件，FileOutputStream，OutputStreamWriter，BufferedWriter；BufferWriter：write，newLine；
8. try-resource语句，自动关闭资源，关闭最外层数据流，将会把其上所有的数据流关闭。
9. 读文件：先打开文件，逐行读入数据，关闭文件；FileInputStream，InputStreamWriter，BufferedReader；BufferReader：readline，try-resource语句自动关闭资源
10. new时可以通过增加编码参数

二进制文件读写

1. 二进制文件：狭义上说采用字节编码，非字符编码的文件；广义上说，一切文件都是二进制文件；用记事本等无法打开/阅读
2. 二进制文件读写，输出数据到文件中；从文件中读取数据
3. 写文件：先创建文件，写入数据，关闭文件FileOutputStream，BufferedOutputSream，DataOutputStream；DataOutputStream：flush，write/writeBoolean/writeByte/WriteChars等；try-resource语句自动关闭资源，关闭最外层数据流就会把其上所有的数据流关闭。
4. 二进制文件读操作：先打开文件，读入数据，关闭文件和写类似。

Zip文件读写

1. 压缩包zip，rar，gz；Java zip包支持Zip和Gzip包的压缩和解压/
2. 压缩过程：单个压缩或多个压缩，打开输出zip文件，添加一个ZipEntry，打开一个输入文件，读数据，向ZipEntry写数据，关闭输入文件，重复以上两个步骤，写入多个文件到zip文件中，关闭zip文件。
3. 解压就是逆过程。