Java文件输入输出

package org.java;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;


public class JavaUseTest {

    public static void main(String[] args) {
/*
 Java文件输入输出
 从输入流中 读取数据
在输出流中 写入数据

Java.io包提供流类
InputStream抽象类    的 子类 创建的 流对象 称为 字节输入流
OutputStream抽象类 的 子类 创建的 流对象 称为  字节输出流
Reader抽象类  的 子类 创建的 流对象 称为字符输入流 
Writer抽象类  的 子类 创建的 流对象 称为字符输出流


File类：
主要 获取一些文本信息：
构造方法:
File(URI uri);//传入文件的目录地址和名字 :file.txt:绝对路径是->C:UsersNirobert EintesonDesktopjavaFilefile.txt
File(String filename);//filename文件名字；会被认为在当前应用程序在同一目录;hello.txt:C:UsersNirobert Eintesoneclipse-workspaceHelloWorldhello.txt
File(String directoryPath,String filename);//directoryPath文件路径
File(File fileParentPath,String name);//在 file 的父路径 路径 下创建  新的 文件 filex.txt;

文件的属性：
public String getName();//获取文件的名字
public boolean canRead();//判断文件是否是  可读的
public boolean canWrite();//判断文件是否是 可被写入
public boolean exists();//判断文件是否 存在
public String getAbsolutePath();//获取文件的绝对路径
public String getParent();//获取文件的父目录
public boolean isFile();//判断文件是否是 一个普通的文件，而不是目录
public boolean isDirectory();//判断文件是否是一个目录
public boolean isHidden();//判断文件是否是 隐藏文件
public long lastModified();//获取文件的 最后修改的时间（毫秒数)
public long length();//获取文件的长度
public boolean delete();//删除文件;file.delete();
public boolean createNewFile();//如果目录中没有要创建的文件，那么会调用这个方法，创建这个文件
public 


文件的创建
File file=new File(filename);
文件的删除

目录：
pubic boolean mkdir();//创建一个目录 创建成功返回true,否则返回false(文件已存在也是false);
public String[] list();//以字符串形式目录下的所有文件
public String[] list(FilenameFilter object);//以字符串形式 返回目录下指定的类型的文件 如：.txt,.java
public File[] listFiles();//以File对象的形式返回目录下的所有文件
public File[] listFiles(FilenameFilter object);//以 File对象的形式 返回返回目录下指定的类型的文件 如：.txt,.java

FilenameFilter是一个接口;有方法accept(File dir,String name);需要实现接口
public boolean accept(File dir,String name);

字节型
 基本管道：FileInputStream  FileOutputStream
增强型 管道：在基本管道的外面 包上一层)
DataInputStream DataOutputStream
BufferedInputStream  BufferedOutputStream
ObjectInputStream ObjectOutputStream
增强型管道的 源 和目的地 都是 字节型 基本管道
public DataInputStream（InputStream   in） 
public DataOutputStream（OutnputStream  out） 
public BufferedInputStream(InputStream in) 
public BufferedInputStream(InputStream in, int size) 
public BufferedOutputStream(OutputStream out) 
public BufferedOutputStream(OutputStream out, int size) 
ObjectInputStream(InputStream in)
ObjectOutputStream(OutputStream out) 
对象输出流使用writeObject(Object obj)方法将一个对象obj写入到一个文件；对象输入流使用readObject()读取一个对象到程序中。
当使用对象流写入或读入对象时，要保证对象是序列化的 
一个类如果实现了Serializable接口(java.io包中的接口)，那么这个类创建的对象就是所谓序列化的对象 。



字符型：
基本管道:
FileReader  FileWriter
增强型:
BufferedReader  BufferedWriter


 
 
 文件字节流：
 读写文件的子类:FileInputStream 和FileOutputStream 
 若只是简单的读写文件，那么就可以使用FileInputStream 和FileOutputStream 
 


 文件字节输入流:
 关闭输入流 :fileInputStream.close();
FileInputStream 是 InputStream 的子类：
构造方法：
FileInputStream(String name);
FileInputStream（File file);
参数name 和file 称为输入流的源，输入流通过调用read方法 读出 源 中的数据

以字节为单位 读 文件
//2^8 =256-> 返回(0,255)字节值，到达末尾 返回-1
int read();//输入流 调用read() 方法 顺序 地 从源 中读取 单个  字节数据 ；
int read(byte b[]);//按照字节  顺序地 从文件中读取b.length个数据，然后放到 字节数组 b里面
int read(byte b[],int off,int len);///按照字节  顺序地 从文件中 off开始  顺序地  读取len个字节 ， 放到 字节数组 b里面
read读取文件，只要不关闭流，那么每次调用read 方法 都会顺序地 读取剩余 的内容，直到读完流中的文件 或者文件关闭

FileOutputStream类：
关闭输出流: 关闭输入流 :fileOutputStream.close();
构造方法：
FileOutputStream(String name);
FileOutputStream(File file);
以name ,file 作为目的地 把数据在 输出流中 写入文件中

以字节为单位 写入文件:
//以字节为单位顺序写入 数据
 public void write(byte b[]);//把字节数组中 数据 全部写入到文件中
 public void write(byte b[],int off,int len);//把字节数组中 偏移量off开始 共len个字节 数据，写入到文件中


字节流 ：的 read()和write() 方法
字节流不能很好的 处理Unicode字符 ，如汉字在文件中 占两个字节，使用字节流，可能出现乱码
可以加大 输入输出流的 强度 

将字节型 流 变成 字符型流
变成 FileReader()和 FileWriter() 是 Reader和Writer的子类
在java.io.*包里面
构造方法:
FileReader(String filename);
FileReader(File filename);
FileWriter(String filename);
FileWriter(File filename);

字符型read()，write()方法
int read();//从源 中读取一个字符  ，返回(0-65535，Unicode字符值)，读出失败返回-1
int read(char ch[]);//从源 中读取  ch.length 个 字符 ，放到 字符 数组 ch中；到达 源(文件) 的末尾 返回-1
int read(char ch[],int offset,int len);//从源 中从off开始 读取  len 个 字符 放到 字符数组 ch里面，到达 源(文件) 的末尾 返回-1;
void write(char ch);//字符输出流 写入 一个 字符
void write(char ch[]);//在字符输出流中  写入 一个 字符数组
void write(char ch[],int off,int len);//在字符输出流中  写入 一个 字符数组 的off开始   ，共len个字符 




缓冲流：
BufferReader类：缓冲输入流
BufferWriter类：缓冲输出流
如果要读取一行，那么字符型输入流 很难 知道一行是 多少个字符，所以采用 缓冲输入流

缓冲流的 源和目的地： 必须是 字符输入流 和 字符输出流 
构造方法：
BufferedReader(reader in);
BufferedWriter(Writer out);

向BufferedReader 传递 一个Reader的 子类 对象   (如：FileReader fileReader)来创建BufferedReader对象
如：        FileReader fileReader=new FileReader(file);
        BufferedReader bufferedReader=new BufferedReader(fileReader);//创建 缓冲 输入流 对象 
        String  str=bufferedReader.readLine();//方法读取一行数据,赋值给str-->toCharArray()变成字符数组
        //newLine();//写入一个回车符号
BufferedWriter(Writer out);

write(String str,int off,int len);//字符串str从 off开始 ，共len个字符 写入 文件中

字符输入流FileReader 首先 将 数据 读入缓存，然后 BufferedReader缓冲输入流 再从 缓存中 读取数据
     BufferedWriter缓冲输出流 先向 缓存中 写入数据，然后字符输入流FileWriter将 缓存 中的 数据 写入 目的地；
         当BufferedWriter 调用flush()方法 刷新 缓存 或close()方法 关闭的时候，即使 缓存 没有 溢出，仍然要 将缓存的内容送入目的地
             要先关闭 缓冲流，然后才能关闭 字符流
     


 */
        String path="C:\Users\Nirobert Einteson\Desktop\java\File\";//文件的所在的目录 
        
        File file=new File(path+"file.txt");//在path路径下 创建file.txt文件
        File file2=new File("file2.txt");//默认 和当前应用程序在同一目录;即:*.java 在同一目录下
        File file3=new File(path,"file3.txt");//在path路径下，创建file3.txt文件
        File file4=new File(file3.getParent(),"file4.txt");//在 file3的父路径 路径 下创建  新的 文件 file4.txt;
    
        System.out.println(file.getName()+" :绝对路径是->"+file.getAbsolutePath());
        System.out.println(file2.getName()+":绝对路径是->"+file2.getAbsolutePath());
        System.out.println(file3.getName()+":绝对路径是->"+file3.getAbsolutePath());
        System.out.println(file4.getName()+":绝对路径是->"+file4.getAbsolutePath());
        
        System.out.println("file文件是否可读"+file.canRead());
        System.out.println("file文件是否可写"+file.canWrite());
        System.out.println("file文件的长度"+file.length());

        //路径  path 下.的内容；//.代表 当前路径
        File dir=new File(path+".");//C:UsersNirobert EintesonDesktopjavaFile.
        //取出目录下的 所有.txt文件
        String[] filenames=dir.list(new FilenameFilter(){
            //重写 接口的 方法，这里属于是匿名接口的实现
            @Override
            public boolean accept(File dir,String name) {
                return name.endsWith(".txt");//dir路径下;名字以.txt结尾的文件
            }});
        //文件以字符串的形式  已经存到 filenames里面
        System.out.println(path+"路径下以.txt结尾的文件有"+filenames.length+"个"+"
"+"分别是:");
        for(String name1:filenames) {
            System.out.println(name1);
        }
        
        //直接获取文件夹里面的所有文件 存到字符串数组里面
        File file5=new File(path+".");//C:UsersNirobert EintesonDesktopjavaFile.
        String names[]=file5.list();//获取这个路径下的所有文件
        System.out.println(path+"路径下以.txt结尾的文件有"+names.length+"个"+"
"+"分别是:");
        for(String name1:names) {
            System.out.println(name1);
        }
        
        //删除文件
        file3.delete();
        System.out.println(file3.exists());
        
        try {//文件可能会抛出异常 ，所以需要在try-catch语句里面进行写
            
            //在输出流中 ，向文件写入数据--write();方法
            FileOutputStream fileOutputStream3=new FileOutputStream(file3);
            //变成字节数组，在 文件输出流中 ，写入到文件里面
            byte byteFile[]="this is a byte stream".getBytes();
            fileOutputStream3.write(byteFile);
            fileOutputStream3.close();
            
            FileOutputStream fileOutputStream4=new FileOutputStream(file4);
            fileOutputStream4.write(byteFile);
            fileOutputStream4.close();
            
            //从文件字节 的输入流 中读数据--->read()方法
            FileInputStream fileInputStream=new FileInputStream(file);
            
            byte byteReadData[]=new byte[8];//初始化8个字节数组
            int data;
            while((data=fileInputStream.read(byteReadData,0,8))!=-1) {//每次都读取8个字节 放到 byteReadData字节数组里面
                //data位每次从输入流中 实际读取了多少个数据
                //String string=new String(byteReadData,0,data);//data是每次读取了多少个字节数，比如8,8,8,3最后一个到不了8个字节
                //String string2=new String(byteReadData,0,8);//每次都输出8个，可能不正确，比如只读出了3个却输出了8个
                //System.out.println(string);
            }
            fileInputStream.close();
            
            
            //字符型 输出流
            
            FileWriter fileWriter=new FileWriter(file);
            char ch[]="这是一个字符型流测试的样例".toCharArray();//字符串 变成 字符串数组
            fileWriter.write(ch);//字符数组
            fileWriter.write(ch, 4, 3);//字符数组
            fileWriter.write('X');//写入一个字符
            fileWriter.write("hello",1,3);//字符串 
            fileWriter.close();
            
            //字符输入流
            FileReader fileReader=new FileReader(file);
            char readChar[]=new char[8];//每次读取8个字符
            int index=0;
            while((index=fileReader.read(readChar,0,8))!=-1) {
                String tmp=new String(readChar,0,index);
                System.out.println("读取的字符型数据："+tmp+"
");
                System.out.println("读取单个字符："+(char)fileReader.read());//返回0-65535转成字符
            }
            fileReader.close();
            
            
            // 缓冲 输出流
            FileWriter fileWriter2=new FileWriter(file);
            BufferedWriter bufferedWriter=new BufferedWriter(fileWriter2);
            bufferedWriter.write("hhhhhhhh+ko+'
'+ok+hhhhhhhh");
            bufferedWriter.newLine();//写入换行符
            bufferedWriter.close();//要先关闭 缓冲流，然后才能关闭 字符流
            fileWriter2.close();
            
            
            //缓冲 输入流
            FileReader fileReader2=new FileReader(file);
            BufferedReader bufferedReader=new BufferedReader(fileReader2);
            String string=null;//string用来接收 readLine() 字符串,最后默认返回为null
            while((string=bufferedReader.readLine())!=null) {//只要读出的 不是null,说明不为空
                System.out.println("缓冲输入流：读出的文件是："+string);
            }
            bufferedReader.close();//要先关闭 缓冲流，然后才能关闭 字符流
            fileReader2.close();
            
            
        }catch (IOException e) {
            System.out.println(e);
        }
        
    }

}

输出结果：

file.txt :绝对路径是->C:UsersNirobert EintesonDesktopjavaFilefile.txt
file2.txt:绝对路径是->C:UsersNirobert Eintesoneclipse-workspaceHelloWorldfile2.txt
file3.txt:绝对路径是->C:UsersNirobert EintesonDesktopjavaFilefile3.txt
file4.txt:绝对路径是->C:UsersNirobert EintesonDesktopjavaFilefile4.txt
file文件是否可读true
file文件是否可写true
file文件的长度29
C:UsersNirobert EintesonDesktopjavaFile路径下以.txt结尾的文件有3个
分别是:
file.txt
file3.txt
file4.txt
C:UsersNirobert EintesonDesktopjavaFile路径下以.txt结尾的文件有3个
分别是:
file.txt
file3.txt
file4.txt
false
读取的字符型数据：这是一个字符型流

读取单个字符：测
读取的字符型数据：试的样例字符型X

读取单个字符：e
读取的字符型数据：ll

读取单个字符：�
缓冲输入流：读出的文件是：hhhhhhhh+ko+'
缓冲输入流：读出的文件是：'+ok+hhhhhhhh