有关java流的知识点

字符流 ：操作的是文本数据 区别是他缓存到字符数组char[]

FileReader
FileWriter
fileReader的read（）方法；他的返回值是int类型
bufferedReader有一个readerLine()返回类型是String 
BufferedWtiter  newLine（）方法  换行 数据在缓冲区里必须刷新一下 flush();或close();关闭流

字节流 操作的是图片数据 他缓存到字节数据byte[]

FileInputStream  //操作文件
FileOutputStream
缓冲区是为了提高效率存在的
BufferedInputStream
BufferedOutputStream
System.in
read()返回值是int类型//键盘录入 他要停止录入用ctrl+c

转换流   字节流转换为字符流
InputStreamReader
OutputStreamWriter
因为字符流的bufferedReader里有一个readLine方法，字节流InputStream 没有readLine方法
为了提高效率此时用转换流将字节流对象转换为字符流InputStreamReader

键盘录入最常见写法
BufferedReader bfr=new BufferedReader(new InputStreamReader( System.in));

装饰和继承的区别：：

装饰模式比继承要灵活，避免了继承体系的臃肿，降低了类与类之间的联系

装饰类因为增强已有对象，具备的功能和已有的是相同的只不过提供了更强功能
所以装饰类和被装饰类通常都属于一个体系中的
 
流操作的基本规律、、

3个明确

1.明确源和目的 操作的是图片数据    字符流操作纯文本文件

源：  输入流 InputStream      Reader
目的：输出流 OutputStream     Writer

2.操作的数据是否是纯文本

是： 字符流
否： 字节流

3.当体系明确后，在明确要使用哪个具体的流对象

通过设备来区分
原设备：内存（还没学）硬盘（文件）键盘
目的设备： 内存（还没学）硬盘（文件）控制台

转换流什么时候使用，字符和字节之间的桥梁 通常涉及到字符编码转换需要用到转换流
只有转换流能指定码表

改变输入输出流设备、

System.setIn()//改变输入设备
System.setOut()//改变输出设备

异常的日志信息
e.printStackTrace()//把异常信息输出到控制台
e.printStackTrace(new PrintStream("a.txt"))//把异常信息输出到文件中
System.setOut(new PrintStream("a.txt"))
e.printStackTrace(System.out);

log4j 工具包

系统信息
Properties prop=System.getProperties();
prop.list(System.out);//按属性信息输出换行在控制台
prop.list(new PrintStream("system.info.txt"));按属性信息输出换行在文件中

package lgf;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class CopyFile {

 /**
  * 需求 将键盘录入保存到一个文件中 源：inputStream Reader 是不是纯文本文件？是 Reader 设备：键盘
  * 对应的对象是System.in 选择的是reader 字符流 而System.in对应的是字节流、
  * 为了操作键盘上的文本数据方便。转成字符流按照字符串操作是最方便的 此时就将S有stem。in 转换成Reader
  * 用了Reader体系中的转换流InputStreamReader
  *
  * InputStreamReader isr= new InputStreamReader(System.in); 学要提高效率
  * 需要：BufferedReader bfr=new BufferedReader(isr);
  *
  *
  * 目的：OutputStream Writer 是否为纯文本文件？ 是 用Writer 设备：硬盘 一个文件使用FileWriter
  * 需要提高效率吗？ 需要 BufferedWriter
  *
  *
  */
 public static void main(String[] args) {
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader bfr = new BufferedReader(isr);
  BufferedWriter bfw = null;
  try {
   FileWriter fw = new FileWriter("f:\\a.txt");
   bfw = new BufferedWriter(fw);
   String len = null;
   while ((len = bfr.readLine()) != null) {
    if (len.equals("over"))
     break;
    bfw.write(len);
    bfw.newLine();
    bfw.flush();
   }
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } finally {
   if (bfr != null)

    if (bfw != null)
     try {
      bfr.close();
      bfw.close();
     } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }

  }

 }

}

流只能操作数据

File 类
里有一个字段separator 系统分隔符跨平台
File f= new File("f:\\a\\b.txt")====("f:"+File.separator+"a"+File.separator+"b.txt")//
常见方法

1，创建
boolean creatNewFile()//在指定位置创建文件 如果该文件已经存在，则不创建 返回false
                      和输出流不一样 输出流对象创建文件 文件若已经存在就覆盖

boolean mkdir()创建一级目录
boolean mkdirs()创建多级目录
2，删除
boolean delete();//删除失败返回假
void deleteOnExit();//在程序退出时删除指定文件
3，判断
canExecute()//是否能执行
boolean exists()//文件是否存在

在判断文件对象是否是文件或者目录时 必须判断该文件对象是否存在
isDirectory();
isFile();
isHidden()是否隐藏
isAbsolute()是否是绝对

4.获取信息
gettName();
getPath()//你传的什么获取什么
getAbsolutePath()//获取绝对路径

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
File 对象功能 文件列表
listRoots()操作的是共有数据返回类型是File :遍历得出所有盘符
String[]  list()遍历得出指定目录下所有的文件

PrintStream:打印流

该流提供了打印方法，可以将各种数据类型的数据原样打印
PrintStream pw=new PrintStream("a.txt")
PrintStream pw=new PrintStream(new FileWriter(a.txt),true)//true表示自动刷新只针对流对象才有
PrintStream 字节打印流 OutputStream的子类
构造函数可以接收的参数类型
1、File 对象
2、字符串路径 String
3 、字节输出流。OutputStream

PrintWriter 字符打印流

构造函数可以接收的参数类型
1、File 对象
2、字符串路径 String
3 、字节输出流。OutputStream
4、字符输出流

合并流
SequenceInputStream
构造函数接收两个流对象

Vector<FileInputStream> v=new Vector<>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration<FileInputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);//把三个流对象合并为一个流对象
目的：FileOutputStream fos=new FileOutputStream("4.txt");
int len=0;
while((len=sis.read(buf))){
fos.write(buf,0,len);

}
fos.close();
sis.close();

切割文件：
 FileInputStream fis=new FileInputStream("e:\\a.jpg");
 FileOutputStream fos=null;
 byte []buf=new byte[1024*10];//切割为几个主要看文件大小和 byte[1024*10]
 int len=0;
 int count=0;
 while((len=fis.read(buf))!=-1){
  fos=new FileOutputStream("e:\\"+count+++".part");
  
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

对象的序列化
没有方法的接口通常叫标记接口
被序列化的对象不存在堆内存里而是存在一个文件里持久化了
静态是不能被序列化的，只有在堆内存中的才被序列化
不想要序列化非静态变量只要让transient 关键字修饰即可
ObjectOutputStream oos=new ObjecOutputStream();
Object writeObject(Object obj)
ObjectInputStream ois=new ObjectInputStream()
Object readObject(Object obj)
这两个对象必须成对使用

管道流
PipedInputStream 和 PipedOutputStream

RandomAccessFile  可以实现多线程下载
该类不是IO体系中的子类
而是直接继承Object

但他是IO包中的成员。因为它具备读和写的功能
内部封装了一个数组，而且通过指针对数组中的元素进行操作
可以通过getFilePointer获取指针的位置
同时可以通过seek改变指针的位置

其实完成读写的原理就是内部封装了字节输入流和输出流
通过构造函数可以看出该类只能操作文件
而且操作文件还有模式 “r”只读“rw" 读写
如果模式为只读时，不会创建文件，会去读取一个已存在的文件，如果文件不存在会报异常
如果模式为读写 会自动创建文件，如果存在则不会覆盖会在原有文件上修改

seek()方法：调到指定的指针
skipBytes(int n)//尝试跳过输入的n个字节不能往回走

DataStream 操作基本数据类型的流对象
如果对方用DataOutputStream
里writeUTF()方法写入
你只能用DataInputStream
里readUTF（）方法读出

ByteArrayStream :用于操作字节数组的流对象

ByteArrayInputStream: 在构造的时候，需要接收数据源，而且数据源是一个字节数组
ByteArrarOutputStream:在构造的时候不用定义数据目的，因为该对象内部已经封装了可变长度的字节数组
这就是数据的目的

因为这两个流对象都操作的数组，并没有使用系统资源，所以不用进行close关闭
//数据源
ByteArrayInputStream bis=new ByteArrayInputStream("absfgh".getByte());
//数据目的
ByteArrayOutputStream bos=new ByteArrayOutputStream();
int by=0;
while((by=bis.read())!=-1){
bos.write(by);
}

在流操作规律讲解时

源设备： 键盘（system.in） 硬盘：FileStream  内存：ArrayStream

目的设备：控制台（system.out） 硬盘：FileStream  内存：ArrayStream

用流的读写思想操作数据

操作汉字最好用它
CharArrayStream 字符数组流
StringStream 字符串流

字符编码
转换流
OutputStreamWriter osw= OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8")//指定编码为utf-8。默认的是gbk
InputStreamReader isr= InputStreamReader(new FileInputStream("utf.txt"),"utf-8")//

编码：字符串变成字节数组
解码：字节数组变成字符串
Strig -->byte[] str.getBytes(charsetName);
byte[]-->String new String(byte[],charsetName)