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 filelist=new ArrayList();
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 userlist=new ArrayList();
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();
}
}
}