java行讀取文件

Ⅰ java如何獲取文件信息

File 類是對文件和文件夾的抽象，包含了對文件和文件夾的多種屬性和操作方法。File類的常用方法如下表：

返回
方法
說明

String getName 獲取文件名稱
String getParent 獲取文件的父路徑字元串
String getPath 獲取文件的相對路徑字元串
String getAbsolutePath 獲取文件的絕對路徑字元串
boolean exists 判斷文件或者文件夾是否存在
boolean isFile 判斷是不是文件類型
boolean isDirectory 判斷是不是文件夾類型
boolean delete 刪除文件或文件夾，如果刪除成功返回結果為true
boolean mkdir 創建文件夾，創建成功返回true
boolean setReadOnly 設置文件或文件夾的只讀屬性
long length 獲取文件的長度
long lastModified 獲取文件的最後修改時間
String[ ] list 獲取文件夾中的文件和子文件夾的名稱，並存放到字元串數組中

Ⅱ java 按行讀取一個文件，存在字元串數組里，一個元素對應一行，再將這個數組按行輸出到一個新的文件里

java 按行讀取一個文件，存在字元串數組里，一個元素對應一行，再將這個數組按行輸出到一個新的文件里，代碼如下：

packagefoo;

importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.File;
importjava.io.FileInputStream;

importjava.io.FileOutputStream;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.OutputStreamWriter;
importjava.util.ArrayList;
importjava.util.List;

/**
*Helloworld!
*
*/
publicclassApp
{
publicstaticvoidmain(String[]args)
{
FilereadFile=newFile("D://home/a.txt");
InputStreamin=null;
InputStreamReaderir=null;
BufferedReaderbr=null;

OutputStreamout=null;
OutputStreamWriterow=null;
BufferedWriterbw=null;
try{
	//用流讀取文件
			in=newBufferedInputStream(newFileInputStream(readFile));
			//如果你文件已utf-8編碼的就按這個編碼來讀取，不然又中文會讀取到亂碼
			ir=newInputStreamReader(in,"utf-8");
			br=	newBufferedReader(ir);
			Stringline="";
			//定義集合一行一行存放
			List<String>list=newArrayList<String>();
			//一行一行讀取
			while((line=br.readLine())!=null){
				System.out.println(line);
				list.add(line);
			}
			//將集合轉換成數組
			String[]arr=list.toArray(newString[list.size()]);
			
			//寫入新文件
			FilenewFile=newFile("D://home/b.txt");
			if(!newFile.exists()){				
				newFile.createNewFile();
			}
			
			out=newBufferedOutputStream(newFileOutputStream(newFile));
			//這里也可以給定編碼寫入新文件
			ow=newOutputStreamWriter(out,"gb2312");
			bw=newBufferedWriter(ow);
			//遍歷數組吧字元串寫入新文件中
			for(intx=0;x<arr.length;x++){
				bw.write(arr[x]);
				if(x!=arr.length-1){
				//換行
				bw.newLine();
				}
				
			}
			//刷新該流的緩沖，這樣才真正寫入完整到新文件中
			bw.flush();
		}catch(Exceptione){
			
			e.printStackTrace();
		}finally{
			//一定要關閉流,倒序關閉
			try{
				if(bw!=null){
					bw.close();
				}
				if(ow!=null){
					ow.close();
				}
				if(out!=null){
					out.close();
				}
				if(br!=null){
					br.close();
				}
				if(ir!=null){
					ir.close();
				}
				if(in!=null){
					in.close();
				}
			}catch(Exceptione2){
				
			}
			
		}
	
}
}

Ⅲ java怎麼讀入文件，並逐行輸出

java讀入文件，並逐行輸出，先在D://home建立個文件夾，然後創建一個a.txt文件，然後編輯文件，文本編輯的編碼是utf-8,然後用流逐行讀取輸出，如下：

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

publicclassTestC{
	
	publicstaticvoidmain(String[]args){
	//獲取要讀取的文件
		FilereadFile=newFile("D://home/a.txt");
		//輸入IO流聲明
	InputStreamin=null;
	InputStreamReaderir=null;
	BufferedReaderbr=null;
	
	try{
		//用流讀取文件
				in=newBufferedInputStream(newFileInputStream(readFile));
				//如果你文件已utf-8編碼的就按這個編碼來讀取，不然又中文會讀取到亂碼
				ir=newInputStreamReader(in,"utf-8");
				//字元輸入流中讀取文本,這樣可以一行一行讀取
				br=	newBufferedReader(ir);
				Stringline="";
				
				//一行一行讀取
				while((line=br.readLine())!=null){
					System.out.println(line);
					
				}
				
	}catch(Exceptione){
				
				e.printStackTrace();
			}finally{
				//一定要關閉流,倒序關閉
				try{
					
					if(br!=null){
						br.close();
					}
					if(ir!=null){
						ir.close();
					}
					if(in!=null){
						in.close();
					}
				}catch(Exceptione2){
					
				}
				
			}
		
	}
	
	
}

結果：
helloworld
您好
123456

Ⅳ java 如何讀寫文件

這個問題問的太泛泛了，讀寫文件，首先了解什麼是輸入流和輸出流，什麼是位元組流，什麼是字元流。然後創建流對象，調用其方法read or write File

Ⅳ Java怎麼讀取文件的任意行

java中沒有指定行的方法。
只能挨個讀取。如果你想快速提取。而且文件又不是很大的話，就用LIST吧。

Ⅵ Java中如何一行行地讀文件

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassReadTest{
	publicstaticvoidmain(String[]args){
		//讀控制台輸入的文字!
		BufferedReaderbr=null;
		Stringstr=null;
		try{
			br=newBufferedReader(newInputStreamReader(System.in));
			while(true){
				str=br.readLine();
				if(str.equals("886"))
					break;
				System.out.println(str);
			}
			//讀文本文件..
			br=newBufferedReader(newFileReader(newFile("C:\Users\Administrator\Desktop\地址.txt")));
			for(str=br.readLine();str!=null;str=br.readLine()){
				//列印你讀的文本數據!
				System.out.println(str);
			}
		}catch(IOExceptione){
			e.printStackTrace();
		}
	}
}

核心就是:readLine()方法,一行一行的讀!

Ⅶ 如何用java按行讀取文本文件

File file = new File("文件地址");
Scanner scanner = new Scanner(file);
String lineContent = null;
while(scanner.hasNextLine()){//如果有下一行
lineContent = scanner.nextLine();//讀取下一行內容
}
scanner.close();//關閉Scanner

Ⅷ JAVA中讀取文件（二進制，字元）內容的幾種方

JAVA中讀取文件內容的方法有很多，比如按位元組讀取文件內容，按字元讀取文件內容，按行讀取文件內容，隨機讀取文件內容等方法，本文就以上方法的具體實現給出代碼，需要的可以直接復制使用

public class ReadFromFile {
/**
* 以位元組為單位讀取文件，常用於讀二進制文件，如圖片、聲音、影像等文件。
*/
public static void readFileByBytes(String fileName) {
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以位元組為單位讀取文件內容，一次讀一個位元組：");
// 一次讀一個位元組
in = new FileInputStream(file);
int tempbyte;
while ((tempbyte = in.read()) != -1) {
System.out.write(tempbyte);
}
in.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
try {
System.out.println("以位元組為單位讀取文件內容，一次讀多個位元組：");
// 一次讀多個位元組
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
// 讀入多個位元組到位元組數組中，byteread為一次讀入的位元組數
while ((byteread = in.read(tempbytes)) != -1) {
System.out.write(tempbytes, 0, byteread);
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}

/**
* 以字元為單位讀取文件，常用於讀文本，數字等類型的文件
*/
public static void readFileByChars(String fileName) {
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字元為單位讀取文件內容，一次讀一個位元組：");
// 一次讀一個字元
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1) {
// 對於windows下，\r\n這兩個字元在一起時，表示一個換行。
// 但如果這兩個字元分開顯示時，會換兩次行。
// 因此，屏蔽掉\r，或者屏蔽\n。否則，將會多出很多空行。
if (((char) tempchar) != '\r') {
System.out.print((char) tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字元為單位讀取文件內容，一次讀多個位元組：");
// 一次讀多個字元
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
// 讀入多個字元到字元數組中，charread為一次讀取字元數
while ((charread = reader.read(tempchars)) != -1) {
// 同樣屏蔽掉\r不顯示
if ((charread == tempchars.length)
&& (tempchars[tempchars.length - 1] != '\r')) {
System.out.print(tempchars);
} else {
for (int i = 0; i < charread; i++) {
if (tempchars[i] == '\r') {
continue;
} else {
System.out.print(tempchars[i]);
}
}
}
}

} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}

/**
* 以行為單位讀取文件，常用於讀面向行的格式化文件
*/
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行為單位讀取文件內容，一次讀一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次讀入一行，直到讀入null為文件結束
while ((tempString = reader.readLine()) != null) {
// 顯示行號
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}

/**
* 隨機讀取文件內容
*/
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) {
}
}
}
}

/**
* 顯示輸入流中還剩的位元組數
*/
private static void showAvailableBytes(InputStream in) {
try {
System.out.println("當前位元組輸入流中的位元組數為:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
String fileName = "C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}

Ⅸ java 按行讀取txt文件的數字

可以通過Java的IO流實現txt文本的讀取，然後用readline實現按行讀取。具體代碼如下：

packagetest;

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileReader;
importjava.io.IOException;
importjava.util.ArrayList;
importjava.util.List;

publicclassTest{
publicstaticdouble[]writeToDat(Stringpath){
Filefile=newFile(path);
Listlist=newArrayList();
double[]nums=null;
try{
BufferedReaderbw=newBufferedReader(newFileReader(file));
Stringline=null;
//因為不知道有幾行數據，所以先存入list集合中
while((line=bw.readLine())!=null){
list.add(line);
}
bw.close();
}catch(IOExceptione){
e.printStackTrace();
}
//確定數組長度
nums=newdouble[list.size()];
for(inti=0;i<list.size();i++){
Strings=(String)list.get(i);
nums[i]=Double.parseDouble(s);
}
returnnums;
}
publicstaticvoidmain(String[]args){
Stringpath="d:/file4.txt";
double[]nums=writeToDat(path);
for(inti=0;i<nums.length;i++){
System.out.println(nums[i]);
}
}
}

Ⅹ java怎樣讀取大文件

讀取文件行的標准方式是在內存中讀取，Guava 和Apache Commons IO都提供了如下所示快速讀取文件行的方法：

Files.readLines(new File(path), Charsets.UTF_8); FileUtils.readLines(new File(path));

這種方法帶來的問題是文件的所有行都被存放在內存中，當文件足夠大時很快就會導致程序拋出OutOfMemoryError 異常。
例如：讀取一個大約1G的文件：

@Testpublic void givenUsingGuava_whenIteratingAFile_thenWorks() throws IOException { String path = ... Files.readLines(new File(path), Charsets.UTF_8);}

這種方式開始時只佔用很少的內存：（大約消耗了0Mb內存）

[main] INFO org.baelng.java.CoreJavaIoUnitTest - Total Memory: 128 Mb[main] INFO org.baelng.java.CoreJavaIoUnitTest - Free Memory: 116 Mb

然而，當文件全部讀到內存中後，我們最後可以看到（大約消耗了2GB內存）：

[main] INFO org.baelng.java.CoreJavaIoUnitTest - Total Memory: 2666 Mb[main] INFO org.baelng.java.CoreJavaIoUnitTest - Free Memory: 490 Mb

這意味這一過程大約耗費了2.1GB的內存——原因很簡單：現在文件的所有行都被存儲在內存中。
把文件所有的內容都放在內存中很快會耗盡可用內存——不論實際可用內存有多大，這點是顯而易見的。
此外，我們通常不需要把文件的所有行一次性地放入內存中——相反，我們只需要遍歷文件的每一行，然後做相應的處理，處理完之後把它扔掉。所以，這正是我們將要做的——通過行迭代，而不是把所有行都放在內存中。