IO-字符流、字節流

原創 程序员_菜鸟 2020-07-01 21:55
一、概述
 
1、IO流：即InputOutput的縮寫。
2、特點：
        1）IO流用來處理設備間的數據傳輸。
        2）Java對數據的操作是通過流的方式。
        3）Java用於操作流的對象都在IO包中。
        4）流按操作數據分爲兩種：字節流和字符流。
        5）流按流向分爲：輸入流和輸出流。
注意：流只能操作數據，而不能操作文件。字符流只用於處理文字數據，而字節流可以處理任何數據。
3、IO流的常用基類：
        1）字節流的抽象基流：InputStream和OutputStream
        2）字符流的抽象基流：Reader和Writer
注：此四個類派生出來的子類 名稱都是以父類名作爲子類名的後綴，以前綴爲其功能；如InputStream子類FileInputStream；Reader子類FileReader
 
二、字符流
 
字符流：
Reader
  |--FileReader
  |--BufferedReader
|-- LineNumberReader
Writer
  |--FileWriter
  |--BufferedWriter
 
1、文件的讀寫：FileWriter&FileReader
 
    文件的寫入：FileWriter
    步驟：
        a、創建一個文件寫入流FileWriter對象，該對象一被初始化，就必須要明確被操作的文件。且該目錄下如果已有同名文件，則同名文件將被覆蓋。其實該步就是在明確數據要存放的目的地。
        b、調用write(String s)方法，將字符串寫入到流中。
        c、調用flush()方法，刷新該流的緩衝，將數據刷新到目的地中。
        d、調用close()方法，關閉流資源。但是關閉前會刷新一次內部的緩衝數據，並將數據刷新到目的地中。
        close()和flush()區別： flush()刷新後，流可以繼續使用；而close()刷新後，將會關閉流，不可再寫入字符流。
 
    文件的續寫：傳遞一個true參數，代表不覆蓋已有的文件。並在已有文件的末尾處進行數據續寫。
    代碼示例：
import java.io.*;
classFileWriterDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
//創建一個FileWriter對象，該對象一被初始化，就必須要明確被操作的文件。
//而且該文件會被創建到指定目錄下。如果該目錄下如果已有同名文件，將被覆蓋。
//其實該步就是在明確數據要存放的目的地。
FileWriter fw =newFileWriter("demo.txt");
 
//調用write方法，將字符串寫入到流中。
		fw.write("abcde");
 
//刷新流對象中緩衝中的數據，將數據刷新到目的地中。
		fw.flush();
 
//關閉流資源。但是關閉前會刷新一次內部的緩衝數據，並將數據刷新到目的地中。
//close()和flush()區別：flush刷新後，流可以繼續使用；而close刷新後，將會關閉流。
 
		fw.close();
//fw.write("gkjfkmk");
//傳遞一個true參數，代表不覆蓋已有的文件。並在已有文件的末尾處進行數據續寫。
FileWriter fw1 =newFileWriter("demo.txt",true);
//windows系統中的文件內換行用\r\n兩個轉義字符表示，在linux系統中只用\n表示換行
		fw1.write("\r\nnishishui");
 
		fw1.close();
 
}
}
 
    文件的讀取：FileReader
    步驟：
        a、創建一個文件讀取流FileReader對象，和指定名稱的文件相關聯。要保證該文件已經存在，若不存在，將會發生異常FileNotFoundException。
        b、調用讀取流對象的read()方法。read()：一次讀一個字符，且會繼續往下讀。
              第一種方式：讀取單個字符。read()：一次讀一個字符，且會繼續往下讀。
              第二種方式：通過字符數組進行讀取。定義一個字符數組。用於存儲讀到的字符。該read(char[])返回的是讀到的字符個數。
        c、讀取後要調用close方法將流資源關閉。
    代碼示例：
import java.io.*;
classFileReaderDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
 
//創建一個文件讀取流對象，和指定名稱的文件相關聯。
//要保證該文件已經存在，若不存在，將會發生異常FileNotFoundException。
FileReader fr =newFileReader("demo.txt");
 
//read_1(fr);
		read_2(fr);
		fr.close();
}
publicstaticvoid read_1(FileReader fr)throwsIOException
{
//調用讀取流對象的read()方法。read()：一次讀一個字符，且會繼續往下讀。
int ch =0;
while((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
}
publicstaticvoid read_2(FileReader fr)throwsIOException
{
//定義一個字符數組。用於存儲讀到的字符。
//該read(char[])返回的是讀到的字符個數。
char[] buf =newchar[1024];
int num =0;
while((num=fr.read(buf))!=-1)
{
System.out.println(newString(buf,0,num));
}
}
}
 
    IO異常處理：IO一定要寫finally，因爲要關閉流。
    代碼示例：
import java.io.*;
classFileWriterDemo1
{
publicstaticvoid main(String[] args)
{
FileWriter fw =null;
try
{
			fw =newFileWriter("demo.txt");
			fw.write("abcdefgh");
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(fw!=null)
					fw.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
例：將c盤一個文本文件複製到d盤。
/*
將c盤一個文本文件複製到d盤。
複製的原理：其實就是將c盤下的文件數據存儲到d盤的一個文件中。
步驟： 
1、在d盤創建一個文件。用於存儲c盤文件中的數據。 
2、定義讀取流和c盤文件關聯。 
3、通過不斷的讀寫完成數據存儲。 
4、關閉資源。
*/
import java.io.*;
classCopyText
{
publicstaticvoid main(String[] args)
{
		copy_2();
}
publicstaticvoid copy_2()
{
FileWriter fw =null;
FileReader fr =null;
 
try
{
			fw =newFileWriter("D:\\CopyText.txt");
			fr =newFileReader("C:\\CopyText.java");
 
char[] buf =newchar[1024];
int len =0;
while((len=fr.read(buf))!=-1)
{
				fw.write(buf,0,len);
}
}
catch(IOException e)
{
thrownewRuntimeException("讀寫失敗");
}
finally
{
if(fr!=null)
try
{
					fr.close();
}
catch(IOException e)
{
thrownewRuntimeException("讀關閉失敗");
}
if(fw!=null)
try
{
					fw.close();
}
catch(IOException e)
{
thrownewRuntimeException("寫關閉失敗");
}
}
}
 
//從C盤讀一個字符，就往D盤寫一個字符。
publicstaticvoid copy_1()throwsIOException
{
//創建目的地。
FileWriter fw =newFileWriter("D:\\CopyText.txt");
 
//與已有文件關聯。
FileReader fr =newFileReader("C:\\CopyText.java");
 
int ch =0;
while((ch=fr.read())!=-1)
{
			fw.write(ch);
}
		fw.close();
		fr.close();
}
}
 
2、字符流的緩衝區：BufferedWriter&BufferedReader
    緩衝區的出現：提高了流的讀寫效率，所以在緩衝區創建前，要先創建流對象。即先將流對象初始化到構造函數中。 
    緩衝技術原理：此對象中封裝了數組，將數據存入，再一次性取出。
 
    寫入流緩衝區：BufferedWriter
    步驟：
        a、創建一個字符寫入流對象。
             如：FileWriter fw=newFileWriter("buf.txt");
        b、爲了提高字符寫入流效率。加入緩衝技術。只要將需要被提高效率的流對象作爲參數傳遞給緩衝區的構造函數即可。
             如： BufferedWriter bufw =new BufferedWriter(fw);
        c、調用write方法寫入數據到指定文件
         如：bufw.write("adfg");
         記住，只要用到緩衝區，就要記得刷新。（關閉流同樣會刷新，但爲了排除意外事故，保證數據存在，建議寫入一次就刷新一次）
         如：bufw.flush();
        d、其實關閉緩衝區，就是在關閉緩衝區中的流對象。
         如： bufw.close();
        
        BufferedWriter緩衝區中提供了一個跨平臺的換行符：newLine();可以在不同操作系統上調用，用作數據換行。如：bufw.newLine();
    代碼示例：
/*
緩衝區的出現是爲了提高流的操作效率，所以在創建緩衝區之前，必須先有流對象。
該緩衝區中提供了一個跨平臺的換行符 newLine();
*/
import java.io.*;
classBufferWriterDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
//創建一個字符寫入流對象。
FileWriter fw =newFileWriter("buf.txt");
//爲了提高字符寫入流效率。加入了緩衝技術。
//只要將需要被提高效率的流對象作爲參數傳遞給緩衝區的構造函數即可。
BufferedWriter bw =newBufferedWriter(fw);
 
for(int x=0; x<5; x++)
{
			bw.write("abcd"+x);
			bw.newLine();
			bw.flush();
}
//記住，只要用到緩衝區，就要記得刷新。
//其實關閉緩衝區就是在關閉緩衝區中的流對象。
		bw.close();
}
}
  
    讀取流緩衝區：BufferedReader
    步驟：
        a、創建一個讀取流對象和文件相關聯
        如： FileReader fr=newFileReader("buf.txt");
        b、爲了提高效率。加入緩衝技術。將字符讀取流對象作爲參數傳遞給緩衝區對象的構造函數。
            如： BufferedReader bufr=new BufferedReader(fr);
       c、調用該緩衝區提供的readLine方法一行一行讀取,如果到達文件末尾，則返回null
            如： String s=bufr.readLine();
       d、關閉流資源
            如： bufr.close();
        該緩衝區提供了一個一次讀一行的方法readLine，方便於堆文本數據的獲取，當返回null時表示讀到文件末尾。
        readLine方法返回的時候，只返回回車符之前的數據內容。並不返回回車符。
        readLine方法原理：
        無論是讀一行。或者讀取多個字符。其實最終都是在在硬盤上一個一個讀取。所以最終使用的還是read方法一次讀一個的方法。
    代碼示例：
/*
字符流讀取緩衝區：
該緩衝區提供了一個一次讀一行的方法 readLine();方便於對文本數據的獲取。
當返回null時，表示讀到文件末尾。
注意：readLine()方法只返回回車符之前的數據內容，並不返回回車符。
*/
import java.io.*;
classBufferReaderDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
//創建一個字符讀取流對象和文件相關聯。
FileReader fr =newFileReader("buf.txt");
//爲了提高字符讀取流效率。加入了緩衝技術。
//只要將需要被提高效率的流對象作爲參數傳遞給緩衝區的構造函數即可。
BufferedReader br =newBufferedReader(fr);
 
String line =null;
while((line=br.readLine())!=null)
{
System.out.println(line);
}
		br.close();
}
}
例：通過緩衝區複製文件
/*
通過緩衝區複製文件
*/
import java.io.*;
classCopyTextByBuf
{
publicstaticvoid main(String[] args)
{
BufferedWriter bw =null;
BufferedReader br =null;
try
{
			bw =newBufferedWriter(newFileWriter("d:\\CopyTextByBuf.txt"));
			br =newBufferedReader(newFileReader("CopyText.java"));
 
String line =null;
while((line=br.readLine())!=null)
{
				bw.write(line);
				bw.newLine();
				bw.flush();
}
}
catch(IOException e)
{
thrownewRuntimeException("讀寫失敗");
}
finally
{
if(br!=null)
try
{
					br.close();
}
catch(IOException e)
{
thrownewRuntimeException("讀關閉失敗");
}
if(bw!=null)
try
{
					bw.close();
}
catch(IOException e)
{
thrownewRuntimeException("寫關閉失敗");
}
}
}
}
 
3、LineNumberReader
    在BufferedReader中有個直接的子類LineNumberReader，其中有特有的方法獲取和設置行號：
    setLineNumber();//設置初始行號
    getLineNumber();//獲取行號
代碼示例：
import java.io.*;
classLineNumberReaderDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
FileReader fr =newFileReader("buf.txt");
LineNumberReader lnr =newLineNumberReader(fr);
 
String line =null;
		lnr.setLineNumber(10);//設置初始行號
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);//獲取行號
}
		lnr.close();
}
}
 
4、裝飾設計模式：
當想要對已有的對象進行功能增強時
可以定義類，將已有對象傳入，基於已有對象的功能，提供加強功能。
那麼自定義的該類稱爲裝飾類.
 
裝飾類通常都會通過構造方法接收被裝飾的對象.
並基於被裝飾的對象的功能，提供更強的功能。
 
裝飾和繼承的區別：
        1）裝飾模式比繼承要靈活。避免了繼承體系的臃腫，且降低了類與類之間的關係。
        2）裝飾類因爲增強已有對象，具備的功能和已有的是相同的，只不過提供了更強的功能，所以裝飾類和被裝飾的類通常都是屬於一個體系。
 
集成體系：
MyReader
    |--MyTextReader
       |--MyBufferTextReader
|--MyMediaReader
       |--MyBufferMediaReader
|--MyDataReader
       |--MyBufferDataReader
裝飾繼承體系：
MyReader
    |--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
 
例：模擬BufferReader
//模擬BufferReader
import java.io.*;
classMyBufferReaderextendsReader
{
privateReader r;
MyBufferReader(Reader r)
{
this.r = r;
}
//可以一次讀一行數據的方法。
publicString myReadLine()throwsIOException
{
//定義一個臨時容器。原BufferReader封裝的是字符數組。
//爲了演示方便。定義一個StringBuilder容器。因爲最終還是要將數據變成字符串。
StringBuilder sb =newStringBuilder();
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();
returnnull;
}
//覆蓋Reader類中的抽象方法。
publicint read(char[] cbuf,int off,int len)throwsIOException
{
return r.read(cbuf,off,len);
}
publicvoid close()throwsIOException
{
		r.close();
}
publicvoid myClose()throwsIOException
{
		r.close();
}
}
 
classMyBufferReaderDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
FileReader fr =newFileReader("buf.txt");
MyBufferReader myBuf =newMyBufferReader(fr);
 
String line =null;
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}
		myBuf.myClose();
}
}
例：模擬LineNumberReader
import java.io.*;
classMyLineNumberReaderextendsMyBufferReader
{
privateint lineNumber;
MyLineNumberReader(Reader r)
{
super(r);
}
publicString myReadLine()throwsIOException
{
		lineNumber++;
returnsuper.myReadLine();
}
publicvoid setLineNumber(int lineNumber)
{
this.lineNumber = lineNumber;
}
publicint getLineNumber()
{
return lineNumber;
}
}
 
classMyLineNumberReaderDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
FileReader fr =newFileReader("buf.txt");
MyLineNumberReader lnr =newMyLineNumberReader(fr);
 
String line =null;
		lnr.setLineNumber(10);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}
		lnr.MyClose();
}
}<span style="font-family: 'Microsoft YaHei'; color: rgb(190, 190, 197);"> </span>
 
三、字節流
字節流：
InputStream  
        |--FileInputStream
        |--BufferedInputStream
OutputStream  
        |--FileOutputStream 
        |--BufferedOutputStreambout
 
1、文件讀寫：
代碼示例：
import java.io.*;
classFileStream
{
publicstaticvoid main(String[] args)throwsIOException
{
		readFile_3();
}
 
publicstaticvoid readFile_3()throwsIOException
{
FileInputStream fis =newFileInputStream("fos.txt");
 
byte[] buf =newbyte[fis.available()];//定義一個剛剛好的緩衝區，不用循環了。
//不過不建議使用，文件過大時，此數組長度所佔內存空間就會溢出。
		fis.read(buf);
 
System.out.println(newString(buf));
		fis.close();
}
 
publicstaticvoid readFile_2()throwsIOException
{
FileInputStream fis =newFileInputStream("fos.txt");
 
byte[] buf =newbyte[1024];
int len =0;
while((len=fis.read(buf))!=-1)
{
System.out.println(newString(buf,0,len));
}
		fis.close();
}
 
publicstaticvoid readFile_1()throwsIOException
{
FileInputStream fis =newFileInputStream("fos.txt");
 
int ch =0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
		fis.close();
}
 
publicstaticvoid writeFile()throwsIOException
{
FileOutputStream fos =newFileOutputStream("fos.txt");
		fos.write("abcde".getBytes());
//不需要刷新操作。
		fos.close();
}
}
例：複製圖片
import java.io.*;
classCopyPic
{
publicstaticvoid main(String[] args)
{
FileOutputStream fos =null;
FileInputStream fis =null;
try
{
			fos =newFileOutputStream("D:\\2.JPG");
			fis =newFileInputStream("D:\\1.JPG");
 
byte[] buf =newbyte[1024];
int len =0;
while((len=fis.read(buf))!=-1)
{
				fos.write(buf,0,len);
}
}
catch(IOException e)
{
thrownewRuntimeException("複製失敗"+ e.toString());
}
finally
{
if(fis!=null)
try
{
					fis.close();
}
catch(IOException e)
{
thrownewRuntimeException("讀關閉失敗");
}
if(fos!=null)
try
{
					fos.close();
}
catch(IOException e)
{
thrownewRuntimeException("寫關閉失敗");
}
}
}
}
2、字節流緩衝區：
代碼示例：
import java.io.*;
 
classBufferStream
{
publicstaticvoid main(String[] args)throwsIOException
{
long start =System.currentTimeMillis();
		copy_2();
long end =System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
 
}
 
publicstaticvoid copy_1()throwsIOException
{
MyBufferedInputStream  bis =newMyBufferedInputStream(newFileInputStream("D:\\1.JPG"));
BufferedOutputStream  bos =newBufferedOutputStream(newFileOutputStream("D:\\2.JPG"));
 
int b =0;
while((b=bis.myRead())!=-1)
{
			bos.write(b);
}
		bos.close();
		bis.myClose();
}
 
publicstaticvoid copy_2()throwsIOException
{
BufferedInputStream  bis =newBufferedInputStream(newFileInputStream("D:\\1.JPG"));
BufferedOutputStream  bos =newBufferedOutputStream(newFileOutputStream("D:\\2.JPG"));
 
int b =0;
while((b=bis.read())!=-1)
{
			bos.write(b);
}
		bos.close();
		bis.close();
}
 
}
 
3、自定義BufferedInputStream 
    read()：會將字節byte型值提升爲int型值
    write()：會將int型強轉爲byte型，即保留二進制數的最後八位。
import java.io.*;
classMyBufferedInputStream
{
privateInputStream in;
privatebyte[] buf =newbyte[1024];
privateint pos =0,count =0;
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
//一次讀一個字節，從緩衝區(字節數組)獲取。
publicint myRead()throwsIOException
{
//通過in對象讀取硬盤上數據，並存在buf中。
if(count==0)
{
			count = in.read(buf);
if(count<0)
return-1;
			pos =0;
byte b = buf[pos];
			count--;
			pos++;
return b&255;
}
elseif(count>0)
{
byte b = buf[pos];
			count--;
			pos++;
return b&0xff;
}
return-1;
}
publicvoid myClose()throwsIOException
{
		in.close();
}
}
 
 
四、流操作規律
 
1、轉換流
Reader
    |--InputStreamReader：是字節流通向字符流的橋樑
Writer
    |--OutputStreamWriter：是字符流通向字節流的橋樑
代碼示例：
import java.io.*;
classTransStreamDemo
{
publicstaticvoid main(String[] args)throwsIOException
{
		transStream();
}
 
/*
	讀取鍵盤錄入
	System.out:對應的標準輸出設備：控制檯
	System.in:對應的標準輸入設備：鍵盤
 
	需求：
	通過鍵盤錄入數據
	當錄入一行數據後，就將該行數據進行打印。
	如果錄入的數據是over，那麼停止錄入。
	*/
publicstaticvoid readIn()throwsIOException
{
InputStream in =System.in;
StringBuilder sb =newStringBuilder();
while(true)
{
int ch = in.read();
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);
}
}
 
/*
		通過剛纔的鍵盤錄入一行數據並打印其大寫，發現其實就是讀一行數據的原理。
		也就是readLine方法。
 
		能不能直接使用readLine方法來完成鍵盤錄入的一行數據的讀取呢？
 
		readLine方法是字符流BufferedReader類中方法。
 
		而鍵盤錄入的read方法是字節流InputStream的方法。
 
        那麼能不能將字節流轉成字符流再使用字符流緩衝區的readLine方法呢？
		*/
publicstaticvoid transStream()throwsIOException
{
/*//獲取鍵盤錄入對象。
 
		InputStream in = System.in;
		//將字節流對象轉成字符流對象，使用轉換流。InputStreamReader
		InputStreamReader isr = new InputStreamReader(in);
 
		//爲了提高效率，將字符串進行緩衝區技術高效操作。使用BufferedReader
		BufferedReader br = new BufferedReader(isr);
		*/
//鍵盤的最常見寫法
BufferedReader br =newBufferedReader(newInputStreamReader(System.in));
 
/*
		OutputStream out = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(out);
		BufferedWriter bw = new BufferedWriter(osw);
		*/
BufferedWriter bw =newBufferedWriter(newOutputStreamWriter(System.out););
 
 
String line =null;
 
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
//System.out.println(line.toUpperCase());
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
}
		br.close();
}
}
 
2、流操作規律
a   明確源和目的。
源：輸入流。InputStream  Reader
目的：輸出流。OutputStream  Writer
b   操作的數據是否是純文本。
是：字符流
否：字節流
c   當體系明確後，再明確要使用哪個具體的對象。通過設備來進行區分：
源設備：內存，硬盤，鍵盤
目的設備：內存，硬盤，控制檯
代碼示例：
/*
 需求：將鍵盤錄入的數據按照指定編碼表UTF-8保存到一個文件中。
        1）源：InputStream和Reader
           是不是純文本？是，Reader
           設備：鍵盤。對應的對象是System.in。
		   既然明確了Reader，那麼就將System.in轉換成Reader。用Reader體系中轉換流,InputStreamReader
           InputStreamReaderisr = new InputStreamReader(System.in);
           需要提高效率嗎？需要，BufferedReader
           BufferedReader br = new BufferedReader(isr);
		2）目的：OutputStream  Writer
           是否是存文本？是！Writer。
           設備：硬盤。一個文件。使用 FileWriter。但是FileWriter是使用的默認編碼表：GBK。
		   而存儲時，需要加入指定編碼表utf-8。而指定的編碼表只有轉換流可以指定。所以要使用的對象是OutputStreamWriter。
		   OutputStreamWriter要接收一個字節輸出流，而且還可以操作的文件的字節輸出流：FileOutputStream
		   OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
           需要提高效率嗎？需要。
           BufferedWriter bufw = new BufferedWriter(osw);
*/
import java.io.*;
class  UTF
{
publicstaticvoid main(String[] args)throwsIOException
{
//鍵盤錄入
BufferedReader br =newBufferedReader(newInputStreamReader(System.in));
 
//按照指定編碼表UTF-8存入文件中
BufferedWriter bw =newBufferedWriter(newOutputStreamWriter(newFileOutputStream("utf.txt"),"UTF-8"));
 
 
String line =null;
 
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
//System.out.println(line.toUpperCase());
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
}
		br.close();
}
}
 
3、改變標準輸入輸出設備
        System.setIn(InputStream in);
        System.setOut(PrintStream out);
通過System類的setIn，setOut方法可以對默認設備進行改變
    
4、異常的日誌信息
    當程序在執行的時候，出現的問題是不希望直接打印給用戶看的，是需要作爲文件存儲起來，方便程序員查看，並及時調整的。
import java.io.*;
import java.util.*;
import java.text.*;
classExceptionInfo
{
publicstaticvoid main(String[] args)throwsIOException
{
try
{
int[] arr =newint[2];
System.out.println(arr[3]);
}
catch(Exception e)
{
Date d =newDate();
SimpleDateFormat sdf =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
 
PrintStream ps =newPrintStream("exception.log");
			ps.println(s);
System.setOut(ps);
			e.printStackTrace(System.out);
}
}
}
 
5、系統信息
import java.io.*;
import java.util.*;
classSystemInfo
{
publicstaticvoid main(String[] args)throwsIOException
{
Properties prop =System.getProperties();
//Systen.out.println(prop);
		prop.list(newPrintStream("systeminfo.txt"));
}
}
 

 

    
    
      
 
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

springboot啓動配置文件加載過程

new SpringApplication(primarySources).run(args); public SpringApplication(ResourceLoader resourceLoader, Class<?>... pri

原創 2024-05-12 10:56:20

通義靈碼企業版正式發佈，滿足企業私域知識檢索、數據合規、統一管理等需求

5 月 9 日阿里雲 AI 峯會，阿里雲智能集團首席技術官周靖人宣佈，通義靈碼企業版正式發佈，滿足企業用戶的定製化需求，幫助企業提升研發效率。 通義靈碼是國內用戶規模第一的智能編碼助手，基於 SOTA 水準的通義千問代碼模型 Code-Qw

原創 2024-05-11 21:15:01

Java程序員5面阿里終獲offer，感慨：原來阿里面試這麼嚴

    坊間傳言的阿里P6招聘需求   感覺面試還是主要圍繞簡歷來問的，所以不熟悉的東西最好不要隨便寫上去。項目和基礎都很重要，項目中最好有難點，能夠體現自己解決問題的過程和思路。   電話面： 自我介紹 事務的特性 ACID ，

原創 2024-05-11 14:54:29

arthas診斷工具使用記錄

下載  curl -O https://arthas.aliyun.com/arthas-boot.jar 啓動指定隨機端口  java -jar arthas-boot.jar --telnet-port 9991 --http-port

原創 2024-05-10 15:54:03

一招MAX降低10倍，現在它是我的了| 京東零售技術團隊

一.背景 性能優化是一場永無止境的旅程。 到家門店系統，作爲到家核心基礎服務之一，門店C端接口有着調用量高，性能要求高的特點。 C端服務經過演進，核心接口先查詢本地緩存，如果本地緩存沒有命中，再查詢Redis。本地緩存命中率99%，服務性能

原創 2024-05-10 12:41:31

深入理解分佈式鎖：原理、應用與挑戰| 京東物流技術團隊

前言 在單機環境中，我們主要通過線程間的加鎖機制來確保同一時間只有一個線程能夠訪問某個共享資源或執行某個關鍵代碼塊，從而防止各種併發修改異常。例如，在Java中提供了synchronized/Lock。但是在分佈式環境中，這種線程間的鎖機制

原創 2024-05-10 00:30:02

【開啓報名】同學看過來，Apache DolphinScheduler開源之夏課題任務正式發佈！

如果你還擁有着一張有效的“學生證”，在這個充滿機遇的夏天，我們誠邀你加入一個充滿挑戰和機遇的開源冒險——開源之夏。 這不僅是一個簡單的編程開發活動，假如你成功參加並結項之後，還能獲得中科院軟件所官方頒發的證書和獎金，簡直太有趣啦！ Apa

原創 2024-05-09 11:55:30

關於Java Chassis 3的契約優先（API First）開發

本文分享自華爲雲社區《Java Chassis 3技術解密：契約優先（API First）開發》，作者： liubao68。 契約優先（API First）開發是指應用程序開發過程中，將API設計作爲第一優先級的任務。契約優先開發隨着Web

原創 2024-05-09 11:21:06

「Java開發指南」如何用MyEclipse搭建GWT 2.1和Spring？（一）

本教程將指導您如何生成一個可運行的Google Web Toolkit (GWT) 2.1和Spring應用程序，該應用程序爲域模型實現了CRUD應用程序模式。在本教程中，您將學習如何： 安裝Google Eclipse插件 爲GWT配置

原創 2024-05-08 11:36:35

眼看他搭中臺，眼看他又拆了

曾幾何時，中臺一度被當做“變革靈藥”，嫁接在“前臺作戰單元”和“後臺資源部門”之間，實現企業各業務線的“打通”和全域業務能力集成，提高開發和服務效率。但在中臺如火如荼之際，我們可以發現各大企業又在反其道而行，紛紛不斷進行“拆中臺”，那

原創 2024-05-08 11:12:05

Java中止線程的方式

正常運行結束 程序運行結束，線程自動結束。 使用退出標誌退出線程 一般 run()方法執行完，線程就會正常結束，但是，有些線程是伺服線程。它們需要長時間的運行，只有在外部某些條件滿足的情況下，才能關閉這些線程。使用一個變量來控制循環

原創 2024-05-07 23:34:59

AI 001 號員工通義靈碼入職阿里雲丨阿里云云原生 4 月產品月報

雲原生月度動態 雲原生是企業數字創新的最短路徑。 《阿里云云原生每月動態》，從趨勢熱點、產品新功能、服務客戶、開源與開發者動態等方面，爲企業提供數字化的路徑與指南。 趨勢熱點 🥇 Cloud Native Day - Indonesia 成

原創 2024-05-07 21:12:05

頻繁FullGC線上問題排查

一、問題 近期頻繁收到關於FullGC的告警 二、基礎知識介紹 2.1 Java內存結構 目前系統使用的是ParNewGC、CMS垃圾回收，此時的1.8JDK內存模型如下： 注意大對象可以直接放到老年代中，可以通過-XX:Pretenur

原創 2024-05-06 23:55:18

Java集合中的Map

Map是用於保存具有映射關係的數據集合，它具有雙列存儲的特點，即一次必須添加兩個元素，即一組鍵值對<Key,Value>，其中Key的值不可重複（當Key的值重複的時候，後面插入的對象會將之前插入的具有相同的Key值的對象覆蓋掉），Valu

原創 2024-05-06 11:34:11

教你用Perl實現Smgp協議

本文分享自華爲雲社區《華爲雲短信服務教你用Perl實現Smgp協議》，作者：張儉。 引言&協議概述 中國電信短消息網關協議（SMGP）是中國網通爲實現短信業務而制定的一種通信協議，全稱叫做Short Message Gateway Pro

原創 2024-05-06 10:32:43