你好，java的API中提供了用于對象輸入輸出文件的操作，實例代碼如下：
成都創(chuàng)新互聯(lián)長期為近千家客戶提供的網(wǎng)站建設(shè)服務(wù)，團隊從業(yè)經(jīng)驗10年，關(guān)注不同地域、不同群體，并針對不同對象提供差異化的產(chǎn)品和服務(wù)；打造開放共贏平臺，與合作伙伴共同營造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為九龍坡企業(yè)提供專業(yè)的成都網(wǎng)站建設(shè)、成都網(wǎng)站制作，九龍坡網(wǎng)站改版等技術(shù)服務(wù)。擁有10多年豐富建站經(jīng)驗和眾多成功案例,為您定制開發(fā)。
定義單詞類如下(注意：你定義的類要實現(xiàn)Serializable接口)
public class Words implements Serializable {
private int size;
private String[] words;
public Words(){};
public Words(String...strs){
this.words = strs;
this.size = strs.length;
}
@Override
public String toString() {
return "Words{" +
"size=" + size +
", words=" + Arrays.toString(words) +
'}';
}
}
2. 對象輸入輸出api測試類
public class ObjIOTest {
public static void main(String[] args) {
String path = "d:/myIOTest.txt";
ObjIOTest objIOTest = new ObjIOTest();
Words words = new Words("hello", "my", "dear", "friend");
try {
objIOTest.writeObject(path,words);
Words wordsFromFile = (Words)objIOTest.readObject(path);
System.out.println(wordsFromFile.toString());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
//java serialize a object to file
public void writeObject(String path,Object map) throws IOException{
File f=new File(path);
FileOutputStream out=new FileOutputStream(f);
ObjectOutputStream objwrite=new ObjectOutputStream(out);
objwrite.writeObject(map);
objwrite.flush();
objwrite.close();
}
// read the object from the file
public Object readObject(String path) throws IOException, ClassNotFoundException{
FileInputStream in=new FileInputStream(path);
ObjectInputStream objread=new ObjectInputStream(in);
Object map=objread.readObject();
objread.close();
return map;
}
}
把兩段代碼拷貝到一個包下即可運行了，希望您的問題得到解答
首先你要知道java的io流主要分兩種，一種是字符流，另一種字節(jié)流，還有一種過濾流，這個不常用，暫且可以忽略。
等你這些都掌握了，推薦你用nio包中的管道流。
流的套用可以提升讀寫效率（這種方式只能是同類流的套用，比如字節(jié)流套用字節(jié)流），還有一種是字符流與字節(jié)流互相轉(zhuǎn)換，轉(zhuǎn)換通過一種叫做“橋轉(zhuǎn)換”的類,比如OutputStreamWriter類。
下面舉個最基礎(chǔ)的字節(jié)流例子：
public void copyFile(String file, String bak) {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
byte[] bytes = new byte[1024];
bis = new BufferedInputStream(new FileInputStream(file));//BufferedInputStream會構(gòu)造一個背部緩沖區(qū)數(shù)組，將FileInputStream中的數(shù)據(jù)存放在緩沖區(qū)中，提升了讀取的性能
bos = new BufferedOutputStream(new FileOutputStream(bak));//同理
int length = bis.read(bytes);
while (length != -1) {
System.out.println("length: " + length);
bos.write(bytes, 0, length);
length = bis.read(bytes);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bis.close();
bos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
字符流的用法：
FileReader fr = new FileReader("D:\\test.txt");
BufferedReader br = new BufferedReader(fr);
或者PrintWriter pw = new PrintWriter(new FileWriter("D:\\test.txt"));
...
一、Java IO學(xué)習基礎(chǔ)之讀寫文本文件
Java的IO操作都是基于流進行操作的，為了提高讀寫效率一般需要進行緩沖。
簡單的示例程序如下：
/**
* 讀出1.txt中的內(nèi)容，寫入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系統(tǒng)
//繼續(xù)讀文件
temp = br.readLine();
}
bw.close();
br.close();
}catch(FileNotFoundException e){ //文件未找到
System.out.println (e);
}catch(IOException e){
System.out.println (e);
}
}
}
以上是一個比較簡單的基礎(chǔ)示例。本文上下兩部分都是從網(wǎng)上摘抄，合并在一起，方便下自己以后查找。
二、Java IO學(xué)習筆記+代碼
文件對象的生成和文件的創(chuàng)建
/*
* ProcessFileName.java
*
* Created on 2006年8月22日, 下午3:10
*
* 文件對象的生成和文件的創(chuàng)建
*/
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); 按參數(shù)中給定的完整路徑更改當前的文件名。
* 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());
}
}
測試和設(shè)置文件屬性
/*
* SetterFileAttribute.java
*
* Created on 2006年8月22日, 下午3:51
*
* 測試和設(shè)置文件屬性
*/
package study.iostudy;
import java.io.*;
public class SetterFileAttribute
{
/*
* File類中提供的有關(guān)文件屬性測試方面的方法有以下幾種：
* boolean exists(); 測試當前文件對象指示的文件是否存在。
* boolean isFile(); 測試當前文件對象是不是文件。
* boolean isDirectory(); 測試當前文件對象是不是目錄。
* boolean canRead(); 測試當前文件對象是否可讀。
* boolean canWrite(); 測試當前文件對象是否可寫。
* boolean setReadOnly(); 將當前文件對象設(shè)置為只讀。
* 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.*;
/*
* 有關(guān)文件操作方面的方法有如下幾種:
* boolean createNewFile(); 根據(jù)當前的文件對象創(chuàng)建一個新的文件。
* boolean mkdir(); 根據(jù)當前的文件對象生成一目錄，也就是指定路徑下的文件夾。
* boolean mkdirs(); 也是根據(jù)當前的文件對象生成一個目錄，
* 不同的地方在于該方法即使創(chuàng)建目錄失敗，
* 也會成功參數(shù)中指定的所有父目錄。
* 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 = 0; i filesObj1.length; i++)
{
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 = 0; i filesObj2.length; i++)
{
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，
* 用來在字節(jié)流和字符流之間作為中介。
*
* 下面是InputStreamReader類和OutputStreamWriter類的常用方法：
*
* public InputStreamReader(InputStream in)
* 根據(jù)當前平臺缺省的編碼規(guī)范，基于字節(jié)流in生成一個輸入字符流。
* public InputStreamReader(InputStream in, String sysCode)throws UnSupportedEncodingException
* 按照參數(shù)sysCode指定的編碼規(guī)范，基于字節(jié)流in構(gòu)造輸入字符流，如果不支持參數(shù)sysCode中指定的編碼規(guī)范，就會產(chǎn)生異常。
* public OutputStreamWriter(OutputStream out)
* 根據(jù)當前平臺缺省的編碼規(guī)范，基于字節(jié)流out生成一個輸入字符流。
* public OutputStreamWriter(OutputStream out, String sysCode) throws UnsupportedEncodingException
* 按照參數(shù)sysCode指定的編碼規(guī)范，基于字節(jié)流out構(gòu)造輸入字符流，如果不支持參數(shù)sysCode中指定的編碼規(guī)范，就會產(chǎn)生異常。
* public String getEncoding()
* 獲得當前字符流使用的編碼方式。
* public void close() throws IOException
* 用于關(guān)閉流。
* public int read() throws IOException
* 用于讀取一個字符。
* public int read(char[] cbuf, int off, int len)
* 用于讀取len個字符到數(shù)組cbuf的索引off處。
* public void write(char[] cbuf, int off, int len) throws IOException
* 將字符數(shù)組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生成相應(yīng)的緩沖流。
* public BufferedReader(Reader in, int bufSize)
* 用于基于普通字符輸入流in生成相應(yīng)的緩沖流，緩沖區(qū)大小為參數(shù)bufSize指定。
* public BufferedWriter(Writer out)
* 用于基于普通字符輸入流out生成相應(yīng)的緩沖流。
* public BufferedWriter(Writer out, int bufSize)
* 用于基于普通字符輸入流out生在相應(yīng)緩沖流，緩沖流大小為參數(shù)bufSize指定。
* public String readLine() throws IOException
* 用于從輸入流中讀取一行字符。
* public void newLine() throws IOException
* 用于向字符輸入流中寫入一行結(jié)束標記，值得注意的是，該標記不是簡單的換行符"\n"，而是系統(tǒng)定義的屬性line.separator。
在上面的程序中，我們首先聲明了FileInputStream類對象inStream和
* FileOutputStream類的對象outStream，接著聲明了BufferInputStream
* 類對象bufObj、BufferedOutputStream類對象bufOutObj、
* DataInputStream類對象dataInObj以及PushbackInputStream類對象pushObj，
* 在try代碼塊中對上面這些對象進行初始化，程序的目的是通過BufferedInputStream
* 類對象bufInObj和BufferedOutputStream類對象bufOutObj將secondFile.txt
* 文件中內(nèi)容輸出到屏幕，并將該文件的內(nèi)容寫入thirdFile.txt文件中，值得注意的是，
* 將secondFile.txt文件中的內(nèi)容輸出之前，程序中使用
* "System.out.println(dataInObj.readBoolean());" 語句根據(jù)readBoolean()結(jié)果
* 輸出了true，而secondFile.txt文件開始內(nèi)容為“Modify”，和一個字符為M，
* 因此輸出的文件內(nèi)容沒有“M”字符，thirdFile.txt文件中也比secondFile.txt
* 文件少第一個字符“M”。隨后，通過PushbackInputStream類對象pushObj讀取
* thirdFile.txt文件中的內(nèi)容，輸出讀到的字符，當讀到的不是字符，輸出回車，將字符
* 數(shù)組pushByte寫回到thirdFile.txt文件中，也就是“ok”寫回文件中。
* 對象串行化
* 對象通過寫出描述自己狀態(tài)的數(shù)值來記錄自己，這個過程叫做對象串行化。對象的壽命通
* 常是隨著生成該對象的程序的終止而終止，在有些情況下，需要將對象的狀態(tài)保存下來，然后
* 在必要的時候?qū)ο蠡謴?fù)，值得注意的是，如果變量是另一個對象的引用，則引用的對象也要
* 串行化，串行化是一個遞歸的過程，可能會涉及到一個復(fù)雜樹結(jié)構(gòu)的串行化，比如包括原有對
* 象，對象的對象等。
* 在java.io包中，接口Serializable是實現(xiàn)對象串行化的工具,只有實現(xiàn)了Serializable
* 的對象才可以被串行化。Serializable接口中沒有任何的方法，當一個類聲明實現(xiàn)Seriali-
* zable接口時，只是表明該類遵循串行化協(xié)議，而不需要實現(xiàn)任何特殊的方法。
* 在進行對象串行化時，需要注意將串行化的對象和輸入、輸出流聯(lián)系起來，首先通過對
* 象輸出流將對象狀態(tài)保存下來，然后通過對象輸入流將對象狀態(tài)恢復(fù)。
import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class StreamTest {
public static void main(String[] args) {
StreamTest st = new StreamTest();
String writeStr = "Hello World!\r\n你好！";
String fileName = "outFile.txt";
st.OutputTest(fileName,writeStr);
st.InputTest(fileName);
}
//字節(jié)-讀
private void InputTest(String fileName) {
File f = createFile(fileName);
FileInputStream fis;
byte[] b = new byte[100];
try {
System.out.println("創(chuàng)建輸入流...");
fis = new FileInputStream(f);
System.out.println("創(chuàng)建輸入流完成");
System.out.println("開始讀取...");
fis.read(b);
System.out.println("讀取完成");
String str = new String(b);
System.out.println("讀取內(nèi)容輸出：\n"+str);
fis.close();
}catch(FileNotFoundException e) {
System.out.println("文件沒有找到");
}catch(IOException e) {
System.out.println("讀取失敗");
}
}
//字節(jié)-寫
private void OutputTest(String fileName,String text) {
File f = createFile(fileName);
FileOutputStream fos;
try{
System.out.println("創(chuàng)建輸出流...");
fos = new FileOutputStream(f);
System.out.println("創(chuàng)建輸出流完成");
byte[] testBArray = text.getBytes();
System.out.println("開始寫數(shù)據(jù)...");
fos.write(testBArray);
fos.flush();
System.out.println("寫數(shù)據(jù)完成");
fos.close();
}catch(FileNotFoundException e) {
System.out.println("文件沒有找到");
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}
//創(chuàng)建文件
private File createFile(String fileName) {
File f = new File(fileName);
if(!f.exists()) {
System.out.println("文件不存在");
try{
System.out.println("創(chuàng)建文件...");
f.createNewFile();
System.out.println("創(chuàng)建文件完成");
}catch(IOException e) {
System.out.println("文件創(chuàng)建失敗");
e.printStackTrace();
}
}else {
System.out.println("文件已經(jīng)存在");
}
return f;
}
}
字符流的話改成FileWriter(),FileReader()就好啦！
不懂加：百度HI！^0^
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class IOTest {
public static void main(String[] args) {
String str = "123\r\n456";
writeFile(str);//寫
String str1 = readFile();//讀
System.out.println(str1);
}
/**
* 傳遞寫的內(nèi)容
* @param str
*/
static void writeFile(String str) {
try {
File file = new File("d:\\file.txt");
if(file.exists()){//存在
file.delete();//刪除再建
file.createNewFile();
}else{
file.createNewFile();//不存在直接創(chuàng)建
}
FileWriter fw = new FileWriter(file);//文件寫IO
fw.write(str);
fw.flush();
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 返回讀取的內(nèi)容
* @return
*/
static String readFile() {
String str = "", temp = null;
try {
File file = new File("d:\\file.txt");
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);//文件讀IO
while((temp = br.readLine())!=null){//讀到結(jié)束為止
str += (temp+"\n");
}
br.close();
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
剛寫的，夠朋友好好學(xué)習一下啦，呵呵
多多看API，多多練習
重慶分公司
重慶分公司
