bijie

File类只用于表示文件（目录）的信息（名称、大小等），丌能对文件的内容进行访问。
File f=new File(".");
System.out.println(f.getCanonicalPath());
f.getCanonicalPath()---获取当前路径

创件一个新的文件
File d=new File(f,"demo");
if(!d.exists()){
d.mkdir();
}

创件新的文件对象
File text=new File(d,"text");
if(!text.exists()){
text.createNewFile();
}

获取文件
 File f=new File("c:");
  System.out.println(f.getCanonicalPath());
  f.getCanonicalPath();
  File[] files=f.listFiles();
  System.out.println(Arrays.toString(files));

FileFilter类是对操作文件的过滤
File f=new File("src/test");
  File[] files=f.listFiles(new FileFilter() {
   @Override
   public boolean accept(File pathname) {
    return pathname.getName().endsWith(".java")&&pathname.isFile();
   }
  });
  for(File file:files){
   System.out.println(file.getName());
  }

listFiles()方法会将dir中每个文件交给accept()方法检测，如果返回true，就作为方法的返回结果元素

Java中的IO流是实现输入/输出的基础。

按照流的方向不同：分为输入流和输出流。
         按照处理数据单位的不同：分为字节流（8位）和字符流（16位）。
         按照功能不同：分为节点流和处理流

所有面向字节的流类都继承于InputStream类（输入流）
 或OutputStream类（输出流），这两个类是抽象类，我们可以利用它的子类来完成不同的功能。

InputStream、OutputStream都是抽象类
 InputStream抽象了应用程序读取数据的方式
 OutputStream抽象类应用程序写出数据的方式

文件输入流 FileInputStream 继承了InputStream，FileInputStream 具体实现了在文件上读取数据。
int b = in.read()  读取一个 byte  无符号填充到 int 低八位,-1 是 EOF
  in.read(byte[] buf)    读取数据填充到 buf 中
  in.read(byte[] buf, int start, int size)  读取数据填充到 buf 中

FileOutputStream
 输出流的基本方法:
  out.write(int b)      写出一个 byte 到流  b 的低八位写出
  out.write(byte[] buf)    将缓冲区 buf 都写入到流
  out.write(byte[] buf, int start, int size)  将 buf 的一部分写到流中
  out.flush()      清理缓冲
  out.close();

注意他们两个都是字节流--用于读取诸如图像数据之类的原始字节流

案例1：使用FileInputStream读取文件
       File file=new File("c:","sql.properties");
  FileInputStream fis=new FileInputStream(file);
  int n=0;
  byte[] b=new byte[1024];
  while((n=fis.read(b))!=-1){
   System.out.println(newString(b,0,n));//System.out.println(new String(b,"gbk"));--控制格式  
  }
  fis.close();

实验2：使用输入输出流复制文件
File file=new File("c:","sql.properties");
  File f2=new File("c:/text2.txt");
  FileInputStream fis=new FileInputStream(file);
  FileOutputStream fo=new FileOutputStream(f2);
  int n=0;
  while((n=fis.read())!=-1){
   fo.write(n);
  }
  fis.close();
    fo.flush();
  fo.close();

案例3：图像的复制

BufferedInputStream && BufferedOutputStream  为 IO 操作提供了缓冲区，一般打开文件进行
写入戒读取操作时，都加上缓冲流，这种流模式是为了提高 IO（输入输出）的性能。

在FileInputStream里有一个说明是说此方法将阻塞，意思就是说在你读一个文件输入流的时候，当读到某个位置的时候，如果做一些其他处理（比如说接受一部分字节做一些处理等等）这个时候输入流在什么位置就是什么位置，不会继续往下读，而BufferedInputStream虽然也有一个read方法，但是从名字就可以看出，它带有一个缓冲区，它是一个非阻塞的方法，在你读到某个位置的时候，做一些处理的时候，输入流可能还会继续读入字节，这样就达到了缓冲的效果。
假设一个文件的长度是100个字节，要将之读取到内存中，再假设您每次只读取10个字节，那么读完整个文件是不是读取10次的呀？

假设老板让你完成100件事情，老板说，你每天只完成10件就可以了，难道你非得等到第十天才完成第100件事情吗？有一天您在中午下班前就完成了10件事情，下午您不妨多干一点，那么也许在第9天的时候就完成了100件事情。

同理，BufferedInputStream有可能会读取比您规定的更多的东西到内存，以减少访问IO的次数，
总之您要记住一句话，访问IO的次数越少，性能就越高，原因就在于CPU和内存的速度》》》》远大于硬盘或其他外部设备的速度。
File f=new File("c:/wode.txt");
byte[] b=new byte[(int) f.length()];
BufferedInputStream bu=new BufferedInputStream(new FileInputStream(f));
int i=0;
while((i=bu.read(b))!=-1){
System.out.println(new String(b,"gbk"));
}

字符流：
字符流(Reader Writer)
字符的处理，一次处理一个字符（unicode 编码）
2)  字符的底层仍然是基本的字节流
3)  字符流的基本实现
?  InputStreamReader    完成 byte 流解析为 char 流,  按照编码解析
?  OutputStreamWriter    提供 char 流到 byte 流,  按照编码处理

主要使用它们两个FileReader FileWriter 
Reader类中两个常用类：
FileReader：以字符流的形式读取文件，与FileInputStream用法基本一致。
BufferedReader：将流读入缓冲区，然后从缓冲区读取，并且提供了readLine()方法，可以从文本文件中整行的读取数据。

Writer类中两个常用类：
FileWriter：以字符流的形式写入文件，与FileOutputStream用法基本一致。
BufferedWriter：将缓冲区输出到流。

它和我我们字节流的区别：
InputStream和OutputStream主要用来处理可以被直接读作bytes的数字。
Reader和Writer用来处理文本。

实验1：写出文件：
  File file=new File("c:\\test.txt");
  FileWriter fw=new
FileWriter(file);//在这里加入参数true会实现对文件的续写
  String s="举头望明月，低头写代码";//\r\n为window下边的换行
  fw.write(s);
  fw.close();

案例2：读取文件
  File file=new File("c:\\test.txt");
  BufferedReader br=new BufferedReader(new FileReader(file));
  String strline =br.readLine();
  System.out.println(strline);
--但是我们发现，这样只读取了一行数据

File file=new File("c:\\test.txt");
  FileReader fr=new FileReader(file);
  int ch=0;
  while((ch=fr.read())!=-1){
   System.out.print((char)ch);
  }

对象序列化
序列化是干什么的？

简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。

什么情况下需要序列化

a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；

对象序列化，就是将 Object 转换为 byte 序列，反之叫对象的反序列化。
1)  序列化流（ObjectOutputStream）,  是过滤流
  ObjectOutputStream writeObject(Object)    序列化对象
  ObjectInputStream readObject()        对象的反序列化
  Users u=new Users();
  u.setUserId(1);
  u.setUserName("zhangsan");
  u.setUserPwd("admin");
  File file=new File("c://wode.txt");
  FileOutputStream fo=new FileOutputStream(file);
  ObjectOutputStream ops=new ObjectOutputStream(fo);
  ops.writeObject(u);

读取：
  File file=new File("c://wode.txt");
  FileInputStream fis=new FileInputStream(file);
  ObjectInputStream ois=new ObjectInputStream(fis);
  Users u=(Users) ois.readObject();
  System.out.println(u.getUserId()+" "+u.getUserName());

2）序列化接口（Serializable）
  对象必须实现“序列化接口”才能进行序列化，否则将出现丌能序列化的异常！
  Serializable 是一个空的接口，没有任何方法，仅作为序列化的一个标识

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。

Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。

3） JavaBean 规范规定，Java 类必须实现 Serializable 接口
Java API 中的类大多是符合 Java Bean 规范的,  基本都实现了 Serializabl