Java IO流及應用（一）

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

IO流

IO流概述及FileWriter類的使用
FileReader類使用
緩衝流介紹和使用
IO流相關案例

NO.one IO流概述及FileWriter類使用

1.1 IO流概述及分類

IO流用來處理裝置之間的資料傳輸

Java對資料的操作是通過流的方式

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

流按流向分為兩種：輸入流，輸出流

1.2 FileWriter類使用

A:開啟幫助文件

B:點選顯示，找到索引，看到輸入框

C:你要學習什麼內容，你就在框框裡面輸入什麼內容

舉例：Random

D:看包

java.lang包下的類在使用的時候是不需要導包的

E:看類的描述

Random類是用於生成隨機數的類

F:看構造方法

Random():無參構造方法

Random r = new Random();

G:看成員方法

public int nextInt(int n):產生的是一個[0,n)範圍內的隨機數

呼叫方法：

看返回值型別：人家返回什麼型別，你就用什麼型別接收

看方法名：名字不要寫錯了

看形式引數：人家要幾個引數，你就給幾個，人家要什麼資料型別的，

你就給什麼資料型別的

int number = r.nextInt(100);

1.2.1 FileWriter向檔案中寫資料

A:FileWriter向檔案中寫資料操作步驟:

a:使用FileWriter流關聯檔案

b:利用FileWriter的寫方法寫資料

c:利用FileWriter的重新整理方法將資料從記憶體刷到硬碟上

d:利用FileWriter的關流方法將釋放佔用的系統底層資源

B:FileWriter方法:

構造方法

FileWriter(String fileName) 傳入一個檔案的路徑

成員方法

void write(String str) 向檔案中寫str

void flush() 將記憶體中的資料重新整理到檔案中

void close() 關流釋放系統底層資源

1.2.1.1 案例程式碼一：

package com.gao_01;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：往檔案中寫資料
 *         寫資料--輸出流--FileWriter
 * 
 * FileWriter:
 *         FileWriter(String fileName):傳遞一個檔名稱
 * 
 * 輸出流寫資料的步驟：
 *         A:建立輸出流物件
 *         B:呼叫輸出流物件的寫資料的方法
 *         C:釋放資源
 */
public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //建立輸出流物件
        FileWriter fw = new FileWriter("d:\\a.txt");
        /*
         * 建立輸出流物件做了哪些事情:
         *         A:呼叫系統資源建立了一個檔案
         *         B:建立輸出流物件
         *         C:把輸出流物件指向檔案
         */
        
        //呼叫輸出流物件的寫資料的方法
        //寫一個字串資料
        fw.write("IO流你好");
        //資料沒有直接寫到檔案，其實是寫到了記憶體緩衝區
        fw.flush();
        
        //釋放資源
        //通知系統釋放和該檔案相關的資源
        fw.close();
        
        //while(true) {}
    }
}

1.2.2 FileWriter 注意事項

1.2.2.1 案例程式碼二：

package com.gao_01;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 輸出流寫資料的步驟：
 *         A:建立輸出流物件
 *         B:呼叫輸出流物件的寫資料方法，並重新整理緩衝區
 *         C:釋放資源
 * 
 * 相對路徑：相對當前專案而言的，在專案的根目錄下(a.txt)
 * 絕對路徑：以碟符開始的路徑(d:\\a.txt)
 * 
 * close()和flush()方法的區別：
 *         flush():重新整理緩衝區。流物件還可以繼續使用。
 *         close():先重新整理緩衝區，然後通知系統釋放資源。流物件不可以再被使用了。
 */
public class FileWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //建立輸出流物件
        //FileWriter fw = new FileWriter("d:\\a.txt");
        FileWriter fw = new FileWriter("a.txt");
        
        //呼叫輸出流物件的寫資料方法，並重新整理緩衝區
        fw.write("helloworld");
        fw.flush();
        fw.write("java");
        fw.flush();
        
        //釋放資源
        fw.close();
        
        //Stream closed
        //fw.write("javaee");
        //fw.flush();
    }
}

1.2.3 FileWriter 其他寫方法

void write(String str):寫一個字串資料

void write(String str,int index,int len):寫一個字串中的一部分資料

void write(int ch):寫一個字元資料,這裡寫int型別的好處是既可以寫char型別的資料，

也可以寫char對應的int型別的值。'a',97

void write(char[] chs):寫一個字元陣列資料

void write(char[] chs,int index,int len):寫一個字元陣列的一部分資料

1.2.3.1 案例程式碼三：

package com.gao_01;
import java.io.FileWriter;
import java.io.IOException;

/*
 * void write(String str):寫一個字串資料
 * void write(String str,int index,int len):寫一個字串中的一部分資料
 * void write(int ch):寫一個字元資料,這裡寫int型別的好處是既可以寫char型別的資料，也可以寫char對應的int型別的值。'a',97
 * void write(char[] chs):寫一個字元陣列資料
 * void write(char[] chs,int index,int len):寫一個字元陣列的一部分資料
 */
public class FileWriterDemo3 {
    public static void main(String[] args) throws IOException {
        //建立輸出流物件
        FileWriter fw = new FileWriter("b.txt");
        
        //void write(String str):寫一個字串資料
        //fw.write("abcde");
        
        //void write(String str,int index,int len):寫一個字串中的一部分資料
        //fw.write("abcde",0,5);
        //fw.write("abcde",1,3);
        
        //void write(int ch):寫一個字元資料,這裡寫int型別的好處是既可以寫char型別的資料，也可以寫char對應的int型別的值。'a',97
        //fw.write('a');
        //fw.write(97);
        
        //void write(char[] chs):寫一個字元陣列資料
        char[] chs = {'a','b','c','d','e'};
        //fw.write(chs);
        
        //void write(char[] chs,int index,int len):寫一個字元陣列的一部分資料
        //fw.write(chs,0,5);
        fw.write(chs,2,3);
        
        //釋放資源
        fw.close();
    }
}

1.2.4 FileWriter 寫入換行以及向文字末尾追加

1.2.4.1 案例程式碼四：

package com.gao_01;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 如何實現資料的換行?
 *         \n可以實現換行，但是windows系統自帶的記事本開啟並沒有換行，這是為什麼呢?因為windows識別的換行不是\n，而是\r\n
 *         windows:\r\n
 *         linux:\n
 *         mac:\r
 * 如何實現資料的追加寫入?
 *         FileWriter(String fileName, boolean append)
 */
public class FileWriterDemo4 {
    public static void main(String[] args) throws IOException {
        //建立輸出流物件
        //FileWriter fw = new FileWriter("c.txt");
        FileWriter fw = new FileWriter("c.txt",true); //表示追加寫入，預設是false
        
        for(int x=0; x<10; x++) {
            fw.write("hello"+x);
            fw.write("\r\n");
        }
        
        //釋放資源
        fw.close();
    }
}

NO.two FileReader類使用

2.1 FileReader 讀資料一次讀取一個字元

2.1.1 案例程式碼五：

package com.gao_02;
import java.io.FileReader;
import java.io.IOException;

/*
 * 需求：從檔案中讀資料並顯示到控制檯
 *         讀資料--輸入流--FileReader
 * 
 * FileReader:
 *         FileReader(String fileName):傳遞檔名稱
 * 
 * 輸入流讀檔案的步驟：
 *         A:建立輸入流物件
 *         B:呼叫輸入流物件的讀資料方法
 *         C:釋放資源
 * 
 * java.io.FileNotFoundException: fr.txt (系統找不到指定的檔案。)
 */
public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //建立輸入流物件
//        FileReader fr = new FileReader("fr.txt");
        FileReader fr = new FileReader("FileWriterDemo.java");
        
        //呼叫輸入流物件的讀資料方法
        //int read():一次讀取一個字元
        
        /*
        //第一次讀資料
        int ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //第二次讀資料
        ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //第三次讀資料
        ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        
        //這是時候，我們發現程式碼的重複度很高，想用迴圈改進，但是不知道迴圈的結束條件是什麼
        ch = fr.read();
        System.out.println(ch);
        
        ch = fr.read();
        System.out.println(ch);
        //通過測試，我們知道，如果讀取資料的返回值是-1的時候，就說明沒有資料了，這也是我們迴圈的結束條件
        */
        
        int ch;
        //1:fr.read()
        //2:ch=fr.read()
        //3:ch != -1
        while((ch=fr.read())!=-1) {
            //System.out.println(ch);
            //System.out.println((char)ch);
            System.out.print((char)ch);
        }
        
        //釋放資源
        fr.close();
    }
}

2.2 利用FileReader 和 FileWriter完成檔案複製

2.2.1 讀一次寫一次

2.2.1.1 案例程式碼六：

package com.gao_03;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把專案路徑下的FileWriterDemo.java中的內容複製到專案路徑下的Copy.java中
 * 
 * 檔案複製也是有規律可循的，也就是說有套路。
 * 
 * 資料來源：
 *         FileWriterDemo.java -- 讀資料 -- FileReader
 * 目的地：
 *         Copy.java -- 寫資料 -- FileWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //建立輸入流物件
        FileReader fr = new FileReader("FileWriterDemo.java");
        //建立輸出流物件
        FileWriter fw = new FileWriter("Copy.java");
        
        //讀寫資料
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.2.2 利用字元陣列拷貝檔案

2.2.2.1 案例程式碼七：

package com.gao_03;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把專案路徑下的FileWriterDemo.java中的內容複製到專案路徑下的Copy.java中
 * 
 * 資料來源：
 *         FileWriterDemo.java -- 讀資料 -- FileReader
 * 目的地：
 *         Copy.java -- 寫資料 -- FileWriter
 */
public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        //建立輸入流物件
        FileReader fr  = new FileReader("FileWriterDemo.java");
        //建立輸出流物件
        FileWriter fw = new FileWriter("Copy.java");
        
        //讀寫資料
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs))!=-1) {
            fw.write(chs, 0, len);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

2.2.3 拷貝檔案的兩種方式圖解

NO.three 緩衝流介紹和使用

3.1 緩衝流的基本使用

3.1.1 案例程式碼八：

package com.gao_04;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * BufferedWriter:將文字寫入字元輸出流，緩衝各個字元，從而提供單個字元、陣列和字串的高效寫入。 
 * BufferedReader:從字元輸入流中讀取文字，緩衝各個字元，從而實現字元、陣列和行的高效讀取。
 */
public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //建立輸出緩衝流物件
        /*
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        bw.write("hello");
        //bw.flush();
        bw.close();
        */
        
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        
        /*
        //一次讀寫一個字元
        int ch;
        while((ch=br.read())!=-1){
            System.out.print((char)ch);
        }
        */
        
        //一次讀寫一個字元陣列
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }
        
        //釋放資源
        br.close();
        
    }
}

3.2 緩衝流複製文字檔案的兩種方式

利用緩衝流把專案路徑下的FileWriterDemo.java中的內容複製到專案路徑下的Copy.java中

第一種方式:使用緩衝流不使用字元陣列

第二種方式:使用緩衝流使用字元陣列

3.2.1 案例程式碼九：

package com.gao_04;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 需求：
 *         把專案路徑下的FileWriterDemo.java中的內容複製到專案路徑下的Copy.java中
 * 
 * 資料來源：
 *         FileWriterDemo.java -- 讀資料 -- FileReader -- 高效的讀資料 -- BufferedReader
 * 目的地：
 *         Copy.java -- 寫資料 -- FileWriter -- 高效的寫資料 -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        
        //讀寫資料
        /*
        //一次讀寫一個字元
        int ch;
        while((ch=br.read())!=-1) {
            bw.write(ch);
        }
        */
        
        
//一次讀寫一個字元陣列
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
}

3.3 緩衝流的特有方法使用

BufferedWriter

void newLine():寫一個換行符，這個換行符由系統決定,不同的作業系統newLine()方法使用的換行符不同

windows: \r\n

linux: \n

mac: \r

BufferedReader

String readLine():一次讀取一行資料，但是不讀取換行符

3.3.1 案例程式碼十：

package com.gao_05;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * 緩衝流的特殊功能：
 * BufferedWriter
 *         void newLine():寫一個換行符，這個換行符由系統決定
 * BufferedReader
 *         String readLine():一次讀取一行資料，但是不讀取換行符
 */
public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        for(int x=0; x<10; x++) {
            bw.write("hello"+x);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        bw.close();
        */
        
        BufferedReader br = new BufferedReader(new FileReader("br.txt"));
        
        /*
        String line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        
        line = br.readLine();
        System.out.println(line);
        */
        
        String line;
        //1:br.readLine()
        //2:line=br.readLine()
        //3:line != null
        while((line=br.readLine())!=null) {
            System.out.println(line);
        }
        
        br.close();
    }
}

3.4 緩衝流的特有方法複製檔案

3.4 案例程式碼十一：

package com.gao_05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
 * 需求：
 *         把專案路徑下的FileWriterDemo.java中的內容複製到專案路徑下的Copy.java中
 * 
 * 資料來源：
 *         FileWriterDemo.java -- 讀資料 -- FileReader -- 高效的讀資料 -- BufferedReader
 * 目的地：
 *         Copy.java -- 寫資料 -- FileWriter -- 高效的寫資料 -- BufferedWriter
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        
        //讀寫資料
        String line;
        while((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //釋放資源
        bw.close();
        br.close();
    }
}

NO.four IO流相關案例

4.1 複製文字檔案的5中方式

A:利用基本流一次讀寫一個字元

B:利用基本流一次讀寫一個字元陣列

C:利用緩衝流一次讀寫一個字元

D:利用緩衝流一次讀寫一個字元陣列

E:利用緩衝流的特有方法一次讀寫一個字串

4.1.1 案例程式碼十二：

package com.gao_06;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 複製文字檔案(5種方式)
 * 
 * 資料來源：
 *         FileWriterDemo.java
 * 目的地：
 *         Copy.java
 */
public class CopyFileTest {
    public static void main(String[] args) throws IOException {
        /*
        method1("FileWriterDemo.java","Copy.java");
        method2("FileWriterDemo.java","Copy.java");
        method3("FileWriterDemo.java","Copy.java");
        method4("FileWriterDemo.java","Copy.java");
        method5("FileWriterDemo.java","Copy.java");
        */
        
        String srcFileName = "FileWriterDemo.java";
        String destFileName = "Copy.java";
        
//        method1(srcFileName,destFileName);
//        method2(srcFileName,destFileName);
        method3(srcFileName,destFileName);
//        method4(srcFileName,destFileName);
//        method5(srcFileName,destFileName);
    }
    
    //緩衝流一次讀寫一個字串
    public static void method5(String srcFileName,String destFileName) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字串
        String line;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //緩衝流一次讀寫一個字元陣列
    public static void method4(String srcFileName,String destFileName) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字元陣列
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //緩衝流一次讀寫一個字元
    public static void method3(String srcFileName,String destFileName) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new BufferedReader(new FileReader(srcFileName));
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
        
        //一次讀寫一個字元
        int ch;
        while((ch=br.read())!=-1) {
            bw.write(ch);
        }
        
        //釋放資源
        bw.close();
        br.close();
    }
    
    //基本流一次讀寫一個字元陣列
    public static void method2(String srcFileName,String destFileName) throws IOException {
        //建立輸入流物件
        FileReader fr = new FileReader(srcFileName);
        //建立輸出流物件
        FileWriter fw = new FileWriter(destFileName);
        
        //一次讀寫一個字元陣列
        char[] chs = new char[1024];
        int len;
        while((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
    
    //基本流一次讀寫一個字元
    public static void method1(String srcFileName,String destFileName) throws IOException {
        //建立輸入流物件
        FileReader fr = new FileReader(srcFileName);
        //建立輸出流物件
        FileWriter fw = new FileWriter(destFileName);
        
        //一次讀寫一個字元
        int ch;
        while((ch=fr.read())!=-1) {
            fw.write(ch);
        }
        
        //釋放資源
        fw.close();
        fr.close();
    }
}

4.2 把集合中的資料寫到文字檔案

把ArrayList集合中的字串資料儲存到文字檔案專案根目下的array.txt中

每一個字串元素作為檔案中的一行資料

4.2.1 案例程式碼十三：

package com.gao_06;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 把ArrayList集合中的字串資料儲存到文字檔案
 * 每一個字串元素作為檔案中的一行資料
 * 
 * 分析：
 *         A:建立集合物件
 *         B:往集合中新增字串元素
 *         C:建立輸出緩衝流物件
 *         D:遍歷集合，得到每一個字串元素，然後把該字串元素作為資料寫到文字檔案
 *         E:釋放資源
 */
public class ArrayListToFileTest {
    public static void main(String[] args) throws IOException {
        //建立集合物件
        ArrayList<String> array = new ArrayList<String>();
        
        //往集合中新增字串元素
        array.add("hello");
        array.add("world");
        array.add("java");
        
        //建立輸出緩衝流物件
        BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
        
        //遍歷集合，得到每一個字串元素，然後把該字串元素作為資料寫到文字檔案
        for(int x=0; x<array.size(); x++) {
            String s = array.get(x);
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        
        //釋放資源
        bw.close();
    }
}

4.3 把文字檔案中的資料讀取到集合

從專案根目錄下的array.txt文字檔案中讀取資料到ArrayList集合中，並遍歷集合,每一行資料作為一個字串元素

4.3.1 案例程式碼十四：

package com.gao_06;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 從文字檔案中讀取資料到ArrayList集合中，並遍歷集合
 * 每一行資料作為一個字串元素
 * 
 * 分析：
 *         A:建立輸入緩衝流物件
 *         B:建立集合物件
 *         C:讀取資料，每次讀取一行資料，把該行資料作為一個元素儲存到集合中
 *         D:釋放資源
 *         E:遍歷集合
 */
public class FileToArrayListTest {
    public static void main(String[] args) throws IOException {
        //建立輸入緩衝流物件
        BufferedReader br = new  BufferedReader(new FileReader("array.txt"));
        
        //建立集合物件
        ArrayList<String> array = new ArrayList<String>();
        
        //讀取資料，每次讀取一行資料，把該行資料作為一個元素儲存到集合中
        String line;
        while((line=br.readLine())!=null) {
            array.add(line);
        }
        
        //釋放資源
        br.close();
        
        //遍歷集合
        for(int x=0; x<array.size(); x++) {
            String s = array.get(x);
            System.out.println(s);
        }
    }
}

Java IO流及應用（一）

IO流 IO流概述及FileWriter類的使用 FileReader類使用緩衝流介紹和使用 IO流相關案例 NO.one IO流概述及FileWriter類使用 1.1 IO流概述及分類 IO流用來處理裝置之間的資料傳輸

IO流的應用（一）：實現檔案的複製

package com.bjpowernode.demo03; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /** 使用FileReader/FileW

java原始碼之 io 流原始碼解讀（一）

剛剛喝了一波毒雞湯，其中印象最深的就是這兩個：沒有人能夠讓你放棄夢想，自己想想就放棄了。找物件的時候不能光看對方的外表。。。。還要看看自己的外表哈哈哈~~ 吸收了這一大波精氣之後，我感覺我的

Java IO流學習總結（轉）

rar output 出現 arr system 不存在技術分享輸出寫入原文地址：http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html Java流操作有關的類或接口： Java流類圖結構：

IO流的應用（三）異常列印日誌檔案中

package com.bjpowernode.demo02; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.i

IO流學習筆記（一）之FileWriter與FileReader

IO流用來處理裝置之間的資料傳輸 Java對資料的操作是通過流的方式 Java用於操作流的物件都在IO包中流按照操作資料分為兩種：位元組流和字元流流按流向分為：輸入流和輸出流輸入流和輸出流是相對於記憶體裝置而言因為記憶體速度快，程式在記憶體中執行，資料從外設（硬碟）讀取到記憶體中為輸入，資料由記憶體

卡爾曼濾波原理及應用（一）

出於科研需要，打算開始學習卡爾曼濾波（Kalmam Filter）。很早之前就聽說過卡爾曼濾波,但一直沒能深入學習，這次終於有機會了，哈哈。 1.卡爾曼濾波的發展過程卡爾曼濾波的本質屬於"估計"範疇.先介紹下估計，所謂“估計”問題，就是對收到隨機干擾和隨機測量誤差作用的物理系統，按照某種效

g2o原理及應用（一）

g2o是一個通用的圖優化框架。本文結合論文g2o: A general framework fo graph optimizaiton說明g2o的理論，然後編寫一個示例程式，說明g2o的使用方法。 g2o理論：許多問題可以建模為最小二乘優化的狀態估計問題。問題形式如圖 F(x)

Java代理模式及應用（三）Cglib實現

前一節所說的靜態代理和動態代理模式都是要求目標物件是實現一個介面的目標物件，但是有時候目標物件只是一個單獨的物件，並沒有實現任何的介面，這個時候就可以使用以目標物件子類的方式類實現代理，這種方法就叫做：Cglib代理 1.Cglib說明 Cglib代理，

通往 BATJ 的 160 道 Java 面試題及答案（一）

一、題目（1~40題） 1、面向物件的特徵有哪些方面？ 2、訪問修飾符 public,private,protected, 以及不寫（預設）時的區別？ 3、String 是最基本的資料型別嗎？ 4、float f=3.4; 是否正確？ 5、short s1 = 1;

DLX演算法及應用（一）DLX模板+解數獨

DLX演算法原理：網上太多了，我就不寫了。。用途：解決精確覆蓋問題下面的程式碼是嚴格按照演算法寫的，其實對於這種沒有資料域的連結串列，是可以用陣列進行模擬的（見DLX演算法及應用（二）Matlab解數獨）。程式碼中全部都用的是vector，更通用一些~ 後半部分給

IO流學習總結（一）

什麼是IO流IO流之前也接觸了好多次，因為這一塊內容很多，所以老是有不太清楚的地方，所以現在來總結一下。流分為位元組流，字元流。簡單的說，位元組流就是由二進位制資料組成的流，一個位元組八個bit，這個計算機很容易理解，但是不方便人閱讀，所以就有了字元流。字元流，有不同的編碼方

Java IO流中拷貝（複製）檔案的寫法

1. 使用位元組流讀寫複製檔案/** * 位元組流讀寫複製檔案 * @param src 原始檔 * @param out 目標檔案 */ public static void InputStreamOutputStream(String

Java 之IO流及應用

生成介紹 lena 刷新 [0 規律 exceptio closed 形式參數 IO流 IO流概述及FileWriter類的使用 FileReader類使用緩沖流介紹和使用 IO流相關案例 NO.one IO流概述及FileWriter類使用

Java中String、StringBuilder、StringBuffer常用源碼分析及比較（一）：String源碼分析

array string類都是 epo sys 匹配字符串 bound 地址簡單 String：一、成員變量： /** The value is used for character storage. */ private final char value[

java中的棧Stack的基本使用和應用（一）

string emp tac logs tor str col () bject 棧定義　　棧是一種只能在一端進行插入或刪除操作的線性表。（先進後出表） java中的Stack繼承Vector 實例化 Stack stack=new Stack(); 基本使用判斷是

Java中io流的學習（九）ByteArrayInputStream和ByteArrayOutputStream

ByteArrayInputStream（記憶體輸入流）繼承於InputStream，ByteArrayOutputStream（記憶體輸出流）繼承於OutputStream。記憶體流是關不掉的，一般用來存放一些臨時性的資料，理論值是記憶體大小。常用的方法是：read（），一系列read方法，

IO流學習筆記（二）之BufferedWriter與BufferedReader及例項Demo

在之前的學習筆記（http://blog.csdn.net/megustas_jjc/article/details/72853059）中，FileWriter與FileReader的Demo使用的中轉資料buf實際就是緩衝區，是由我們自己建立的。緩衝區可以提高效率，Java對緩衝區進行了封裝，封裝成了物

Java中io流的學習（八）PrintStream和PrintWriter

PrintStream（可以將位元組流封裝成列印流）繼承於FilterOutputStream，FilterOutputStream是繼承於OutputStream的；PrintWriter（可以將位元組流、字元流封裝成列印流）繼承於Writer的。其中可以使用Print

純java寫2D格鬥遊戲（一）——介面背景設定及人物的簡單設定

/**莫言情難忘QQ：1179307527*/這幾天Java的實訓算是非常完美，自我感覺進步很大，但僅限於一般的程式設計，這兩天也看了不少思想，決定寫一個2D格鬥遊戲，原因有四：1.鍛鍊自己的技術2.分享技術3.感覺做一個自己的遊戲才好玩，畢竟現階段2D格鬥的遊戲我都不愛玩4

Java IO流及應用（一）

IO流

NO.one IO流概述及FileWriter類使用

相關推薦