java IO常用的很多，这个文章是总结，而不是介绍。

部分代码及说法参考...好吧，已经找不到出处了。

字节流

以二进制为基础进行处理

注：java提供的方法很多，个人觉得也很杂， 甚至连将对象与变量数据写入文件都有提供对应的类，但是个人觉得不用学。创建文件时，可以没有文件，但是一定要有目录，没有就用File类自己创，或者想别的办法。

字符流

以一个一个字符进行处理（有时也直接一行一行的读）

总结常用如下：

字节流（输入&输入都有例子）

我一般用两种，一种是有缓存，一种是没缓存的。
1 无缓存： InputStreamstreamReader

package com.hxw.io;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
import java.io.InputStream;  
public class FileCount {  
   /** 
    * 我们写一个检测文件长度的小程序，别看这个程序挺长的，你忽略try catch块后发现也就那么几行而已。 
    */  
   publicstatic void main(String[] args) {  
      //TODO 自动生成的方法存根  
             int count=0;  //统计文件字节长度  
      InputStreamstreamReader = null;   //文件输入流  
      try{  
          streamReader=newFileInputStream(new File("D:/David/Java/java 高级进阶/files/tiger.jpg"));  
          /*1.new File()里面的文件地址也可以写成D:\\David\\Java\\java 高级进阶\\files\\tiger.jpg,前一个\是用来对后一个 
           * 进行转换的，FileInputStream是有缓冲区的，所以用完之后必须关闭，否则可能导致内存占满，数据丢失。 
          */  
          while(streamReader.read()!=-1) {  //读取文件字节，并递增指针到下一个字节  
             count++;  
          }  
          System.out.println("---长度是： "+count+" 字节");  
      }catch (final IOException e) {  
          //TODO 自动生成的 catch 块  
          e.printStackTrace();  
      }finally{  
          try{  
             streamReader.close();  
          }catch (IOException e) {  
             //TODO 自动生成的 catch 块  
             e.printStackTrace();  
          }  
      }  
   }  
   
}

2 有缓存

package com.hxw.io;  
import java.io.*;  
   
public class FileCopy {  
   
  public static void main(String[] args) {  
     // TODO自动生成的方法存根  
     byte[] buffer=new byte[512];   //一次取出的字节数大小,缓冲区大小  
     int numberRead=0;  
     FileInputStream input=null;  
     FileOutputStream out =null;  
     try {  
        input=new FileInputStream("D:/David/Java/java 高级进阶/files/tiger.jpg");  
        out=new FileOutputStream("D:/David/Java/java 高级进阶/files/tiger2.jpg"); //如果文件不存在会自动创建  
         
        while ((numberRead=input.read(buffer))!=-1) {  //numberRead的目的在于防止最后一次读取的字节小于buffer长度，  
           out.write(buffer, 0, numberRead);       //否则会自动被填充0  
        }  
     } catch (final IOException e) {  
        // TODO自动生成的 catch 块  
        e.printStackTrace();  
     }finally{  
        try {  
           input.close();  
           out.close();  
        } catch (IOException e) {  
           // TODO自动生成的 catch 块  
           e.printStackTrace();  
        }  
         
     }  
  }  
   
}

3 还有一种特殊的，随机流，用来随意的移动指针位置，代码我在网上抄了一段
出处：IBM 中国

/**
   * 随机读取文件内容
   * @param fileName 文件名
   */
public static void readFileByRandomAccess(String fileName){
   RandomAccessFile randomFile = null;
   try {
    System.out.println("随机读取一段文件内容：");
    // 打开一个随机访问文件流，按只读方式
    randomFile = new RandomAccessFile(fileName, "r");
    // 文件长度，字节数
    long fileLength = randomFile.length();
    // 读文件的起始位置
    int beginIndex = (fileLength > 4) ? 4 : 0;
    //将读文件的开始位置移到beginIndex位置。
    randomFile.seek(beginIndex);
    byte[] bytes = new byte[10];
    int byteread = 0;
    //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
    //将一次读取的字节数赋给byteread
    while ((byteread = randomFile.read(bytes)) != -1){
     System.out.write(bytes, 0, byteread);
    }
   } catch (IOException e){
    e.printStackTrace();
   } finally {
    if (randomFile != null){
     try {
      randomFile.close();
     } catch (IOException e1) {
     }
    }
   }
}

随意移动并写，只要改成下例子中A方法的 randomFile.seek(fileLength)即可。
定位到尾部，追加操作
查了下，是覆盖原有内容。

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
* 将内容追加到文件尾部
*/
public class AppendToFile {

/**
   * A方法追加文件：使用RandomAccessFile
   * @param fileName 文件名
   * @param content 追加的内容
   */
public static void appendMethodA(String fileName, String content){
   try {
    // 打开一个随机访问文件流，按读写方式
    RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
    // 文件长度，字节数
    long fileLength = randomFile.length();
    //将写文件指针移到文件尾。
    randomFile.seek(fileLength);
    randomFile.writeBytes(content);
    randomFile.close();
   } catch (IOException e){
    e.printStackTrace();
   }
}
/**
   * B方法追加文件：使用FileWriter
   * @param fileName
   * @param content
   */
public static void appendMethodB(String fileName, String content){
   try {
    //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
    FileWriter writer = new FileWriter(fileName, true);
    writer.write(content);
    writer.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
}

public static void main(String[] args) {
   String fileName = "C:/temp/newTemp.txt";
   String content = "new append!";
   //按方法A追加文件
   AppendToFile.appendMethodA(fileName, content);
   AppendToFile.appendMethodA(fileName, "append end. /n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
   //按方法B追加文件
   AppendToFile.appendMethodB(fileName, content);
   AppendToFile.appendMethodB(fileName, "append end. /n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
}
}

字符流

说实话，java的这里我觉得设计的并不好，我的用法总结如下(我会总结各个类的继承关系):
1 坚持用UTF-8
写BufferedWriter writer=new OutputStreamWriter(new FileOutputStream(new File("you path")),"UTF-8")
读BufferedReader reader=new InputStreamReader(new FileIntputStream(new File("you path")),"UTF-8")

2 对UTF-8没要求
写BufferedWriter writer=new BufferedWriter(new FileWriter(new File("you path")))
读BufferedReader reader=new BufferedReader(new FileReader("you path"))

注1：这里要补充两点，一个是File类，这是个很实用的类，一个是他们的继承关系
注2：在下面的例子，只要替换BufferedWriter的构造方式就可改写为UTF-8格式，所以不再举第一种用UTF-8的例子了 ，不懂UTF-8，，，，，百度去吧（搜了就懂，都是这么过来的）。
注3：追加操作的话，如下所示：
FileWriter writer = new FileWriter(fileName, true); //第二个参数为即为true即为追加

1 file 类

//一些功能：
File f=new File("E:/电脑桌面/jar/files/create.txt");  
f.createNewFile();  //当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空
System.out.println("该分区大小"+f.getTotalSpace()/(1024*1024*1024)+"G"); //返回由此抽象路径名表示的文件或目录的名称。  
f.mkdirs();  //创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。  
// f.delete(); //  删除此抽象路径名表示的文件或目录  

System.out.println("文件名  "+f.getName());  //  返回由此抽象路径名表示的文件或目录的名称。  
System.out.println("文件父目录字符串 "+f.getParent());// 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。  


//获得 path文件夹下的 *.java文件 示例
ArrayList<String> filelist=new ArrayList<String>();
private void filter()
    {
        File root= new File(path1);
        File[] files=root.listFiles();
        
        for(File file:files)
        {
            String name=file.getName();
            if(name.endsWith(".java")||name.endsWith(".JAVA"))
            {
                filelist.add(name);
            }
        }
        
        
        
    }
  

2 继承关系
fileoutputstream<-outputstreamwriter<-bufferedwriter
最左为最小的子类

总结常用如下：

字符流（输入&输入都有例子）

将
用户名+换行
密码+换行
写入并读

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class dosomething {

    
    ArrayList<user> userlist=new ArrayList<user>();
    

    public dosomething()
    {
        loading();
    }
    
    
    
    
    //读
    private void loading() {
        // TODO Auto-generated method stub
        //userlist.add(new user("liu","123"));
        try {
            BufferedReader reader=new BufferedReader(new FileReader("user.txt"));
            String line;
            while ((line=reader.readLine())!=null) 
            {  
                String name=line;
                String pass=reader.readLine();  
                
                userlist.add(new user(name,pass));
            }
            
            reader.close();
        }
        catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block

            e1.printStackTrace();
        }  
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        
    }





    public boolean login(String username,String password)
    {
    
        user u=null;
        for(Object i:userlist)
        {
            boolean flag=((user)i).login(username, password);
            if(flag)
                u=(user)i;

        }
        if(u!=null)
            return true;
        
        
        
        return false;
    }
    
    public boolean register(String username,String password)
    {
        user u=null;
        for(Object i:userlist)
        {
            boolean flag=username.equals(      
                    
                    ((user)i).getusername()
                    
                    );
            if(flag)
                u=(user)i;
            
            
            
            
            
        }
        if(u!= null)
            return false;
        
        
        userlist.add(new user(username,password));
        
        save(username,password);
        
        return true;
    }




      //写
    private void save(String username, String password) {
        // TODO Auto-generated method stub
        try {
            BufferedWriter writer=new BufferedWriter(new FileWriter("user.txt"));
            for(user i:userlist)
            {
                writer.write(i.getusername());
                writer.newLine();
                writer.write(i.getpassword());
                writer.newLine();
                writer.flush();
            }
            
            writer.close();
            
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
        
    }
}