I/O流經常使用代碼

時間  2019-11-21
標籤 流經 常使 代碼 简体版
原文   原文鏈接

【案例1】建立一個新文件 php

1
2
3
4
5
6
7
8
9
10
11
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        File f=newFile("D:\\hello.txt");
        try{
            f.createNewFile();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

【運行結果】： java

程序運行以後，在d盤下會有一個名字爲hello.txt的文件。 python

【案例2】File類的兩個常量 linux

?
1
2
3
4
5
6
7
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        System.out.println(File.separator);
        System.out.println(File.pathSeparator);
    }
}

【運行結果】： web

\ shell

;
 apache

此處多說幾句：有些同窗可能認爲，我直接在windows下使用\進行分割不行嗎？固然是能夠的。可是在linux下就不是\了。因此，要想使得咱們的代碼跨平臺，更加健壯，因此，你們都採用這兩個常量吧，其實也多寫不了幾行。呵呵、 windows

如今咱們使用File類中的常量改寫上面的代碼： 數組

 

?
1
2
3
4
5
6
7
8
9
10
11
12
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        try{
            f.createNewFile();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

你看，沒有多寫多少吧，呵呵。因此建議使用File類中的常量。 dom

 

刪除一個文件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        if(f.exists()){
            f.delete();
        }else{
            System.out.println("文件不存在");
        }
          
    }
}

建立一個文件夾

?
1
2
3
4
5
6
7
8
9
10
11
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator+"hello";
        File f=newFile(fileName);
        f.mkdir();
    }
}

【運行結果】：

D盤下多了一個hello文件夾

 

列出指定目錄的所有文件（包括隱藏文件）：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator;
        File f=newFile(fileName);
        String[] str=f.list();
        for(inti =0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
}

【運行結果】：

$RECYCLE.BIN

360

360Downloads

360Rec

360SoftMove

Config.Msi

da

Downloads

DriversBackup

eclipse

java web整合開發和項目實戰

Lenovo

MSOCache

Program

Program Files

python

RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

System Volume Information

Tomcat6

var

vod_cache_data

新建文件夾

（你的運行結果應該和這個不同的，呵呵）

可是使用list返回的是String數組，。並且列出的不是完整路徑，若是想列出完整路徑的話，須要使用listFiles.他返回的是File的數組

 

列出指定目錄的所有文件（包括隱藏文件）：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator;
        File f=newFile(fileName);
        File[] str=f.listFiles();
        for(inti =0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
}

【運行結果】：

D:\$RECYCLE.BIN

D:\360

D:\360Downloads

D:\360Rec

D:\360SoftMove

D:\Config.Msi

D:\da

D:\Downloads

D:\DriversBackup

D:\eclipse

D:\java web整合開發和項目實戰

D:\Lenovo

D:\MSOCache

D:\Program

D:\Program Files

D:\python

D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

D:\System Volume Information

D:\Tomcat6

D:\var

D:\vod_cache_data

D:\新建文件夾

經過比較能夠指定，使用listFiles更加方便、

 

判斷一個指定的路徑是否爲目錄

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator;
        File f=newFile(fileName);
        if(f.isDirectory()){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}

【運行結果】：YES

 

搜索指定目錄的所有內容

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args) {
        String fileName="D:"+File.separator;
        File f=newFile(fileName);
        print(f);
    }
    publicstaticvoidprint(File f){
        if(f!=null){
            if(f.isDirectory()){
                File[] fileArray=f.listFiles();
                if(fileArray!=null){
                    for(inti =0; i < fileArray.length; i++) {
                        //遞歸調用
                        print(fileArray[i]);
                    }
                }
            }
            else{
                System.out.println(f);
            }
        }
    }
}

 

【運行結果】：

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class

……

 

【使用RandomAccessFile寫入文件】

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        RandomAccessFile demo=newRandomAccessFile(f,"rw");
        demo.writeBytes("asdsad");
        demo.writeInt(12);
        demo.writeBoolean(true);
        demo.writeChar('A');
        demo.writeFloat(1.21f);
        demo.writeDouble(12.123);
        demo.close();   
    }
}

 

若是你此時打開hello。txt查看的話，會發現那是亂碼。

 

字節流

【向文件中寫入字符串】

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        OutputStream out =newFileOutputStream(f);
        String str="你好";
        byte[] b=str.getBytes();
        out.write(b);
        out.close();
    }
}

查看hello.txt會看到「你好」

固然也能夠一個字節一個字節的寫。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        OutputStream out =newFileOutputStream(f);
        String str="你好";
        byte[] b=str.getBytes();
        for(inti =0; i < b.length; i++) {
            out.write(b[i]);
        }
        out.close();
    }
}

 

結果仍是：「你好」

 

向文件中追加新內容：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        OutputStream out =newFileOutputStream(f,true);
        String str="Rollen";
        //String str="\r\nRollen";  能夠換行
        byte[] b=str.getBytes();
        for(inti =0; i < b.length; i++) {
            out.write(b[i]);
        }
        out.close();
    }
}

 

【運行結果】：

你好Rollen

 

【讀取文件內容】

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        InputStream in=newFileInputStream(f);
        byte[] b=newbyte[1024];
        in.read(b);
        in.close();
        System.out.println(newString(b));
    }
}

 

【運行結果】

你好Rollen

Rollen_

可是這個例子讀取出來會有大量的空格，咱們能夠利用in.read(b);的返回值來設計程序。以下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        InputStream in=newFileInputStream(f);
        byte[] b=newbyte[1024];
        intlen=in.read(b);
        in.close();
        System.out.println("讀入長度爲："+len);
        System.out.println(newString(b,0,len));
    }
}

 

【運行結果】：

讀入長度爲：18

你好Rollen

Rollen

 

讀者觀察上面的例子能夠看出，咱們預先申請了一個指定大小的空間，可是有時候這個空間可能過小，有時候可能太大，咱們須要準確的大小，這樣節省空間，那麼咱們能夠這樣幹：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        InputStream in=newFileInputStream(f);
        byte[] b=newbyte[(int)f.length()];
        in.read(b);
        System.out.println("文件長度爲："+f.length());
        in.close();
        System.out.println(newString(b));
    }
}

 

文件長度爲：18

你好Rollen

Rollen

 

將上面的例子改成一個一個讀：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        InputStream in=newFileInputStream(f);
        byte[] b=newbyte[(int)f.length()];
        for(inti =0; i < b.length; i++) {
            b[i]=(byte)in.read();
        }
        in.close();
        System.out.println(newString(b));
    }
}

 

輸出的結果和上面的同樣。

 

細心的讀者可能會發現，上面的幾個例子都是在知道文件的內容多大，而後才展開的，有時候咱們不知道文件有多大，這種狀況下，咱們須要判斷是否獨到文件的末尾。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        InputStream in=newFileInputStream(f);
        byte[] b=newbyte[1024];
        intcount =0;
        inttemp=0;
        while((temp=in.read())!=(-1)){
            b[count++]=(byte)temp;
        }
        in.close();
        System.out.println(newString(b));
    }
}

 

【運行結果】

你好Rollen

Rollen_

提醒一下，當獨到文件末尾的時候會返回-1.正常狀況下是不會返回-1的

 

字符流

【向文件中寫入數據】

如今咱們使用字符流

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        Writer out =newFileWriter(f);
        String str="hello";
        out.write(str);
        out.close();
    }
}

 

當你打開hello。txt的時候，會看到hello

其實這個例子上以前的例子沒什麼區別，只是你能夠直接輸入字符串，而不須要你將字符串轉化爲字節數組。

當你若是想問文件中追加內容的時候，可使用將上面的聲明out的哪一行換爲：

Writer out =new FileWriter(f,true);

這樣，當你運行程序的時候，會發現文件內容變爲：

hellohello若是想在文件中換行的話，須要使用「\r\n」

好比將str變爲String str="\r\nhello";

這樣文件追加的str的內容就會換行了。

 

從文件中讀內容：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        char[] ch=newchar[100];
        Reader read=newFileReader(f);
        intcount=read.read(ch);
        read.close();
        System.out.println("讀入的長度爲："+count);
        System.out.println("內容爲"+newString(ch,0,count));
    }
}

 

【運行結果】：

讀入的長度爲：17

內容爲hellohello

hello

 

固然最好採用循環讀取的方式，由於咱們有時候不知道文件到底有多大。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="D:"+File.separator+"hello.txt";
        File f=newFile(fileName);
        char[] ch=newchar[100];
        Reader read=newFileReader(f);
        inttemp=0;
        intcount=0;
        while((temp=read.read())!=(-1)){
            ch[count++]=(char)temp;
        }
        read.close();
        System.out.println("內容爲"+newString(ch,0,count));
    }
}

 

運行結果：

內容爲hellohello

hello

 

關於字節流和字符流的區別

實際上字節流在操做的時候自己是不會用到緩衝區的，是文件自己的直接操做的，可是字符流在操做的 時候下後是會用到緩衝區的，是經過緩衝區來操做文件的。

讀者能夠試着將上面的字節流和字符流的程序的最後一行關閉文件的代碼註釋掉，而後運行程序看看。你就會發現使用字節流的話，文件中已經存在內容，可是使用字符流的時候，文件中仍是沒有內容的，這個時候就要刷新緩衝區。

 

使用字節流好仍是字符流好呢？

答案是字節流。首先由於硬盤上的全部文件都是以字節的形式進行傳輸或者保存的，包括圖片等內容。可是字符只是在內存中才會造成的，因此在開發中，字節流使用普遍。

 

文件的複製

其實ＤＯＳ下就有一個文件複製功能，好比咱們想把ｄ盤下面的ｈｅｌｌｏ．ｔｘｔ文件複製到d盤下面的rollen.txt文件中，那麼咱們就可使用下面的命令：

copy d:\hello.txt d:\rollen.txt

 

運行以後你會在d盤中看見hello.txt.，而且兩個文件的內容是同樣的，（這是屁話）

 

下面咱們使用程序來複制文件吧。

基本思路仍是從一個文件中讀入內容，邊讀邊寫入另外一個文件，就是這麼簡單。、

首先編寫下面的代碼：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        if(args.length!=2){
            System.out.println("命令行參數輸入有誤，請檢查");
            System.exit(1);
        }
        File file1=newFile(args[0]);
        File file2=newFile(args[1]);
          
        if(!file1.exists()){
            System.out.println("被複制的文件不存在");
            System.exit(1);
        }
        InputStream input=newFileInputStream(file1);
        OutputStream output=newFileOutputStream(file2);
        if((input!=null)&&(output!=null)){
            inttemp=0;
            while((temp=input.read())!=(-1)){
                output.write(temp);
            }
        }
        input.close();
        output.close(); 
    }
}

而後在命令行下面

javac hello.java

java hello d:\hello.txt d:\rollen.txt

如今你就會在d盤看到rollen。txt了，

 

 

OutputStreramWriter 和InputStreamReader類

整個IO類中除了字節流和字符流還包括字節和字符轉換流。

OutputStreramWriter將輸出的字符流轉化爲字節流

InputStreamReader將輸入的字節流轉換爲字符流

可是無論如何操做，最後都是以字節的形式保存在文件中的。

 

將字節輸出流轉化爲字符輸出流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="d:"+File.separator+"hello.txt";
        File file=newFile(fileName);
        Writer out=newOutputStreamWriter(newFileOutputStream(file));
        out.write("hello");
        out.close();
    }
}

運行結果：文件中內容爲：hello

將字節輸入流變爲字符輸入流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String fileName="d:"+File.separator+"hello.txt";
        File file=newFile(fileName);
        Reader read=newInputStreamReader(newFileInputStream(file));
        char[] b=newchar[100];
        intlen=read.read(b);
        System.out.println(newString(b,0,len));
        read.close();
    }
}

【運行結果】：hello

前面列舉的輸出輸入都是以文件進行的，如今咱們之內容爲輸出輸入目的地，使用內存操做流

ByteArrayInputStream 主要將內容寫入內容

ByteArrayOutputStream  主要將內容從內存輸出

使用內存操做流將一個大寫字母轉化爲小寫字母

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
importjava.io.*;
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        String str="ROLLENHOLT";
        ByteArrayInputStream input=newByteArrayInputStream(str.getBytes());
        ByteArrayOutputStream output=newByteArrayOutputStream();
        inttemp=0;
        while((temp=input.read())!=-1){
            charch=(char)temp;
            output.write(Character.toLowerCase(ch));
        }
        String outStr=output.toString();
        input.close();
        output.close();
        System.out.println(outStr);
    }
}

【運行結果】：

rollenholt

內容操做流通常使用來生成一些臨時信息採用的，這樣能夠避免刪除的麻煩。

管道流

管道流主要能夠進行兩個線程之間的通訊。

PipedOutputStream 管道輸出流

PipedInputStream 管道輸入流

驗證管道流
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
importjava.io.*;
  
classSendimplementsRunnable{
    privatePipedOutputStream out=null;
    publicSend() {
        out=newPipedOutputStream();
    }
    publicPipedOutputStream getOut(){
        returnthis.out;
    }
    publicvoidrun(){
        String message="hello , Rollen";
        try{
            out.write(message.getBytes());
        }catch(Exception e) {
            e.printStackTrace();
        }try{
            out.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}
  
classReciveimplementsRunnable{
    privatePipedInputStream input=null;
    publicRecive(){
        this.input=newPipedInputStream();
    }
    publicPipedInputStream getInput(){
        returnthis.input;
    }
    publicvoidrun(){
        byte[] b=newbyte[1000];
        intlen=0;
        try{
            len=this.input.read(b);
        }catch(Exception e) {
            e.printStackTrace();
        }try{
            input.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
        System.out.println("接受的內容爲 "+(newString(b,0,len)));
    }
}
classhello{
    publicstaticvoidmain(String[] args)throwsIOException {
        Send send=newSend();
        Recive recive=newRecive();
        try{
//管道鏈接
            send.getOut().connect(recive.getInput());
        }catch(Exception e) {
            e.printStackTrace();
        }
        newThread(send).start();
        newThread(recive).start();
    }
}

【運行結果】：

接受的內容爲 hello , Rollen

打印流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
importjava.io.*;
  
classhello {
    publicstaticvoidmain(String[] args)throwsIOException {
        PrintStream print =newPrintStream(newFileOutputStream(newFile("d:"
                + File.separator +"hello.txt")));
        print.println(true);
        print.println("Rollen");
        print.close();
    }
}

【運行結果】：

true

Rollen

固然也能夠格式化輸出

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
importjava.io.*;
classhello {
    publicstaticvoidmain(String[] args)throwsIOException {
        PrintStream print =newPrintStream(newFileOutputStream(newFile("d:"
                + File.separator +"hello.txt")));
        String name="Rollen";
        intage=20;
        print.printf("姓名：%s. 年齡：%d.",name,age);
        print.close();
    }
}

【運行結果】：

姓名：Rollen. 年齡：20.

 

使用OutputStream向屏幕上輸出內容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importjava.io.*;
classhello {
    publicstaticvoidmain(String[] args)throwsIOException {
        OutputStream out=System.out;
        try{
            out.write("hello".getBytes());
        }catch(Exception e) {
            e.printStackTrace();
        }
        try{
            out.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

【運行結果】：

hello

 

輸入輸出重定向

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.PrintStream;
  
publicclasssystemDemo{
    publicstaticvoidmain(String[] args){
        // 此刻直接輸出到屏幕
        System.out.println("hello");
        File file =newFile("d:"+ File.separator +"hello.txt");
        try{
            System.setOut(newPrintStream(newFileOutputStream(file)));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        System.out.println("這些內容在文件中才能看到哦！");
    }
}

【運行結果】：

eclipse的控制檯輸出的是hello。而後當咱們查看d盤下面的hello.txt文件的時候，會在裏面看到：這些內容在文件中才能看到哦！

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.PrintStream;
  
publicclasssystemErr{
    publicstaticvoidmain(String[] args){
        File file =newFile("d:"+ File.separator +"hello.txt");
        System.err.println("這些在控制檯輸出");
        try{
            System.setErr(newPrintStream(newFileOutputStream(file)));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        System.err.println("這些在文件中才能看到哦！");
    }
}

【運行結果】：

你會在eclipse的控制檯看到紅色的輸出：「這些在控制檯輸出」，而後在d盤下面的hello.txt中會看到：這些在文件中才能看到哦！

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.IOException;
  
publicclasssystemIn{
    publicstaticvoidmain(String[] args){
        File file =newFile("d:"+ File.separator +"hello.txt");
        if(!file.exists()){
            return;
        }else{
            try{
                System.setIn(newFileInputStream(file));
            }catch(FileNotFoundException e){
                e.printStackTrace();
            }
            byte[] bytes =newbyte[1024];
            intlen =0;
            try{
                len = System.in.read(bytes);
            }catch(IOException e){
                e.printStackTrace();
            }
            System.out.println("讀入的內容爲："+newString(bytes,0, len));
        }
    }
}

【運行結果】：

前提是個人d盤下面的hello.txt中的內容是：「這些文件中的內容哦！」，而後運行程序，輸出的結果爲：讀入的內容爲：這些文件中的內容哦！

 

BufferedReader的小例子

注意： BufferedReader只能接受字符流的緩衝區，由於每個中文須要佔據兩個字節，因此須要將System.in這個字節輸入流變爲字符輸入流，採用：

?
BufferedReader buf =newBufferedReader(
                newInputStreamReader(System.in));

下面給一個實例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
  
publicclassBufferedReaderDemo{
    publicstaticvoidmain(String[] args){
        BufferedReader buf =newBufferedReader(
                newInputStreamReader(System.in));
        String str =null;
        System.out.println("請輸入內容");
        try{
            str = buf.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        System.out.println("你輸入的內容是："+ str);
    }
}

運行結果：

請輸入內容

dasdas

你輸入的內容是：dasdas

 

Scanner類

其實咱們比較經常使用的是採用Scanner類來進行數據輸入，下面來給一個Scanner的例子吧

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.util.Scanner;
  
publicclassScannerDemo{
    publicstaticvoidmain(String[] args){
        Scanner sca =newScanner(System.in);
        // 讀一個整數
        inttemp = sca.nextInt();
        System.out.println(temp);
        //讀取浮點數
        floatflo=sca.nextFloat();
        System.out.println(flo);
        //讀取字符
        //...等等的，都是一些太基礎的，就不師範了。
    }
}

其實Scanner能夠接受任何的輸入流

下面給一個使用Scanner類從文件中讀出內容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.Scanner;
  
publicclassScannerDemo{
    publicstaticvoidmain(String[] args){
  
        File file =newFile("d:"+ File.separator +"hello.txt");
        Scanner sca =null;
        try{
            sca =newScanner(file);
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        String str = sca.next();
        System.out.println("從文件中讀取的內容是："+ str);
    }
}

 

【運行結果】：

從文件中讀取的內容是：這些文件中的內容哦！

數據操做流DataOutputStream、DataInputStream類

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.DataOutputStream;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
  
publicclassDataOutputStreamDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        char[] ch = {'A','B','C'};
        DataOutputStream out =null;
        out =newDataOutputStream(newFileOutputStream(file));
        for(chartemp : ch){
            out.writeChar(temp);
        }
        out.close();
    }
}

A B C

如今咱們在上面例子的基礎上，使用DataInputStream讀出內容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
importjava.io.DataInputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
  
publicclassDataOutputStreamDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        DataInputStream input =newDataInputStream(newFileInputStream(file));
        char[] ch =newchar[10];
        intcount =0;
        chartemp;
        while((temp = input.readChar()) !='C'){
            ch[count++] = temp;
        }
        System.out.println(ch);
    }
}

【運行結果】：

AB

合併流 SequenceInputStream

SequenceInputStream主要用來將2個流合併在一塊兒，好比將兩個txt中的內容合併爲另一個txt。下面給出一個實例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.io.SequenceInputStream;
  
publicclassSequenceInputStreamDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file1 =newFile("d:"+ File.separator +"hello1.txt");
        File file2 =newFile("d:"+ File.separator +"hello2.txt");
        File file3 =newFile("d:"+ File.separator +"hello.txt");
        InputStream input1 =newFileInputStream(file1);
        InputStream input2 =newFileInputStream(file2);
        OutputStream output =newFileOutputStream(file3);
        // 合併流
        SequenceInputStream sis =newSequenceInputStream(input1, input2);
        inttemp =0;
        while((temp = sis.read()) != -1){
            output.write(temp);
        }
        input1.close();
        input2.close();
        output.close();
        sis.close();
    }
}

【運行結果】

結果會在hello.txt文件中包含hello1.txt和hello2.txt文件中的內容。

文件壓縮 ZipOutputStream類

先舉一個壓縮單個文件的例子吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipOutputStream;
  
publicclassZipOutputStreamDemo1{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        File zipFile =newFile("d:"+ File.separator +"hello.zip");
        InputStream input =newFileInputStream(file);
        ZipOutputStream zipOut =newZipOutputStream(newFileOutputStream(
                zipFile));
        zipOut.putNextEntry(newZipEntry(file.getName()));
        // 設置註釋
        zipOut.setComment("hello");
        inttemp =0;
        while((temp = input.read()) != -1){
            zipOut.write(temp);
        }
        input.close();
        zipOut.close();
    }
}

【運行結果】

運行結果以前，我建立了一個hello.txt的文件，本來大小56個字節，可是壓縮以後產生hello.zip以後，竟然變成了175個字節，有點搞不懂。

不過結果確定是正確的，我只是提出個人一個疑問而已。

上面的這個例子測試的是壓縮單個文件，下面的們來看看如何壓縮多個文件。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipOutputStream;
  
publicclassZipOutputStreamDemo2{
    publicstaticvoidmain(String[] args)throwsIOException{
        // 要被壓縮的文件夾
        File file =newFile("d:"+ File.separator +"temp");
        File zipFile =newFile("d:"+ File.separator +"zipFile.zip");
        InputStream input =null;
        ZipOutputStream zipOut =newZipOutputStream(newFileOutputStream(
                zipFile));
        zipOut.setComment("hello");
        if(file.isDirectory()){
            File[] files = file.listFiles();
            for(inti =0; i < files.length; ++i){
                input =newFileInputStream(files[i]);
                zipOut.putNextEntry(newZipEntry(file.getName()
                        + File.separator + files[i].getName()));
                inttemp =0;
                while((temp = input.read()) != -1){
                    zipOut.write(temp);
                }
                input.close();
            }
        }
        zipOut.close();
    }
}

【運行結果】

先看看要被壓縮的文件吧：

接下來看看壓縮以後的：

你們天然想到，既然能壓縮，天然能解壓縮，在談解壓縮以前，咱們會用到一個ZipFile類，先給一個這個例子吧。java中的每個壓縮文件都是可使用ZipFile來進行表示的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
importjava.io.File;
importjava.io.IOException;
importjava.util.zip.ZipFile;
  
publicclassZipFileDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.zip");
        ZipFile zipFile =newZipFile(file);
        System.out.println("壓縮文件的名稱爲："+ zipFile.getName());
    }
}

 

【運行結果】：

壓縮文件的名稱爲：d:\hello.zip

 

如今咱們呢是時候來看看如何加壓縮文件了，和以前同樣，先讓咱們來解壓單個壓縮文件（也就是壓縮文件中只有一個文件的狀況），咱們採用前面的例子產生的壓縮文件hello.zip

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipFile;
  
publicclassZipFileDemo2{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.zip");
        File outFile =newFile("d:"+ File.separator +"unZipFile.txt");
        ZipFile zipFile =newZipFile(file);
        ZipEntry entry = zipFile.getEntry("hello.txt");
        InputStream input = zipFile.getInputStream(entry);
        OutputStream output =newFileOutputStream(outFile);
        inttemp =0;
        while((temp = input.read()) != -1){
            output.write(temp);
        }
        input.close();
        output.close();
    }
}

【運行結果】：

解壓縮以前：

 

這個壓縮文件仍是175字節

解壓以後產生：

又回到了56字節，表示鬱悶。

 

如今讓咱們來解壓一個壓縮文件中包含多個文件的狀況吧

ZipInputStream類

當咱們須要解壓縮多個文件的時候，ZipEntry就沒法使用了，若是想操做更加複雜的壓縮文件，咱們就必須使用ZipInputStream類

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.util.zip.ZipEntry;
importjava.util.zip.ZipFile;
importjava.util.zip.ZipInputStream;
  
publicclassZipFileDemo3{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"zipFile.zip");
        File outFile =null;
        ZipFile zipFile =newZipFile(file);
        ZipInputStream zipInput =newZipInputStream(newFileInputStream(file));
        ZipEntry entry =null;
        InputStream input =null;
        OutputStream output =null;
        while((entry = zipInput.getNextEntry()) !=null){
            System.out.println("解壓縮"+ entry.getName() +"文件");
            outFile =newFile("d:"+ File.separator + entry.getName());
            if(!outFile.getParentFile().exists()){
                outFile.getParentFile().mkdir();
            }
            if(!outFile.exists()){
                outFile.createNewFile();
            }
            input = zipFile.getInputStream(entry);
            output =newFileOutputStream(outFile);
            inttemp =0;
            while((temp = input.read()) != -1){
                output.write(temp);
            }
            input.close();
            output.close();
        }
    }
}

【運行結果】：

被解壓的文件：

解壓以後再D盤下會出現一個temp文件夾，裏面內容：

PushBackInputStream回退流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
importjava.io.ByteArrayInputStream;
importjava.io.IOException;
importjava.io.PushbackInputStream;
  
publicclassPushBackInputStreamDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        String str ="hello,rollenholt";
        PushbackInputStream push =null;
        ByteArrayInputStream bat =null;
        bat =newByteArrayInputStream(str.getBytes());
        push =newPushbackInputStream(bat);
        inttemp =0;
        while((temp = push.read()) != -1){
            if(temp ==','){
                push.unread(temp);
                temp = push.read();
                System.out.print("(回退"+ (char) temp +") ");
            }else{
                System.out.print((char) temp);
            }
        }
    }
}

 

【運行結果】：

hello(回退,) rollenholt

 

?
1
2
3
4
5
6
7
8
publicclassCharSetDemo{
    publicstaticvoidmain(String[] args){
        System.out.println("系統默認編碼爲："+ System.getProperty("file.encoding"));
    }
}

 

【運行結果】：

系統默認編碼爲：GBK

 

亂碼的產生：

?
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.OutputStream;
  
publicclassCharSetDemo2{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        OutputStream out =newFileOutputStream(file);
        byte[] bytes ="你好".getBytes("ISO8859-1");
        out.write(bytes);
        out.close();
    }
}

 

【運行結果】：

??

 

通常狀況下產生亂碼，都是因爲編碼不一致的問題。

對象的序列化

對象序列化就是把一個對象變爲二進制數據流的一種方法。

一個類要想被序列化，就行必須實現java.io.Serializable接口。雖然這個接口中沒有任何方法，就如同以前的cloneable接口同樣。實現了這個接口以後，就表示這個類具備被序列化的能力。

先讓咱們實現一個具備序列化能力的類吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
importjava.io.*;
publicclassSerializableDemoimplementsSerializable{
    publicSerializableDemo(){
          
    }
    publicSerializableDemo(String name,intage){
        this.name=name;
        this.age=age;
    }
    @Override
    publicString toString(){
        return"姓名："+name+"  年齡："+age;
    }
    privateString name;
    privateintage;
}

這個類就具備實現序列化能力，

在繼續將序列化以前，先將一下ObjectInputStream和ObjectOutputStream這兩個類

先給一個ObjectOutputStream的例子吧：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
importjava.io.Serializable;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectOutputStream;
  
publicclassPersonimplementsSerializable{
    publicPerson(){
  
    }
  
    publicPerson(String name,intage){
        this.name = name;
        this.age = age;
    }
  
    @Override
    publicString toString(){
        return"姓名："+ name +"  年齡："+ age;
    }
  
    privateString name;
    privateintage;
}
publicclassObjectOutputStreamDemo{
    publicstaticvoidmain(String[] args)throwsIOException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectOutputStream oos =newObjectOutputStream(newFileOutputStream(
                file));
        oos.writeObject(newPerson("rollen",20));
        oos.close();
    }
}

 

【運行結果】：

當咱們查看產生的hello.txt的時候，看到的是亂碼，呵呵。由於是二進制文件。

雖然咱們不能直接查看裏面的內容，可是咱們可使用ObjectＩｎｐｕｔＳｔｒｅａｍ類查看：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.ObjectInputStream;
  
publicclassObjectInputStreamDemo{
    publicstaticvoidmain(String[] args)throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectInputStream input =newObjectInputStream(newFileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}

 

【運行結果】

姓名：rollen  年齡：20

 

到底序列化什麼內容呢？

其實只有屬性會被序列化。

Externalizable接口

被Serializable接口聲明的類的對象的屬性都將被序列化，可是若是想自定義序列化的內容的時候，就須要實現Externalizable接口。

當一個類要使用Externalizable這個接口的時候，這個類中必需要有一個無參的構造函數，若是沒有的話，在構造的時候會產生異常，這是由於在反序列話的時候會默認調用無參的構造函數。

如今咱們來演示一下序列化和反序列話：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
packageIO;
  
importjava.io.Externalizable;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectInput;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutput;
importjava.io.ObjectOutputStream;
  
publicclassExternalizableDemo{
    publicstaticvoidmain(String[] args)throwsException{
        ser();// 序列化
        dser();// 反序列話
    }
  
    publicstaticvoidser()throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectOutputStream out =newObjectOutputStream(newFileOutputStream(
                file));
        out.writeObject(newPerson("rollen",20));
        out.close();
    }
  
    publicstaticvoiddser()throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectInputStream input =newObjectInputStream(newFileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}
  
classPersonimplementsExternalizable{
    publicPerson(){
  
    }
  
    publicPerson(String name,intage){
        this.name = name;
        this.age = age;
    }
  
    @Override
    publicString toString(){
        return"姓名："+ name +"  年齡："+ age;
    }
  
    // 複寫這個方法，根據須要能夠保存的屬性或者具體內容，在序列化的時候使用
    @Override
    publicvoidwriteExternal(ObjectOutput out)throwsIOException{
        out.writeObject(this.name);
        out.writeInt(age);
    }
  
    // 複寫這個方法，根據須要讀取內容 反序列話的時候須要
    @Override
    publicvoidreadExternal(ObjectInput in)throwsIOException,
            ClassNotFoundException{
        this.name = (String) in.readObject();
        this.age = in.readInt();
    }
  
    privateString name;
    privateintage;
}

【運行結果】：

姓名：rollen  年齡：20

本例中，咱們將所有的屬性都保留了下來，

Serializable接口實現的操做實際上是吧一個對象中的所有屬性進行序列化，固然也可使用咱們上使用是Externalizable接口以實現部分屬性的序列化，可是這樣的操做比較麻煩，

當咱們使用Serializable接口實現序列化操做的時候，若是一個對象的某一個屬性不想被序列化保存下來，那麼咱們可使用transient關鍵字進行說明：

下面舉一個例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
packageIO;
  
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serializable;
  
publicclassserDemo{
    publicstaticvoidmain(String[] args)throwsException{
        ser();// 序列化
        dser();// 反序列話
    }
  
    publicstaticvoidser()throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectOutputStream out =newObjectOutputStream(newFileOutputStream(
                file));
        out.writeObject(newPerson1("rollen",20));
        out.close();
    }
  
    publicstaticvoiddser()throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectInputStream input =newObjectInputStream(newFileInputStream(
                file));
        Object obj = input.readObject();
        input.close();
        System.out.println(obj);
    }
}
  
classPerson1implementsSerializable{
    publicPerson1(){
  
    }
  
    publicPerson1(String name,intage){
        this.name = name;
        this.age = age;
    }
  
    @Override
    publicString toString(){
        return"姓名："+ name +"  年齡："+ age;
    }
  
    // 注意這裏
    privatetransientString name;
    privateintage;
}

【運行結果】：

姓名：null  年齡：20

最後在給一個序列化一組對象的例子吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serializable;
  
publicclassSerDemo1{
    publicstaticvoidmain(String[] args)throwsException{
        Student[] stu = {newStudent("hello",20),newStudent("world",30),
                newStudent("rollen",40) };
        ser(stu);
        Object[] obj = dser();
        for(inti =0; i < obj.length; ++i){
            Student s = (Student) obj[i];
            System.out.println(s);
        }
    }
  
    // 序列化
    publicstaticvoidser(Object[] obj)throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectOutputStream out =newObjectOutputStream(newFileOutputStream(
                file));
        out.writeObject(obj);
        out.close();
    }
  
    // 反序列化
    publicstaticObject[] dser()throwsException{
        File file =newFile("d:"+ File.separator +"hello.txt");
        ObjectInputStream input =newObjectInputStream(newFileInputStream(
                file));
        Object[] obj = (Object[]) input.readObject();
        input.close();
        returnobj;
    }
}
  
classStudentimplementsSerializable{
    publicStudent(){
  
    }
  
    publicStudent(String name,intage){
        this.name = name;
        this.age = age;
    }
  
    @Override
    publicString toString(){
        return"姓名：  "+ name +"  年齡："+ age;
    }
  
    privateString name;
    privateintage;
}

 

【運行結果】：

姓名：  hello  年齡：20

姓名：  world  年齡：30

姓名：  rollen  年齡：40

 

寫在最後：本文章沒有涉及java.nio，等我有時間，我自會補上的，歡迎你們關注個人博客，你們一塊兒交流學習

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程