Java常用IO流

File类

构造方法:
File f1=new File(“K:\XiKai\Java\d17\fa.txt”);
//将f1指向当前目录:K:\XiKai\Java\d17\fa.txt

创建文件:
若此时所指向的目录若不存在便会出现IOException:系统找不到指定路径
File fa=new File(“E:\XiKai\Java\d17\fa.txt”);
fa.createNewFile()在指定目录下创建一个新文件:fa.txt

//不带盘符默认在当前项目下创建指定的文件
File fa2=new File(“fa2.txt”);
fa2.createNewFile();

创建目录:
File fa1=new File(“E:\XiKai\Java\d17\myFiles”);
//在指定路径下生成指定创建的目录
fa1.mkdir();//在E:\XiKai\Java\d17下创建了一个文件夹myFiles

创建多级目录:
//public boolean mkdirs()

File file4 = new File(“E:\aaa\bbb\ccc\ddd”) ;
file4.mkdirs();//在在E盘下生成目录aaa\bbb\ccc\ddd

删除
删除文件
public boolean delete()删除此抽象路径名表示的文件或目录
删除不能删除带有文件或者文件夹的目录

File fa=new File(“E:\XiKai\Java\d17\fa.txt”);
fa.createNewFile();
//删除文件fa.txt
fa.delete();

//需求:删除aaa\bbb\ccc
File file3 = new File(“aaa\bbb\ccc”) ;
System.out.println(“delte:”+file3.delete());
File file4 = new File(“aaa\bbb”) ;
System.out.println(file4.delete());
File file5 = new File(“aaa”) ;
System.out.println(file5.delete());

//重命名
File fb1=new File(“E:\XiKai\Java\d17\fos.txt”);
//fb1.createNewFile();
//fb2与fb1的抽象路径不一致,fb1.renameTo(fb2);将fos.txt从fb1所指的路径下剪切到了fb2所在的路径下
File fb2=new File(“fb2.txt”);//默认指向当前项目所在的路径
//fb1.renameTo(fb2);//将fb2.txt剪切到了当前项目路径下

    //当两者抽象路径一致时
    File fb3=new File("E:\\XiKai\\Java\\d17\\fb3.txt");
    fb1.renameTo(fb3);
    System.out.println(fb1.getName());//fos.txt
    System.out.println(fb3.getName());//fb3.txt
    //相当于将fos.txt复制到了fb3的位置,且为fb3的指定文件名

/*File类的高就获取功能:
* public String[] list():返回对象是一个字符串数组,当前哪个一盘符下的所有的文件以及文件夹的字符串名称数组
* public File[] listFiles():返回对象是一个File数组,当前哪个盘下的所有的文件以及文件夹的File数组
*/
//需求:获取e盘下所有的文件夹以及文件的字符串名称数组

    //用File对象封装下e盘
    File file = new File("E:\\") ;

    ////        public String[] list()
    String[] strArray = file.list() ;
    //遍历:遍历之前,一定要做非空判断
    if(strArray!=null){
        //增强for遍历
        for(String s:strArray){
            System.out.println(s);
        }
    }

    System.out.println("------------------------------------------");
    //public File[] listFiles():
    File[] fileArray = file.listFiles() ;
    if(fileArray !=null){
        for(File f :fileArray){
            System.out.println(f.getName());
        }
    }

文件过滤器:Xi-Java.myFile.FileFilter

IO流:
指的是设备和设备之间的的数据传输,即硬盘和内存之间的数据传输.
IO流的分类:
按流的方向分:
* 输入流:读数据的
* 输出流:写数据的
*
* 按数据类型分:
* 字节流:
* 字节输入流:InputStream
* 字节输出流:OutputStream
* 字符流
* 字符输入流:Reader
* 字符输出流:Writer

• 需求:输出一个文本文件,给文本文件中写一句话:hello,IO,Im’coming…
• 
  
  • 分析:
• 一旦提到文本文件,那么就是用字符流,但是字符流是在字节流之后出现的,所以先学习字节流!
• 用windows自带的记事本打开一个文件,你自己看懂,一般情况使用字符流最好.如果打开之后,读不懂,那么使用字节流.
• 使用字节流,来输出这个文件
• OutputStream:字节输出流,该类是抽象类,不能实例化,但是这里提到文件,刚才学习的File类就是描述文件的.
• FileOutputStream:OutputStream的子类
• 构造方法:
• public FileOutputStream(String name)
• 在抽象类的前面加上前缀:
• XXXInputStream
• XXXOutputStream
• XXXReader
• XXXWriter
• FileInputStream
  字符流:
• FileReader
• FileWriter
• 
  
  • 开发步骤”
• 1)创建文件输出流对象
• 2)写数据
• 3)关闭资源
• • @author Apple
    */
    public class OutputStreamDemo {

  public static void main(String[] args) throws IOException {
  //创建输出流对象
  // OutputStream os = new FileOutputStream(“os.txt”) ;//抽象类多态

  FileOutputStream fos = new FileOutputStream("fos.txt") ;
  
  /**
   * 创建文件输出流对象做了哪些事情:
   *  Java语言不能创建系统资源,通过C或C++间接创建系统资源
   *  创建的这个输出流对象,并指向这个fos.txt文件进行输出.
   */
  
  //有对象了,写数据
  //String类中一个方法:
          //getBytes() ;
  fos.write("hello,io,i'm coming...".getBytes()) ;
  
  //释放流资源
  fos.close() ;
  /**
   * 关闭流资源,关闭了就不能在写数据了
   * 并且该流对象输出完毕之后,不指向这个文件了,所以需要将它关闭掉
   */
  
  //java.io.IOException: Stream Closed:流已经关闭了,不能在操作了!
  

  // fos.write(“高圆圆”.getBytes()) ;
  }
  }

/**
* 针对输出流中写数据的方法:
* public abstract void write(int b):将指定的字节写入到输出流中
* public void write(byte[] b):将指定的字节数组写入到输出流中
* public void write(byte[] b, int off,int len):将字节数组的一部分写入到输出流中

//创建一个文件输出流对象
FileOutputStream fos = new FileOutputStream(“fos2.txt”) ;

    //写数据
    //      public abstract void write(int b):将指定的字节写入到输出流中

// fos.write(97) ;//—->二进制数据—–>记事本打开—>就找会找ASCII码表中找有没有该值对应的一个字符: a
// fos.write(55) ;
// fos.write(57) ;
// fos.write(65) ;

    //public void write(byte[] b):将指定的字节数组写入到输出流中
    byte[] bys = {97,98,99,100,101} ;
    fos.write(bys) ;

    //public void write(byte[] b, int off,int len):实际开发中:该方法和读数据一块使用
    fos.write(bys, 1, 3) ;

    //关闭资源
    fos.close() ;

将文件写到文件末尾:
public FileOutputStream(File file,Booean append)
第二个参数设置为true表示从文件的末尾开始写入内容
(
关于换行符号:
对于windows操作系统来说:换行符号:\r或者\n
* 对于Linux操操作系统来说:\n
* 对于Mac操作系统来说:\r
)
FileOutputStream fos=new FileOutputStream(“fb2.txt”,true);//File f=new File(“fb2.txt”);
for(int i=0;i<3;i++)
{
fos.write((i+1+”朵小花”).getBytes());
fos.write(“\n”.getBytes());
}
fos.close();
/**
* 运行结果:
*
* fb2.txt中的内容:
*
* 1朵小花
* 2朵小花
* 3朵小花
*
*/

//IO流中加入异常操作的标准用法:
//加入标准格式:try…catch…finally
//声明一个变量
FileOutputStream fos = null ;

        try {
            fos = new FileOutputStream("fos4.txt") ;

            //写数据
            fos.write("hello,Javaweb".getBytes()) ;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //释放资源的
            //由于是流对象,要对流对象做非空判断
            if(fos !=null){
                try {
                    fos.close() ;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

文件的读写:
读文件:
字节输入流(InputStream的子类):
1)public int read();一次读取一个字节
2)public int read(byte[] b);一次读取一个字节数组
//从此输入流中最多将b.length个字节的数据读入到一个byte数组中.

字符流(Reader的子类):
1)public int read();一次读取一个字节
2)public int read(byte[] b);一次读取一个字节数组
写文件:
字节输出流(OutputStream的子类):
1)public void write();一次写入一个字节
2)public void write(byte[] b);一次写入一个字节数组
字符输出流:(Writer的子类):
2

字节流文件读取示例:
假设当前项目下有一个a.txt文件,要将它的内容写到当前项目下的b.txt文件中.
//首先创建一个输入流对象,指向要读取的文件,即a.txt
InputStream is=new FileInputStream(“a.txt”);
//再创建一个输出流对象,指向要写入的文件,即b.txt
OutputSream os=new FileOutputStream(“b.txt”);
/*1)一次读取一个字节
int by=0;
while((by=is.read())!=-1)//到达文件末尾时返回-1
{
//对应的一次写入一个字节
os.write(by);
}
*/
//2)一次读取一个字节数组(比一次读取一个字节要快)
byte[] bys=new byte[1024];//一次最多读取的字节数,通常取2^10B即,1KB的大小
int length=0;//每次实际所读取的字节数
while((length=is.read(bys))!=-1)
{
//对应的一次写入一个实际读取到的字节数组
os.write(bys);
}

缓冲流:
BufferedInputStream
BufferedOutputStream
缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作.

flush()和close()方法的区别?
* flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
* close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!

使用缓冲流为什么比基本流要快?
缓冲流会有一个缓冲区.
当从从文件中读数据时,将读入的字符先存在缓冲区,如果缓冲区空间不足时,才会将数据存在流中.然后再次访问文件,从文件中读取内容.

当向文件中写入数据时,输出缓存流调用write方法将数据写在缓冲区中,等到缓冲区满了之后才将数据发送到流中.所以写入缓冲区的数据太小时,就经常会写不到指定文件中,所以最好在调用write方法后再调用flush方法,调用flush方法可以强制的将缓冲区中的数据发送到流中,不必等到缓冲区满.

使用缓冲流与基本流相比避免了多次访问文件.

GBK一个中文对应两个字节
unicode一个中文对应三个字节

字符流:
Reader
writer
字符输入流=字节输入流+编码格式(默认GBK)
public InputStreamReader(InputStream in,charset sc) ;
OutputStreamWriter——>字符转换流:可以将字节输出流转换字符流
Reader—->InputStreamReader(InputStream in):字符转换输入流
* 目的地:b.txt—->Writer—->OutputStreamWriter(Outputstream out):字符转换输出流
便捷类:
FileReader,FileWriter
FileReder(String fileName)
FieWriter(String fileName)

         //1)封装数据源和目的地
    FileReader fr = new FileReader("a.txt") ;
    FileWriter fw = new FileWriter("b.txt") ;

    //一次读取一个字符数组
    char[] chs = new char[1024] ;
    int len = 0 ;
    while((len=fr.read(chs))!=-1){
        fw.write(chs, 0, len) ;
        fw.flush() ;
    }

    //关闭资源
    fw.close() ;
    fr.close() ;

关于字符缓冲输入流的特有功能:
* BufferedWriter:
* public void newLine():写入一个换行符号
* BufferReader:
* public String readLine():一次读取一行

BufferedReader:字符缓冲输入流
* BufferedWriter:字符缓冲输出流
* 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
* 可以指定缓冲区的大小，或者接受默认的大小
*
* 构造方式:
* public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流

使用BufferedReader自定义输入:
package d18File;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.OutputStream;

/**
* 一次读取一行,同时写入文件
* @author Administrator
*
*/
public class InputStreamReader1 {

public static void main(String[] args) throws IOException {
    System.out.println("请输入一行数据");
    InputStreamReader isr=new InputStreamReader(System.in);
    BufferedReader br=new BufferedReader(isr);

    OutputStream os=new FileOutputStream("fis.txt");
    BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
    String str=null;
    while((str=br.readLine())!=null){
        if(str.equals("886")){//自定义结束标记
            break ;
        }
        bw.write(str);
        bw.newLine() ;
        bw.flush() ;        
    }
}

}
DataOutputStream和DataInputStream
* 都属于数据流:可以针对Java基本数据类型的数据进行读写操作
*
* DataOutputStream构造方法
* public DataOutputStream(OutputStream out)

PrintWriter:有自动刷新功能:
* public PrintWriter(Writer out,boolean autoFlush)
* 第二个参数指定为true,则启动自动刷新
* PrintWriter pw = new PrintWriter(new FileWriter(“pw.txt”),true) ;
* 加入自动刷新功能并且在写数据的时候,使用println():换行
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
* ByteArrayInputStream和ByteArrayOutStream(重点)
* 内存操作流:针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
* 特点:针对小文件进行操作!(聊天室项目中使用它进行发送文件)
*
*
* ByteArrayOutputStream:
* public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
* 成员方法:
* public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
* void reset():重置内存操作输出流
* ByteArrayInputStream:内存操作输入流:
* public ByteArrayInputStream(byte[] buf):参数数一个字节数组(缓冲数组)
*
* @author Apple
*/
public class ByteArrayStreamDemo {

public static void main(String[] args) throws IOException {

    //创建内存操作输出流对象
    ByteArrayOutputStream baos = new ByteArrayOutputStream() ;

    //写数据
    for(int x = 0 ; x <5 ; x ++){
        baos.write(("hello"+x).getBytes()) ;
    }

    /**
     * 内存操作流:查看其释放流对象的源码:
     * public void close() throws IOException {}
     * 并没有具体的关闭流对象,所以此流对象可以不关闭
     */
    //关闭资源

// baos.close() ;

    //将内存操作输出流对象转换成字节数组
    //public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
    byte[] buffer = baos.toByteArray() ;

    //创建内存操作输入流对象
    ByteArrayInputStream bais = new ByteArrayInputStream(buffer) ;

    //一次读取一个字节
    int by = 0 ;
    while((by=bais.read())!=-1){
        System.out.print((char)by);
    }

    //关闭

// bais.close() ;
}
}
标准输入和输出流
* System类中有两个字段:
* in:—–>InputStream is = System.in ;
* out—–>PrintStream ps = System.out ;
SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联
* 合并流在复制文件的时候,只能操作数据源,不能操作目的地
*
* 之前的操作:
* a.txt–>b.txt
* c.txt—>d.txt
*

SequenceInputStream(合并流)
* 现在有合并流(将两个文件中的内容复制到另一个文件中)
* a.txt+b.txt—>c.txt文件中
* 构造方法:
* public SequenceInputStream(InputStream s1,InputStream s2)
* 需求:将DataStreamDemo.java和ByteArrayStreamDemo.java两个java文件中的内容复制
*/
public class SequenceInputStreamDemo {

public static void main(String[] args) throws IOException {
    //分别封装这个两个java文件
    InputStream s1 = new FileInputStream("DataStreamDemo.java") ;
    InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java") ;

    //创建合并流对象
    SequenceInputStream sis = new SequenceInputStream(s1, s2) ;

    //封装目的地
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream("Copy.java"));

    //一次一个字节数组
    byte[] bys = new byte[1024] ;
    int len = 0 ;
    while((len = sis.read(bys))!=-1){
        //写数据
        bos.write(bys, 0, len) ;
        bos.flush() ;
    }       

// 释放资源
sis.close() ;
bos.close() ;
}
}

package org.westos_06;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/**
* SequenceInputStream的另一种构造方法:复制多个文件
* public SequenceInputStream(Enumeration