java之路，IO操作

import java.io.*

class FileTest
{
 public static void main(String[] args)
 {
  File f = new File("1.txt");
  f.createNewFile();      //创建一个文件
  f.mkdir();              //创建一个目录
  
  File f = new File("E:\code\java\1.txt");   //使用绝对路径创建
  f.createNewFile();         
  
  //separator是一个分隔符，解决的不同平台下分隔符不一样的问题
  //例如在windows平台下是\ ，而在linux平台下是/
  File fd = new File("File.separator");   //创建根目录
  String sf = "e:" + File.separator + "code" + File.separator + "1.txt";
  File f = new File(fd, sf);
  f.createNewFile();
  
  f.delete();         //删除文件
  f.deleteOnExit();   //程序退出的时候删除
  Thread.sleep(3000);
  
  for(int i=0; i<5; i++)
  {
   //在默认的临时文件目录创建临时文件,java自动给文件加序号
   //createTempFile是静态方法，可以直接访问，创建临时文件
   File f = File.createTempFile("wj", ".tmp");   //在默认的临时文件目录创建临时文件,java自动给文件加序号
   f.deleteOnExit();
  }
  Thread.sleep(3000);
  
  //list()返回目录下所有的文件名和子目录名字
  //FilenameFilter(),文件名过滤器，实现accept方法
  String sf = "e:" + File.separator; + "code" + File.separator + "1.txt";
  File f = new File(fd, sf);
  f.createNewFile();  
  String[] names = f.list(new FilenameFilter()
  {
   public boolean accept(File dir, String name)  //accept
   {
    return name.indexOf(“java”) != -1;  //indexOf查找一个子串，不存在返回-1，存在返回索引值
   }
  });
  for(int i=0; i   {
   System.out.println(names[i]);
  }
  
 }
}

流(Stream)是字节的源或目的。
两种基本的流是：输入流(Input Stream)和输出流(Output Stream)。可从中读出一系列字节的对象称为输入流。而能向其中写入一系列字节的对象称为输出流。
节点流：从特定的地方读写的流类，例如：磁盘或一块内存区域。
过滤流：使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。

三个基本的读方法：
abstract int read() ：读取一个字节数据，并返回读到的数据，如果返回-1，表示读到了输入流的末尾。
int read(byte[] b) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。
int read(byte[] b, int off, int len) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置；len指定读取的最大字节数。
其它方法：
long skip(long n) ：在输入流中跳过n个字节，并返回实际跳过的字节数。
int available() ：返回在不发生阻塞的情况下，可读取的字节数。
void close() ：关闭输入流，释放和这个流相关的系统资源。
void mark(int readlimit) ：在输入流的当前位置放置一个标记，如果读取的字节数多于readlimit设置的值，则流忽略这个标记。
void reset() ：返回到上一个标记。
boolean markSupported() ：测试当前流是否支持mark和reset方法。如果支持，返回true，否则返回false。

三个基本的写方法:
abstract void write(int b) ：往输出流中写入一个字节。
void write(byte[] b) ：往输出流中写入数组b中的所有字节。
void write(byte[] b, int off, int len) ：往输出流中写入数组b中从偏移量off开始的len个字节的数据。
其它方法
void flush() ：刷新输出流，强制缓冲区中的输出字节被写出。
void close() ：关闭输出流，释放和这个流相关的系统资源。

基本的流类：
FileInputStream和FileOutputStream
    节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经存在，则覆盖这个文件。
BufferedInputStream和BufferedOutputStream
    过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。
DataInputStream和DataOutputStream
      过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。
PipedInputStream和PipedOutputStream
    管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。

import java.io.*;
class StreamTest
{
 public static void main(String[] args)  throws Exception
 {
 /*
  int data;
  while((data=System.in.read()) != -1)
  {
   System.out.write(data);
  }
 */
  /*
  FileOutputStream fos = new FileOutputStream("1.txt");
  //write方法只能写入字节数组，不能操作字符串；通过String类的getBytes方法返回一个字节数组
  fos.write("());
  fos.close();
  BufferedOutputStream bos = new BufferedOutputStream("fos");
  bos.write("());
  bos.flush();   //刷新缓冲区
  DataOutputStream dos = new DataOutputStream(bos);
  byte b = 1;
  char c = 'a';
  dos.writeByte(b);
  dos.writeChar(c);
  dos.close();
  
  FileInputStream fis = new FileInputStream("1.txt");
  byte[] buf = new byte[100];
  int len = fis.read(buf);
  BufferedInputStream bis = new BufferedInputStream(fis);
  int len = bis.read(buf);
  //String方法构造一个字符串
  System.out.println(new String(buf, 0, len));
  DataInputStream dis = new DataInputStream(bis);
  System.out.println(dis.readByte());
  System.out.println(dis.readChar());
  fis.close();
  */
  
  //OutputStreamWriter和InputStreamReader是字节流和字符流直接的桥梁
  //BufferedWriter和BufferedReader是操作字符流的类
  //OutputStream和InputStream是操作字节流的类
  FileOutputStream fos = new FileOutputStream("2.txt");
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  BufferedWriter bw = new BufferedWriter(osw);
  bw.write("");
  
  FileInputStream fis = new FileInputStream("2.txt");
  InputStreamReader isr = new InputStreamReader(fis);
  BufferedReader bw = new BufferedReader(isr);
  bw.readLine();
 }
}