java流處理
Ⅰ java流的主要方法
Java的流操作分為位元組流和字元流兩種。
1、 位元組流
所有的讀操作都繼承自一個公共超類java.io.InputStream類。
所有的寫操作都繼承自一個公共超類java.io.OutputStream類。
InputStream和OutputStream都是抽象類。
InputStream有6個低級輸入流：
低級流
流的用途
ByteArrayInputStream
從內存數組中讀取數據位元組
FileInputStream
從本地文件系統中讀取數據位元組
PipedInputStream
從線程管道中讀取數據位元組
StringBufferInputStream
從字元串中讀取數據位元組
SequenceInputStream
從兩個或多個低級流中讀取數據位元組，當到達流的末尾時從一個流轉到另一個流
System.in
從用戶控制台讀取數據位元組
InputStream還有一個子類：過濾器流java.io.FilterInputStream。過濾器流即能把基本流包裹起來，提供更多方便的用法。
FilterInputStream 類的構造方法為FilterInputStream(InputStream)，在指定的輸入流之上，創建一個輸入流過濾器。
過濾器輸入流
流的用途
BufferedInputStream
緩沖區對數據的訪問，以提高效率
DataInputStream
從輸入流中讀取基本數據類型，如int、float、double或者甚至一行文本
LineNumberInputStream
在翻譯行結束符的基礎上，維護一個計數器，該計數器表明正在讀取的是哪一行。
PushbackInputStream
允許把數據位元組向後推到流的首部
2、 字元流
註：是在jdk1.1裡面引進的，上面位元組流是在jdk1.0引進的。當用於處理文本數據時，選擇字元流比位元組流更好。但對只出路基本數據類型的開發者，可以繼續使用位元組流。
所有的讀操作都繼承自一個公共超類java.io.Reader類。
所有的寫操作都繼承自一個公共超類java.io.Writer類。
同樣Reader和Writer也是抽象類。
Reader的常用的子類如下：
低級讀取器
流的用途
CharArrayReader
從字元數組中讀取數據
InputStreamReader
FileReader（InputStreamReader的子類）
從本地文件系統中讀取字元序列
StringReader
從字元串中讀取字元序列
PipedReader
從線程管道中讀取字元序列
InputStreamReader重點講解：
InputStreamReader是從輸入流中讀取數據，連接輸入流於讀取器。如：
new InputStreamReader(System.in)
構造方法：
InputStreamReader(InputStream)
用預設的字元編碼方式，創建一個 InputStreamReader。
InputStreamReader(InputStream, String) 用已命名的字元編碼方式，創建一個 InputStreamReader。 常用的過濾器讀取器：
過濾器讀取器
流的用途
BufferedReader
緩沖數據的訪問，以提高效率
LineNumberReader（BufferedReader的子類）
維護一個計數器，該計數器表明正在讀取的是哪一行。
FilterReader（抽象類）
提供一個類創建過濾器時可以擴展這個類
PushbackReader（FilterReader的子類）
允許把文本數據推回到讀取器的流中
這些過濾器讀取器都可以傳入一個Reader作為構造方法的參數。
Ⅱ java的流處理程序PrintStream編譯不成功是怎麼回事呢
你應該是沒有導入java.util.Date這個類
Ⅲ java中高級流、低級流如何分
在輸入輸出里，有位元組流和字元流分，這兩者區別在於所操作的數據單元不同。還有另外一種認識，輸入輸出流可以分為節點劉和處理流（包裝流），節點流有時候會被稱為低級流，節點流是直接和實際的數據源相互連接的，和實際的輸入輸出點連接。處理流有時候也成為高級流，是對一個已存在的流進行連接或封裝。區分節點流和處理流，只要看給出的參數是什麼就行了，如果是一個實際的數據源，就是節點流，如果是一個流，就是處理流。如 x0dx0aPrintStream ps = new PrintStream(new FileOutputStream("out.txt"));x0dx0a在這里，FileOutputStream就是一個節點流，PrintStream就是一個處理流。x0dx0a至於說到，java里有哪些低級流，其實這個有很多，你可以看一下流的體系就行了。x0dx0aInputStream類中常用的低級流有InputStream、FileInputStream等，高級流有DataInputStream和BufferedInputStream，一般高級流要封裝低級流，一般以read()方法讀入。OutputStream類中常用的低級流有OutputStream、PipedOutputStream等，高級流有DataOutputStream和BufferedOutputStream，一般以Writer（）、Print()方法寫入。字元流主要有Reader和Writer兩種抽象類，Reader類中常用的低級流有FileReader等，高級流有BufferedReader、InputStreamReader等，以readLine()方法讀一行字元。Writer類中常用的低級流有StringWriter、FileWriter等，高級流有BufferedWriter、PrintWriter等，以writer()和print()方法寫入，如果用BufferedWriter時還要用flush()方法才能寫入。
Ⅳ java中怎麼識別節點流和處理流
按照流是否直接與特定的地方(如磁碟、內存、設備等)相連，分為節點流和處理流兩類。
節點流：可以從或向一個特定的地方(節點)讀寫數據。如FileReader.
處理流：是對一個已存在的流的連接和封裝，通過所封裝的流的功能調用實現數據讀寫。如BufferedReader.處理流的構造方法總是要帶一個其他的流對象做參數。一個流對象經過其他流的多次包裝，稱為流的鏈接。
JAVA常用的節點流有以下幾個：
文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件進行處理的節點流。
字元串 StringReader StringWriter 對字元串進行處理的節點流。
數 組 ByteArrayInputStream CharArrayWriter 對數組進行處理的節點流(對應的不再是文件，而是內存中的一個數組)。
管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter對管道進行處理的節點流。
父 類 InputStream OutputStream Reader Writer
常用處理流(關閉處理流使用關閉裡面的節點流)
緩沖流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter
增加緩沖功能，避免頻繁讀寫硬碟。
轉換流：InputStreamReader OutputStreamReader實現位元組流和字元流之間的轉換。
數據流 DataInputStream DataOutputStream 等-提供將基礎數據類型寫入到文件中，或者讀取出來。
Ⅳ Java中一個數據流處理的問題
對象序列化，把類的對象寫入文件。虛擬機一關機對象就沒了，對象序列化實現把對象從內存上存到硬碟上。如果對象很多，內存不夠用,就可使對象序列化 。
輸入輸出流分別是ObjectInputStream和ObjectOutputSream:
如果類想要實現對象序列話必須實現 介面Serilizable.Serilizable介面中無任何方法。
下面給你個以前寫的例子：
import java.io.Serializable;
public class Foo implements Serializable{
private String str;
private int value;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
public class TestOISOOS {
/**
* @param args
* @throws IOException
* @throws FileNotFoundException
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(new File("7.txt")));
Foo foo=new Foo();
foo.setStr("foo");
foo.setValue(100);
//oos.writeObject(foo);
//oos.close();
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("7.txt")));
//Foo foo2=(Foo)ois.readObject();
//System.out.println(foo2.getStr());
//System.out.println(foo2.getValue());
ArrayList<Foo> fooList=new ArrayList<Foo>();
for(int i=0;i<10;i++){
Foo foo3=new Foo();
foo3.setStr(i+"a");
foo3.setValue(i+100);
fooList.add(foo3);
}
oos.writeObject(fooList);
oos.close();
fooList=(ArrayList<Foo>) ois.readObject();
for(int i=0;i<fooList.size();i++){
System.out.println(fooList.get(i).getStr());
System.out.println(fooList.get(i).getValue());
}
}
}
上面就是講實例後的Foo對象寫入到硬碟文件中。
Ⅵ 在java語言中處理數據基於流的形式，流有哪些分類形式
Java中的流從不同的角度可以分為以下幾類：
1. 處理的數據單位不同，可分為：字元流，位元組流
2.數據流方向不同，可分為：輸入流，輸出流
3.功能不同，可分為：節點流，處理流
Ⅶ Java字元流和位元組流對文件操作的區別
Java字元流是處理字元（Char）對象用的，位元組流是處理位元組（Byte）對象用的。處理的目標對象不同，處理方法也就不一樣了。
字元流處理的基本單位是字元（Java中的字元是16位的），輸入流以Reader為基礎，輸出流以Writer為基礎；
位元組流的基本單位是位元組（Java中的位元組是8位的），輸入流以 InputStream為基礎，輸出流以 OutputStream為基礎；
字元流在輸入時可以按字元讀取，也可以按行讀取，會去掉回車換行，常用於讀取字元數據；
而位元組流按位元組讀取，不作任何處理，常用於讀取二進制數據。
Java中的字元在內部都是使用Unicode進行表示的，因此，要正確讀取字元數據，需要知道字元的編碼字元集，字元流提供編碼字元集的指定，如果不指定使用系統默認的方式對字元數據進行編碼轉換，這個編碼字元集不正確，會造成讀進來的地字元出現亂碼。
位元組流雖然是讀取二進制數據用的，但也可以讀取字元文件，按位元組進行處理，讀進來之後可以根據編碼字元集進行轉換，也可以變成字元串。
Ⅷ java中的「流」是什麼
Java中的流是個抽象的概念，當程序需要從某個數據源讀入數據的時候，就會開啟一個數據流，數據源可以是文件、內存或網路等等。相反地，需要寫出數據到某個數據源目的地的時候，也會開啟一個數據流，這個數據源目的地也可以是文件、內存或網路等等x0dx0ax0dx0aJava中的流可以從不同的角度進行分類：x0dx0a按照流的方向不同：分為輸入流和輸出流。x0dx0a按照處理數據單位的不同：分為位元組流（8位）和字元流（16位）。x0dx0a按照功能不同：分為節點流和處理流。x0dx0a節點流：是可以從一個特定的數據源（節點）讀寫數據的流（例如文件，內存）。就像是一條單一的管子接到水龍頭上開始放水。x0dx0a處理流：是「連接」在已經存在的流（節點流或處理流）之上，通過對數據的處理為程序提供更為強大的讀寫功能。就像在已經接了一條管子（節點流）的基礎上，又套上幾個更粗，具有特殊功能的管子（處理流）對流出的水進一步的處理。x0dx0a四種基本流InputStream，OutputStream，Reader，Writer又分別有更具體的子類，分為文件流，緩沖流，數據流，轉換流，Print流，Object流等，都分別有特定的功能或用來操作特定的數據
Ⅸ 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介面時，只是表明該類遵循串列化協議，而不需要實現任何特殊的方法。
* 在進行對象串列化時，需要注意將串列化的對象和輸入、輸出流聯系起來，首先通過對
* 象輸出流將對象狀態保存下來，然後通過對象輸入流將對象狀態恢復。