I/O流（三）

LineNumberReader：
- public int getLineNumber():獲取行號
- public void setLineNumber(int lineNumber):設置起始行號
  String readLine()：讀取一行
  案例：讀取文件，每次讀取一行打印並且加上行號

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
public class LineNumberReaderDemo {
    public static void main(String[] args) throws IOException {
        //創建LineNumberReader對象
        //public LineNumberReader(Reader in)
        LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));

        //默認起始行號從0開始


        //一次讀取一行
        String line;
        while ((line = lnr.readLine())!=null) {
            //打印每一行的行號和內容
            System.out.println(lnr.getLineNumber()+":"+line);
        }

        //關流
        lnr.close();
    }

}

注意：如果你沒有設置行號的，默認從0開始，如果設置行號後，則從設置的行號開始算起

2.操作基本數據類型的流
* 可以操作基本類型的流對象。
* DataInputStream:讀數據
* DataOutputStream:寫數據
*
案例：給流中寫基本類型的數據，並且讀取
強調：讀寫順序必須一致，即當你向文件中寫入數據的時候，寫的什麼數據類型，讀的時候就必須用什麼數據類型去讀，不然會出現錯誤

public class DataOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //寫數據
        //write();
        read();
    }

    private static void read() throws IOException {
        //DataInputStream:讀數據
        //創建對象：public DataInputStream(InputStream in)
        DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));

        //讀數據了,按什麼順序寫入就必須按照什麼順序讀出來
        System.out.println(dis.readByte());
        System.out.println(dis.readShort());
        System.out.println(dis.readInt());
        System.out.println(dis.readLong());
        System.out.println(dis.readChar());
        System.out.println(dis.readFloat());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());

        //關流
        dis.close();
    }

    private static void write() throws IOException {
        //public DataOutputStream(OutputStream out)
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));

        //給流關聯的文件中寫入基本類型的數據
        dos.writeByte(20);
        dos.writeShort(200);
        dos.writeInt(2000);
        dos.writeLong(20000L);

        dos.writeChar(97);
        dos.writeFloat(12.34F);
        dos.writeDouble(23.34);
        dos.writeBoolean(true);

        //關流
        dos.close();
    }

}

3.
內存操作流：解決臨時數據存儲的問題。
操作字節數組(演示着一個案例即可)
ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 將之前寫入內存的流轉換成字節數組
注意：在寫入文件的時候，是直接將文件寫入內存中，寫的時候可以用不同的方式，在讀取的時候，必須將寫入文件的數據封裝成相應的數組，這樣才能讀取出來的

操作字符數組
CharArrayReader
CharArrayWrite

操作字符串
StringReader
StringWriter
操作字節數組
ByteArrayInputStream
ByteArrayOutputStream
將數據寫到流中保存在內存，並且讀取

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //給內存中寫數據public ByteArrayOutputStream()
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //給內存中調用方法寫數據
        baos.write("hello".getBytes());
        //將寫入內存中的數據讀取出來
        byte[] buf = baos.toByteArray();//調用這個方法，將之前寫入內存中的數據存儲到字節數組中
        ByteArrayInputStream bais = new ByteArrayInputStream(buf);//將剛纔存儲到字節數組中的內容關聯上bais

        //只有這樣之後，我們纔可以直接從bais中讀取我們想要的內容
        //一次讀取一個字節
        int by;
        while ((by=bais.read())!=-1) {
            System.out.print((char)by);
        }
        //關流
        bais.close();
        baos.close();
    }

}

4.
* 打印流：
* 字節打印流 PrintStream
* 字符打印流 PrintWriter
*

特點：
A:只能操作目的地，不能操作數據源
B:可以操作任意類型的數據
C:如果啓動了自動刷新，能夠自動刷新
D:可以操作文件的流
注意：什麼流可以直接操作文件？
看流對象的API,如果其構造方法同時有File和String類型的參數，就可以直接操作文件。

案例1：利用字符打印流給文件中書寫數據（String類型），需要手動刷新

import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //使用打印流給文件中寫入hello,java,world
        //public PrintWriter(String fileName)
        PrintWriter pw = new PrintWriter("pw.txt");

        //給流關聯的文件中寫數據
        pw.write("hello");
        pw.write("java");
        pw.write("world");

        //刷新
        pw.flush();

        //3.關流
        pw.close();

    }

}

此時，我們沒有開啓自動刷新功能。
* 如何啓動自動刷新：利用構造
* PrintWriter(OutputStream out, boolean autoFlush)
* PrintWriter(Writer out, boolean autoFlush)
* boolean autoFlush :需要傳遞一個Boolean類型的參數，當傳遞進來的參數爲True時，表示自動刷新已經開始
* 如果啓用了自動刷新，則只有在調用 println、printf 或 format 的其中一個方法時纔可能完成此操作
* println():如果啓動了自動刷新，能夠實現刷新，而且還實現了自動換行。

案例2：利用字符流給文件中寫數據（int類型，boolean類型），啓動自動刷新

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

public class PrintWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //創建字符打印流對象，並開啓自動刷新
        //public PrintWriter(Writer out,boolean autoFlush)
        PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);

        //給流中寫數據
        //pw.write("hello");
        //pw.write("java");

        //注意：如果已經開啓了自動刷新功能，必須調用則 println、printf 或 format的時候，纔可以實現自動刷新
        pw.println("hello");
        pw.println("java");
        pw.println("world");//調用println這個方法給文件中寫數據，1.寫數據  2.換行  3.刷新

        //可以操作任意類型的數據
        pw.println(true);
        pw.println(12.34);

        //關流
        pw.close();

    }

}

**強調：實現自動刷新必須要倆個條件：1，必須利用
PrintWriter(OutputStream out, boolean autoFlush)
* PrintWriter(Writer out, boolean autoFlush) 的構造方法
* 2.必須在調用 println、printf 或 format 的其中一個方法時纔可以開啓自動刷新
3.當調用上面三個其中一個方法時，他會完成的操作是：
1.寫入代碼 2.換行 3 .自動刷新
：**
5.標準輸入輸出流
* System類下有這樣的兩個成員變量：

標準輸入流：
public static final InputStream in
標準輸出流：
public static final PrintStream out

案例1：利用標註輸入流進行鍵盤錄入，錄入後讀取流並打印在控制檯

import java.io.IOException;
import java.io.InputStream;

public class SystemIn {
    public static void main(String[] args) throws IOException {
        /**
         * public static final InputStream in
         */
        //將鍵盤錄入的數據封裝在了輸入流中
        //Scanner sc = new Scanner(System.in);
        InputStream is = System.in;

        //將鍵盤錄入的數據從輸入流中讀取出來
        int by;
        while ((by=is.read())!=-1) {
            System.out.print((char)by);
        }

        //關流
        is.close();
    }

}

案例2：用IO流實現鍵盤錄入，一次讀取一行數據
分析：由於是每次讀取一行，所以我們可以BuffferedReader()
InputStream is = System.in;
此時讀取的是字節流，而BufferedReader()需要的是字符流，
所以傳遞進來的參數必須是字符流，因此我們需要將字節流轉換成字符流 InputStreamReader()

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SystemIn2 {
    public static void main(String[] args) throws IOException {
        /**
         * 案例2：用IO流實現鍵盤錄入，一次讀取一行數據
         * InputStream is = System.in;
         * InputSreamReader isr = new InputStreamReader(is)
         * BufferedReader br = new BufferedReader(isr); 
         */
        //將上面的分析寫爲一部
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //一次讀取一行數據
        System.out.println("請輸入你的姓名");
        String name = br.readLine();
        System.out.println("請輸入你的年齡");
        String age = br.readLine();

        System.out.println(name+":"+age);
    }

}

案例：解析輸出語句System.out.println(“helloworld”);

import java.io.PrintStream;

/**
 *  標準輸出流：
 *  public static final PrintStream out
 *
 */
public class SystemOut {
    public static void main(String[] args) {
//      PrintStream ps = System.out;
//      ps.println(true);

        //上面兩行合併爲一行,底層調用的字節打印流中的方法
        System.out.println(true);
    }
}

注意：這句語句的本質是System中有一個out的靜態字段，所以我們可以通過System調用out字段，返回一個標準的輸出類，然後再調用println（）方法，打印數據

6.
* 合併流：SequenceInputStream類可以將多個輸入流串流在一起，合併爲一個輸入流，因此，該流也被稱爲合併流。

構造：
SequenceInputStream(InputStream s1, InputStream s2) ：將s1和s2合併成一個輸入流，先讀取s1後讀取s2

案例1：
我要把a.txt和b.txt寫到一個文件copy.txt
- 數據源：
a.txt
b.txt
目的地：
copy.txt

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //創建合併流對象
        //SequenceInputStream(InputStream s1, InputStream s2) ：將s1和s2合併成一個輸入流，先讀取s1後讀取s2
        //將兩個數據源合而爲一
        SequenceInputStream sis = new SequenceInputStream(new FileInputStream("a.txt"), new FileInputStream("b.txt"));
        //封裝目的地
        FileOutputStream fos = new FileOutputStream("copy2.java");

        //一下讀寫一個字節數組
        byte[] buf = new byte[1024];
        int len;
        while ((len=sis.read(buf))!=-1) {
            //讀多少寫多少
            fos.write(buf, 0, len);
        }

        //關流
        fos.close();
        sis.close();

    }

}

對象的序列化和反序列化
- 序列化流：把對象按照流一樣的方式寫到文件或者在網絡中傳輸。
- 反序列化流：把文件或者網絡中的流對象數據還原對象。
- - ObjectOutputStream：序列化流
    writeObject(Object obj) 將指定的對象寫入 ObjectOutputStream。
- ObjectInputStream：反序列化流
  Object readObject() 從 ObjectInputStream 讀取對象。
  *

1。先創建出一個學生類
import java.io.Serializable;

public class Studnet implements Serializable{
    //實現這個接口不需要實現任何方法，這個接口說白了就是僅僅給Student類，打上了一個可以被序列化的標示
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Studnet(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Studnet() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Studnet [name=" + name + ", age=" + age + "]";
    }
}

2. 利用序列化流將對象寫入文本中
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //創建序列化流對象
        //public ObjectOutputStream(OutputStream out)
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));

        //創建一個學生對象，將學生對象寫入文件中
        Studnet s = new Studnet("劉德華", 50);
        oos.writeObject(s);
        // java.io.NotSerializableException
        //類通過實現 java.io.Serializable 接口以啓用其序列化功能

        //關流
        oos.close();

    }

}

3.利用反序列化流將存儲到文件的對象讀取出來
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws Exception {
        //創建反序列化流對象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));

        //讀取文件中存儲的對象，以實現反序列化
        //readObject()
        Object object = ois.readObject();
        System.out.println(object);

        //關流
        ois.close();
    }
}

注意：如果一個類不是實現Serializable接口無法把實例化，會拋出異常Java.io.NotSerializableException
類通過實現 java.io.Serializable 接口以啓用其序列化功能。未實現此接口的類將無法使其任何狀態序列化或反序列化，所以我們可以通過讓對象的所屬類來實現序列化西街口

Properties
- Properties:Properties 類表示了一個持久的屬性集。
- 屬性列表中每個鍵及其對應值都是一個字符串。
- 特點：Properties 可保存在流中或從流中加載。
  案例：使用map集合的put方法給集合中存儲數據並且遍歷

import java.util.Properties;
import java.util.Set;
public class ProppertiesDemo {
    public static void main(String[] args) {
        //創建Properties對象，本質上上是一個map幾個，但是鍵值都是String類型
        Properties prop = new Properties();

        //給對象中存儲元素
        prop.put("zhangjie", "xiena");
        prop.put("huangxiaoming", "baby");
        prop.put("wanglaoshi", "zhangziyi");

        //map集合遍歷
        //獲取鍵的集合
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            System.out.println(key+":"+prop.get(key));

        }

    }
}

9.2
* Properties的特有功能：
* A:添加元素
* public Object setProperty(String key,String value)
* B:獲取元素
* public String getProperty(String key)
* public Set stringPropertyNames()
案例：使用它的特有功能添加元素並遍歷

package com.edu_08;

import java.util.Properties;
import java.util.Set;
public class PropertiesDemo2 {
    public static void main(String[] args) {
        //創建Properties這個集合
        Properties prop = new Properties();

        //調用public Object setProperty(String key,String value)
        prop.setProperty("huangxiaoming", "baby");
        prop.setProperty("dengchao", "sunli");
        prop.setProperty("xidada", "pengliyuan");

        //1.獲取所有鍵的集合
        //public Set<String> stringPropertyNames()
        Set<String> keys = prop.stringPropertyNames();
        //遍歷鍵，根據鍵找值
        for (String key : keys) {
            System.out.println(key+":"+prop.getProperty(key));
        }
    }

}

9.3
* 可以和IO流進行結合使用：
* 把文件中的數據加載到集合中。注意：文件中的數據必須是鍵值對象形式的（例如：String1=String2)
* public void load(InputStream inStream)
* public void load(Reader reader)
案例：創建一個鍵值對文件，將文件中的鍵值對加載到集合中，輸出集合

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo3 {
    public static void main(String[] args) throws IOException {
        //創建集合
        Properties prop = new Properties();

        //將文件中的鍵值對，加載到集合中
        prop.load(new FileReader("prop.txt"));

        //遍歷集合
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            System.out.println(key+":"+prop.getProperty(key));
        }

    }

}

- 把集合中的數據存儲到文本文件中，並且是按照鍵值對形式存儲的。
public void store(OutputStream out,String comments)
public void store(Writer writer,String comments)
案例：將創建的鍵值對集合加載到文件中

package com.edu_08;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo4 {
    public static void main(String[] args) throws IOException {
        //創建集合
        Properties prop = new Properties();

        //給集合中存儲數據
        prop.setProperty("liudehua", "50");
        prop.setProperty("liming", "60");
        prop.setProperty("zhangxueyou", "40");

        //將集合中的元素，存儲到文本文件中
        prop.store(new FileWriter("prop2.txt"), "name=age");

    }

}

案例：我有一個文本文件，我知道數據是鍵值對形式的，但是不知道內容是什麼。請寫一個程序判斷是否有“lisi”這樣的鍵存在，如果有就改變其值爲”100”
分析：1.我們可以先將文本加載到集合中，然後獲取所有的鍵的集合
2.在判斷集合中是否有這樣的鍵，如果有的話，重新給集合中添加這樣的鍵值對，
3.最後將修改後的集合，寫入到文本中

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropTest {
    public static void main(String[] args) throws IOException {
        /**
         *            zhangsan=3
           lisi=4
           wangwu=5
           1.創建集合對象
           2.將文件中的鍵值對加載到集合中
           3.獲取多有的鍵的集合，遍歷，判斷
           4.如果存在lisi，的話，給集合中重新存儲鍵值對lisi=100
           5.將集合中的數據存儲到文件中
         */
        //1.創建集合對象
        Properties prop = new Properties();

        // 2.將文件中的鍵值對加載到集合中
        prop.load(new FileReader("prop3.txt"));

        //3.獲取多有的鍵的集合，遍歷，判斷
        Set<String> keys = prop.stringPropertyNames();

        // 4.如果存在lisi，的話，給集合中重新存儲鍵值對lisi=100
        for (String key : keys) {
            if ("lisi".equals(key)) {
                prop.setProperty(key, "100");
            }
        }

        //5.將集合中的數據存儲到文件中
        prop.store(new FileWriter("prop3.txt"), null);

    }

案例：我有一個猜數字小遊戲的程序，請寫一個程序實現在測試類中只能用分超過5次提示：遊戲試玩已結束，請付費。態
態`這裏寫代碼片態析：

1.先創建一個運行遊戲的類，注意一定是靜態的，因爲只有靜態才能調用靜態

2.創建一個文本，裏面存入count=1,然後將文本加載到集合中，
3.然後將取出的文本，獲取count對應的次數，

4. 判斷，如果次數大於0，就開始執行遊戲，每運行一次後，次數加一，然後添加到集合中，

5，將集合中數據，加載到文本中

   1.創建遊戲類，
import java.util.Scanner;

public class GuessNumber {
    public static void startGame(){
        int ran = (int) (Math.random()*100+1);
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("請輸入你猜測得數字");
            int number = sc.nextInt();
            if (number>ran) {
                System.out.println("大了");
            }else if (number<ran) {
                System.out.println("小了");
            }else if (number==ran) {
                System.out.println("猜對了");
                break;
            }
        }
    }


}

2.創建測試類
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropTest {
    public static void main(String[] args) throws IOException {
        //1.將文件中的鍵值對加載到集合中
        Properties prop = new Properties();
        prop.load(new FileReader("count.txt"));

        //2.拿出已經玩耍的次數做判斷
        String count = prop.getProperty("count");
        //將String類型轉換爲int類型
        int number = Integer.parseInt(count);
        if (number>4) {
            System.out.println("次數已到，請付費");
        }else {
            //開啓遊戲
            GuessNumber.startGame();
            number++;
            //將自增的次數重新存儲到文件中
            prop.setProperty("count", number+"");
            //將新的prop集合存儲到文件中
            prop.store(new FileWriter("count.txt"), null);
        }
    }

}

DAY_03 面向對象思想_01修煉之路

Day4 某菜狗子的練習，查找字符串中重複的元素並輸出

淺析Java中的抽樣類和接口

淺析數組

DAY_02淺談ifelse與switch語句的不同菜狗子的修煉之路

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結