黑馬程序員_Java IO流(上)

IO流是用來處理設備之間的數據傳輸

Java對數據的操作是通過流的方式

Java用於操作流的對象都在IO包中

流按照操作數據分兩種：字節流和字符流

流按照流向分爲：輸入流和輸出流。

IO流常用基類

字節流的抽象基類：

InputStream ，OutputStream。

字符流的抽象基類：

Reader，Writer。

注：由這四個派生出來的子類名稱都是以其父類名作爲子類名的後綴。

如：InputStream的子類FileInputStream。

Reader的子類FileReader。

先學習一下字符流特點。

既然IO流失用於操作數據的，

那麼數據的最常見體現形式：文件。

那麼先以操作文件爲主來演示。

需求：在硬盤上創建一個文件，並寫入一些文字數據。

找到一個專門用於操作文件的Writer子類對象：FileWriter。後綴名是父類名，前綴名是該流對象的功能。

import java.io.*;
class  FileWriterDemo
{
	public static void main(String[] args) throws IOException
	{
		//創建一個FileWriter對象，該對象一被初始化就必須要明確被操作的文件。
		//而且該文件會被創建到指定的目錄下。如果該目錄下已有同名文件，將被覆蓋。
		//其實該步驟就是在明確數據要存放的目的地。
		FileWriter fw = new FileWriter("demo.txt");

		//調用write方法，將字符串寫入流中。
		fw.write("abcde");

		//刷新流對象緩衝中的數據。將數據刷到目的地中。
		fw.flush();
		
		//關閉流資源，但是關閉之前會刷新一次內部的緩衝中的數據，將數據刷到目的地中。
		fw.close();
	}
}

IO異常的處理方式。

/*
IO異常的處理方式。
*/


import java.io.*;
class FileWriterDemo2 
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt");
			fw.write("abcdefg");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null) //一定要注意判斷fw是否建立成功
					fw.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
			
		}
	}
}

演示對已有文件的數據續寫。

/*
演示對已有文件的數據續寫。
*/

import java.io.*;
class FileWriterDemo3 
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			//傳遞一個true參數，代表不覆蓋已有的文件，並在已有文件的末尾處進行數據續寫。
			fw = new FileWriter("demo.txt",true);
			fw.write("haha\r\nhehe");	//windows換行用\r\n
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)	//一定要注意判斷fw是否建立成功
					fw.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
			
		}
		
	}
}

文本文件讀取方式

import java.io.*;
class FileReaderDemo 
{
	public static void main(String[] args) throws IOException
	{
		//創建一個文件讀取流對象，和指定名稱的文件相關聯。
		//要保證該文件是已經存在的，如果不存在，會發生異常FileNotFoundException
		FileReader fr = new FileReader("demo.txt");
		
		//弟阿勇讀取流對象的read方法。
		//read():一次讀一個字符，而且會自動往下讀。
		/*
		while(true)
		{
			int ch = fr.read();
			if(ch==-1)
				break;
			System.out.println("ch="+(char)ch);
		}
		*/
		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			System.out.println((char)ch);
		}
		fr.close();
	}
}

/*
第二種方式：通過字符數組進行讀取。
*/


import java.io.*;
class FlieReaderDemo2 
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("demo.txt");
		
		//定義一個字符數組，用於存儲讀到字符。
		//該read(char[])返回的是讀到的個數。
		char[] buf = new char[1024];
		int num = 0;
		while((num=fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();
	}
}

練習：

/*
練習：讀取一個.java文件，並打印在控制檯上。
*/

import java.io.*;
class  FlieReaderTest
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("DateDemo.java");
		char[] buf = new char[1024];
		int num = 0;
		while((num=fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();
	}
}

拷貝文本文件練習：

/*
練習：將c盤中一個文件複製到d盤。

複製原理：
其實就是將c盤的文件數據存儲到d盤的一個文件中。

步驟：
1.在d盤創建一個文件，用於存儲c盤文件中的數據。
2.定義讀取流和c盤文件關聯。
3.通過不斷的讀寫完成數據存儲。
4.關閉資源。
*/


import java.io.*;
class CopyTest 
{
	public static void main(String[] args) throws IOException
	{
		copy_1();
		copy_2();
	}
	
	//從c盤讀一個字符就往d盤寫一個字符。
	public static void copy_1() throws IOException
	{
		//創建目的地。
		FileWriter fw = new FileWriter("RuntimeDemo_copy.text");
		
		//與已有文件關聯。
		FileReader fr =new FileReader("RuntimeDemo.java");

		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();

	}

	public static void copy_2()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("SystemDemo_copy.txt");
			fr = new FileReader("SystemDemo.java");
			char[] buf = new char[1024];
			int len = 0;
			while((len=fr.read(buf))!=-1)
			{
				fw.write(buf,0,len);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("讀寫失敗");
		}
		finally
		{
			if(fr!=null)
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
				}
			if(fw!=null)
				try
				{
					fw.close();
				}
				catch (IOException e)
				{
				}
		}
	}
}

字符流的緩衝區

緩衝區的出現提高了對數據的讀寫效率

對應類：

BufferedWriter

BufferedReader

緩衝區要結合流纔可以使用

在流的基礎上對流的功能進行增強

BufferedWriter

字符輸入流緩衝區：

緩衝區的出現是爲了提高流的操作效率而出現的。

所以在創建緩衝區之前，必須要先有流對象。

該緩衝區中提供了一個跨平臺的換行符：newLine().

/*
緩衝區的出現是爲了提高流的操作效率而出現的。
所以在創建緩衝區之前，必須要先有流對象。

該緩衝區中提供了一個跨平臺的換行符：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("abcde"+x);
			bufw.newLine();
			bufw.flush();
		}

		//記住，只要用到緩衝區，就要記得刷新。
		bufw.flush();

		//其實關閉緩衝區，就是在關閉緩衝區中的流對象。
		bufw.close();
	}
}

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.println(line);
		}
		//String s1 = bufr.readLine();
		bufr.close();
	}
}

通過緩衝區複製一個文本文件。

/*
通過緩衝區複製一個.java文件。
*/

import java.io.*;
class  CopyTextByBuf
{
	public static void main(String[] args) 
	{
		BufferedReader bufr = null;
		BufferedWriter bufw = null;

		try
		{
			bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
			bufw = new BufferedWriter(new FileWriter("bufferedWriterDemo.txt"));

			String line = null;

			while((line=bufr.readLine())!=null)
			{
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("讀寫失敗");
		}
		finally
		{
			try
			{
				if(bufr!=null)
					bufr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("讀取關閉失敗");
			}
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("寫入關閉失敗");
			}
		}	
	}
}

MyBufferedReader的設計

/*
自定義一個類包含一個功能和readLine一致的方法來模擬一下BufferedReader。
*/
import java.io.*;
class MyBufferedReader extends Reader
{
	private FileReader r;
	MyBufferedReader(FileReader r)
	{
		this.r = r;
	}
	//可以一次讀一行數據的方法。
	public String myReadLine()throws IOException
	{
		//定義一個臨時容器，原BufferedReader封裝的是字符數組。
		//爲了演示方便，定義一個StringBuilder容器，因爲最終還是要將數據變成字符串。
		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;
	}
	
	//覆蓋Reader類中的抽象方法。
	public void close()throws IOException
	{
		r.close();
	}
	public int read(char[] cbuf,int off,int len)throws IOException
	{
		return r.read(cbuf,off,len);
	}

	public void myClose()throws IOException
	{
		r.close();
	}
}

class MyBufferedReaderDemo 
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("buf.txt");

		MyBufferedReader myBuf = new MyBufferedReader(fr);

		String line = null;

		while((line=myBuf.myReadLine())!=null)
		{
			System.out.println(line);
		}
		myBuf.myClose();
	}
}

裝飾設計模式

當想要對已有的對象進行功能增強時，

可以定義類，將已有對象傳入，基於已有的功能，並提供加強功能。

那麼自定義的類稱爲裝飾類。

裝飾類通常會通過構造方法接收被裝飾對象，並基於被裝飾的對象的功能，提供更強的功能。

class Person
{
	public void chifan()
	{
		System.out.println("吃飯");
	}
}

class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p=p;
	}
	public void superChifan()
	{
		System.out.println("開胃酒");
		p.chifan();
		System.out.println("甜點");
	}
}

class PersonDemo 
{
	public static void main(String[] args) 
	{
		Person p = new Person();
		p.chifan();

		SuperPerson sp = new SuperPerson(p);
		sp.superChifan();
	}
}

裝飾和繼承的區別

MyReader//專門用於讀取數據的對象。

|--MyTextReader

|--MyBufferTextReader

|--MyMediaReader

|--MyBufferMediaReader

|--MyDataReader

|--MyBufferDataReader

class MyBufferReader

{

MyBufferedReader(MyTextReader text){}

MyBufferedReader(MyMediaReader Media){}

MyBufferedReader(MyDataReader Data){}

}

上面這個類擴展性很差。

找到其參數的共同類型，通過多態的形式，可以提高擴展性。

class MyBufferReader extends MyReader

{

private MyReader r;

MyBufferedReader(MyReader r){}

}

MyReader//專門用於讀取數據的對象。

|--MyTextReader

|--MyMediaReader

|--MyDataReader

|--MyBufferReader

裝飾模式比繼承要靈活，避免了繼承體系的臃腫。

而且降低了類與類之間的關係。

裝飾類因爲增強已有對象，具備的功能和已有對象是相同的，只不過提供了更強功能。

所以裝飾類和被裝飾類通常都屬於一個體系中。

LineNumberReaderDemo

import java.io.*;
class LineNumberReaderDemo 
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("PersonDemo.java");

		LineNumberReader lnr = new LineNumberReader(fr);

		String line = null;
		lnr.setLineNumber(100);
		while((line=lnr.readLine())!=null)
		{
			System.out.println(lnr.getLineNumber()+":"+line);
		}
		lnr.close();

	}
}

//練習：模擬一個帶行號的緩衝區對象。


import java.io.*;

class MyLineNumberReader
{
	private Reader r;
	private int lineNumber;
	MyLineNumberReader(Reader r)
	{
		this.r = r;
	}

	public String myReadLine()throws IOException
	{
		lineNumber++;
		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 setLineNumber(int lineNumber)
	{
		this.lineNumber = lineNumber;
	}
	public int getLineNumber()
	{
		return lineNumber;
	}

	public void myClose()throws IOException
	{
		r.close();
	}
}
class MyLineNumberReaderDemo 
{
	public static void main(String[] args) throws IOException
	{
		FileReader fr = new FileReader("copyTextByBuf.java");
		MyLineNumberReader mylnr = new MyLineNumberReader(fr);
		String line = null;
		mylnr.setLineNumber(100);
		while((line=mylnr.myReadLine())!=null)
		{
			System.out.println(mylnr.getLineNumber()+"::"+line);
		}
		mylnr.myClose();
	}
}

字節流File讀寫操作

/*
字節流：
InputStream
OutputStream

需求:想要操作圖片，這時就要用到字節流。
*/

import java.io.*;
class  FileStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		readFile();
		readFile_2();
		readFile_3();
		writeFile();
	}

	public static void readFile()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=fis.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}

	public static void readFile_2()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		int ch = 0;
		while((ch=fis.read())!=-1)
		{
			System.out.println((char)ch);
		}
		fis.close();
	}

	public static void readFile_3()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		byte[] buf = new byte[fis.available()];//定義一個剛剛好的緩衝區。不需要循環。
		fis.read(buf);
		System.out.println(new String(buf));
		fis.close();
	}

	public static void writeFile()throws IOException
	{
		FileOutputStream fos = new FileOutputStream("fos.txt");
		
		fos.write("abcde".getBytes());
		fos.close();
	}
}

練習：複製一張圖片。

/*
複製一個圖片：
思路：
1.用字節讀取流對象和圖片關聯。
2.用字節寫入流對象創建一個圖片文件，用於存儲獲取到的圖片數據。
3.通過循環讀寫，完成數據的存儲。
4.關閉資源。
*/


import java.io.*;
class CopyPic 
{
	public static void main(String[] args) 
	{
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try
		{
			fos = new FileOutputStream("c:\\2.png");
			fis = new FileInputStream("c:\\1.png");
			
			byte[] buf = new byte[1024];
			int len = 0;
			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("文件複製失敗");
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("文件讀取失敗");
			}
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("文件寫入失敗");
			}
		}
	}
}

字節流的緩衝區

/*
演示MP3的複製，通過緩衝區：
BufferedOutputStream
BUfferedInputStream
*/


import java.io.*;
class CopyMp3 
{
	public static void main(String[] args) throws IOException
	{
		long start = System.currentTimeMillis();
		copy_1();
		long end = System.currentTimeMillis();
		System.out.println((end-start)+"毫秒");
	}

	public static void copy_1()throws IOException
	{
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("f:\\KuGou\\M-Girls - 心願.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));

		int by = 0;
		while((by=bufis.read())!=-1)
		{
			bufos.write(by);
		}

		bufos.close();
		bufis.close();
	}
}

讀取鍵盤錄入

/*
讀取鍵盤錄入。
System.out:對應的是標準的輸出設備，控制檯。
System.in:對應的是標準的輸入設備，鍵盤。


需求：通過鍵盤錄入數據，當錄入一行數據後，就將該行數據進行打印，
	  如果錄入的數據是over時，那麼停止錄入。
*/


import java.io.*;
class  ReadIn
{
	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("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方法呢？

import java.io.*;
class  TransStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		//獲取鍵盤錄入對象。
		InputStream in = System.in;
		
		//將字節流對象轉換成字符流對象。
		InputStreamReader isr = new InputStreamReader(in);

		//爲了提高效率，將字符流進行緩衝區技術高效操作。
		BufferedReader bufr = new BufferedReader(isr);
		//也可以用一句代碼表示上述3句(鍵盤錄入最常用寫法)：
		//BufferedReader bufr = new BufferedReader(new InputStreamReader( System.in));

		OutputStream out = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(out);
		BufferedWriter bufw = new BufferedWriter(osw);
		//也可以用一句代碼表示上述3句：
		//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));


		String line= null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();  
		}
		bufr.close();
	}
}

流操作的基本規律：

最痛苦的就是流對象有很多，不知道該用哪一個。

通過三個明確來完成。

1.明確源和目的。

源：輸入流。InputStream Reader

目的：輸出流。OutputStream Writer

2.明確操作的數據是否是純文本。

是：字符流。

不是：字節流。

3.當體系明確後，再明確要使用哪個具體的對象。

通過設備來進行區分：

源設備：內存，硬盤，鍵盤。

目的設備：內存，硬盤，控制檯。

舉例：1.將一個文本文件中數據存儲到另一個文件中。複製文件。

源：InputStream Reader。

是不是操作文本文件：是。選擇Reader。

這樣體系就明確了。

接下來明確要使用該體系中的哪個對象。

明確設備：硬盤上一個文件。

Reader體系中可以操作文件的對象是FileReader

是否需要提高效率：是！加入Reader體系中的緩衝區 BufferedReader

FileReader fr = new FileReader(“a.txt”)

BufferedReader bufr = new BufferedReader(fr)

目的：OutPutStream Writer

是否是純文本：是：Writer。

設備：硬盤上一個文件。

可以操作Writer體系中文件的對象是FileWriter。

是否需要提高效率：是！加入Writer體系中的緩衝區 BufferedWriter

FileWriter fw = new FileWriter(“b.txt”)

BufferedWriter bufw = new Buffered(fw)

2.將鍵盤錄入的數據保存到一個文件中。

這個需求中源和目的都存在。

源：InputStream Reader

是不是純文本？是。Reader

設備：鍵盤。對應的對象是System.in。

不是選擇Reader麼？System.in對應的不是InputStream麼？

爲了操作鍵盤的文本數據方便，轉成字符流按照字符串操作是最方便的。

所以既然明確了Reader，就將System.in轉成字符流。

用到了Reader體系中的轉換流，InputStreamReader。

InputStreamReader isr = new InputStreamReader(System.out)；

需要提高效率麼？要。

BufferedReader bufr = new BufferedReader(isr)

目的：OutputStream Writer

是否是純文本？是：Writer

設備：硬盤上一個文件。使用FileWriter。

FileWriter fw = new FileWriter(“c.txt”)

需要提高效率麼？要。

BufferedWriter bufw= new BufferedWriter(fw)

擴展一下，想要把錄入的數據按照指定的編碼表（utf-8），將數據存到文件中。

目的：OutputStream Writer

是否是純文本？是：Writer

設備：硬盤上一個文件。使用FileWriter。

但是FIleWriter使用的是默認編碼表。

因此存儲時，需要加入指定編碼表，而指定的編碼表，只有轉換流才能使用。

所以要使用的對象是OutPutStreamWriter。

而該轉換流對象要接收一個字節輸出流，而且還可以操作文件的字節輸出流：

FileOutPutStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“d.txt”,UTF-8))

需要提高效率麼？要。

BufferedWriter bufw= new BufferedWriter(osw)

所以記住，轉換流什麼時候使用呢？

字符和字節之間的橋樑，通常涉及到字符編碼轉化時，需要用到轉換流。

異常的日誌信息

import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo 
{
	public static void main(String[] args)
	{
		try
		{
			int[] arr = new int[2];
			System.out.println(arr[3]);
		}
		catch (Exception e)
		{
			try
			{
				Date d = new Date();
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				String s = sdf.format(d);
				PrintStream ps = new PrintStream("exeception.log");
				ps.println(d.toString());
				System.setOut(ps);
				
				
			}
			catch (Exception e1)
			{
				throw new RuntimeException("日誌文件創建失敗");
			}
			e.printStackTrace(System.out);
		}
	}
}
//網上可以下載工具包log4j直接使用。

系統信息

import java.util.*;
import java.io.*;
class SystemInfo 
{
	public static void main(String[] args) throws IOException
	{
		Properties prop = System.getProperties();
		prop.list(new PrintStream("sysinfo.txt"));
	}
}

黑馬程序員_Java IO流(上)

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

WindowsServer--SQL Server搭建主從同步實現讀寫分離 - 事務性分發

java由於越界導致的報錯

黑馬程序員_Java的基本常識

黑馬程序員_Java IO流(上)

黑馬程序員_Java高新技術(內省、註解、泛型、類加載器、代理)

黑馬程序員_Java高新技術(靜態導入、可變參數、增強for循環、自動拆裝箱、枚舉、反射)

Java集合框架(下)

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結