Java 輸入輸出流筆記

阿新 • • 發佈：2018-12-09

流的分類

按流的方向
1. 輸入流 InputStream Reader
2. 輸出流 OutputStream Writer
按資料單元
1. 位元組流位元組流操作的資料單元是8 位的位元組二進位制資料 InputStream OutputStream
2. 字元流字元流操作的資料單元是16位的字元對字元效能方面提升 Reader Writer
按功能分類
1. 節點流最基本的檔案流直接和底層檔案關聯
2. 處理流必須在節點流的基礎上建立|包裝 > 修飾器設計模式

流的基礎用法

InputStream > FileInputStream

方法
1. int read() 逐個位元組讀取，並返回讀取的內容（int單個位元組） IO的頻率最高
2. int read( byte[] ) 一次讀取位元組到byte[]陣列中，並返回讀取的資料長度

	//read()
	private void read1() {
		InputStream is = null;
		try {
			is = new FileInputStream(filePath);
			int c = 0;
			do {
				c = is.read();
				System.out.print((char) c);
			} while (c != -1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	

	//read(byte)
	private void read2() {
		InputStream is = null;
		try {
			is = new FileInputStream(filePath);
			byte[] b = new byte[1024];
			int len = 0;
			do {
				len = is.read(b);
				for (int i = 0; i < len; i++) {
					System.out.print((char) b[i]);
				}
			} while (len != -1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

OutputStream > FileOutputStream

方法
1. void write( int i ) 單個位元組寫入
2. void write( byte[] ) 寫入一批位元組


	/**
	 * write(byte) write()
	 * @param str 寫入內容
	 */
	private void write1(String str) {
		OutputStream ops = null;
		try {
			ops = new FileOutputStream(filePath, true);
			// int
			ops.write((char) 65);
			// String
			ops.write(str.getBytes());
			// String offset length
			ops.write(str.getBytes(), 0, str.length());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				ops.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

Reader > FileReader

方法
1. int read()
2. int read( char[] )

private void read1() {
		Reader r = null;
		try {
			r = new FileReader(new File("iotest.txt"));
			char[] buffer = new char[1024];
			StringBuffer sb = new StringBuffer();
			while (true) {
				int len = r.read(buffer);
				if (len == -1)
					break;
				sb.append(buffer, 0, len);
			}
			System.out.println(sb.toString());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				r.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

Writer > FileWriter

方法
1. void write( int i )
2. void write( String str )

private void write1() {
		Writer w = null;
		try {
			/*
			 * FileWriter(File file, boolean append)
			 * 引數append為true時，則續寫反之重寫
			 */
			w = new FileWriter(new File("iotest.txt"), true);
			char[] cbuf = "\nbyteTest".toCharArray();
			String str = "\nHelloWorld3.......\r\n你好世界";
			// int
			w.write(65);
			// char[]
			w.write(cbuf);
			// char[] offset length
			w.write(cbuf, 0, cbuf.length);
			// String
			w.write(str);
			// String offset length
			w.write(str, 0, str.length());
			// 清除快取
			w.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// close在呼叫時會呼叫flush
			try {
				w.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

綜合

	private void copyText(String readFilePath,String writeFilePath) {
		Reader read = null;
		Writer write = null;
		try {
			read = new FileReader(new File(readFilePath));
			write = new FileWriter(new File(writeFilePath));
			char[] buffer = new char[1024];
			int len = 0;
			while ((len = read.read(buffer)) != -1) {
				write.write(buffer, 0, len);
				write.flush();
			}
			System.out.println("copy complete");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				read.close();
				write.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	private void copyImage(String readFilePath,String writeFilePath) {
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(new File(readFilePath));
			out = new FileOutputStream(new File(writeFilePath));
			byte[] buffer = new byte[1024];
			int len = 0;
			while ((len = in.read(buffer)) != -1) {
				out.write(buffer, 0, len);
				out.flush();
			}
			System.out.println("copy complete");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				in.close();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

緩衝流

特點
1. 不能單獨建立，必須藉助節點流建立

類別

BufferedInputStream > int read read( byte offset length ) 資料讀取到末尾時返回-1

BufferedOutputStream > void write weite(byte offset length)

綜合

    private void copyFile() {
	BufferedInputStream bis = null;
	BufferedOutputStream bos = null;
	try {
	    bos = new BufferedOutputStream(
                            new FileOutputStream("iotest2.txt"));
	    bis = new BufferedInputStream(
                            new FileInputStream("iotest.txt"));
	    byte[] arr = new byte[1024];
            int len = -1;
            while ((len = bis.read(arr)) != -1) {
	        bos.write(arr, 0, len);
            }
        } catch (FileNotFoundException e) {
	    e.printStackTrace();
        } catch (IOException e) {
	    e.printStackTrace();
        } finally {
	        try {
		        bis.close();
		        bos.close();
	    } catch (IOException e) {
		    e.printStackTrace();
	    }
    }
}

BufferedReader > readLine資料讀取到末尾時返回null

private void bufferRead() {
	BufferedReader br = null;
	try {
		FileReader r = new FileReader(
                            new File("iotest.txt"));
		br = new BufferedReader(r);
		MyBufferedReader mb = new MyBufferedReader(r);
		String str = null;
		// while ((str = mb.myReadLine()) != null) {
		while ((str = br.readLine()) != null) {
			System.out.println(str);
		}
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		try {
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

BufferedWriter > 寫入後需要重新整理flush，關閉前會先重新整理

public void bufferWrite() {
	BufferedWriter bw = null;
	try {
		bw = new BufferedWriter(
                        new FileWriter("iotest2.txt"));
		bw.write("bufferWrite重寫");
		bw.flush();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		try {
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

轉換流

類別
1. public class OutputStreamWriter extends > WriterOutputStreamWriter ( OutputStream out )
2. public class InputStreamReader extends > ReaderInputStreamReader ( InputStream in )

        //在控制檯輸入字元回車後，列印大寫字元
        private void test1() throws IOException {
		InputStream is = System.in;
		OutputStream ou = System.out;
		BufferedReader br = new BufferedReader(
                                       new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(
                                       new OutputStreamWriter(ou));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
		}

		br.close();
		bw.close();

	}

        //在控制檯輸入字元回車後，列印大寫字元在檔案中
	private void test2() throws IOException {
		InputStream is = System.in;

		BufferedReader br = new BufferedReader(
                                new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(
                                new FileWriter("iotest.txt"));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
                        //newLine()可跨平臺換行
			bw.newLine();
			bw.flush();
		}
		br.close();
		bw.close();
	}

        //讀取檔案中字元，列印到控制檯中
	private void test3() throws IOException {
		OutputStream ou = System.out;

		BufferedReader br = new BufferedReader(
                                new FileReader("iotest.txt"));
		BufferedWriter bw = new BufferedWriter(
                                new OutputStreamWriter(ou));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
		}
		br.close();
		bw.close();
	}


        private void test4() throws IOException {
	    InputStream is = System.in;
	    OutputStream ou = System.out;

	    BufferedInputStream bis = new BufferedInputStream(is);
	    BufferedOutputStream bos = new BufferedOutputStream(ou);
	
            byte[] buffer = new byte[1024];
	    bis.read(buffer);
	    bos.write(buffer);
	    bos.close();
        }

列印流

PrintWriter(OutputStream out, boolean autoFlush) autoFlush為true,自動重新整理

private void test1() throws IOException {
		InputStream is = System.in;
		PrintWriter out = new PrintWriter(System.out, true);
		BufferedReader br = new BufferedReader(
                                        new InputStreamReader(is));
		String str = null;
		while ((str = br.readLine()) != null) {
			if ("end".equals(str))
				break;
			out.println(str.toUpperCase());
		}
		out.close();
		br.close();
	}

記憶體流

特點
1. io 的行為並不是對檔案進行操作，而是對記憶體中byte[]陣列進行操作
2. byte[ ] 在程式中，是一個臨時存放資料的空間，並不是底層的資源，所以並不需要關閉流
類別
1. ByteArrayInputStream(byte[] buf)
2. ByteArrayOutputStream()

	// 將bos讀取到的input中的內容，寫入bais中toString返回輸出
	public String getTextByInputStream(InputStream input) {
		BufferedInputStream bos = null;
		ByteArrayOutputStream bais = null;
		try {
			bos = new BufferedInputStream(input);
			bais = new ByteArrayOutputStream();
			int len = -1;
			while ((len = bos.read()) != -1) {
				bais.write(len);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return bais.toString();
	}

	private void test1() {
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			// 將圖片檔案讀取，存入到記憶體流中
			bis = new BufferedInputStream(
				   new FileInputStream("image.png"));
			bos = new BufferedOutputStream(
                                   new FileOutputStream("copyimage.png"));
			ByteArrayOutputStream baos = 
                                   new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int i = -1;
			// while ((i = bis.read()) != -1) {
			// baos.write(i);
			// }
			while ((i = bis.read(buffer)) != -1) {
				baos.write(buffer, 0, i);
			}
			System.out.println("完成存入記憶體操作");

			// 將記憶體流中的圖片讀取，寫入到檔案中
			ByteArrayInputStream bais = 
                        new ByteArrayInputStream(baos.toByteArray());
			int j = -1;
			while ((j = bais.read()) != -1) {
				bos.write(j);
			}
			System.out.println("完成磁碟寫入操作");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bis.close();
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

物件流

序列化：把物件狀態（內部資料等）儲存到某種介質中，該介質可以是檔案、網路等
反序列化：從介質中根據所儲存的物件狀態資訊，重構物件
類別
1. ObjectInputStream(InputStream in) 將物件儲存到二進位制檔案中序列化（序列化）
2. ObjectOutputStream (OutputStream out) 在二進位制檔案中查詢物件進行反序列化（並行化）

        private void readObject() {
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(
					new FileInputStream("iotest2.bin"));
			Person person = (Person) ois.readObject();
			System.out.println("——重構物件完成——");
			System.out.println(person);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	private void writeTo(Person person) {

		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(
					new FileOutputStream("iotest2.bin"));
			oos.writeObject(person);
			System.out.println("——寫入物件完成——");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

        //只有支援java.io.Serializable介面的物件才能寫入流中
        //只能從流中讀取支援java.io.Serializable或 java.io.Externalizable介面的物件
        public class Person implements Serializable {
	    private static final long serialVersionUID = 1293810121342278585L;
	    private String name;
	    private String sex;

	    public Person(String name, String sex) {
		    super();
		    this.name = name;
		    this.sex = sex;
	    }
        //省略toString()
        }

資料流

特點：提供了各種資料型別對應的讀取和寫入的方式
類別
1. DataInputStream (InputStream in)
2. DataOutputStream (OutputStream out)

    public static void main(String[] args) {
		DataOutputStream dataOutput = null;
		DataInputStream dataInput = null;
		try {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		dataOutput = new DataOutputStream(baos);
		dataOutput.writeBoolean(true);
		dataOutput.writeUTF("string");
		dataOutput.writeInt(1024);

		ByteArrayInputStream bais = 
				new ByteArrayInputStream(baos.toByteArray());
		dataInput = new DataInputStream(bais);

			System.out.println(
					dataInput.readBoolean() +
					":" + dataInput.readUTF() +
					":" + dataInput.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				dataOutput.close();
				dataInput.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

序列流

類別
1. SequenceInputStream (InputStream s1, InputStream s2) 合併兩個輸入位元組流
2. SequenceInputStream (Enumeration<? extends InputStream> e) 合併多個個輸入位元組流

    
        /**
	 * 合併多個檔案
	 */
	private void test2() {
		FileInputStream fis1 = null;
		FileInputStream fis2 = null;
		FileInputStream fis3 = null;
		FileOutputStream fos = null;
		SequenceInputStream sis = null;
		try {

			fis1 = new FileInputStream(new File("iotest.txt"));
			fis2 = new FileInputStream(new File("iotest2.txt"));
			fis3 = new FileInputStream(new File("iotest3.txt"));
			fos = new FileOutputStream(new File("iotest1.txt"));
			Vector<InputStream> v = new Vector<>();
			v.add(fis1);
			v.add(fis2);
			v.add(fis3);
			Enumeration<InputStream> enumeration = v.elements();
			sis = new SequenceInputStream(enumeration);
			byte[] buffer = new byte[1024];
			int len = -1;
			while ((len = sis.read(buffer)) != -1) {
				fos.write(buffer, 0, len);
			}
			System.out.println("——合併完成——");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fis1.close();
				fis2.close();
				fis3.close();
				fos.close();
				sis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 合併兩個檔案
	 */
	private void test1() {
		SequenceInputStream sis = null;
		FileOutputStream fos = null;
		InputStream f1 = null;
		InputStream f2 = null;
		try {
			f1 = new FileInputStream("iotest.txt");
			f2 = new FileInputStream("iotest2.txt");
			fos = new FileOutputStream("iotest3.txt");
			sis = new SequenceInputStream(f1, f2);
			int len = -1;
			byte[] buffer = new byte[1024];
			while ((len = sis.read(buffer)) != -1) {
				fos.write(buffer, 0, len);
			}
			System.out.println("————合併完成————");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				f1.close();
				f2.close();
				sis.close();
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

RandomAccessFile

特點：RandomAccessFile（任意訪問檔案）實現 DataOutput和 DataInput 具備對檔案讀取和寫入的功能
方法
1. void seek(long pos) 設定檔案指標偏移，從該檔案的開頭測量，發生下一次讀取或寫入
2. long getFilePointer() 返回此檔案中的當前偏移量

        //寫入物件	
        private void test2() throws IOException {
	  RandomAccessFile ra = new RandomAccessFile("002.bin", "rw");
	  Person person1 = new Person("make", "male");
	  Person person2 = new Person("mary", "female");
	  person1.writeToFile(ra);
	  person2.writeToFile(ra);
	  for (int i = 0; i < ra.length(); i = (int) ra.getFilePointer()){
              ra.seek(i);
	      System.out.println(ra.readUTF() + "," + ra.readUTF());
	  }
	  ra.close();
	  }

        //寫入字串
	private void test1() throws IOException {
          /**
           * r    以只讀的方式開啟檔案   
           * rw   以讀、寫的方式開啟檔案，如果不存在嘗試建立
           * rwd  相對rw模式，還要求對檔案<內容>的每個更新都同步寫入到底層儲存裝置中
           * rws  相對rw模式，還要求對檔案的<內容或元資料>的每個更新都同步寫入到底層儲存裝置中   
           */
	  RandomAccessFile raf = new RandomAccessFile("001.txt", "rw");
	  System.out.println(raf.getFilePointer());
	  raf.writeUTF("helloworld");

	  System.out.println(raf.getFilePointer());
	  raf.writeUTF("你好世界HelloWorld");
	  System.out.println("寫入完成");
	  // raf.seek(0);
	  // System.out.println(raf.readUTF());
	  // raf.seek(12);
	  // System.out.println(raf.readInt());
	for (int i = 0; i < raf.length();i = (int) raf.getFilePointer()){
		raf.seek(i);
		System.out.println(raf.readUTF());
		}
		raf.close();
	}


        public class Person implements Serializable {	
	    private static final long 
                serialVersionUID = 1293810121342278585L;
	    private String name;
	    private String sex;

	    public Person(String name, String sex) {
	    	super();
	    	this.name = name;
	    	this.sex = sex;
	    }

	    public void writeToFile(RandomAccessFile ra) {
	    	try {
		    ra.writeUTF(this.name);
		    ra.writeUTF(this.sex);
	    	} catch (IOException e) {
		    	e.printStackTrace();
	    	}
    	    }

    	    @Override
    	    public String toString() {
	        return "Person [name=" + name + ", sex=" + sex + "]";
        	}
        }

Java 輸入輸出流筆記

流的分類按流的方向輸入流 InputStream Reader 輸出流 OutputStream Writer 按資料單元位元組流位元組流操作的資料單元是8 位的位元組二進位制資料 InputStream OutputStream

Java輸入輸出流（轉載）

字符串數組三種 dir row 接口 jdk1 end get 繼承看到一篇超清晰的輸入輸出流文章，就轉載一下，膜拜 http://blog.csdn.net/hguisu/article/details/7418161 1.什麽是IO Java中I/O操作

Java 輸入輸出流

red 處理 adl 分享圖片效率人的耗時 buffer IE 這篇不是為了系統介紹Java的輸入輸出流機制的，僅為個人筆記作為Java小菜，每次上網搜別人的Java讀寫文件的程序參考，總覺得一頭霧水，為什麽要聲明這麽多類，規則是什麽，全然分から

Java輸入輸出流詳解2

output put 輸入流基類 inpu reader 讀取輸入輸出 NPU InputStream/Reader:所有輸入流的基類，只能從中讀取數據； OutputStream/Writer:所有輸出流的基類，只能向其寫入數據。Java輸入輸出流詳解2

Java 輸入/輸出——流體系（處理流）

void dso span style output amt nbsp public 用處　　關於使用處理流的優勢，歸納起來就是兩點：（1）對於開發人員來說，使用處理流進行輸入/輸出操作更簡單；（2）使用處理流執行效率更高。　　下面程序使用PrintStream處理流來

Java輸入輸出流---面試

目錄和檔案操作關鍵考點：  File類的概念。  如何用File類看來操作目錄和檔案。答案： Java提供了java.io.File類對目錄和檔案進行操作。主要的操作方法包括：路徑字串構造方法、isDirectory、isFile、createNew

Java輸入輸出流

I/O 流即資料傳輸通道。可以使用這條通道把源中的資料傳送給目標。把輸入流的指向稱做源。程式通過指向源的輸入流讀取源中的資料。把輸出流的指向叫做目標。程式通過指向目標的輸出流向目標寫資料。雖然I/O 流經常與磁碟檔案存取有關。但是程式的源和目的地也可以是鍵盤。滑鼠

JAVA輸入/輸出流程式例題（檔案和目錄、位元組流、字元流）

一.檔案和目錄 1.顯示檔案的基本資訊。 2.顯示目錄的基本資訊。 3.在指定目錄下建立單個檔案。 4.指定目錄下建立多個臨時檔案。二、位元組流 1.生成ZIP壓縮檔案 2.解壓縮zip檔案 3.生成Excel檔案 4.讀取excel檔案 5.生成PDF檔案 6.讀取P

java輸入輸出流詳細講解（入門經典），詳細講解JAVA中的IO流

今天我們開始進入學習 java 中比較讓人頭疼的事，那就是 I/O 流、多執行緒、網路程式設計。這裡對 I/O 流的一個詳細講解。希望對大家有點用吧。（不看後悔哦）一、什麼是IO Java中I/O操作主要是指使用Java進行輸入，輸出操作。 Java所有的I/O機制都是基於資料流進行輸入

Java 輸入/輸出流

1. 編碼問題在介紹輸入輸出之前我們先介紹下關於編碼的一些基本知識點，當一個檔案中既有中文字元又有英文字元時，他們在不同的編碼方式下會佔據不同的記憶體： 1. ANSI 中文佔據 2 個位元組的記憶體空間，英文佔據 1 個位元組的記憶體空間。 2. GB

Java輸入輸出流詳解

通過資料流、序列化和檔案系統提供系統輸入和輸出。 Java把這些不同來源和目標的資料都統一抽象為資料流。Java語言的輸入輸出功能是十分強大而靈活的，美中不足的是看上去輸入輸出的程式碼並不是很簡潔，因為你往往需要包裝許多不同的物件。在Java類庫中，IO部分的內容是很龐大的，因為它涉

java實驗8-Java輸入輸出流

1 讀寫檔案【實驗目的】（1）掌握文字檔案的讀寫方法。（2）掌握隨機檔案的讀寫方法。（3）掌握InputStream、OutputStream抽象類的基本使用。（4）掌握FileInputStream、FileOutputStream、DataInputStrea

Java輸入輸出流（I/O）

第十四天：目標： ------------------------------------------------------------ 第十四章 Stream I/O and Files, 共 44 個slide(411-455); 知識點：一. 流的概念

java 輸入輸出流和File簡單解析（附android中文亂碼問題解決）

java的輸入輸出流是用來幹甚麼的？以下來自百度。點選開啟連結現在只有檔案輸出輸出流和File的簡單應用，以後再補輸入輸出不是對機器而言的輸入輸出是相對於程式來說的。程式執行時是在記憶體中的輸入是指將硬碟或其他儲存裝置的資料讀入記憶體輸出是指將記憶體中的資料寫入

Java 輸入 / 輸出流

Java語言定義了許多類負責各種方式的輸入/輸出，這些類都放在 java.io 包中。所有的輸入流類都是抽象類InputStream（位元組輸入流）或抽象類Reader（字元輸入流）的子類；而所有輸出流都是抽象類OutputStream（位元組輸出流）或抽象類Writ

java輸入輸出流（I/O）總結

io流的四個基本類 Java.io包中包含了流式I/O所需要的所有類。在java.io包中有四個基本類：InputStream、OutputStream及Reader、Writer類，它們分別處理位元組流和字元流：基本資料流的I/O 輸入/輸出

java輸入輸出流例項(FileInputStream、FileOutputStream例項)

----------------------------------------------------------------------------------------------------------------------

Java輸入輸出流與緩衝區的使用

一，Input/Output流：將外設中的資料讀取到記憶體中就是輸入。將記憶體中的資料寫入到外設中就是出。I/O流就是用來處理裝置間的資料傳輸。用於操作流的物件都放在IO包中。流按操作方式分為位元組流和字元流。位元組流能處理所有的資料。字元流的由來：其實就是位元組流讀取文字

java 輸入輸出流詳解

1.什麼是IO Java中I/O操作主要是指使用Java進行輸入，輸出操作. Java所有的I/O機制都是基於資料流進行輸入輸出，這些資料流表示了字元或者位元組資料的流動序列。Java的I/O流提供了讀寫資料的標準方法。任何Java中表示

Thinking in java自讀筆記：常用輸入輸出流

這次總結以用法為主，涉及的深入原理暫不理會 1 繼承於InputStream的常用輸入流 (1). 檔案輸入流FileInputStream (2). 管道輸入流PipedInputStream (3). 緩衝輸入流BufferedInputStream (4). 合併輸入流Se

Java 輸入輸出流筆記

流的基礎用法

緩衝流

轉換流

列印流

記憶體流

物件流

資料流

序列流

RandomAccessFile

相關推薦