JAVA（三）JAVA经常使用类库/JAVA IO

成鹏致远 |  lcw.cnblog.com  |2014-02-01

JAVA经常使用类库

1.StringBuffer

1. StringBuffer是使用缓冲区的，自己也是操做字符串的，可是与String类不一样，String类的内容一旦声明以后则不可改变，改变的只是其内存地址的指向，而StringBuffer中的内容是能够改变的
2. 对于StringBuffer而言，自己是一个具体的操做类，因此不能你String那样采用直接赋值的方式进行对象的实例化，必须经过构造方法完成
3. 当一个字符串的内容须要被常常改变时就要使用StringBuffer
4. StringBuffer的内容是能够修改的，经过引用传递的方式完成
5. StringBuffer经常使用方法
1. 字符串链接操做：append()
2. 在任意位置处为StringBuffer添加内容：insert(int offset, boolean b)
3. 字符串反转操做：reverse()
4. 替换指定范围的内容：replace(int start, int end, String str)
5. 字符串截取：substring(int start, int end)
6. 字符串截取：delete(int start, int end)
7. 查找指定的内容是否存在：indexOf()
8. 以上的经常使用方法，实际上对于String类中也是存在的，因此使用的时候直接根据DOC文档查看便可
6. 小结
1. 凡是须要频繁修改字符串内容的时候，都要使用StringBuffer类完成
2. StringBuffer类中也提供了一些方法是String类中所没有的，包括：delete()、insert()等等，这些方法须要的时候直接经过DOC文档进行查找

2.Runtime类

1. Runtime：运行时，是一个封装了 JVM进程的类。每个JAVA程序实际上都是启动了一个 JVM进程，那么每个JVM进程都是对应这一个Runtime实例，此实例是由 JVM为其实例化的
2. Runtime类的定义中根本就没有构造方法，本类的构造方法被私有化了，经过 getRuntime()静态方法就能够取得Runtime类的实例
3. 获得 JVM信息：每个Runtime对象都是由 JVM进行实例化，因此，能够直接经过此类取得一些信息
4. 能够直接使用 Runtime类运行本机的可执行程序：public Process exec(String command) throws IOException
5. exec()方法的加值值是 Process，表示一个进程的操做类，能够经过 destroy()方法销毁掉一个进程
6. 小结
1. Runtime类自己就是单态设计的一种应用，由于在整个 JVM中只存在一个Runtime类的对象
2. 可使用Runtime类取得 JVM的系统处，或者使用 gc()方法释放掉垃圾空间
3. 还可使用此类运行本机的程序

3.国际化程序

1. 国际化：程序根据不一样的语言环境找到不一样的资源文件，以后从资源文件中取出内容，资源文件中的内容都是以 key ->value的形式保存的，因此在读取的时候经过其 key找到对应的 value便可
2. 若是要想实现 Java程序的国际化操做必须经过如下的三个类完成
1. java.util.Locale：用于表示一个国家语言类
2. java.util.ResourceBundle：用于访问资源文件
3. java.text.MessageFormat：格式化资源文件的占位字符串
3. Locale类
1. Locale表示的是本地，实际上使用的是一个 ISO编码的封装类。
2. 对于各个国家来讲都存在一个惟一的编码，那么这种编码就称为 ISO编码，使用Locale能够指定好一个具体的国家编码
1. 中国编码：zh-CN
2. 英语-美国的编码：eh-US
3. 法语的编码：fr-FR
4. ResourceBundle
1. 此类是专门完成属性文件读取操做的，读取的时候直接指定文件名称便可（此文件名称通常不须要指定后缀，后缀统一为 *.properties）
2. 能够根据Locale所指定的区域码来自动选择所须要的资源文件
3. public static final ResourceBundle getBundle(String baseName)，此方法就是指定要操做的资源文件，此方法找到的是默认的操做系统的语言Locale对象
4. public final String getString(String key)根据 key取得对应的 value
5. 资源文件命名的时候最好采用单词首字母大写的方式完成
5. 【注意】对于中文的资源文件虽然能够直接通中文读取，可是这样作是不合理的，应该将其进行 Unicode编码，转换为Java认识的16进制，这样能够避免一些系统所带来的乱码问题，此工具为 JDK自动提供：native2ascii.exe，只要是中文，就必须进行转码操做
6. 处理动态文本：就必须在资源文件中进行一些动态文本的配置，设置点位符，则必须使用 MessageForm类，此类是在 java.text包中定义的
7. 在 Format类中还存在数字格式化的 Format（NumberFormat）、日期格式化的 Format（DateFormat）
8. JAVA新特性：可变参数：在 JDK1.5以后增长了新特性的操做，能够向方法中传递可变的参数
9. 小结
1. 国际化程序实现的思路：程序与显示相分离，根据不一样的 Locale指定的区域找到不一样的资源文件并根据其 key取得对应的 value
2. 使用资源文件的方式保存全部的信息内容，其基本原理就是依靠了 ResourceBundle类取得资源文件中的内容
3. MessageForm是 Format类的子类，之后还会有 Format其它子类的讲解

4.System类

1. System类是一些与系统相关的属性和方法的集合在 System类中全部的属性都是静态的，要想引用这些属性和方法，直接使用System类调用便可
2. System类能够经过方法取得一个操做的计算时间：System.currentTimeMillis()
3. 还能够列出本机的所有系统属性：getProperties()
4. 一个对象若是不使用，则要等待进行垃圾收集，垃圾收集能够自动调用也能够手工调用，手工调用的时候就是调用 System.gc()或者 Runtime.getRuntiom().gc()。可是，若是一个对象在回收以前须要作一些收尾的工做，则就必须覆写 Object类中的：protected void finalize() throws Throwable，在对象被回收以前进行调用，以处理对象回收前的若干操做，例如释放资源等等
5. 只有强制性调用 gc()的时候才能够发现对象被回收，固然，若是不调用，则系统也会在必定时间内自动进行回收
6. 对象生命周期：初始化->对象实例化->垃圾收集->对象终结->卸载
7. 小结
1. System类自己提供的静态属性都是与 IO操做有关的，在 IO操做中还将进一步涉及 System类的使用，可使用 System类取得计算的时间，以及经过 gc()方法进行垃圾收集，此方法就是包装了 Runtime类中的 gc()方法

5.日期操做类

1. Date类是一个较为经常使用的类，可是其操做的日期格式会有一些不符合于我的的要求，而若是要想进一步取得一些本身须要的时间，则可使用Calendar类
2. 在java.util包中定义了 Date类，Data类自己使用很是简单，直接输出其实例化对象便可
3. 若是但愿能够按照本身须要的格式显示时间，可使用 Calendar类，此类能够直接将日期精确到毫秒
4. Calendar类是一个抽象类，既然是一个抽象类则确定没法直接使用，此时就要利用对象多态性的概念，经过向上转型关系实例化本类对象
5. 使用 Calendar类能够很是轻松取得一个完整的日期，可是在取得月份的时候要特别注意，须要增长1
6. 最好的作法是将 Date进行一些相关的格式化操做
7. 小结
1. Date类虽然直接取出的时间格式并非十分理想，可是其做用依然很大
2. 经过 Calendar类能够完整的取得时间

6.DateFormat、SimpleDateFormat

1. DateFormat类是一个抽象类，其类自己的内部提供了能够直接为其实例化的操做
1. 获得日期的 DateFormat对象：public static final DateFormat getDateInstance()
2. 获得日期时间的 DateFormat对象：public static final DateFormat getDateTimeInstance()
2. 直接使用 DateFormat类完成Date类的转换：public final String Format(Date date)
3. 经过DateFormat类能够直接将 date类的显示进行合理的格式化操做，此时采用的是默认的格式化操做，也能够经过 Locale对象指定要显示的区域
4. SimpleDateFormat类：功能是完成日期的显示格式化的
1. 要想实现转换，则必须首先准备好一个模板，经过此模板进行日期数据的提取工做
2. 在SimpleDateFormat类使用的时候，必须注意的是构造对象时要传入匹配的模板
3. 构造方法：public SimpleDateFormat(String pattern)
4. 转换：public Date parse(String source) throws ParseException：此时取得的是所有的时间数
5. 格式化：public final String format(Date date)：将时间从新格式化成字符串显示
5. 小结
1. DateFormat能够直接使用，但其自己是一个抽象类，能够根据 Locale指定的区域不一样获得不一样的日期时间显示效果
2. SimpleDateFormat类是 DateFormat类的子类，通常状况下来讲 DateFormat类不多会直接使用，而都使用 SimpleDateFormat类完成
3. 直接使用 SimpleDateFormat类取得时间会比使用 Calendar类更加方便，并且不用去增长补零的操做，因此在开发中若是须要取得一个日期的话，则基本上都使用 SimpleDateFormat类进行操做

7.Math与Random

1. Math类，表示数学操做，Math类中的方法都是静态方法，直接使用“类.方法名称()”的形式调用便可
2. Math.round求四舍五入的时候其实是将小数点以后的内容所有忽略掉了，若是此时须要进行准确倍数的四舍五入，则须要使用其它的类完成：BigDecimal
3. Random类的主要功能是产生随机数，能够产生一个指定范围的随机数，Random类是定义在 java.util包中的类
4. 小结
1. Math类中的 round()方法要特别注意
2. Random类的主要功能

8.NumberFormat

1. 可使用 NumberFormat类进行本地化的数字显示
2. 可使用 DecimalFormat指定格式化模板
3. NumberFormat表示数字的格式化类，即：能够按照本地的风格习惯进行数字的显示
4. MessageForm、DateFormat、NumberFormat是 Format三个经常使用的子类，若是要想进一步完成一个好的国际化程序，则确定须要同时使用这样三个类完成，根据不一样的国家显示日期，或者显示货币的形式
5. DecimalFormat是 NumberFormat类的子类，能够直接指定其显示的模板
6. DecimalFormat主要的做用是用来格式化数字使用，固然，在格式化数字的时候要比直接使用 NumberFormat更加方便，由于能够直接指定按用户自定义的方式进行格式化操做，与以前讲解的 SimpleDateFormat相似，若是要想进行自定义格式化操做，则必须指定格式化操做的模板
7. 小结
1. NumberFormat完成的功能只是根据区域不一样固定的数字显示格式
2. DecimalFormat是能够由用户本身指定其显示的形式，因此比较好用　

9.大数操做

1. 在java中有两个大数的操做类
1. 操做整型：BigInteger
2. 操做小数：BigDecimal
2. 若是在操做的时候一个整型数据已经超过了整数的最大类型长度long的话，则此数据就没法装入，因此，此时要使用BigInteger类进行操做
3. BigDecimal：使用此类能够完成大的小数操做，并且也可使用此类进行精确的四舍五入，这一点在开发中常用
4. 对于不须要任何准确计算精度的程序能够直接使用float或double完成，可是若是须要精确计算的结果，则必须使用BigDecimal类
5. 小结
1. 使用BigDecimal能够指定好四舍五入的精确位置

10.对象克隆技术

1. 对象克隆：对象的复制，完整的复制一个对象
2. 若是要想完成对象克隆的话，则确定依靠 Object类：方法：protected Object clone() throws CloneNotSupportedExcetion
3. 以上的方法就是对象克隆的方法，若是如今一个类的对象被克隆，则就必须在此类中明确的覆写此方法，可是此方法不能直接调用
4. Cloneable是一个接口，可是在此接口中并无规定任何的操做方法，因此此接口实际上属性标识接口，表示一种能力
5. 对象克隆支持：在java中支持对象的克隆操做，直接使用 Object类中的clone()方法便可
6. 对象全部的类必须实现 Cloneable接口才能够完成对象的克隆操做
7. 小结
1. 在之后的JAVA类库中会常常看到 Cloneable接口的出现
2. 只有实现了 Cloneable接口的对象才能够被克隆，不然没法克隆

11.比较器（Comparable、Comparator）

1. Array类中存在 sort()方法，此方法能够直接对对象进行排序
2. 能够直接使用 java.util.Arrays类进行数组的排序操做，但对象所在的类必须实现 Comparable接口，用于指定排序接口
3. 比较器的排序原理：实际上比较器的操做，就是常常听到的二叉树的排序算法
4. 排序的基本原理：使用第一个元素做为根节点，以后若是后面的内容比根节点要小，则放在左子树，若是内容比根节点的内容要大，则放在右子树
5. 另外一种比较器：若是一个类已经开发完成，可是此类创建的初期并不实现 Comparable接口，此时确定是没法进行对象排序操做的，因此为了解决这样的问题，java又定义了另外一个比较器的操做接口：Comparator
6. 小结
1. 在使用中尽量仍是使用 Comparable在须要排序的类上实现好此接口，而 Comparator须要单独创建一个排序的类，这样若是有不少的话，则排序的规则类就会很是的多，操做起来比较麻烦
2. 掌握一点：只要是对象排序，则在java中永远是以 Comparable接口为准

12.观察者模式

1. 若是要想实现观察者模式，则必须依靠java.util包中提供的 Observable类和 Observer接口
2. 在 Observer接口中的 update方法里面有两个参数
1. o：表示 Observable类的对象
2. arg：须要被观察的内容
3. 小结
1. 此模式是一种Java自己的机制，不使用 Observer和 Observable也是能够实现的，只是比较复杂

13.正则表达式

1. 正则表达式能够方便的对数据进行匹配，能够执行更加复杂的字符串验证，拆分、替换功能
2. Pattern、Matcher两个类为正则的核心操做类，两个类都定义在 java.util.regex包中
1. Pattern类的主要做用是进行正则规范（如“[0-9]”就属于正则规范）的编写
2. Matcher类主要是执行规范，验证一个字符串是否符合其规范
3. 正则表达式
1. \d：表示数字，[0-9]
2. \D：表示非数字，[^0-9]
3. \w：表示字母、数字、下划线，[a-zA-Z0-9]
4. \W：表示非字母、数字、下划线，[^a-zA-Z0-9]
4. 要想驱动正则表达式，必须依靠Pattern类和Matcher类
5. Pattern类中没有明确的构造方法能够供用户使用，那么则确定此类的构造方法被私有化了，则能够直接从Pattern类中取得本类的实例
1. 指定好操做的正则：public static Pattern compile(String regex)
2. 能够为 matcher类实例化：public Matcher matcher(CharSequence input)
3. 拆分：public String[] spilt(Charsequence input)
6. 若是要验证一个字符串是否符合规范，则可使用Matcher类
1. 进行字符串的验证：public boolean matcher()
2. 字符串替换：public String replaceAll(String replacement)
7. 只要使用正则的验证的规则，那么就能够匹配各类复杂的字符串
8. String类对正则的支持：在 JDK1.4以后，Java对正则进行了一些扩充，在 String中开始直接支持正则的操做
1. 字符串匹配：public boolean matchers(String regex)
2. 字符串替换：public String replaceAll(String regex, String replacement)
3. 字符串拆分：public String[] split(String regex)
9. 【注意】若是有时候发现一个字符串没法按照指定的字符拆分的话，则须要使用“\”转义，转义的时候两个“\”表示一个“\”
10. 小结
1. 使用正则能够方便的完成字符串的验证、拆分、替换等复杂功能
2. 在开发中通常都会直接使用 String类中提供好的正则支持，而每每不多直接使用 Pattern类或者Matcher类
3. 在一些正则应用的时候，对于一些敏感的字符要进行转义操做

14.定时调度

1. 定时调度：每当一段时间，程序会自动执行，称为定时调度
2. 若是要使用定时调度，则必须保证程序始终运行着才能够，也就是说是至关于定时调度是在程序以外又启动了一个新的线程
3. Timer和 TimerTask两个类完成定时调度
4. Timer类
1. Timer类是一种线程设施，能够用来实如今某一时间或某一段时间后，安排某一个任务执行一次，或按期重复执行
2. 该功能要与 TimerTask配合使用。
3. TimerTask类用来实现由 Timer安排的一次或重复执行的某一个任务
4. 每个 Timer对象对应的是一个线程，所以计时器所执行的任务应该迅速完成，不然可能会延迟后续任务的执行，而这些后续的任务就有可能堆在一块儿，等到该任务完成后才能快速连续执行
5. schedule()与scheduleAtFixedRate()方法的区别
1. 二者的区别在与重复执行任务时，对于时间间隔出现延迟的状况处理
2. schedule()方法的执行时间间隔永远是固定的，若是以前出现了延迟的状况，以后也会继续按照设定好的间隔时间来执行
3. scheduleAtFixedRate()方法能够根据出现的延迟时间自动调整下一次间隔的执行时间
6. TimerTask类
1. 要想执行具体的任务，则必须使用TimerTask类，TimerTask类是一个抽象类，若是要使用该类，须要本身创建一个类来继承此类，并实现其中的抽象方法
2. 若是如今一个 Timer类要想调度程序的话，则须要使用 TimerTask的子类
3. 完成一个具体的任务操做类，之后定时调度的是此类的操做，方法的主体就是 run()方法
7. 小结
1. 通常在 web的开发中此内容比较有用，由于要维护一个窗口不关闭才能够一直定时操做下去

---

JAVA IO

1.File类

1. 全部的 io操做都保存在 java.io包中
2. 在整个 io包中，惟一表示与文件自己有关的类就是 File类
3. 使用 File类能够进行建立或删除文件等经常使用操做
4. 构造方法：public File(String pathname) ->实例化 File类的时候，必须设置好路径，直接根据路径找到文件
5. File类经常使用方法
1. 建立文件：public boolean createNewFile() throws IOException
2. 分隔符：File.separator
3. 删除一个文件：public boolean delete()
4. 判断文件是否存在：public boolean exists()
5. 全部的 JAVA IO操做并不会马上执行，由于 JAVA是经过 JVM与底层进行交互的，因此全部的操做须要通过 JVM完成，那么就有可能产生延迟
6. 建立文件夹：public boolean mkdir()
7. 列出指定目录的所有文件
1. 以字符串数组的形式返回：public String[] list() ->只是列出所有的名字，包括文件夹名字和文件名字
2. 以 File数组的形式返回：pulic File[] listFiles() ->列出一个完整的路径，这样对于程序自己来讲是很容易操做的
8. 判断一个给定的路径是不是目录：public boolean isDirectory()
9. 小结
1. File类是在 java.io包中惟一与文件自己有关的
2. 可使用 File类建立、删除等常见的文件操做
3. 在使用 File类指定路径的时候必定要注意操做系统间的差别，尽可能使用 separator进行分割

2.RandomAccessFile

1. RandomAccessFile类的主要功能是完成随机读取功能，能够读取指定位置的内容
2. RandomAccessFile写数据的时候能够将一个字符串写入，读的时候须要一个个的以字节的形式读取出来
3. 若是要想操做文件内容的话，可使用 RandomAccessFile完成
4. 小结
1. RandomAccessFile类的做用
2. RandomAccessFile类操做起来比较麻烦，因此在 IO中会提供专门的输入、输出操做

3.字节流与字符流

1. 流：在程序中全部的数据都是流的方式进行传输或保存的，程序须要数据的时候要使用输入流读取数据，而当程序须要将数据保存起来的时候，就要使用输出流完成
2. 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件
3. 在 java.io包中操做文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操做
1. 在字节流中输出数据主要是使用 OutputStream完成，输入使的是 InputStream
2. 在字符流中输出数据主要是使用 Writer类完成，输入主要是使用 Reader类完成
3. 实际上四个操做类都是抽象类
4. 在 JAVA中 IO操做也是有相应步骤的，以文件操做为例，主要的操做流程以下：
1. 使用 File类打开一个文件
2. 经过字节流或字符流的子类，指定输出的位置
3. 进行读/写操做
4. 关闭输入/输出
5. 使用 File类操做的时候必定要有路径的问题，注意分隔符
6. IO操做属于资源操做，对于资源操做，操做的最后都必须关闭，不然就有可能出现未知的错误
7. 字节流
1. 字节流主要是操做 byte类型数据，以 byte数组为准，主要操做类就是 OutputStream、InputStream
2. Byte是字节，确定是字节流操做，全部的数据基本上均可以直接使用 byte数组表示出来
3. OutputStream
1. OutputStream是整个 IO包中字节输出流的最大父类
2. OutputStream是一个抽象类，若是要想使用此类的话，则首先必须子类实例化对象，那么若是如今要操做的是一个文件，则可使用：FileOutputStream类，经过向上转型以后，能够为 OutputStream实例化
3. Closeable：表示能够关闭的操做，由于程序运行到最后确定要关闭
4. Flushable：表示刷新，清空内存中的数据
4. InputStream
1. 经过 InputStream能够从文件中把内容读取进来
2. InputStream自己也是一个抽象类，必须依靠其子类，若是如今是从文件中读取，子类确定是 FileInputStream
3. 知道文件大小：直接使用 File类便可：public long length()
8. 字符流
1. 在程序中一个字符等于2个字节，JAVA提供了Reader、Writer两个专门操做字符流的类
2. Writer
1. Writer自己也是一个抽象类，若是要想使用此类，则确定要使用其子类，此时若是是向文件中写入内容，因此应该使用 FileWriter的子类
2. 字符流的操做比字节流操做好在一点：就是能够直接输出字符串了，不用再像以前那样进行转换操做了
3. Reader
1. Reader是使用字符的方式从文件之中取出数据
2. Reader自己也是抽象类，若是如今要从文件中读取内容，则能够直接使用 FileReader子类
9. 字节流与字符流的区别
1. 字节流和字符流使用是很是类似的
2. 字节流在操做的时候自己是不会用到缓冲区（内存）的，是与文件自己直接操做的
3. 字符流在操做的时候是使用到缓冲区的
10. 【问题】开发中使用字节流好仍是字符流好：在全部的硬盘上保存文件或是进行传输的时候都是以字节的方式进行的。包括图片也是按字节完成，而字符是只有在内存中才会造成的，因此使用字节的操做是最多的
11. 小结
1. 掌握流的概念
2. 掌握字节流和字符流操做文件的基本步骤
1. 本章是以文件为例，实际之后的全部操做均可以经过此段代码完成，只是替换子类而已
3. 字节流和字符流的区别
1. 字节流：没有使用缓冲区
2. 字符流：使用了缓冲区
4. 边读边写的方式在开发中很是有用处

4.字节-字符转换流

1. 在整个 IO包中，实际上就是分为字节流和字符流，可是除了这两个流以外，还存在了一组字节流-字符流的转换
2. OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象
3. InputStreamReader：是Reader的子类，将输入的字节流变为字符流：即：将一个字节流的输入对象变为字符流的输入对象
4. 若是以文件操做为例
1. 则在内存中的字符数据须要经过 OutputStreamWriter变为字节流才能保存在文件之中，读取的时候须要将读入的字节流经过 InputStreamReader变为字符流
3. 虽然只是以文件操做为例，由于 OutputStreamWriter中接收的类型是 OutputStream，只要是字节输出流均可以使用字符的形式操做
4. 而InputStreamReader()中接收的类型是 InputStream，只要是字节的输入流均可以使用字符的输入流操做
5. FileWriter和FileReader的说明
1. 从 JDK文档中能够知道 FileOutputStream是 OutputStream的直接子类，FileOutputStream也是 InputStream的直接子类
2. 可是在字符流文件的两个操做类却有一些特殊
3. FileWriter并不直接是Writer的子类，而是 OutputStreamWriter的子类，而 FileReader也是直接是 Reader的子类，是 InputStreamReader的子类
4. 那么从这两个类的继承关系就可清楚的发现，无论是使用字节流仍是字符流实际上最终都是以字节的形式操做输入输出流的
5. 也就是说：最后无论如何，虽然是以字符的输出流形式操做了字节的输出流，可是实际上仍是以字节的形式输出，而字符的输入流，虽然以字符的形式操做，可是实际仍是使用的字节流
6. 也就是说：传输或者是从文件读取数据的时候，文件里真正保存的数据永远是字节
6. 小结
1. 必定要掌握两个转换类的做用
2. 必定要明白，操做的终端点实际上都是以字节的形式进行的
3. FileWriter和FileReader两个子类的定义，中间使用了转换类

5.内存操做流

1. 以前的输入和输出都是从文件中来的，固然，也能够将输出的位置设置在内存之上
2. 此时就要使用 ByteArrayInputStream、ByteArrayOutputStream来完成输入、输出功能了
3. ByteArrayInputStream：主要完成将内容写入到内存之中
4. ByteArrayOutputStream：主要将内存中的数据输出
5. 此时操做的时候应该之内存为操做点
7. 若是要想把一个字符变为小写，则能够经过包装类：Character
8. 小结
1. 内存操做流的操做对象必定是之内存为准，不要以程序为准
2. 实际上此时能够经过向上转型的关系为 OutputStream或 InputStream实例化
3. 这样的操做能够很好的体现对象的多态性，经过实例化其子类的不一样，完成的功能也不一样，也就至关于输出位置也就不一样，若是是文件，则使用 FileXxx，若是是内存，则使用 ByteArrayXxx
4. 内存输出流是 JAVA开发中也常常要使用到，要重点掌握

6.管道流

1. 管道流的主要做用是能够进行两个线程间的通信，分为管道输出流（PipedOutputStream）、管道输入流（PipedInputStream）
2. 若是要想进行管道输出，则必须把输出流连在输入流之上，在PipedOutputStream类上有一个方法用于链接管道：public void connect(PipedInputStream snk) throws IOException
4. 要想实现管道流，则可使用 PipedInputStream和 PipedOutputStream
5. 小结
1. 在 JAVA开发中不多直接去开发多线程程序

7.打印流

1. 在整个 IO包中，打印流是输出信息最方便的类，主要包含字节打印流（PrintStream）和字符打印流（PrintWriter）
2. 在打印流类中定义了不少的 print()或 println()方法，System.out.println()，此方法能够打印任何数据类型
3. 构造方法：public PrintStream(OutputStream out) ->参数指定输出位置
4. 在 JDK1.5以后，JAVA又对 PrintStream类进行了扩充，增长了格式化的输出方式，直接使用 printf()方法就能够完成操做
5. 小结
1. PrintStream能够方便的完成输出的功能
2. 在之后的输出中基本上都使用 PrintStream完成，由于比较方便一些
3. PrintStream属于装饰设计模式

8.System类对 IO类的支持

1. System.out和 System.err的区别
1. System.out和 System.err都是 PrintStream的实例化对象，并且二者均可以输出错误信息，可是通常来说 System.out是将信息显示给用户看，是正常的信息显示，而 System.err的信息正好相反是不但愿用户看到的，会直接在后台打印，是专门显示错误的
2. System.in其实是一个键盘的输入流，其自己是 InputStream类型的对象，那么，此时就能够利用此方式完成从键盘读取数据的功能
1. 指定了输入数据的长度，若是如今输入的数据超过了长度范围，则只能输入部分数据
2. 指定的 byte数组长度是奇数的话，则还有可能出现中文乱码的问题
3. 最好的输入方式
1. 最好的输入方式是将所有输入的数据暂放到一块内存之中，以后一次性的从内存中读取出数据，这样全部数据只读了一次，则不会形成乱码，并且也不会受长度的限制
2. 若是要想实现以上的功能，则只能经过 BufferReader类完成
4. 重定向
1. 为 System.out输出重定向：使用 setOut()方法完成
2. 为 System.err输出重定向：使用 setErr()方法完成
3. 为 System.in输出重定向：使用 setIn()方法完成
4. 对于重定向操做，基本上都在 System.out上使用，以把信息展示给用户观看
5. 小结
1. 三个常量的使用
1. System.out：是但愿用户能够看见的信息，用 IDE（Eclipse）的话错误信息是用黑颜色显示的
2. System.err：是不但愿用户能够看见的信息，用 IDE（Eclipse）的话错误信息是用红颜色显示的
3. System.in：对应键盘输
2. 以上三个常量的输入、输出均可以重定向，可是通常只建议修改 setOut的重定向
3. System.in 读取的时候会出现中文乱码问题，则能够经过 BufferReader完成读取功能

9.BufferedReader类

1. 若是想接收任意长度的数据，并且避免乱码产生，就可使用 BufferedReader
2. public class BufferedReader extends Reader　->由于输入的有可能出现中文，因此，此处使用字符流完成
3. BufferedReader是从缓冲区中读取内容，全部的输入的字节数据都将放在缓冲区之中
4. System.in自己表示的是 InputSteam（字节流），如今要求接收的是一个字符流，则须要将字节流变为字符流才能够，InputStreamReader
6. 小结
1. 掌握 BufferedReader类的做用
2. 可使用 BufferedReader接收输入的数据

10.Scanner类

1. 在 JDK1.5以后 JAVA提供了专门的输入数据类，此类能够完成 BufferReader类的功能，也能够方便的对输入数据进行验证，此类放在 java.util包中，此类是个工具类
2. 若是要想输入空格的话，则就必须修改分隔符，将分隔符变成“\n”
3. Scanner这个类虽然能够接收各类类型，可是对于日期型的数据却没法接收
4. 若是要想接收 Date类型的数据，则只能经过字符串转型，可是在接收的时候依然可使用 Scanner类中提供的方法进行验证
1. 进行验证：public String next(Pattern pattern)
2. 进行接收：public String next(String pattern)
5. 还能够直接从文件中读取信息
6. 在使用 Scanner读文件的时候，要考虑到换行的功能
7. 小结
1. 掌握 Scanner类的做用：方便的读取数据
2. 在读取操做的时候必定要注意分隔符的影响

11.数据操做流

1. 在 IO包中，提供了两个与平台无关的数据操做流
1. 数据输出流：DataOutputStream
2. 数据输入流：DataInputStream
2. 一般数据输出流会按照必定的格式将数据输出，再经过数据输入流按照必定的格式将数据读入
3. 若是要想使用数据操做流，则确定要由用户本身指定数据的保存格式，必须按指定好的格式保存数据，才可使用数据输入流将数据读取出来
4. DataOutputStream继承自 FilterOutputStream类（FilterOutputStream是 OutputStream的子类）同时实现了 DataOutput接口，在 DataOutput接口定义了一系列的写入各类数据的方法
5. DataOutputStream接口定义了一系列的 writeXxx()的操做，能够写入各类数据类型的数据
6. 要想使用 DataOutputStream写入数据的话，则必须指定好数据的输出格式
7. 小结
1. 随机读取访问很类似
2. 两个接口：DataOutput接口、DataInput接口，这两个接口的操做彼此对应，并且之后还要使用

12.合并流

1. 合并流：从概念上讲就是内容合并在一块儿了
2. 合并流的主要功能就是将两个文件的内容合并成一个文件
3. 主要操做的是内容
4. SequenceInputStream类直接继承自 InputStream

13.压缩流

1. ZIP是一种常见的压缩形式，在 Java中要想实现 ZIP的压缩须要导入 java.util.zip包，可使用此包中的 ZipFile、ZipOutputStream、ZipInputStream、ZipEntry几个类完成操做
2. 在 JAVA IO中不只能够实现 ZIP压缩格式的输入、输出，也能够实现 JAR及 GZIP文件格式的压缩
3. ZipEntry：在每个压缩文件中都会存在多个子文件，那么这每个的子文件在 JAVA中就使用 ZipEntry表示
4. 在实例化 ZipEntry的时候，要设置名称，此名称实际上就是压缩文件中每个元素的名称
5. 若是要想完成一个文件或文件夹的压缩，要使用 ZipOutputStream类完成，ZipOutputStream是 OutputStream的子类，就是一个字节的输出流，此类的功能就是 ZIP格式输出的
6. 在压缩文件中，每个压缩的内容均可以用一个 ZipEntry表示，因此在进行压缩以前必须经过 puNextEntry设置一个 ZipEntry便可
7. ZipFile：是一个专门表示压缩文件的类
8. 在 Java中，每个压缩文件均可以使用 ZipFile表示，还可使用 ZipFile根据压缩后的文件名称找到每个压缩文件中的 ZipEntry并将其进行解压缩操做
9. ZipFile在实例化的时候必须接收 File类的实例，此 File类的实例是指向一个压缩的 *.zip文件
10. ZipEntry对象，能够找到每个 ZipEntry的输入流，可是 ZipInputStream并不能获得每个输入流，因此须要使用 ZipFile，可是 ZipInputStream在取得每个 ZipEntry的时候，不须要每个 ZipEntry的名称
11. 小结
1. 压缩文件中每个压缩实体都使用 ZipEntry保存，一个压缩文件中可能包含一个或多个的 ZipEntry对象
2. 在 JAVA中能够进行zip/jar/gz三种格式的压缩支持，操做流程基本是同样的
3. ZipOutputStream能够进行压缩的输出，可是输出的位置不必定是文件
4. ZipFile表示每个压缩文件，能够获得每个压缩实体的输入流

14.回退流

1. 回退：给了用户第二次读的机会
2. 在 JAVA IO中全部的数据都是采用顺序的读取方式，即，对于一个输入流来说都是采用从头至尾顺序读取的，若是在输入流中某个不须要的内容被读取进来，则只能经过程序将这些不须要的内容处理掉，为了解决这样的读取问题，在 Java中提供了一种回退输入流（PusbackInputStream、PushbackReader）能够把读取进来的某些数据从新退回到输入流的缓冲区中
3. 使用 InputStream要使用 read()方法不断读取，是采用顺序的读取方式
4. 回退操做一样分为字节和字符流
5. 对于回退操做来讲，提供了三个 unread()的操做方法，这三个操做方法与 InputStream类中的 read()方法是一一对应的

15.字符编码

1. 在计算机世界里，任何的文字都是以指定的　编码方式存在的，在 JAVA程序的开发中最多见的是如下的几种：、GBK/GB23十二、unicode、UTF
1. ISO8859-1：编码属于单字节编码，最多只能表示 0~255的字符范围，主要在英文上应用
2. GBK/GB2312：中文的国标编码，专门用来表示汉字，是双字节编码，GBK包括中文繁体，字库更大
3. unicode：java中就是使用此编码式，也是最标准的一种编码，是使用16进制表示的编码，但此编码不兼容ISO8859-1编码
4. UTF：因为 nnicode不支持 ISO8859-1编码，并且容易占用更多的空间，并且对于英文字母也须要使用两个字节编码，这样使用 unicode不便于传输和存储，所以产生了 utf编码，utf编码兼容了 ISO8859-1编码，同时也能够用来表示全部的语言字符，不过 utf编码是不定长编码，每个字符的长度从 1~6个字节不等，通常在中文网页中使用此编码，由于这样能够节省空间
2. 若是没有处理好编码的事情，则确定在程序中出现乱码
3. 乱码产生的根本缘由就是字符编码不统一形成的
4. 小结
1. 了解几种经常使用的编码特色
2. 理解乱码是如何产生的

16.对象序列化

1. 什么叫对象序列化：一个对象产生以后其实是在内存中为其开辟了一个存储空间，方便存储信息
2. 对象序列化：就是把一个对象变为二进制的数据流的一种方法，经过对象序列化能够方便的实现对象的传输或存储
3. 若是一个类的对象想被序列化，则对象所在的类必须实现 java.io.Serializable接口
4. Serializable接口中没有一个方法，此接口属于一个标识接口，表示具有了某种能力
5. 被序列化了的对象，变为二进制 byte流
6. 对象的序列化和反序列化
1. 要想完成的输入或输出，还必须依靠对象输出流（ObjectOutputStream）和对象输入流（ObjectInputStream）
2. 使用对象输出流输出序列化对象的步骤，有时也称为序列化，而使用对象输入读入对象的过程，有时也称为反序列化
4. 对象序列化依靠：ObjectOutputStream，对象反序列化依靠：ObjectInputStream
5. ObjectOutputStream类的使用形式与 PrintStream很是的类似，在实例化时也须要传入一个 OutputStream的子类对象，以后根据传和的 OutputStream子类的对象不一样，输出的位置也不一样（装饰模式）
7. SerialVersionUID：在对象进行序列化或反序列化操做的时候，要考虑 JDK版本的问题，若是序列化的 JDK版本和反序列化的 JDK版本不统一则就有可能形成异常，因此在序列化操做中引入了一个 SerialVersionUID的常量，能够经过此常量来验证版本的一致性，在进行反序列化时，JVM会把传来的字节流中的 SerialVersionUID与本地相应实体（类）的　SerialVersionUID进行比较，若是相同就认为是一致的，要以进行反序列化，不然就会出现序列化版本不一致的异常
8. 【问题】对象序列化到底序列化了哪些东西：全部的对象拥有各自的属性值，可是全部的方法都是公共的，因此序列化对象的时候实际上序列化的就是属性
9. Externalizable接口
1. 使用Serializable接口能够方便的序列化一个对象，可是在序列化操做中也提供了另一种序列化机制：Externalizable接口
2. 被 Serializable接口声明的类其对象的内容都将被序列化，若是如今用户但愿能够本身指定序列化的内容，则可让一个类实现 Externalizable接口
3. 写入方法：void writeExternal(ObjectOutput put) throws IOException
4. 读取方法：void readExternal(ObjectInput in) throws IOExcetion,ClassNotFoundExceteption
5. 在使用 Externalizable接口的时候须要在被序列化的类中定义一个无参构造函数，由于此接口在进行反序列化的时候，会先用类中的无参构造方法为其进行实例化，以后再将内容分别设置到属性之中
10. transient关键字：当使用 Serializable接口实现序列化操做时，若是一个对象中的某个属性不但愿被序列化的话，则可使用 transient关键字进行声明
11. transient + Serializable接口完成能够取代 Externalizable接口的功能
12. 序列化一组对象
1. 对象输出时只提供了一个对象的输出操做（writeObject(Object obj)），并无提供多个对象的输出，因此若是如今要同时序列化多个对象的时候就可使用对象数组进行操做，由于数组属于引用数据类型，因此能够直接使用 Object类型进行接收
2. 若是要保存多个对象，则最好使用对象数组的形式完成
3. 数组保存的数据有限，因此为了解决这样的问题，Java中引入了类集框架解决数组的存储限制问题
13. 小结
1. 对象序列化的做用：对象序列化并不必定都向文件中保存，也有可能面向于其它的输入或输出
2. 被序列化的类必须实现 Serializable接口，若是某个属性不但愿被保存下来，则可使用 transient关键字声明
3. ObjectOutputStream序列化对象，ObjectInputStream反序列化对象
4. Externalizable接口的做用：开发人员手工实现序列化的操做
5. 使用序列化保存一组对象的时候要使用对象数组的形式操做