字節流File讀寫
一、功能定義
OutputStream<--FileOutputStream 字節流寫入
InputStream<--FileInputStream 字節流讀出
二、方法
1.FileOutputStream
1)構造方法（創建一個向指定
File 對象表示的文件中寫入數據的文件輸出流。）FileOutputStream(File file)
2）將 b.length 個字節從指定 byte 數組寫入此文件輸出流中。void write(byte[] b)
import java.io.*;
class FileOutputStreamDemo
{
public static void main(String[] args) throws IOException
{
FileOutputStream fos=new FileOutputStream("demo4.txt");
fos.write("abcde".getBytes());
//未刷新，也未關閉，同樣可以把數據存入，由於一箇中文有兩個字節，當計算機讀入一個字節時沒法操作，
//所以需要刷新一下確定字節全部讀入，而字節流不需要刷新
}
}
1)構造方法（通過打開一個到實際文件的連接來創建一個
FileInputStream，該文件通過文件系統中的 File 對象file 指定。）FileInputStream(File file)3)從此輸入流中將最多
b.length 個字節的數據讀入一個 byte 數組中。int
read(byte[] b)import java.io.*;
class FileOutputStreamDemo
{
public static void main(String[] args) throws IOException
{
FileOutputStream fos=new FileOutputStream("demo4.txt");
fos.write("abcde".getBytes());
//未刷新，也未關閉，同樣可以把數據存入，由於一箇中文有兩個字節，當計算機讀入一個字節時沒法操作，
//所以需要刷新一下確定字節全部讀入，而字節流不需要刷新
fos.close();
FileInputStream fis=new FileInputStream("demo2.txt");
/*read()方法
int ch=0;
while((ch=fis.read())!=-1)
{
System.out.print((char)ch);
}
*/
//read(byte[] b)方法
byte[] a=new byte[1024];
int num=0;
while((num=fis.read(a))!=-1)
{
System.out.println(new String(a,0,num));
}
}
}
int available() FileInputStream fis=new FileInputStream("demo2.txt");
byte[] a=new byte[fis.available];//利用available方法，可以直接定義已知大小的數組來存放數據，但是如果數據過大，還是採用1024的方法
fis.read(a)
System.out.println(new String(a)拷貝一個圖片
拷貝一個圖片一、代碼import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos=null;
FileInputStream fis=null;
try
{
fos=new FileOutputStream("demo5.jpg");
fis=new FileInputStream("1.jpg");
byte[] buf=new byte[1024];
int num=0;
while((num=fis.read(buf))!=-1)
{
fos.write(buf,0,num);
}
}
catch (IOException e)
{
throw new RuntimeException("圖片讀取出現問題");
}
finally
{
if(fos!=null)
try
{
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("寫入圖片失敗");
}
if(fis!=null)
try
{
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("讀取圖片失敗");
}
}
}
}字節流的緩衝區
字節流的緩衝區一、功能定義BufferedOutputStream 該類實現緩衝的輸出流。通過設置這種輸出流，應用程序就可以將各個字節寫入底層輸出流中，而不必針對每次字節寫入調用底層系統。BufferedInputStream 爲另一個輸入流添加一些功能，即緩衝輸入以及支持mark 和reset 方法的能力。二、代碼import java.io.*;
class BufferedXputStreamDemo
{
public static void main(String[] args) throws IOException
{
long start=System.currentTimeMillis();
copy_1();
long end=System.currentTimeMillis();
System.out.println(start+"..."+end);
System.out.println((end-start)+"毫秒");
}
public static void copy_1() throws IOException
{
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("1.jpg"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("2.jpg"));
int by=0;
while((by=bis.read())!=-1)
{
bos.write(by);
}
bis.close();
bos.close();
}
}
自定義字節流緩衝區
一、代碼
import java.io.*;
class MyBufferedInputStreamDemo
{
private FileInputStream fis=null;
private int pos=0,count=0;
private byte[] buf=new byte[1024];//建立一個字節數組緩衝區
MyBufferedInputStreamDemo(FileInputStream fis)
{
this.fis=fis;
}
public int myRead() throws IOException
{
if(count==0)
{
count=fis.read(buf);
if(count<0)
return -1;
pos=0;
byte b=buf[pos];
pos++;
count--;
return b&255;//將int類型的前32位全變爲0
}
else if(count>0)
{
byte b=buf[pos];
pos++;
count--;
return b&255;//將int類型的前32位全變爲0
}
return -1;
}
public void myClose() throws IOException
{
fis.close();
}
}
class BufferedXputStreamDemo2
{
public static void main(String[] args) throws IOException
{
long start=System.currentTimeMillis();
copy_1();
long end=System.currentTimeMillis();
System.out.println(start+"..."+end);
System.out.println((end-start)+"毫秒");
}
public static void copy_1() throws IOException
{
MyBufferedInputStreamDemo bis=new MyBufferedInputStreamDemo(new FileInputStream("1.jpg"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("3.jpg"));
int by=0;
while((by=bis.myRead())!=-1)
{
bos.write(by);
}
bis.myClose();
bos.close();
}
}
read()方法返回int類型的數據，將byte類型的數據提升爲了int類型，即變成了4個字節的數據
write()方法則進行了強轉，把int類型強轉回了byte類型。
讀取鍵盤錄入
一、代碼1.簡單的鍵盤錄入讀取
import java.io.*;
class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in=System.in;
int by=in.read();
System.out.println(by);
}
}
import java.io.*;
class ReadIn2
{
public static void main(String[] args) throws IOException
{
InputStream in=System.in;
StringBuilder sb=new StringBuilder();
while(true)
{
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if(s.equals("over"))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}讀取轉換流（InputStreamReader)
一、功能定義
InputStreamReader 是字節流通向字符流的橋樑。二、代碼
import java.io.*;
class InputStreamReaderDemo
{
public static void main(String[] args) throws IOException
{
InputStream in=System.in;//獲取鍵盤錄入流
InputStreamReader fr=new InputStreamReader(in);//將字節流轉換成字符流
BufferedReader br=new BufferedReader(fr);//將字符流進行緩衝區技術高效操作
String line=null;
while((line=br.readLine())!=null)
{
if(line.equals("over"))
break;
System.out.println(line.toUpperCase());
}
br.close();
}
}寫入轉換流（OutputStreamWriter）
一、功能定義OutputStreamWriter 是字符流通向字節流的橋樑。
二、代碼
import java.io.*;
class OutputStreamWriterDemo
{
public static void main(String[] args) throws IOException
{
//InputStream in=System.in;
//InputStreamReader isr=new InputStreamReader(in);
//BufferedReader br=new BufferedReader(isr);
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//獲取鍵盤錄入
//OutputStream out=System.out;
//OutputStreamWriter osw=new OutputStreamWriter(out);
//BufferedWriter bw=new BufferedWriter(osw);
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));//將數據輸出到控制檯
String line=null;
while((line=br.readLine())!=null)
{
if(line.equals("over"))
break;
bw.write(line.toUpperCase());
bw.newLine();
bw.flush();
}
br.close();
bw.close();
}
}
流操作規律（1）
一、步驟
二、實例
詳情參見——19-18,19-19
改變標準輸入輸出設備
一、概述
System類中有兩個方法可以改變輸入輸出設備
1.重新分配“標準”輸入流。static void setIn(InputStream in)2.重新分配“標準”輸出流。static void setOut(PrintStream out)
二、代碼![]()
IO流——異常的日誌信息
一、代碼
log4j是一個專門用於生成日誌信息的工具包
系統信息
一、方法
1.將屬性列表輸出到指定的輸出流。
void
list(PrintStream out)--->list(System.out)則輸出到控制檯二、代碼
File類概述
一、File概述
1.用來將文件或者文件夾封裝成對象
2.方便對文件或者文件進行屬性信息進行操作
3.File對象可以作爲參數——傳遞給流的構造函數
4.彌補了“流”的不足，因爲流只能操作數據，操作文件的信息必須要用File對象。
定義：文件和目錄路徑名的抽象表示形式。
二、方法（字段）
1.與系統有關的默認名稱分隔符。
static String separator2.構造方法（通過將給定路徑名字符串轉換爲抽象路徑名來創建一個新
File 實例。）
3.構造方法（根據 parent 路徑名字符串和 child 路徑名字符串創建一個新
File 實例。）
4.構造方法（根據 parent 抽象路徑名和 child 路徑名字符串創建一個新File 實例。）
![]()
File對象功能
一、File類常見方法
1.創建
1）當且僅當不存在具有此抽象路徑名指定名稱的文件時，不可分地創建一個新的空文件。
boolean
createNewFile()
在指定位置創建文件，如果該文件已經存在，返回false，否則返回true代表創建成功。![]()
2.刪除
1）刪除此抽象路徑名錶示的文件或目錄。
boolean
delete() 
2)在虛擬機終止時，請求刪除此抽象路徑名錶示的文件或目錄。
void
deleteOnExit() 3.判斷
1）測試應用程序是否可以執行此抽象路徑名錶示的文件。
boolean canExecute()
2）測試應用程序是否可以讀取此抽象路徑名錶示的文件。boolean canRead()
3）測試應用程序是否可以修改此抽象路徑名錶示的文件。boolean canWrite()4）按字母順序比較兩個抽象路徑名。
***5）測試此抽象路徑名錶示的文件或目錄是否存在。boolean
exists() 在判斷一個File對象是目錄還是文件時，要先判斷該文件是否存在 ***6）測試此抽象路徑名錶示的文件是否是一個目錄。
boolean
isDirectory()***7）測試此抽象路徑名錶示的文件是否是一個標準文件。
boolean
isFile()
4.獲取信息
1.返回由此抽象路徑名錶示的文件或目錄的名稱。
2.將此抽象路徑名轉換爲一個路徑名字符串。3.返回此抽象路徑名錶示的文件最後一次被修改的時間。long lastModified()
4.返回由此抽象路徑名錶示的文件的長度。
long length()
5.返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回null。
文件列表
一、方法
1.列出可用的文件系統根。
static File[ ] listRoots()
![]()
2.返回一個字符串數組，這些字符串指定此抽象路徑名錶示的目錄中的文件和目錄。
![]()
3. 返回一個字符串數組，這些字符串指定此抽象路徑名錶示的目錄中滿足指定過濾器的文件和目錄。
![]()
列出目錄下的所有內容——遞歸
代碼：
import java.io.*;
class FileListDemo
{
public static void main(String[] args)
{
File f=new File("C:\\");
list(f);
}
public static void list(File f)
{
System.out.println(f);
File[] fl=f.listFiles();
for(int i=0;i<fl.length;i++)
{
if(fl[i].isDirectory())
list(fl[i]);
else
System.out.println(fl[i]);
}
}
}
1.要注意遞歸結束條件，避免死循環。
2.注意遞歸的次數，避免內存溢出。
刪除一個帶內容的目錄
一、刪除原理
在Windows中，刪除目錄，是從裏往外刪除文件。
二、代碼
import java.io.*;
class FileRemoveDemo
{
public static void main(String[] args)
{
File f=new File("D:\\remove");
list(f);
}
public static void list(File f)
{
File[] fl=f.listFiles();
for(int i=0;i<fl.length;i++)
{
if(fl[i].isDirectory())
list(fl[i]);
else
System.out.println(fl[i]+"文件"+fl[i].delete());
}
System.out.println(f+"文件夾"+f.delete());
}
}
創建Java文件列表清單
一、思路
1.對指定的目錄進行遞歸
2.獲取遞歸過程所有java文件的路徑
3.將這些路徑存儲在集合中
4.將集合中的數據存入文件中
1.將指定目錄下的所有.java文件存儲到集合中
import java.io.*;
import java.util.*;
class JavaFileListDemo
{
public static void main(String[] args)
{
File f=new File("D:\\javap");
ArrayList<File> a=new ArrayList<File>();
fileToList(f,a);
System.out.println(a.size());
}
public static void fileToList(File f,ArrayList<File> a)
{
File[] fl=f.listFiles();
for(File f1 : fl)
{
if(f1.isDirectory())
fileToList(f1,a);
else
{
if(f1.getName().endsWith(".java"));
a.add(f1);
}
}
}
}
import java.io.*;
import java.util.*;
class JavaFileListDemo2
{
public static void main(String[] args) throws IOException
{
File f=new File("D:\\javap");
ArrayList<File> a=new ArrayList<File>();
fileToList(f,a);
System.out.println(a.size());
BufferedWriter bw=new BufferedWriter(new FileWriter("JavaList.txt"));
listToFile(bw,a);
try
{
if(bw!=null)
{
bw.close();
}
}
catch (IOException e)
{
throw e;
}
}
public static void fileToList(File f,ArrayList<File> a)
{
File[] fl=f.listFiles();
for(File f1 : fl)
{
if(f1.isDirectory())
fileToList(f1,a);
else
{
if(f1.getName().endsWith(".java"))
a.add(f1);
}
}
}
public static void listToFile(BufferedWriter bw,ArrayList<File> a)
{
for(File fl:a)
{
try
{
String s=fl.getAbsolutePath();
bw.write(s);
bw.newLine();
bw.flush();
}
catch (IOException e)
{
throw new RuntimeException("文件寫入發生錯誤");
}
}
}
}Properties
一、概述
二、方法
1.用指定的鍵在此屬性列表中搜索屬性。
2.調用 Hashtable 的方法
put。import java.io.*;
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
setAndGet();
}
public static void setAndGet()
{
Properties p=new Properties();
p.setProperty("zhangsan","14");
p.setProperty("lisi","15");
p.setProperty("wangwu","16");
System.out.println(p);
System.out.println(p.getProperty("wangwu"));
}
}
import java.io.*;
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
setAndGet();
}
public static void setAndGet()
{
Properties p=new Properties();
p.setProperty("zhangsan","14");
p.setProperty("lisi","15");
p.setProperty("wangwu","16");
Set<String> set=p.stringPropertyNames();
for(String s: set)
{
System.out.println(s+"...."+p.getProperty(s));
}
}
}void
![]()
2.方法二
1.以適合使用
list(PrintStream out) ——System.out類型是 PrintStreamProperties存取配置文件
一、思路
二、代碼(Properties從文件取出）
1.方法一
import java.io.*;
import java.util.*;
class PropertiesDemo2
{
public static void main(String[] args) throws IOException
{
Properties p=new Properties();
streamToProperties(p);
}
public static void streamToProperties(Properties p) throws IOException
{
BufferedReader br=new BufferedReader(new FileReader("info.txt"));
String len=null;
while((len=br.readLine())!=null)
{
String[] s=len.split("=");
p.setProperty(s[0],s[1]);
}
br.close();
System.out.println(p);
}
}
1.從輸入流中讀取屬性列表（鍵和元素對）。
void
load(InputStream inStream) public static void loadDemo() throws IOException
{
Properties p=new Properties();
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("info.txt"));
p.load(bis);
System.out.println(p);
}1.以適合使用
load(InputStream) 方法加載到Properties 表中的格式，將此Properties 表中的屬性列表（鍵和元素對）寫入輸出流。void
store(OutputStream out,String comments) public static void storeDemo() throws IOException
{
Properties p=new Properties();
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("info.txt"));
p.load(bis);
p.setProperty("wangwu","99");
FileOutputStream fos=new FileOutputStream("info.txt");
p.store(fos,"haha");
}PrintWriter(PrintStream)
一、功能定義1.打印流
該流提供了打印方法，可以將各種數據類型的數據原樣打印
1）PrintWriter 字符打印流(比較常用）
構造函數可以接收的數據類型
1.file對象。 File
2.字符串路徑。 String
3.字節輸出流。 OutputStream
4.字符輸出流。 Writer
2）PrintStream 字節打印流
構造函數可以接收的數據類型
1.file對象。 File
2.字符串路徑。 String
3.字節輸出流。 OutputStream
二、代碼
1.PrintWriter 字符打印流(比較常用）
import java.io.*;
class PrintWriterDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(new BufferedWriter(new FileWriter("b.txt")),true);
String len=null;
while((len=br.readLine())!=null)
{
if(len.equals("over"))
break;
pw.println(len.toUpperCase());
}
br.close();
pw.close();
}
}
合併流（序列流——SequenceInputStream)
一、功能定義SequenceInputStream 表示其他輸入流的邏輯串聯。它從輸入流的有序集合開始，並從第一個輸入流開始讀取，直到到達文件末尾，接着從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾爲止。二、方法
1.構造方法（將按順序讀取這兩個參數，先讀取
s1，然後讀取 s2）import java.io.*;
import java.util.*;
class SequenceInputStreamDemo
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration<FileInputStream> e=v.elements();
SequenceInputStream sis=new SequenceInputStream(e);
FileOutputStream fos=new FileOutputStream("4.txt");
byte[] c=new byte[1024];
int len=0;
while((len=sis.read(c))!=-1)
{
fos.write(c,0,len);
}
sis.close();
fos.close();
}
}
切割文件與合併文件
一、切割文件
public static void spiltFile() throws IOException
{
FileInputStream fis=new FileInputStream("1.jpg");
FileOutputStream fos=null;
byte[] b=new byte[1024*20];
int len=0;
int count=1;
while((len=fis.read(b))!=-1)
{
fos=new FileOutputStream("D:\\javap\\javapart\\"+(count++)+".part");
fos.write(b,0,len);
fos.close();
}
}二、合併被切割文件
public static void merge() throws IOException
{
ArrayList<FileInputStream> a=new ArrayList<FileInputStream>();
a.add(new FileInputStream("D:\\javap\\javapart\\1.part"));//可以用for循環
a.add(new FileInputStream("D:\\javap\\javapart\\2.part"));
a.add(new FileInputStream("D:\\javap\\javapart\\3.part"));
a.add(new FileInputStream("D:\\javap\\javapart\\4.part"));
a.add(new FileInputStream("D:\\javap\\javapart\\5.part"));
final Iterator<FileInputStream> it=a.iterator();//匿名內部類要調用本類變量，該變量需要是final類型
Enumeration<FileInputStream> e=new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(e);
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("D:\\javap\\javapart\\6.jpg"));
byte[] b=new byte[1024*20];
int len=0;
while((len=sis.read(b))!=-1)
{
bos.write(b,0,len);
}
sis.close();
bos.close();
}對象的序列化
一、功能定義
將堆內存中的對象存到硬盤上，將Java 對象的基本數據類型和圖形寫入OutputStream，並用InputSream讀取。。即將對象序列化和反序列化——ObjectOutputStream 和 ObjectInputStream類
二、代碼
1.將對象序列化
public static void writeObject() throws IOException
{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("object.txt"));
oos.writeObject(new Person("zhangsan","15"));
oos.close();
}2.將對象反序列化
public static void readObject() throws Exception//由於readObject方法會報出ClassNotFoundException,所以要進行拋出
{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("object.txt"));
Person p=(Person)ois.readObject();//返回的是Object類型，要記得強轉
System.out.println(p);
ois.close();
}3.對象在序列化之前需要進行的操作
<pre name="code" class="java">class Person implements Serializable
{
static final long serialVersionUID = 42L;//可以自定義序列號UID，防止對象修改後反序列化過程中無法返回對象。
String name=null;
String age=null;
Person(String name,String age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name+":"+age;
}
}管道流
一、功能定義輸入輸出可以直接進行連接，通過結合現成使用
使用PipedInputStream 和PipedOutputStream類來實現
1.管道輸入流應該連接到管道輸出流；管道輸入流提供要寫入管道輸出流的所有數據字節。
2.通常，數據由某個線程從
PipedInputStream 對象讀取，並由其他線程將其寫入到相應的 PipedOutputStream。不建議對這兩個對象嘗試使用單個線程，因爲這樣可能死鎖線程。二、代碼
import java.io.*;
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
PipedInputStream in=new PipedInputStream();
PipedOutputStream out=new PipedOutputStream();
in.connect(out);
Read r=new Read(in);
Write w=new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in=in;
}
public void run()
{
try
{
byte[] buf=new byte[1024];
int len=in.read(buf);
String s=new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道讀取失敗");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out=out;
}
public void run()
{
try
{
out.write("piped lai la".getBytes());
out.close();
}
catch (IOException e)
{
throw new RuntimeException("管道寫入失敗");
}
}
}RandomAccessFile
一、功能定義
1.此類的實例支持對隨機訪問文件的讀取和寫入。
2.隨機訪問文件的行爲類似存儲在文件系統中的一個大型 byte 數組。（即內部封裝了一個數組，可以通過指針位置來對數組元素進行操作）
3.存在指向該隱含數組的光標或索引，稱爲文件指針；輸入操作從文件指針開始讀取字節，並隨着對字節的讀取而前移此文件指針。
4.如果隨機訪問文件以讀取/寫入模式創建，則輸出操作也可用；輸出操作從文件指針開始寫入字節，並隨着對字節的寫入而前移此文件指針。
5.該文件指針可以通過
getFilePointer 方法讀取，並通過 seek 方法設置。 6.通過構造方法可以看出，該類只能操作文件
7.如果模式爲r，那麼則會去讀取一個文件，如果這個文件不存在，那麼就會報異常。
8.如果模式爲rw，那麼如果文件不存在，則會去自動創建；如果文件存在，則不會覆蓋
9.可以實現數據的分段寫入（即一個線程負責一段數據來進行寫入——下載軟件的原理）
完成讀寫的原理——內部封裝了字節輸入流和字節輸出流。
二、方法
1.mode 參數指定用以打開文件的訪問模式。
| "r" | 以只讀方式打開。調用結果對象的任何 write 方法都將導致拋出
IOException。 |
| "rw" | 打開以便讀取和寫入。如果該文件尚不存在，則嘗試創建該文件。 |
| "rws" | 打開以便讀取和寫入，對於 "rw"，還要求對文件的內容或元數據的每個更新都同步寫入到底層存儲設備。 |
| "rwd" | 打開以便讀取和寫入，對於 "rw"，還要求對文件內容的每個更新都同步寫入到底層存儲設備。 |
2.設置到此文件開頭測量到的文件指針偏移量，在該位置發生下一個讀取或寫入操作。
void
seek(long pos)
3.向此文件寫入指定的字節。void
write(int b)
4.按四個字節將 int 寫入該文件，先寫高字節。void writeInt(int v)import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//Write();
//Read();
Write2();
}
public static void Write() throws IOException
{
RandomAccessFile raf=new RandomAccessFile("random.txt","rw");
raf.write("趙四".getBytes());
raf.writeInt(97);//write()方法只保留最低8位，所以會造成數據丟失。所以使用writeInt()方法來寫入int類型數據。
raf.write("老七".getBytes());
raf.writeInt(95);
raf.close();
}
public static void Read() throws IOException
{
RandomAccessFile raf=new RandomAccessFile("random.txt","r");
raf.seek(8);//如果想直接取老七的數據，那麼設定指針爲8。因爲趙四和年齡的數據佔8個字節
//raf.skipBytes(8) 只能往前跳，不能往後跳————指針跳過指定的字節數
byte[] buf=new byte[4];
raf.read(buf);
String name=new String(buf);
int age=raf.readInt();
System.out.println(name+"..."+age);
}
public static void Write2() throws IOException//隨機位置寫入數據。不同於流，流需要按照順序寫入
{
RandomAccessFile raf=new RandomAccessFile("random.txt","rw");
raf.seek(8*3);//如果設置8*0，那麼就會用王五來覆蓋趙四的數據。
raf.write("王五".getBytes());
raf.writeInt(99);
}
}
DataStream
一、功能定義DataStreamDataOutputStream 和 DataInputStream1.數據輸出流允許應用程序以適當方式將基本 Java 數據類型寫入輸出流中。
2.不同於ObjectStream是處理對象，DataStream是專門用來處理基本數據類型的。
二、方法
1.創建一個新的數據輸出流，將數據寫入指定基礎輸出流。
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args) throws IOException
{
writeData();
}
public static void writeData() throws IOException
{
DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543);
dos.close();
}
public static void readData() throws IOException
{
DataInputStream dis=new DataInputStream(new FileInputStream("data.txt"));
int num=dis.readInt();
boolean b=dis.readBoolean();
double d=dis.readDouble();
dis.close();
}
}ByteArrayStream
一、功能定義
——用流的思想來操作數組
相似的類有——CharArrayReader和CharArrayWriter StringReader和StringWriter
二、代碼
import java.io.*;
class ByteStreamDemo
{
public static void main(String[] args)
{
ByteArrayInputStream bsis=new ByteArrayInputStream("ABCDEF".getBytes());
ByteArrayOutputStream baos=new ByteArrayOutputStream();
int by=0;
while((by=bsis.read())!=-1)
{
baos.write(by);
}
System.out.println(baos.size());
System.out.println(baos.toString());
}
}