java之IO 总结和笔记

创建一个文件
Java代码

   1. File f=new File("1.txt"); 
   2. f.createNewFile();//创建文件 
   3. f.mkdir();//创建目录 
   4. f.deleteOnExit();//程序结束时自动删除创建的文件 
   5. File.separator 是跨系统文件分隔符

//list方法，列出文件夹下所有的文件和目录名称，如果过滤，传入FilenameFilter，下面是只返回扩展名是java的文件名
Java代码

   1. String[] names=f.list(new FilenameFilter() 
   2.         { 
   3.             public boolean accept(File dir,String name) 
   4.             { 
   5.                 return name.indexOf(".java")!=-1; 
   6.             } 
   7.         }); 

String[] names=f.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
return name.indexOf(".java")!=-1;
}
});



输入输出流：
节点流
过滤流
InputStream                OutputStream
FileInputStream            FileOutputStream

BufferedInputStream 带缓冲过滤流
BufferedOutputStream 带缓冲输出过滤流
DataInputStream  提供读写java中基本数据类型的过滤流

PipedInputStream和PipedOutputStream
管道流，用于线程间的通信。
一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。
要使管道流有用，必须同时构造管道输入流和管道输出流。

Java代码

   1. import java.io.*; 
   2. class PipedStreamTest 
   3. { 
   4.     public static void main(String[] args) 
   5.     { 
   6.         PipedOutputStream pos=new PipedOutputStream(); 
   7.         PipedInputStream pis=new PipedInputStream(); 
   8.         try 
   9.         { 
  10.             pos.connect(pis); 
  11.             new Producer(pos).start(); 
  12.             new Consumer(pis).start(); 
  13.         } 
  14.         catch(Exception e) 
  15.         { 
  16.             e.printStackTrace(); 
  17.         } 
  18.          
  19.     } 
  20. } 
  21.  
  22. class Producer extends Thread 
  23. { 
  24.     private PipedOutputStream pos; 
  25.     public Producer(PipedOutputStream pos) 
  26.     { 
  27.         this.pos=pos; 
  28.     } 
  29.     public void run() 
  30.     { 
  31.         try 
  32.         { 
  33.             pos.write("Hello,welcome you!".getBytes()); 
  34.             pos.close(); 
  35.         } 
  36.         catch(Exception e) 
  37.         { 
  38.             e.printStackTrace(); 
  39.         } 
  40.     } 
  41. } 
  42.  
  43. class Consumer extends Thread 
  44. { 
  45.     private PipedInputStream pis; 
  46.     public Consumer(PipedInputStream pis) 
  47.     { 
  48.         this.pis=pis; 
  49.     } 
  50.     public void run() 
  51.     { 
  52.         try 
  53.         { 
  54.             byte[] buf=new byte[100]; 
  55.             int len=pis.read(buf); 
  56.             System.out.println(new String(buf,0,len)); 
  57.             pis.close(); 
  58.         } 
  59.         catch(Exception e) 
  60.         { 
  61.             e.printStackTrace(); 
  62.         } 
  63.     } 
  64. } 

import java.io.*;
class PipedStreamTest
{
public static void main(String[] args)
{
PipedOutputStream pos=new PipedOutputStream();
PipedInputStream pis=new PipedInputStream();
try
{
pos.connect(pis);
new Producer(pos).start();
new Consumer(pis).start();
}
catch(Exception e)
{
e.printStackTrace();
}

}
}

class Producer extends Thread
{
private PipedOutputStream pos;
public Producer(PipedOutputStream pos)
{
this.pos=pos;
}
public void run()
{
try
{
pos.write("Hello,welcome you!".getBytes());
pos.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

class Consumer extends Thread
{
private PipedInputStream pis;
public Consumer(PipedInputStream pis)
{
this.pis=pis;
}
public void run()
{
try
{
byte[] buf=new byte[100];
int len=pis.read(buf);
System.out.println(new String(buf,0,len));
pis.close();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}




Reader和Writer这两个抽象类主要用来读写字符流

InputStreamReader OutputStreamWriter 字节流和字符流的桥梁

FileInputStream fis=new FileInputStream("1.txt");
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr);
System.out.println(br.readLine());
br.close();

InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String strLine;
while((strLine=br.readLine())!=null)
{
System.out.println(strLine);
}
br.close();