---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity開發</a>、<a href="http://www.itheima.com"target="blank">.Net培訓</a>、期待與您交流！ ----------------------
1.IO流（概述）
字符流的兩個基類：Reader Writer
字節流的兩個基類：InputStream OutputStream
2.IO流（FileWriter）
需求：在硬盤上創建一個文件並寫入一些文字數據。
代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
//創建一個FileWriter對象。該對象一被初始化就必須要明確被操作的文件。
//而且該文件會被創建到指定目錄下。如果該目錄下已有同名文件，將被覆蓋。
//其實該步就是在明確數據要存放的目的地。
Writer w=new FileWriter("d:/a.txt");
//調用write方法，將字符串寫入到流中。
w.write("nihao");
//刷新流對象中的緩衝中的數據。
//將數據刷到目的地中。
w.flush();
//關閉流資源，但是關閉之前會刷新一次內部的緩衝中的數據。
//將數據刷到目的地中。
//和flush區別：flush刷新後，流可以繼續使用，close刷新後，會將流關閉。
w.close();
}
}3.IO流（IO異常處理方式）
IO異常處理示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
FileWriter fw=null;
try
{
fw=new FileWriter("d:/a.txt");
fw.write("aaa");
fw.flush();
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}4.IO流（文件的續寫）
FileWriter fw=new FileWriter(“Demo.txt”,true);
傳遞一個true參數，代表不覆蓋已有的文件，並在已有的文件的末尾處進行數據的續寫，如果沒有該文件，則創建。
5.IO流（文本文件讀取方式一）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
//創建一個文件讀取流對象，和指定名稱的文件相關聯。
//要保證該文件是已經存在的，如果不存在，會發生異常FileNotFoundException
FileReader fr=new FileReader("d:/a.txt");
//調用讀取流對象的read方法。
//read():一次讀一個字符。而且會自動往下讀。
int ch=0;
while((ch=fr.read())!=-1)
{
System.out.print((char)ch);
}
fr.close();
}
}6.IO流（文本文件讀取方式二）
通過字符數組進行讀取示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
FileReader fr=new FileReader("d:/a.txt");
char[] buf=new char[1024];
int n=0;
while((n=fr.read(buf))!=-1)
{
String str=new String(buf,0,n);
System.out.println(str);
}
fr.close();
}
}7.IO流（文本文件讀取練習）
讀取一個java文件到控制檯上。示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
FileReader fr=null;
try
{
fr=new FileReader("D:/Test.java");
char[] buf=new char[1024];
int num=0;
while((num=fr.read(buf))!=-1)
{
String str=new String(buf,0,num);
System.out.print(str);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(fr!=null)
fr.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}8.IO流（拷貝文本文件）
將D盤一個文本文件複製到C盤：
步驟：
1，在D盤創建一個文件。用於存儲C盤文件中的數據。
2，定義讀取流和C盤文件關聯。
3，通過不斷的讀寫完成數據存儲。
4，關閉資源。
方式1（一個一個字符的讀）代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
try
{
fr=new FileReader("d:/Test.java");
fw=new FileWriter("c:/Test.java");
int num=0;
while((num=fr.read())!=-1)
{
fw.write((char)num);
}
}
catch (IOException e)
{
throw new RuntimeException("讀寫失敗");
}
finally
{
try
{
if(fr!=null)
fr.close();
if(fw!=null)
fw.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
方式2（通過緩衝數組讀）代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
try
{
fr=new FileReader("d:/Test.java");
fw=new FileWriter("c:/Test.java");
char[] buf=new char[1024];
int num=0;
while((num=fr.read(buf))!=-1)
{
String str=new String(buf,0,num);
fw.write(str);
}
}
catch (IOException e)
{
throw new RuntimeException("讀寫失敗");
}
finally
{
try
{
if(fr!=null)
fr.close();
if(fw!=null)
fw.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}9.IO流（BufferedWriter）
緩衝區的出現是爲了提高流的操作效率而出現的。
所以在創建緩衝區之前，必須要先有流對象。
該緩衝區中提供了一個跨平臺的換行符newLine();
示例代碼：
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
//創建一個字符寫入流對象。
FileWriter fw = new FileWriter("buf.txt");
//爲了提高字符寫入流效率。加入了緩衝技術。
//只要將需要被提高效率的流對象作爲參數傳遞給緩衝區的構造函數即可。
BufferedWriter bufw = new BufferedWriter(fw);
for(int x=1; x<5; x++)
{
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
//只要用到緩衝區，就要記得刷新。
bufw.flush();
//其實關閉緩衝區，就是在關閉緩衝區中的流對象。
bufw.close();
}
}10.IO流（BufferedReader）
字符讀取流緩衝區：BufferedReader
該緩衝區提供了一個一次讀一行的方法 readLine，方便於對文本數據的獲取。
當返回null時，表示讀到文件末尾。
readLine方法返回的時候只返回回車符之前的數據內容。並不返回回車符。
示例代碼：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//創建一個讀取流對象和文件相關聯。
FileReader fr = new FileReader("buf.txt");
//爲了提高效率。加入緩衝技術。將字符讀取流對象作爲參數傳遞給緩衝對象的構造函數。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null)
{
System.out.print(line);
}
bufr.close();
}
}11.IO流（通過緩衝區複製文本文件）
自定義一個類中包含一個功能和readLine一致的方法。來模擬一下BufferedReader
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
BufferedReader br=null;
BufferedWriter bw=null;
try
{
br=new BufferedReader(new FileReader("D:/Test.java"));
bw=new BufferedWriter(new FileWriter("C:/Test1.java"));
String str=null;
while((str=br.readLine())!=null)
{
bw.write(str);
bw.newLine();
bw.flush();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(br!=null)
br.close();
if(bw!=null)
bw.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}12.IO流（MyBufferedReader）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
MyBufferedReader mbr=null;
try
{
mbr=new MyBufferedReader(new FileReader("d:/Test.java"));
String str=null;
while((str=mbr.myReadLine())!=null)
{
System.out.println(str);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(mbr!=null)
mbr.myclose();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
class MyBufferedReader
{
private Reader r=null;
public MyBufferedReader(Reader r)
{
this.r=r;
}
public String myReadLine()throws IOException
{
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=r.read())!=-1)
{
if(ch=='\r')continue;
if(ch=='\n') return sb.toString();
else sb.append((char)ch);
}
if(sb.length()!=0) return sb.toString();
return null;
}
public void myclose() throws IOException
{
r.close();
}
}13.IO流（裝飾設計模式）
裝飾設計模式：當想要對已有對象進行功能增強時，可以定義類，將已有對象傳入，基於已有的功能，並提供加強功能，那麼自定義的該類稱爲裝飾類。
裝飾類通常會通過構造方法接收被裝飾的對象。並基於被裝飾的對象的功能提供更強的功能。
BufferedReader同理。
14.IO流（LineNumberReader）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
LineNumberReader lnr=null;
try
{
lnr=new LineNumberReader(new FileReader("d:/Test.java"));
String str=null;
while((str=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+str);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(lnr!=null)
lnr.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}15.IO流（MyLineNumberReader）
模擬一個帶行號的緩衝區對象：
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
MyLineNumberReader mlr=null;
try
{
mlr=new MyLineNumberReader(new FileReader("d:/Test.java"));
String str=null;
mlr.setLineNumber(100);
while((str=mlr.myReadLine())!=null)
{
System.out.println(mlr.getLineNumber()+str);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(mlr!=null)
mlr.myclose();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
class MyLineNumberReader extends MyBufferedReader
{
private int lineNumber;
public MyLineNumberReader(Reader r)
{
super(r);
}
public String myReadLine()throws IOException
{
lineNumber++;
return super.myReadLine();
}
public int getLineNumber()
{
return this.lineNumber;
}
public void setLineNumber(int lineNumber)
{
this.lineNumber=lineNumber;
}
}
class MyBufferedReader
{
private Reader r=null;
public MyBufferedReader(Reader r)
{
this.r=r;
}
public String myReadLine()throws IOException
{
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=r.read())!=-1)
{
if(ch=='\r')continue;
if(ch=='\n') return sb.toString();
else sb.append((char)ch);
}
if(sb.length()!=0) return sb.toString();
return null;
}
public void myclose() throws IOException
{
r.close();
}
}16.IO流（字節流File讀寫操作）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
//writeFile();
//readFile1();
//readFile2();
readFile3();
}
//往硬盤上寫數據
public static void writeFile()throws IOException
{
FileOutputStream fos=new FileOutputStream("d:/a.txt");
fos.write("nihaonihao".getBytes());
fos.close();
}
//一個一個的讀
public static void readFile1() throws IOException
{
FileInputStream fis=new FileInputStream("d:/a.txt");
int ch=0;
while((ch=fis.read())!=-1)
{
System.out.print((char)ch);
}
fis.close();
}
//使用字節數組讀，建議使用這種方式
public static void readFile2() throws IOException
{
FileInputStream fis=new FileInputStream("d:/a.txt");
byte[] buf=new byte[1024];
int num=0;
while((num=fis.read(buf))!=-1)
{
String str=new String(buf,0,num);
System.out.println(str);
}
fis.close();
}
//定義一個剛剛好的緩衝區，不用循環，不建議使用
public static void readFile3()throws IOException
{
FileInputStream fis=new FileInputStream("d:/a.txt");
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
}17.IO流（拷貝圖片）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
fis=new FileInputStream("d:/Desert.jpg");
fos=new FileOutputStream("c:/Desert.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
{
try
{
if(fis!=null)
fis.close();
if(fos!=null)
fos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}18.IO流（字節流的緩衝區）
利用字節流緩衝區BufferedInputStream，BufferedOutoutStream拷貝mp3
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try
{
bis=new BufferedInputStream(new FileInputStream("d:/1.mp3"));
bos=new BufferedOutputStream(new FileOutputStream("c:/2.mp3"));
int ch=0;
while((ch=bis.read())!=-1)
{
bos.write(ch);
}
}
catch (IOException e)
{
throw new RuntimeException("failed");
}
finally
{
try
{
if(bis!=null)
bis.close();
if(bos!=null)
bos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}19.IO流（自定義字節流緩衝區）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
MyBufferedInputStream bis=null;
BufferedOutputStream bos=null;
try
{
bis=new MyBufferedInputStream(new FileInputStream("d:/1.mp3"));
bos=new BufferedOutputStream(new FileOutputStream("c:/2.mp3"));
int ch=0;
while((ch=bis.read())!=-1)
{
bos.write(ch);
}
}
catch (IOException e)
{
throw new RuntimeException("failed");
}
finally
{
try
{
if(bis!=null)
bis.close();
if(bos!=null)
bos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
class MyBufferedInputStream
{
private FileInputStream fis=null;
private int pos=0;
private int count=0;
private byte[] buf=new byte[1024];
MyBufferedInputStream(FileInputStream fis)
{
this.fis=fis;
}
public int read() throws IOException
{
if(count==0)
{
count = fis.read(buf);
if(count<0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;
}
else if(count>0)
{
byte b = buf[pos];
count--;
pos++;
return b&0xff;
}
return -1;
}
public void close() throws IOException
{
fis.close();
}
}20.IO流（讀取鍵盤錄入）
需求：通過鍵盤錄入數據，當錄入一行數據後，就對該行數據進行打印，如果錄入的數據是over的活，就停止：
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
InputStream in=System.in;
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=in.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}21.IO流（讀取轉換流）
鍵盤錄入數據代碼完善：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str=null;
while((str=br.readLine())!=null)
{
if(str.equals("over"))
break;
System.out.println(str.toUpperCase());
}
br.close();
}
}22.IO流（寫入轉換流）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
String str=null;
while((str=br.readLine())!=null)
{
if(str.equals("over"))
break;
bw.write(str.toUpperCase());
bw.newLine();
bw.flush();
}
br.close();
}
}23.IO流(流操作的規律）
流操作的基本規律：
通過三個明確來完成。
1，明確源和目的。
源：輸入流。InputStream Reader
目的：輸出流。OutputStream Writer。
2，操作的數據是否是純文本。
是：字符流。
不是：字節流。
3，當體系明確後，在明確要使用哪個具體的對象。
源設備：內存，硬盤。鍵盤
目的設備：內存，硬盤，控制檯。
4.是否需要提高效率？
是：加緩衝區
不是：不加緩衝區
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:/aa.txt"),"utf-8"));
String str=null;
while((str=br.readLine())!=null)
{
if("over".equals(str))
break;
bw.write(str);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
}
}24.IO流（改變標準輸入輸出設備）
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("Test.java"));//改變標準輸入設備
System.setOut(new PrintStream("zz.txt"));//改變標準輸出設備
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
String str=null;
while((str=br.readLine())!=null)
{
if("over".equals(str))
break;
bw.write(str);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
}
}25.IO流（異常的日誌信息）
示例代碼：
import java.io.*;
import java.util.*;
import java.text.*;
import java.io.*;
class Test
{
public static void main(String[] args)
{
try
{
int[] arr=new int[3];
System.out.println(arr[3]);
}
catch (Exception e)
{
PrintStream ps=null;
try
{
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
ps=new PrintStream("a.txt");
ps.println(sdf.format(d));
}
catch (Exception e1)
{
throw new RuntimeException("日誌文件建立失敗");
}
e.printStackTrace(ps);
}
}
}26.IO流（File概述）
File類常見方法：
1，創建。
boolean createNewFile():在指定位置創建文件，如果該文件已經存在，則不創建，返回false。和輸出流不一樣，輸出流對象一建立創建文件。而且文件已經存在，會覆蓋。
boolean mkdir():創建文件夾。
boolean mkdirs():創建多級文件夾。
2，刪除。
boolean delete()：刪除失敗返回false。如果文件正在被使用，則刪除不了返回falsel。
void deleteOnExit();在程序退出時刪除指定文件。
3，判斷。
boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4，獲取信息。
getName():
getPath():
getParent():
getAbsolutePath()
long lastModified()
long length()
renameTo()
27.IO流（File對象功能文件列表）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
//listRootDemo();
//listDemo();
//FilterDemo();
ListFIlesDemo();
}
//列出系統有效盤符
public static void listRootDemo()
{
File[] files=File.listRoots();
for(File f:files)
{
System.out.println(f);
}
}
//列出某一個目錄下所有的文件的名稱
public static void listDemo()
{
File f=new File("c:/");
String[]names=f.list();
for(String name:names)
System.out.println(name);
}
//列出指定目錄下所有的.java文件
public static void FilterDemo()
{
File dir=new File("d:/");
String[] arr=dir.list(new FilenameFilter(){
public boolean accept(File dir,String name)
{
return name.endsWith(".java");
}
});
for(String name:arr)
{
System.out.println(name);
}
}
//列出指定目錄下所有文件的文件對象
public static void ListFIlesDemo()
{
File dir=new File("c:/");
File[] files=dir.listFiles();
for(File f:files)
System.out.println(f.getName());
}
}28.IO流（列出目錄下所有內容-遞歸）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)
{
showDir(new File("c:/"));
}
//列出指定目錄下的所有目錄，包括子目錄
public static void showDir(File dir)
{
System.out.println(dir.getName())
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x]);
else
System.out.println(files[x]);
}
}
}29.IO流（列出目錄下所有的內容-帶層次）
示例代碼；
import java.io.*;
class Test
{
public static void main(String[] args)
{
showDir(new File("c:/"),0);
}
//列出指定目錄下的所有目錄，包括子目錄
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}
public static String getLevel(int level)
{
StringBuilder sb=new StringBuilder();
sb.append("|--");
for(int x=0;x<level;x++)
sb.insert(0," ");
return sb.toString();
}
}30.IO流（刪除一個帶內容的目錄）
import java.io.*;
class Test
{
public static void main(String[] args)
{
deleteDir(new File("d:/test"));
}
//列出指定目錄下的所有目錄，包括子目錄
public static void deleteDir(File dir)
{
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
deleteDir(files[x]);
else
System.out.println(files[x].delete());
}
System.out.println(dir.delete());
}
}
31.IO流（創建java文件列表）
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args)
{
File dir=new File("d:/Test");
List<File> list=new ArrayList<File>();
fileToList(dir,list);
File file=new File(dir,"javaList.txt");
writeToFile(list,file);
}
public static void fileToList(File dir,List<File> list)
{
File[] files=dir.listFiles();
for(File file:files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
public static void writeToFile(List<File> list,File javaFile)
{
BufferedWriter bw=null;
try
{
bw=new BufferedWriter(new FileWriter(javaFile));
for(File f:list)
{
String path=f.getAbsolutePath();
bw.write(path);
bw.newLine();
bw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException();
}
finally
{
try
{
if(bw!=null)
bw.close();
}
catch (Exception e)
{
throw new RuntimeException();
}
}
}
}32.IO流（Properties簡述）
Properties是Hashtable的子類，也就是說，它具備了Map集合的特點，而且它裏面存儲的鍵值對都是字符串，不需要泛型。是集合中和IO技術相結合的集合容器。
該對象的特點：可以用於鍵值對形式的配置文件。
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args)
{
Properties prop=new Properties();
prop.setProperty("zhangsan",223+"");
prop.setProperty("lisi",33+"");
Set<String> names=prop.stringPropertyNames();
for(String name:names)
{
System.out.println(name+" "+prop.getProperty(name));
}
}
}Properties存取配置文件：
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args) throws IOException
{
FileInputStream fis=new FileInputStream("d:/info.txt");
Properties prop=new Properties();
//將配置文件加載到內存中
prop.load(fis);
prop.setProperty("zhangsan",89+"");
prop.list(System.out);
FileOutputStream fos=new FileOutputStream("d:/info.txt");
//將內存中的數據保存到硬盤上
prop.store(fos,"haha");
fis.close();
fos.close();
}
} 需求：用於記錄應用程序的運行次數。
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args) throws IOException
{
File f=new File("d:infom.properties");
if(!f.exists())
{
f.createNewFile();
}
FileInputStream fis=new FileInputStream(f);
Properties prop=new Properties();
prop.load(fis);
String value=prop.getProperty("time");
if(value==null)
{
prop.setProperty("time",1+"");
}
else
prop.setProperty("time",Integer.parseInt(value)+1+"");
FileOutputStream fos=new FileOutputStream(f);
prop.store(fos,"");
fis.close();
fos.close();
}
}33.IO流（PrintWriter）
打印流：該流提供了打印方法，可以將各種數據類型的數據都原樣打印。
PrintStream：字節打印流
構造函數可以接收的參數類型
1.File對象 File
2.字符串路徑 String
3.字節輸出流 OutputStream
PrintWriter：字符打印流
構造函數可以接收的參數類型
1.File對象 File
2.字符串路徑 String
3.字節輸出流 OutputStream
4.字符輸出流 Writer
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(new FileWriter("d:/info.txt"),true);
String str=null;
while((str=br.readLine())!=null)
{
if("over".equals(str))
break;
pw.println(str.toUpperCase());
}
br.close();
pw.close();
}
}34.IO流（合併流）
序列流：SequenceInputStream將多個流合併成一個讀取流
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("d:/1.txt"));
v.add(new FileInputStream("d:/2.txt"));
v.add(new FileInputStream("d:/3.txt"));
Enumeration<FileInputStream> en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("d:/4.txt");
byte[] buf=new byte[1024];
int ch=0;
while((ch=sis.read(buf))!=-1)
{
fos.write(buf,0,ch);
}
sis.close();
fos.close();
}
}35.IO流（切割文件）
需求：切割文件，然後合併文件
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args) throws IOException
{
split();
hebin();
}
//合併流
public static void hebin() throws IOException
{
ArrayList<FileInputStream> aL=new ArrayList<FileInputStream>();
for(int x=1;x<=15;x++)
{
aL.add(new FileInputStream("d:/"+x+".part"));
}
final Iterator<FileInputStream> it=aL.iterator();
Enumeration<FileInputStream> en=new Enumeration<FileInputStream>(){
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("d:/test.bmp");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
//切割流
public static void split()throws IOException
{
FileInputStream fis=new FileInputStream("d:/1.bmp");
FileOutputStream fos=null;
byte[] buf=new byte[1024];
int len=0;
int count=1;
while((len=fis.read(buf))!=-1)
{
fos=new FileOutputStream("d:/"+count+".part");
count++;
fos.write(buf,0,len);
fos.close();
}
}
}36.IO流（對象的序列化）
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args) throws Exception
{
//writeObj();
readObj();
}
public static void writeObj()throws Exception
{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:object.txt"));
oos.writeObject(new Person("lisi",34,"kr"));
oos.close();
}
public static void readObj()throws Exception
{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:/object.txt"));
Person p=(Person)ois.readObject();
System.out.println(p);
ois.close();
}
}
class Person implements Serializable
{
public static final long serialVersionUID=42L;
String name;
transient int age;
static String country="cn";
Person(String name,int age,String country)
{
this.name=name;
this.age=age;
this.country=country;
}
public String toString()
{
return this.name+" "+this.age+" "+this.country;
}
}
注意：
1如果這個類的成員就加了一個private的話，還想使用原來的序列化對象，在定義Person類的時候，自己定義一個UID。
public static final long serialVersionUID=42L;
2 靜態不能被序列化，因爲序列化的是堆內存，而靜態的在方法區。
3如果對非靜態成員也不想進行序列化的話，那麼就加一個關鍵字修飾。
transient int age;
4一般不存成.txt文件，一般存爲.object文件。
5.ObjectInputStream和ObjectOutputStream成對使用。
37.IO流（管道流）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)throws IOException
{
PipedInputStream pis=new PipedInputStream();
PipedOutputStream pos=new PipedOutputStream();
pis.connect(pos);
new Thread(new Read(pis)).start();
new Thread(new Write(pos)).start();
}
}
class Read implements Runnable
{
private PipedInputStream in;
public Read(PipedInputStream in)
{
this.in=in;
}
public void run()
{
try
{
byte[] buf=new byte[1024];
int len=0;
while((len=in.read(buf))!=-01)
{
System.out.println(new String(buf,0,len));
}
}
catch (IOException e)
{
e.printStackTrace();
}finally
{
try
{
if(in!=null)
in.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
public Write(PipedOutputStream out)
{
this.out=out;
}
public void run()
{
try
{
try
{
Thread.sleep(6000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
out.write("pipe is coming".getBytes());
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if(out!=null)
out.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}38.IO流（RandomAccessFile)
該類不算是IO體系的子類，而是直接繼承自Object，但是IO包中的成員，因爲它具備讀和寫功能，內部封裝了一個byte數組，而且通過指針對數組中的元素進行操作，可以通過getFilePointer（）獲取指針位置，請過seek（）改變指針位置。
其實完成讀寫對的原理：內部封裝了字節數入流，字節輸出流。
通過構造函數可以看出，該類只能操作文件，而且操作文件還有模式：只讀r，讀寫rw。
如果模式爲只讀 r。不會創建文件。會去讀取一個已存在文件，如果該文件不存在，則會出現異常。
如果模式rw。操作的文件不存在，會自動創建。如果存則不會覆蓋。
示例代碼：
寫數據：
RandomAccessFile raf=new RandomAccessFile("d:/raf.txt","rw");
raf.write("張三".getBytes());
raf.writeInt(97);
raf.close();讀數據：
RandomAccessFile raf=new RandomAccessFile("d:/raf.txt","r");
byte[] buf=new byte[4];
int len=raf.read(buf);
int age=raf.readInt();
System.out.println(new String(buf,0,len)+" "+age);調整對象的指針：raf.seek(8);/
跳過指定的字節數：raf.skipBytes(8);//它不能往回走
隨機讀寫示例代碼：
RandomAccessFile raf=new RandomAccessFile("d:/raf.txt","rw");
raf.seek(8*5);
raf.write("週期".getBytes());
raf.writeInt(89);
raf.close();39.IO流（操作基本數據類型）
DataInputStream和DataOutputStream用於操作基本數據類型數據的流對象。
寫數據示例代碼：
DataOutputStream dos=new DataOutputStream(new FileOutputStream("d:/info.txt"));
dos.writeInt(123);
dos.writeBoolean(true);
dos.writeDouble(9.9);
dos.close();讀數據示例代碼：
DataInputStream dis=new DataInputStream(new FileInputStream("d:/info.txt"));
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
dis.close();注:使用DataOutputStream中的writeUTF(),只能使用DataInputStream中的readUTF()讀出來。
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)throws IOException
{
DataOutputStream dos=new DataOutputStream(new FileOutputStream("d:/info.txt"));
dos.writeUTF("你好");
dos.close();
DataInputStream dis=new DataInputStream(new FileInputStream("d:/info.txt"));
System.out.println(dis.readUTF());
dis.close();
}
}40.IO流（轉換流）
示例代碼：
import java.io.*;
class Test
{
public static void main(String[] args)throws IOException
{
//寫
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d:/gbk.txt"),"gbk");
osw.write("你好");
osw.close();
//讀
InputStreamReader isr=new InputStreamReader(new FileInputStream("d:/gbk.txt"),"gbk");
char[]buf=new char[10];
int len=isr.read(buf);
System.out.println(new String(buf,0,len));
}
}注意：如果寫數據時用的編碼表與讀時候用的編碼表不一致，則會出現亂碼。
編碼解碼示例代碼：
import java.util.*;
class Test
{
public static void main(String[] args)throws Exception
{
//編碼
String s="你好";
byte[] b1=s.getBytes("GBK");
System.out.println(Arrays.toString(b1));
//解碼
String s1=new String(b1,"GBK");
System.out.println(s1);
}
}41.IO流（練習）
有五個學生，每個學生有3門課的成績，
從鍵盤輸入以上數據（包括姓名，三門課成績），
輸入的格式：如：zhagnsan，30，40，60計算出總成績，
並把學生的信息和計算出的總分數高低順序存放在磁盤文件"stud.txt"中。
1，描述學生對象。
2，定義一個可操作學生對象的工具類。
思想：
1，通過獲取鍵盤錄入一行數據，並將該行中的信息取出封裝成學生對象。
2，因爲學生有很多，那麼就需要存儲，使用到集合。因爲要對學生的總分排序。
所以可以使用TreeSet。
3，將集合的信息寫入到一個文件中。
示例代碼：
import java.io.*;
import java.util.*;
class Test
{
public static void main(String[] args)throws Exception
{
Comparator<Student> cmp=Collections.reverseOrder();
Set<Student> stus=StudentInfoTool.getStudent(cmp);
StudentInfoTool.writeToFile(stus);
}
}
class Student implements Comparable<Student>
{
private String name;
private double english;
private double chinese;
private double math;
private double sum;
public Student(String name,double english,double chinese,double math)
{
this.name=name;
this.english=english;
this.chinese=chinese;
this.math=math;
this.sum=this.english+this.chinese+this.math;
}
public double getSum()
{
return this.sum;
}
public String getName()
{
return this.name;
}
public int hashCode()
{
return this.name.hashCode();
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("不是Student對象");
Student s=(Student)obj;
return this.getName().equals(s.getName())&&this.getSum()==s.getSum();
}
public int compareTo(Student s)
{
int num=new Double(this.getSum()).compareTo(s.getSum());
if(num==0)
return this.getName().compareTo(s.getName());
return num;
}
public String toString()
{
return this.name+" "+this.english+" "+this.chinese+" "+this.math+" "+this.sum;
}
}
class StudentInfoTool
{
public static Set<Student> getStudent(Comparator<Student> cmp)throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str=null;
Set<Student> stus=null;
if(cmp==null)
stus=new TreeSet<Student>();
else
stus=new TreeSet<Student>(cmp);
while((str=br.readLine())!=null)
{
if("over".equals(str))
break;
String []info=str.split(",");
Student stu=new Student(info[0],Double.parseDouble(info[1]),Double.parseDouble(info[2]),Double.parseDouble(info[3]));
stus.add(stu);
}
br.close();
return stus;
}
public static Set<Student> getStudent()throws IOException
{
return getStudent(null);
}
public static void writeToFile(Set<Student> stus)throws IOException
{
BufferedWriter bw=new BufferedWriter(new FileWriter("d:/stu.txt"));
for(Student stu:stus)
{
bw.write(stu.toString());
bw.newLine();
bw.flush();
}
bw.close();
}
}
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity開發</a>、<a href="http://www.itheima.com"target="blank">.Net培訓</a>、期待與您交流！ ----------------------