java讀寫文本

Ⅰ java 如何讀取txt文件的內容

java讀取txt文件內容。可以作如下理解：

• 首先獲得一個文件句柄。File file = new File(); file即為文件句柄。兩人之間連通電話網路了。接下來可以開始打電話了。

• 通過這條線路讀取甲方的信息：new FileInputStream(file) 目前這個信息已經讀進來內存當中了。接下來需要解讀成乙方可以理解的東西

• 既然你使用了FileInputStream()。那麼對應的需要使用InputStreamReader()這個方法進行解讀剛才裝進來內存當中的數據

• 解讀完成後要輸出呀。那當然要轉換成IO可以識別的數據呀。那就需要調用位元組碼讀取的方法BufferedReader()。同時使用bufferedReader()的readline(）方法讀取txt文件中的每一行數據哈。

packagecom.campu;

importjava.io.BufferedInputStream;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.InputStreamReader;
importjava.io.Reader;

/**
*@authorJava團長
*H20121012.java
*2017-10-29上午11:22:21
*/
publicclassH20121012{
/**
*功能：Java讀取txt文件的內容
*步驟：1：先獲得文件句柄
*2：獲得文件句柄當做是輸入一個位元組碼流，需要對這個輸入流進行讀取
*3：讀取到輸入流後，需要讀取生成位元組流
*4：一行一行的輸出。readline()。
*備註：需要考慮的是異常情況
*@paramfilePath
*/
publicstaticvoidreadTxtFile(StringfilePath){
try{
Stringencoding="GBK";
Filefile=newFile(filePath);
if(file.isFile()&&file.exists()){//判斷文件是否存在
InputStreamReaderread=newInputStreamReader(
newFileInputStream(file),encoding);//考慮到編碼格式
BufferedReaderbufferedReader=newBufferedReader(read);
StringlineTxt=null;
while((lineTxt=bufferedReader.readLine())!=null){
System.out.println(lineTxt);
}
read.close();
}else{
System.out.println("找不到指定的文件");
}
}catch(Exceptione){
System.out.println("讀取文件內容出錯");
e.printStackTrace();
}

}

publicstaticvoidmain(Stringargv[]){
StringfilePath="L:\Apache\htdocs\res\20121012.txt";
//"res/";
readTxtFile(filePath);
}}

我有一個微信公眾號，經常會分享一些Java技術相關的干貨文章，還有一些學習資源。
如果你需要的話，可以用微信搜索「Java團長」或者「javatuanzhang」關注。

Ⅱ java 中簡述使用流進行讀寫文本文件的步驟

一、Java IO學習基礎之讀寫文本文件

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 = 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，
* 用來在位元組流和字元流之間作為中介。
*
* 下面是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介面時，只是表明該類遵循串列化協議，而不需要實現任何特殊的方法。
* 在進行對象串列化時，需要注意將串列化的對象和輸入、輸出流聯系起來，首先通過對
* 象輸出流將對象狀態保存下來，然後通過對象輸入流將對象狀態恢復。

Ⅲ java中讀入和輸出文本文件

/**
	*測試3：從文本文件中讀取數據
	*/
	staticvoidtestExample03(){
		//1、在內存中打開要讀取文件的字元流對象
		try{
			Readerreader=newFileReader("e:/ReadMe.log");
			//2、從字元流中讀取數據
			//一次讀取一個字元（麻煩）
			/*intnum=reader.read();
			System.out.println((char)num);
			num=reader.read();
			System.out.println((char)num);*/
			//一次讀取一個數組（必須確定數組的長度）
			/*char[]cbuf=newchar[10];
			reader.read(cbuf);
			System.out.println(newString(cbuf));*/
			//循環讀取，一次就讀一個
			intch=reader.read();
			StringBufferbuffer=newStringBuffer();
			while(ch!=-1){//讀取成功
				buffer.append((char)ch);
				ch=reader.read();
			}
			System.out.println(buffer.toString());
			//3、關閉流
			reader.close();
		}catch(FileNotFoundExceptione){
			System.out.println("要讀取的文件不存在："+e.getMessage());
		}catch(IOExceptione){
			System.out.println("文件讀取錯誤："+e.getMessage());
		}
	}

/**
	*測試4：向文本文件中寫入數據
	*/
	staticvoidtestExample04(){
		System.out.println("請輸入內容：");
		Stringtext=input.next();
		try{
			//1、打開流
			Writerw=newFileWriter("e:/測試.txt",true);
			//2、寫入內容
			w.write(text);
			//3、關閉流
			w.close();
		}catch(IOExceptione){
			System.out.println("文件寫入錯誤："+e.getMessage());
		}
	}

/**
	*測試5：使用效率高的字元流讀寫數據
	*/
	staticvoidtestExample05(){
		try{
			//1、創建流對象
			Readerreader=newFileReader("e:/ReadMe.log");
			//構建高效流對象
			BufferedReaderbuffReader=newBufferedReader(reader);
			
			//2、讀取一行字元串
			Stringline=buffReader.readLine();
			StringBufferbuffer=newStringBuffer();
			while(line!=null){
				buffer.append(line+"
");
				line=buffReader.readLine();
			}
			System.out.println(buffer.toString());;
			//3、關閉流
			buffReader.close();
			reader.close();
			
			Writerw=newFileWriter("e:/NewReadMe.txt");
			BufferedWriterbuffWriter=newBufferedWriter(w);
			
			buffWriter.write(buffer.toString());
			
			buffWriter.close();
			w.close();
			System.out.println("寫入成功！");
			
		}catch(FileNotFoundExceptione){
			System.out.println("要讀取的文件不存在："+e.getMessage());
		}catch(IOExceptione){
			System.out.println("文件讀取錯誤："+e.getMessage());
		}
	}

Ⅳ java中如何使用緩沖區對文件進行讀寫操作

首先，了解下什麼是緩沖區：
電腦內存分成5個區，他們分別是堆、棧、自由存儲區、全局/靜態存儲區和常量存儲區。

棧——就是那些由編譯器在需要的時候分配，在不需要的時候自動清楚的變數的存儲區。裡面的變數通常是局部變數、函數參數等。

堆——就是那些由new分配的內存塊，他們的釋放編譯器不去管，由我們的應用程序去控制，一般一個new就要對應一個delete.如果程序員沒有釋放掉，那麼在程序結束後，操作系統會自動回收。

自由存儲區——就是那些由malloc等分配的內存塊，他和堆是十分相似的，不過它是用free來結束自己的生命的。

全局/靜態存儲區——全局變數和靜態變數被分配到同一塊內存中，在以前的C語言中，全局變數又分為初始化的和未初始化的，在C++裡面沒有這個區分了，他們共同佔用同一塊內存區。

常量存儲區，這是一塊比較特殊的存儲區，他們裡面存放的是常量，不允許修改（當然，你要通過非正當手段也可以修改）

電腦緩沖區就是預留下來的做為急用的那一部分，為暫時置放輸出或輸入資料的內存。

如何對緩沖區進行操作：
當我們讀寫文本文件的時候，採用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的類是InputStreamReader， 它是位元組轉換為字元的橋梁。你可以在構造器重指定編碼的方式，如果不指定的話將採用底層操作系統的默認編碼方式，例如GBK等。使用FileReader讀取文件：
FileReader fr = new FileReader("ming.txt");
int ch = 0;
while((ch = fr.read())!=-1 )
{
System.out.print((char)ch);
}
其中read()方法返回的是讀取得下個字元。當然你也可以使用read(char[] ch,int off,int length)這和處理二進制文件的時候類似。
事實上在FileReader中的方法都是從InputStreamReader中繼承過來的。read()方法是比較好費時間的，如果為了提高效率我們可以使用BufferedReader對Reader進行包裝，這樣可以提高讀取得速度，我們可以一行一行的讀取文本，使用readLine()方法。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
了解了FileReader操作使用FileWriter寫文件就簡單了，這里不贅述。
Eg.我的綜合實例：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class testFile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// file(內存)----輸入流---->【程序】----輸出流---->file(內存)
File file = new File("d:/temp", "addfile.txt");
try {
file.createNewFile(); // 創建文件
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

// 向文件寫入內容(輸出流)
String str = "親愛的小南瓜！";
byte bt[] = new byte[1024];
bt = str.getBytes();
try {
FileOutputStream in = new FileOutputStream(file);
try {
in.write(bt, 0, bt.length);
in.close();
// boolean success=true;
// System.out.println("寫入文件成功");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
// 讀取文件內容 (輸入流)
FileInputStream out = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(out);
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}
} catch (Exception e) {
// TODO: handle exception
}
}
}

Ⅳ java 讀文本文件的常用類和方法有哪些

File類是直接繼承Object類的。Object類的方法我就不不寫了：
欄位摘要
static String pathSeparator
與系統有關的路徑分隔符，為了方便，它被表示為一個字元串。
static char pathSeparatorChar
與系統有關的路徑分隔符。
static String separator
與系統有關的默認名稱分隔符，為了方便，它被表示為一個字元串。
static char separatorChar
與系統有關的默認名稱分隔符。
構造方法摘要
File(File parent, String child)
根據 parent 抽象路徑名和 child 路徑名字元串創建一個新 File 實例。
File(String pathname)
通過將給定路徑名字元串轉換為抽象路徑名來創建一個新 File 實例。
File(String parent, String child)
根據 parent 路徑名字元串和 child 路徑名字元串創建一個新 File 實例。
File(URI uri)
通過將給定的 file: URI 轉換為一個抽象路徑名來創建一個新的 File 實例。
方法摘要
boolean canExecute()
測試應用程序是否可以執行此抽象路徑名表示的文件。
boolean canRead()
測試應用程序是否可以讀取此抽象路徑名表示的文件。
boolean canWrite()
測試應用程序是否可以修改此抽象路徑名表示的文件。
int compareTo(File pathname)
按字母順序比較兩個抽象路徑名。
boolean createNewFile()
當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。
static File createTempFile(String prefix, String suffix)
在默認臨時文件目錄中創建一個空文件，使用給定前綴和後綴生成其名稱。
static File createTempFile(String prefix, String suffix, File directory)
在指定目錄中創建一個新的空文件，使用給定的前綴和後綴字元串生成其名稱。
boolean delete()
刪除此抽象路徑名表示的文件或目錄。
void deleteOnExit()
在虛擬機終止時，請求刪除此抽象路徑名表示的文件或目錄。
boolean equals(Object obj)
測試此抽象路徑名與給定對象是否相等。
boolean exists()
測試此抽象路徑名表示的文件或目錄是否存在。
File getAbsoluteFile()
返回此抽象路徑名的絕對路徑名形式。
String getAbsolutePath()
返回此抽象路徑名的絕對路徑名字元串。
File getCanonicalFile()
返回此抽象路徑名的規范形式。
String getCanonicalPath()
返回此抽象路徑名的規范路徑名字元串。
long getFreeSpace()
返回此抽象路徑名指定的分區中未分配的位元組數。
String getName()
返回由此抽象路徑名表示的文件或目錄的名稱。
String getParent()
返回此抽象路徑名父目錄的路徑名字元串；如果此路徑名沒有指定父目錄，則返回 null。
File getParentFile()
返回此抽象路徑名父目錄的抽象路徑名；如果此路徑名沒有指定父目錄，則返回 null。
String getPath()
將此抽象路徑名轉換為一個路徑名字元串。
long getTotalSpace()
返回此抽象路徑名指定的分區大小。
long getUsableSpace()
返回此抽象路徑名指定的分區上可用於此虛擬機的位元組數。
int hashCode()
計算此抽象路徑名的哈希碼。
boolean isAbsolute()
測試此抽象路徑名是否為絕對路徑名。
boolean isDirectory()
測試此抽象路徑名表示的文件是否是一個目錄。
boolean isFile()
測試此抽象路徑名表示的文件是否是一個標准文件。
boolean isHidden()
測試此抽象路徑名指定的文件是否是一個隱藏文件。
long lastModified()
返回此抽象路徑名表示的文件最後一次被修改的時間。
long length()
返回由此抽象路徑名表示的文件的長度。
String[] list()
返回一個字元串數組，這些字元串指定此抽象路徑名表示的目錄中的文件和目錄。
String[] list(FilenameFilter filter)
返回一個字元串數組，這些字元串指定此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。
File[] listFiles()
返回一個抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中的文件。
File[] listFiles(FileFilter filter)
返回抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。
File[] listFiles(FilenameFilter filter)
返回抽象路徑名數組，這些路徑名表示此抽象路徑名表示的目錄中滿足指定過濾器的文件和目錄。
static File[] listRoots()
列出可用的文件系統根。
boolean mkdir()
創建此抽象路徑名指定的目錄。
boolean mkdirs()
創建此抽象路徑名指定的目錄，包括所有必需但不存在的父目錄。
boolean renameTo(File dest)
重新命名此抽象路徑名表示的文件。
boolean setExecutable(boolean executable)
設置此抽象路徑名所有者執行許可權的一個便捷方法。
boolean setExecutable(boolean executable, boolean ownerOnly)
設置此抽象路徑名的所有者或所有用戶的執行許可權。
boolean setLastModified(long time)
設置此抽象路徑名指定的文件或目錄的最後一次修改時間。
boolean setReadable(boolean readable)
設置此抽象路徑名所有者讀許可權的一個便捷方法。
boolean setReadable(boolean readable, boolean ownerOnly)
設置此抽象路徑名的所有者或所有用戶的讀許可權。
boolean setReadOnly()
標記此抽象路徑名指定的文件或目錄，從而只能對其進行讀操作。
boolean setWritable(boolean writable)
設置此抽象路徑名所有者寫許可權的一個便捷方法。
boolean setWritable(boolean writable, boolean ownerOnly)
設置此抽象路徑名的所有者或所有用戶的寫許可權。
String toString()
返回此抽象路徑名的路徑名字元串。
URI toURI()
構造一個表示此抽象路徑名的 file: URI。
URL toURL()
已過時。 此方法不會自動轉義 URL 中的非法字元。建議新的代碼使用以下方式將抽象路徑名轉換為 URL：首先通過 toURI 方法將其轉換為 URI，然後通過 URI.toURL 方法將 URI 裝換為 URL。

Ⅵ 怎麼使用JAVA，POI讀寫word文檔

如何使用JAVA、POI讀寫word文檔？？
能不能將一個word的內容完全讀過來，放到一個新生成的word文件中去，要求能將word中的表格、圖片等保留，格式不變。最好能給個例子？網上多是很早以前的那個解決方法如下：，只能讀文本內容，且新生成的word文件打開時總是要提示選擇編碼，不太好用，希望能有新的解決方案？？！！

poi操作word
1.1 添加poi支持：包下載地址

1.2 POI對Excel文件的讀取操作比較方便，POI還提供對Word的DOC格式文件的讀取。但在它的發行版本中沒有發布對Word支持的模塊，需要另外下載一個POI的擴展的Jar包。下載地址為;下載extractors-0.4_zip這個文件

2、提取Doc文件內容

public static String readDoc(String doc) throws Exception {
// 創建輸入流讀取DOC文件
FileInputStream in = new FileInputStream(new File(doc));
WordExtractor extractor = null;
String text = null;
// 創建WordExtractor
extractor = new WordExtractor();
// 對DOC文件進行提取
text = extractor.extractText(in);
return text;
}

public static void main(String[] args) {
try{
String text = WordReader.readDoc("c:/test.doc");
System.out.println(text);
}catch(Exception e){
e.printStackTrace();
}
}

3、寫入Doc文檔

import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.poi.poifs.filesystem.DirectoryEntry;
import org.apache.poi.poifs.filesystem.DocumentEntry;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

public class WordWriter {
public static boolean writeDoc(String path, String content) {
boolean w = false;
try {

// byte b[] = content.getBytes("ISO-8859-1");
byte b[] = content.getBytes();

ByteArrayInputStream s = new ByteArrayInputStream(b);

POIFSFileSystem fs = new POIFSFileSystem();
DirectoryEntry directory = fs.getRoot();

DocumentEntry de = directory.createDocument("WordDocument", s);

FileOutputStream ostream = new FileOutputStream(path);

fs.writeFilesystem(ostream);

s.close();
ostream.close();

} catch (IOException e) {
e.printStackTrace();
}
return w;
}
public static void main(String[] args) throws Exception{
String wr=WordReader.readDoc("D:\\test.doc");
boolean b = writeDoc("D:\\result.doc",wr);

Ⅶ java 中簡述使用流進行讀寫文本文件的步驟

InputStream
三個基本的讀方法
abstract int read() ： 讀取一個位元組數據，並返回讀到的數據，如果返回-1，表示讀到了輸入流的末尾。
int read(byte[] b) ： 將數據讀入一個位元組數組，同時返回實際讀取的位元組數。如果返回-1，表示讀到了輸入流的末尾。
int read(byte[] b, int off, int len) ：將數據讀入一個位元組數組，同時返回實際讀取的位元組數。如果返回-1，表示讀到了輸入流的末尾。off指定在數組b中存放數據的起始偏移位置；len指定讀取的最大位元組數。
OutputStream
三個基本的寫方法
abstract void write(int b) ：往輸出流中寫入一個位元組。
void write(byte[] b) ：往輸出流中寫入數組b中的所有位元組。
void write(byte[] b, int off, int len) ：往輸出流中寫入數組b中從偏移量off開始的len個位元組的數據。
其它方法
void flush() ：刷新輸出流，強制緩沖區中的輸出位元組被寫出。
void close() ：關閉輸出流，釋放和這個流相關的系統資源。

Ⅷ java怎樣實現讀寫TXT文件

主要有用到java原生態的Io類，沒有第三個包。直接上代碼：

importjava.io.*;

publicclasswrite{
publicstaticvoidmain(String[]args){
write("E://123.txt","hello");
}

publicstaticvoidwrite(Stringpath,Stringcontent){
try{
Filef=newFile(path);

if(f.exists()){
System.out.println("文件存在");
}else{
System.out.println("文件不存在，正在創建...");
if(f.createNewFile()){
System.out.println("文件創建成功！");
}else{
System.out.println("文件創建失敗！");
}
}
BufferedWriteroutput=newBufferedWriter(newFileWriter(f));
output.write(content);
output.close();
}catch(Exceptione){
e.printStackTrace();
}
}
}

Ⅸ 如何使用JAVA，POI讀寫word文檔

public class HwpfTest {

@SuppressWarnings("deprecation")
@Test
public void testReadByExtractor() throws Exception {
InputStream is = new FileInputStream("D:\\test.doc");
WordExtractor extractor = new WordExtractor(is);
//輸出word文檔所有的文本
System.out.println(extractor.getText());
System.out.println(extractor.getTextFromPieces());
//輸出頁眉的內容
System.out.println("頁眉：" + extractor.getHeaderText());
//輸出頁腳的內容
System.out.println("頁腳：" + extractor.getFooterText());
//輸出當前word文檔的元數據信息，包括作者、文檔的修改時間等。
System.out.println(extractor.getMetadataTextExtractor().getText());
//獲取各個段落的文本
String paraTexts[] = extractor.getParagraphText();
for (int i=0; i<paraTexts.length; i++) {
System.out.println("Paragraph " + (i+1) + " : " + paraTexts[i]);
}
//輸出當前word的一些信息
printInfo(extractor.getSummaryInformation());
//輸出當前word的一些信息
this.printInfo(extractor.getDocSummaryInformation());
this.closeStream(is);
}

/**
* 輸出SummaryInfomation
* @param info
*/
private void printInfo(SummaryInformation info) {
//作者
System.out.println(info.getAuthor());
//字元統計
System.out.println(info.getCharCount());
//頁數
System.out.println(info.getPageCount());
//標題
System.out.println(info.getTitle());
//主題
System.out.println(info.getSubject());
}

/**
* 輸出DocumentSummaryInfomation
* @param info
*/
private void printInfo(DocumentSummaryInformation info) {
//分類
System.out.println(info.getCategory());
//公司
System.out.println(info.getCompany());
}

/**
* 關閉輸入流
* @param is
*/
private void closeStream(InputStream is) {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

}

Ⅹ java讀取、修改、寫入txt文件

模擬：先創建一個TXT文件(內容來自控制台)；然後讀取文件並在控制台輸出；最後實現對新創建的TXT文件(的數據進行排序後)的復制。分別對應三個函數，調用順序需要注意：創建、讀取、復制。

效果圖如下：綠色部分為控制台輸入的內容(當輸入end時，結束)

packagecom.;

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.OutputStreamWriter;
importjava.util.Arrays;
importjava.util.Scanner;
importjava.util.Vector;

publicclassCreateAndReadTxt{
//文件名稱
publicstaticStringfileName=".txt";
publicstaticStringnewFileName=".txt";
//文件路徑
publicfinalstaticStringURL=System.getProperty("user.dir");

//CreateAndReadTxt.class.getResource("/").getPath();

//創建TXT文件
publicstaticvoidcreateTxtFile(StringfName,StringfileContent){
//創建文件
fileName=fName+fileName;
Filefile=newFile(fileName);
//可以更改
file.setWritable(true);
//判斷當前路徑下是否存在同名文件
booleanisExist=file.exists();
if(isExist){
//文件存在，刪除
file.delete();
}
//寫入文件
try{
//文件寫入對象
FileOutputStreamfos=newFileOutputStream(file);
//輸入流寫入----默認字元為GBK
OutputStreamWriterosw=newOutputStreamWriter(fos);
//寫入
osw.write(fileContent);
//寫入完畢後關閉
osw.close();
System.out.println("成功創建文件: "+fileName);
}catch(IOExceptione){
System.out.println("寫入文件失敗: "+e.getMessage());
}
}

//閱讀文件
publicstaticvoidreadFile(StringfileName){
System.out.println("開始讀取文件: "+fileName);
//產生文件對象
Filefile=newFile(fileName);
//
try{
//字元讀取
FileReaderfr=newFileReader(file);
//緩沖處理
BufferedReaderbr=newBufferedReader(fr);
Stringstr="";
while((str=br.readLine())!=null){
System.out.println(str);
}
//關閉
br.close();
fr.close();
}catch(FileNotFoundExceptione){
System.out.println("讀取文件失敗: "+e.getMessage());
}catch(IOExceptione){
System.out.println("讀取文件失敗: "+e.getMessage());
}
}
//文件復制
publicstaticvoidFile(StringfromFileName,StringtoFileName){
//讀取文件
Filefile=newFile(fromFileName);
try{
FileReaderfr=newFileReader(file);
BufferedReaderbr=newBufferedReader(fr);
//定義接收變數
Vector<Double>vec=newVector<Double>();
Strings="";
while(null!=(s=br.readLine())){
vec.add(Double.parseDouble(s));
}
br.close();
fr.close();
//保存到數組並進行排序
Doubledou[]=newDouble[vec.size()];
vec.toArray(dou);
Arrays.sort(dou);
System.out.println("========復制文件=========");
//寫入新文件
newFileName="副本"+newFileName;
FilenewFile=newFile(toFileName);
FileOutputStreamfos=newFileOutputStream(newFile,true);
OutputStreamWriterosm=newOutputStreamWriter(fos);
for(Doubled:dou){
osm.write(d.doubleValue()+" ");
}
osm.close();
fos.close();
}catch(FileNotFoundExceptione){
System.out.println("讀取文件失敗: "+e.getMessage());
}catch(IOExceptione){
System.out.println("讀取文件失敗: "+e.getMessage());
}

}
publicstaticvoidmain(String[]args){
/**
*構造數據
*/
Scannerscan=newScanner(System.in);
StringBuildersb=newStringBuilder();
Strings="";
while(!("end".equals(s=scan.next()))){//當輸入end時，結束
sb.append(s);
sb.append(" ");
}
scan.close();
/**
*使用數據
*/
CreateAndReadTxt.createTxtFile("creat",sb.toString());
CreateAndReadTxt.readFile(fileName);
System.out.println(fileName);
CreateAndReadTxt.File(fileName,newFileName);
CreateAndReadTxt.readFile(newFileName);
}

}