Java的IO *** 作都是基于流进行 *** 作的，为了提高读写效率一般需要进行缓冲。
简单的示例程序如下：
/**
* 读出1.txt中的内容，写入2.txt中
*
*/
import java.io.*
public class ReadWriteFile{
public static void main(String[] args){
try{
File read = new File("c:\\1.txt")
File write = new File("c:\\2.txt")
BufferedReader br = new BufferedReader(
new FileReader(read))
BufferedWriter bw = new BufferedWriter(
new FileWriter(write))
String temp = null
temp = br.readLine()
while(temp != null){
//写文件
bw.write(temp + "\r\n")//只适用Windows系统
//继续读文件
temp = br.readLine()
}
bw.close()
br.close()
}catch(FileNotFoundException e){ //文件未找到
System.out.println (e)
}catch(IOException e){
System.out.println (e)
}
}
}
以上是一个比较简单的基础示例。本文上下两部分都是从网上摘抄，合并在一起，方便下自己以后查找。
二、Java IO学习笔记+代码
文件对象的生成和文件的创建
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件对象的生成和文件的创建
*/
package study.iostudy
import java.io.*
public class GenerateFile
{
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir")
File fileObject1 = new File("oneFirst.txt")
File fileObject2 = new File("d:\\mydir", "firstFile.txt")
System.out.println(fileObject2)
try
{
dirObject.mkdir()
}catch(SecurityException e)
{
e.printStackTrace()
}
try
{
fileObject2.createNewFile()
fileObject1.createNewFile()
}catch(IOException e)
{
e.printStackTrace()
}
}
}
文件名的处理
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:29
*
* 文件名的处理
*/
package study.iostudy
import java.io.*
/*
* 文件名的处理
* String getName()获得文件的名称，不包含文件所在的路径。
* String getPath()获得文件的路径。
* String getAbsolutePath()获得文件的绝对路径。
* String getParent()获得文件的上一级目录的名称。
* String renameTo(File newName)按参数中给定的完整路径更改当前的文件名。
* int compareTo(File pathName)按照字典顺序比较两个文件对象的路径。
* boolean isAbsolute()测试文件对象的路径是不是绝对路径。
*/
public class ProcesserFileName
{
public static void main(String[] args)
{
File fileObject1 = new File("d:\\mydir\\firstFile.txt")
File fileObject2 = new File("d:\\firstFile.txt")
boolean pathAbsolute = fileObject1.isAbsolute()
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ")
System.out.println("There are some information of fileObject1's file name:")
System.out.println("fileObject1: " + fileObject1)
System.out.println("fileObject2: " + fileObject2)
System.out.println("file name: " + fileObject1.getName())
System.out.println("file path: " + fileObject1.getPath())
System.out.println("file absolute path: " + fileObject1.getAbsolutePath())
System.out.println("file's parent directory: " + fileObject1.getParent())
System.out.println("file's absoulte path: " + pathAbsolute)
int sameName = fileObject1.compareTo(fileObject2)
System.out.println("fileObject1 compare to fileObject2: " + sameName)
fileObject1.renameTo(fileObject2)
System.out.println("file's new name: " + fileObject1.getName())
}
}
测试和设置文件属性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 测试和设置文件属性
*/
package study.iostudy
import java.io.*
public class SetterFileAttribute
{
/*
* File类中提供的有关文件属性测试方面的方法有以下几种：
* boolean exists()测试当前文件对象指示的文件是否存在。
* boolean isFile()测试当前文件对象是不是文件。
* boolean isDirectory()测试当前文件对象是不是目录。
* boolean canRead()测试当前文件对象是否可读。
* boolean canWrite()测试当前文件对象是否可写。
* boolean setReadOnly()将当前文件对象设置为只读。
* long length()获得当前文件对象的长度。
*/
public static void main(String[] args)
{
File dirObject = new File("d:\\mydir")
File fileObject = new File("d:\\mydir\\firstFile.txt")
try
{
dirObject.mkdir()
fileObject.createNewFile()
}catch(IOException e)
{
e.printStackTrace()
}
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ")
System.out.println("there are some information about property of file object:")
System.out.println("file object : " + fileObject)
System.out.println("file exist? " + fileObject.exists())
System.out.println("Is a file? " + fileObject.isFile())
System.out.println("Is a directory?" + fileObject.isDirectory())
System.out.println("Can read this file? " + fileObject.canRead())
System.out.println("Can write this fie? " + fileObject.canWrite())
long fileLen = fileObject.length()
System.out.println("file length: " +fileLen)
boolean fileRead = fileObject.setReadOnly()
System.out.println(fileRead)
System.out.println("Can read this file? " + fileObject.canRead())
System.out.println("Can write this fie? " + fileObject.canWrite())
System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * ")
}
}
文件 *** 作方法
/*
* FileOperation.java
*
* Created on 2006年8月22日, 下午4:25
*
* 文件 *** 作方法
*/
package study.iostudy
import java.io.*
/*
* 有关文件 *** 作方面的方法有如下几种:
* boolean createNewFile()根据当前的文件对象创建一个新的文件。
* boolean mkdir()根据当前的文件对象生成一目录，也就是指定路径下的文件夹。
* boolean mkdirs()也是根据当前的文件对象生成一个目录，
*不同的地方在于该方法即使创建目录失败，
*也会成功参数中指定的所有父目录。
* boolean delete()删除当前的文件。
* void deleteOnExit()当前Java虚拟机终止时删除当前的文件。
* String list()列出当前目录下的文件。
*/
public class FileOperation
* 找出一个目录下所有的文件
package study.iostudy
import java.io.*
public class SearchFile
{
public static void main(String[] args)
{
File dirObject = new File("D:\\aa")
Filter1 filterObj1 = new Filter1("HTML")
Filter2 filterObj2 = new Filter2("Applet")
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
System.out.println("list HTML files in directory: " + dirObject)
String[] filesObj1 = dirObject.list(filterObj1)
for (int i = 0i <filesObj1.lengthi++)
{
File fileObject = new File(dirObject, filesObj1[i])
System.out.println(((fileObject.isFile())
? "HTML file: " : "sub directory: ") + fileObject)
}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
String[] filesObj2 = dirObject.list(filterObj2)
for (int i = 0i <filesObj2.lengthi++)
{
File fileObject = new File(dirObject, filesObj2[i])
System.out.println(((fileObject.isFile())
? "htm file: " : "sub directory: ") + fileObject)
}
}
}
class Filter1 implements FilenameFilter
{
String fileExtent
Filter1(String extentObj)
{
fileExtent = extentObj
}
public boolean accept(File dir, String name)
{
return name.endsWith("." + fileExtent)
}
}
class Filter2 implements FilenameFilter
{
String fileName
Filter2(String fileName)
{
this.fileName = fileName
字符流处理
* ProcesserCharacterStream.java
* 字符流处理
*
* java.io包中加入了专门用于字符流处理的类，这些类都是Reader和Writer类的子类，
* Reader和Writer是两个抽象类，只提供了一系列用于字符流处理的接口，不能生成这
* 两个类的实例。
* java.io包中用于字符流处理的最基本的类是InputStreamReader和OutputStreamWriter，
* 用来在字节流和字符流之间作为中介。
*
* 下面是InputStreamReader类和OutputStreamWriter类的常用方法：
*
* public InputStreamReader(InputStream in)
* 根据当前平台缺省的编码规范，基于字节流in生成一个输入字符流。
* public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流in构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public OutputStreamWriter(OutputStream out)
* 根据当前平台缺省的编码规范，基于字节流out生成一个输入字符流。
* public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException
* 按照参数sysCode指定的编码规范，基于字节流out构造输入字符流，如果不支持参数sysCode中指定的编码规范，就会产生异常。
* public String getEncoding()
* 获得当前字符流使用的编码方式。
* public void close() throws IOException
* 用于关闭流。
* public int read() throws IOException
* 用于读取一个字符。
* public int read(char[] cbuf, int off, int len)
* 用于读取len个字符到数组cbuf的索引off处。
* public void write(char[] cbuf, int off, int len) throws IOException
* 将字符数组cbuf中从索引off处开始的len个字符写入输出流。
* public void write(int c) throws IOException
* 将单个字符写入输入流。
* public void write(String str, int off, int len) throws IOException
* 将字符串str中从索引off位置开始的ltn个字符写入输出流。
*
* 此外，为了提高字符流处理的效率，在Java语言中，引入了BufferedReader和BufferWriter类，这两个类对字符流进行块处理。
* 两个类的常用方法如下：
* public BufferedReader(Reader in)
* 用于基于普通字符输入流in生成相应的缓冲流。
* public BufferedReader(Reader in, int bufSize)
* 用于基于普通字符输入流in生成相应的缓冲流，缓冲区大小为参数bufSize指定。
* public BufferedWriter(Writer out)
* 用于基于普通字符输入流out生成相应的缓冲流。
* public BufferedWriter(Writer out, int bufSize)
* 用于基于普通字符输入流out生在相应缓冲流，缓冲流大小为参数bufSize指定。
* public String readLine() throws IOException
* 用于从输入流中读取一行字符。
* public void newLine() throws IOException
* 用于向字符输入流中写入一行结束标记，值得注意的是，该标记不是简单的换行符"\n"，而是系统定义的属性line.separator。
在上面的程序中，我们首先声明了FileInputStream类对象inStream和
* FileOutputStream类的对象outStream，接着声明了BufferInputStream
* 类对象bufObj、BufferedOutputStream类对象bufOutObj、
* DataInputStream类对象dataInObj以及PushbackInputStream类对象pushObj，
* 在try代码块中对上面这些对象进行初始化，程序的目的是通过BufferedInputStream
* 类对象bufInObj和BufferedOutputStream类对象bufOutObj将secondFile.txt
* 文件中内容输出到屏幕，并将该文件的内容写入thirdFile.txt文件中，值得注意的是，
* 将secondFile.txt文件中的内容输出之前，程序中使用
* "System.out.println(dataInObj.readBoolean())" 语句根据readBoolean()结果
* 输出了true，而secondFile.txt文件开始内容为“Modify”，和一个字符为M，
* 因此输出的文件内容没有“M”字符，thirdFile.txt文件中也比secondFile.txt
* 文件少第一个字符“M”。随后，通过PushbackInputStream类对象pushObj读取
* thirdFile.txt文件中的内容，输出读到的字符，当读到的不是字符，输出回车，将字符
* 数组pushByte写回到thirdFile.txt文件中，也就是“ok”写回文件中。
* 对象串行化
* 对象通过写出描述自己状态的数值来记录自己，这个过程叫做对象串行化。对象的寿命通
* 常是随着生成该对象的程序的终止而终止，在有些情况下，需要将对象的状态保存下来，然后
* 在必要的时候将对象恢复，值得注意的是，如果变量是另一个对象的引用，则引用的对象也要
* 串行化，串行化是一个递归的过程，可能会涉及到一个复杂树结构的串行化，比如包括原有对
* 象，对象的对象等。
* 在java.io包中，接口Serializable是实现对象串行化的工具,只有实现了Serializable
* 的对象才可以被串行化。Serializable接口中没有任何的方法，当一个类声明实现Seriali-
* zable接口时，只是表明该类遵循串行化协议，而不需要实现任何特殊的方法。
* 在进行对象串行化时，需要注意将串行化的对象和输入、输出流联系起来，首先通过对
* 象输出流将对象状态保存下来，然后通过对象输入流将对象状态恢复。
import java.io.BufferedReader
import java.io.File
import java.io.FileInputStream
import java.io.IOException
import java.io.InputStreamReader
import java.io.PrintWriter
public class Test10 {
/**
* 复制当前的源程序到项目的根目录
* @throws IOException
*/
public static void main(String[] args) throws IOException {
/*
* 1:读取原文件
* 2：项目标文件中写
* 3：使用缓冲流按行读写
*/
FileInputStream fis=new FileInputStream("src"+File.separator+"day01"+File.separator+"Test1.java")
//转化为字符输出流
InputStreamReader isr=new InputStreamReader(fis)
//按行为单位读取字符串
BufferedReader br=new BufferedReader(isr)
//
PrintWriter pw=new PrintWriter("Test1.java")
String line=null
while((line=br.readLine())!=null){
pw.println(line)
}
pw.close()
br.close()
}
}
使用工具类Properties
工具类有Load（）方法 用于加载文件
首先将文件写成流（输入）
File file=new File(confPath)
in = new FileInputStream(file)
加载流load（in）如果需要 *** 作则完成具体 *** 作
输出流并保存文件
out2 = new OutputStreamWriter(new FileOutputStream(confPath),"GBK")
cp.store(out2)
完成
具体实例代码
public String updateConfParam(ConfParam cpl) throws IOException {
String error = null
Properties cp=new Properties()
InputStream in= null
OutputStreamWriter out1=null
OutputStreamWriter out2=null
JSONObject jObj = new JSONObject()
try {
String confPath=validateSystem(cpl.getConfAddress()+"/"+cpl.getConfName())
File file=new File(confPath)
in = new FileInputStream(file)
cp.load(in)
out1=new OutputStreamWriter(new FileOutputStream(confPath+".bak"),"GBK")
cp.store(out1)
cpl.setParaOldValue(cp.getProperty(cpl.getParaKey()))
cp.setProperty(cpl.getParaKey(), cpl.getParaValue())
out2 = new OutputStreamWriter(new FileOutputStream(confPath),"GBK")
cp.store(out2)
jObj.put("paraOldValue", cpl.getParaOldValue())
jObj.put("paraValue", cpl.getParaValue())
} catch (FileNotFoundException e) {
error=e.getMessage()
} catch (IOException e1) {
error = e1.getMessage()
}
finally{
if(in !=null){
in.close()
}
if(out1 !=null){
out1.close()
}
if(out2 !=null){
out2.close()
}
if(error != null){
jObj.put("error", error)
}
}
return jObj.toString()
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）