Java第10课（Java的输入输出），

Java第10课（Java的输入输出），

本文参考《Java编程手记——从实践中学习Java》 欧二强等编著 

--------------------------------------------------------------------------数据流
字节流：由字节组成的，主要用于处理二进制数据。
字符流：由字符组成的，主要用于处理文本数据。

Java流的实现定义在java.io包内部的类层次结构中，要用流，必须导入java.io包。Java
除了java.io包中的流类外，还有内置流位于java.lang包中，这个类就是System类，该类
包含了3个预定义的流变量，分别是in,out,err，他们被声明为public static，这意味着
不通过System类的对象就可以直接调用。

System.out是标准的输出流，默认情况下向显示器输出。System.in是标准输入流，默认情
况下是输入键盘的数据。System.err是标准错误流，默认情况下是向显示器输出。

Java中一个字节有8b,一个字符由两个字节组成。

--------------------------------------------------------------------------File类
java.io.File不属于Java流系统

File类的对象是一个“文件或目录”的抽象代表。File类的对象并不打开文件或目录，而
是制定要操作的文件或目录。File类的对象一旦创建，就不能再更改，就是说它代表的抽
象路径是不能改变的。

File类的常量、构造函数、常用函数有很多，下面介绍的仅仅是常用的几个，以后学习中
也要注意，很多类的用法很多，随用可以随查，特别注意这一点。

1）创建、删除文件，获取文件属性信息

package package_java;

import java.io.File;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop","file.docx");//创建File类对象
        //也可以这么写：File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\file.docx");
        if(file.exists()) { //若存在，删除
            file.delete();
            System.out.println("删除成功！");
        }else {     //不存在，创建
            create_file(file);
        }
    }
    public static void create_file(File file) {
        try {
            file.createNewFile();   //创建文件
            System.out.println("创建成功！");

            //获取文件的属性信息
            System.out.println("文件名： "+file.getName());
            System.out.println("文件路径： "+file.getPath());
            System.out.println("文件大小： "+file.length());
            System.out.println("文件最后修改的时间： "+file.lastModified());
            System.out.println("文件可读： "+file.canRead()+"\t"+"文件可写： "+file.canWrite());
        }catch(IOException e) {
            System.out.println("创建失败！");
            e.printStackTrace();
        }
    }

}

程序运行一次结果：
在指定位置创建了文件：file.docx，同时输出下面信息

创建成功！
文件名： file.docx
文件路径： C:\Users\ccnuacmhdu\Desktop\file.docx
文件大小： 0
文件最后修改的时间： 1517470122499
文件可读： true  文件可写： true

再运行一次结果：
删除了指定位置的file.docx文件，同时输出下面信息
删除成功！


2）输出目录中的所有文件

list()：只返回文件名
listFiles()：返回文件名及路径信息

package package_java;

import java.io.File;

public class Student{
    public static void main(String []args){
        File file=new File("F:\\Java学习笔记");//创建File类对象
        String list[]=file.list();
        System.out.println("******list()******");
        for(int i=0;i<list.length;i++)
            System.out.println(list[i]);

        System.out.println();
        System.out.println("******listFiles()******");
        File listFile[]=file.listFiles();
        for(int i=0;i<listFile.length;i++)
            System.out.println(listFile[i]);
    }
}

输出结果：
******list()******
.metadata
.recommenders
123
J
Java第10课（Java的输入输出）.txt
Java第1课---第一个Java程序.txt
Java第2课（数组）.txt
Java第3课（方法（函数）） - 副本.txt
Java第4课（String类） - 副本.txt
Java第5课（StringBuffer类）.txt
Java第6课（核心内容：类） - 副本.txt
Java第7课（核心内容：继承与多态） - 副本.txt
Java第8课（类的高级使用） - 副本.txt
Java第9课（异常处理） - 副本.txt
RemoteSystemsTempFiles

******listFiles()******
F:\Java学习笔记\.metadata
F:\Java学习笔记\.recommenders
F:\Java学习笔记\123
F:\Java学习笔记\J
F:\Java学习笔记\Java第10课（Java的输入输出）.txt
F:\Java学习笔记\Java第1课---第一个Java程序.txt
F:\Java学习笔记\Java第2课（数组）.txt
F:\Java学习笔记\Java第3课（方法（函数）） - 副本.txt
F:\Java学习笔记\Java第4课（String类） - 副本.txt
F:\Java学习笔记\Java第5课（StringBuffer类）.txt
F:\Java学习笔记\Java第6课（核心内容：类） - 副本.txt
F:\Java学习笔记\Java第7课（核心内容：继承与多态） - 副本.txt
F:\Java学习笔记\Java第8课（类的高级使用） - 副本.txt
F:\Java学习笔记\Java第9课（异常处理） - 副本.txt
F:\Java学习笔记\RemoteSystemsTempFiles


3）创建目录
mkdir()：只能创建单级目录
mkdirs()：可以创建多级目录，就是说一次性可以把一个目录及其子目录同时创建出来


package package_java;

import java.io.File;

public class Student{
    public static void main(String []args){
        File file1=new File("F:\\Java学习笔记\\ok");//创建File类对象
        if(file1.mkdir()) {
            System.out.println("F:\\Java学习笔记\\ok 创建成功！");
        }else {
            System.out.println("F:\\Java学习笔记\\ok 创建失败！");
        }

        File file2=new File("F:\\Java学习笔记\\not ok\\not okok\\not okokok");//创建File类对象
        if(file2.mkdirs()) {
            System.out.println("F:\\Java学习笔记\\not ok 创建成功！");
        }else {
            System.out.println("F:\\Java学习笔记\\not ok 创建失败！");
        }
    }
}


--------------------------------------------------------------------------字节流
1）字节输入流：InputStream类（是个抽象类）。
所有字节输入流都是InputStream的子类。以InputStream类的子类FileInputStream类介绍

//从文件读入数据
package package_java;

import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");

        byte b[]=new byte[(int)file.length()];
        try {
            FileInputStream input=new FileInputStream(file);
            input.read(b);
            input.close();
        }catch(IOException e) {
            e.printStackTrace();
        }
        System.out.println(new String(b));
    }
}


//一个一个字节读取
package package_java;

import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");

        byte b[]=new byte[(int)file.length()];
        try {
            FileInputStream input=new FileInputStream(file);
            int len=0;
            int tmp;
            while((tmp=input.read())!=-1) { //到达结尾tmp=-1
                b[len++]=(byte)tmp;
            }
            System.out.println((b[0]+b[1]));
            input.close();
        }catch(IOException e) {
            e.printStackTrace();
        }
        System.out.println(new String(b));
    }
}

2）字节输出流：OutputStream类（是个抽象类）
所有字节输入流都是OutputStream的子类。以OutputStream类的子类FileOutputStream类介绍

//向文件中写入数据（下面程序是写入数据覆盖掉之前的）
package package_java;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        OutputStream out=null;
        String str="Hello, Java!";
        byte b[]=str.getBytes();
        try {
            out=new FileOutputStream(file);

            out.write(b);
            out.close();
            System.out.println("写入成功");
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}


//上面代码稍微改动，向文件中追加数据，而不是把原文件覆盖掉
package package_java;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        OutputStream out=null;
        String str="\r\nHello, Java!";//需要换行的话，前面加上\r\n
        byte b[]=str.getBytes();
        try {
            out=new FileOutputStream(file,true);//增加true，向文件中追加数据，而不是覆盖原来的

            out.write(b);
            out.close();
            System.out.println("写入成功");
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}


--------------------------------------------------------------------------字符流
在程序设计中，绝大多数应用程序都是使用字符流读取或写入“文本数据”。因为字符流支持
Unicode标准字符集的各种字符集，而字节流仅支持“ISO 8859-1（Latin-1）”字符集。
字符流不能处理二进制文件的主要原因是：字符流对象在写文件时会解释和处理文件中的特殊
字符，例如回车符、换行符、文件结束符等。特别地，当它碰到文件结束符时就会认为文件已
结束，而二进制文件可能在文件中间就出现文件结束符。

1）字符输入流：Reader类（是抽象类，用法类似InputStream类，区别是Reader读取单位是字符）
FileReader的构造函数:public FileReader(File file) throws FileNotFoundException


package package_java;

import java.io.File;
import java.io.Reader;
import java.io.FileReader;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        char str[]=new char[(int)file.length()];
        try {
            Reader read=new FileReader(file);
            read.read(str);
            read.close();
        }catch(IOException e) {
            System.out.println("读取失败！！！");
            e.printStackTrace();
        }
        System.out.println(str);
    }
}



//一个字符一个字符地读
package package_java;

import java.io.File;
import java.io.Reader;
import java.io.FileReader;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        char str[]=new char[(int)file.length()];
        int len=0;
        int tmp=0;
        try {
            Reader read=new FileReader(file);
            while((tmp=read.read())!=-1) {
                str[len++]=(char)tmp;
            }
            read.close();
        }catch(IOException e) {
            System.out.println("读取失败！！！");
            e.printStackTrace();
        }
        System.out.println(str);
    }
}


2）字符输出流：Writer类（是抽象类，用法类似OutputStream类，区别是Writer读取单位是字符）
FileWriter的构造函数：
public FileWriter(File file) throws IOException
public FileWriter(File file,boolean append) throws IOException


//覆盖原数据
package package_java;

import java.io.File;
import java.io.Writer;
import java.io.FileWriter;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");

        String str1="I love you.";
        String str2="\r\nI hate you.";
        char c[]=str2.toCharArray();
        try {
            Writer write=new FileWriter(file);
            write.write(str1);//可以用字符串
            write.write(c);//可以用字符数组，其他方式自行查阅文档
            System.out.println("写入成功！");
            write.close();
        }catch(IOException e) {
            System.out.println("写入失败！！！");
            e.printStackTrace();
        }
    }
} 


//追加数据（不覆盖原数据）
（可把上面代码改一下Writer write=new FileWriter(file,true);就变成了追加数据）
（可以用write.append(str1);//可以用字符串）


上面代码中，如果没有write.close()，将不能向文件中写入内容。字节流对文件操作，不需要
经过缓冲区；而字符流则要通过缓冲流来操作文件。也就是说，使用字节流时，就算没有执行
close()关闭字节流的操作，还是可以向文件输出内容的。但是在字符流中，若不执行close()，
就无法向文件写入内容。可以用write.flush()代替write.close()，清除缓冲区内容，写数据
到文件。


--------------------------------------------------------------------------转换流
1）输入字节流转为字符流：InputStreamReader类
转换时默认使用本次操作系统的字符编码或者指定其他字符编码
如果下面的程序不转换成字符的话，读中文这样的字节文件会出现乱码


package package_java;

import java.io.File;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");

        try {
            FileInputStream fin=new FileInputStream(file);
            InputStreamReader cin=new InputStreamReader(fin);
            int tmp;
            while((tmp=cin.read())!=-1) {
                System.out.print((char)tmp);
            }
            cin.close();
            fin.close();
        }catch(IOException e) {
            System.out.println("读取失败！！！");
            e.printStackTrace();
        }
    }
}

2）输出字节流转为字符流：OutputStreamWriter类
package package_java;

import java.io.File;
import java.io.OutputStreamWriter;
import java.io.FileOutputStream;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");

        try {
            FileOutputStream fout=new FileOutputStream(file);
            OutputStreamWriter cout=new OutputStreamWriter(fout);
            String str="我是中国人";
            cout.write(str);
            cout.close();//注意cout.close()要在fout.close()前面
            fout.close();
        }catch(IOException e) {
            System.out.println("写入失败！！！");
            e.printStackTrace();
        }
    }
}


--------------------------------------------------------------------------缓冲流

缓冲流把数据从原始流成块读入或把数据积累到一个大数据块后（到缓冲区）再成批写出，
通过减少系统资源的读写次数来加快程序的执行。

1）BufferedReader类

package package_java;

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

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        String str="";
        try {
            FileReader fread=new FileReader(file);
            BufferedReader bread=new BufferedReader(fread);
            str=bread.readLine();//读一行
            bread.close();
            fread.close();
        }catch(IOException e) {
            e.printStackTrace();
        }
        System.out.println(str);
    }
}


BufferedReader类还可以接收来自键盘输入的子节流，但需要使用InputStreamReader将键盘的子节流
System.in转化为字符流，如下：

//从键盘读入数据
package package_java;

import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.Reader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Student{
    public static void main(String []args){
        String str="";
        try {

            BufferedReader bin=new BufferedReader(new InputStreamReader(System.in));
            str=bin.readLine();//读一行
            bin.close();
        }catch(IOException e) {
            e.printStackTrace();
        }
        System.out.println(str);
    }
}


2）BufferedWriter类

package package_java;

import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        try {
            FileWriter fw=new FileWriter(file);
            BufferedWriter bw=new BufferedWriter(fw);
            String str[]={"我是小华","我来自北京","我骄傲"};
            for(int i=0;i<str.length;i++) {
                bw.write(str[i]);
                bw.newLine();//加上换行符
            }
            bw.close();
            fw.close();
            System.out.println("写入成功");
        }catch(IOException e) {
            e.printStackTrace();
            System.out.println("写入失败");
        }
    }
}



--------------------------------------------------------------------------内存操作流
略

ByteArrayInputStream类
ByteArrayOutputStream类



--------------------------------------------------------------------------打印流
PrintStream类

package package_java;

import java.io.PrintStream;

public class Student{
    public static void main(String []args){
        PrintStream ps=new PrintStream(System.out);
        ps.printf("%s","I am a boy.\n");
    }
}
--------------------------------------------------------------------------Scanner类
package package_java;

import java.util.Scanner;

public class Student{
    public static void main(String []args){
        Scanner scan=new Scanner(System.in);
        scan.useDelimiter("\n");//输入一行即换行
        System.out.println("请输入字符串： ");
        String str=scan.next();
        System.out.println(str);
    }
}



//正则式检验输入的邮箱是否正确
package package_java;

import java.util.Scanner;

public class Student{
    public static void main(String []args){
        Scanner scan=new Scanner(System.in);
        String pattern="^[a-zA-Z0-9_\\.]+@[a-zA-Z0-9-]+[\\.a-zA-Z]+$";
        System.out.println("请输入邮箱地址： ");
        String mail=null;
        if(scan.hasNext(pattern)) {
            mail=scan.nextLine();
            System.out.println("您输入的邮箱地址是： "+mail);
        }else {
            System.out.println("您输入的邮箱地址不正确！！！");
        }
    }
}



//从文件读取数据
package package_java;

import java.util.Scanner;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Student{
    public static void main(String []args){
        File file=new File("C:\\Users\\ccnuacmhdu\\Desktop\\java.txt");
        FileInputStream fis=null;
        Scanner  scan=null;
        try {
            fis=new FileInputStream(file);
            scan=new Scanner(fis);
        }catch(IOException e) {
            e.printStackTrace();
        }
        while(scan.hasNext()) {
            System.out.println(scan.next());
        }
    }
}

--------------------------------------------------------------------------RandomAccessFile类
略

可以从文件任何位置访问文件

--------------------------------------------------------------------------SequenceInputStream类
略
--------------------------------------------------------------------------压缩流
略