JAVA之IO流

Posted 大忽悠爱忽悠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVA之IO流相关的知识,希望对你有一定的参考价值。

IO流

IO流分类


File类

注意,\\在文件中是路径的分隔符,但是在java编程中一个\\的意思时转义符,在java中\\或者/才是文件的分隔符


文件类里面的基础方法

public class test {
    public static void main(String[] args) {
        //File f1=new File("D:\\\\IO","dhy.txt");//父路径和子路径
          //也可也File.separator作为文件分隔符
        //File  f7=new File("D:"+File.separator+"IO\\\\dhy.txt");
        File  f7=new File("D:\\\\IO\\\\dhy.txt");
        System.out.println(f7.getName());//获取文件名或者当前文件夹的名称
        System.out.println(f7.getPath());//获取文件或者文件夹的路径,就是new file时候写的路径
        System.out.println(f7.getAbsolutePath());//获取当前文件的绝对路径
        System.out.println(f7);//返回一个用当前文件的相对路径构建的对象
        System.out.println(f7.getAbsoluteFile());//返回一个用当前文件的绝对路径构建的file对象
        System.out.println(f7.getParent());//返回当前文件或者文件夹的父级路径
        f7.renameTo(new File("D:\\\\IO\\\\dhy.txt"));//给文件或文件夹重命名
        System.out.println(f7.exists());//判断文件或者文件夹是否存在
        System.out.println(f7.canWrite());//判断文件是否可写
        System.out.println(f7.canRead());//判断文件是否可读
        System.out.println(f7.isFile());//判断当前的file对象是不是文件
        System.out.println(f7.isDirectory());//判断当前的file对象是不是文件夹或者目录
        System.out.println(f7.lastModified());//获取文件的最后修改时间,返回的是一个毫秒数
        System.out.println(f7.length());//返回文件的长度,单位是字节数
    }
}


文件的新建,删除

public class test {
    public static void main(String[] args) {
        File  f7=new File("D:\\\\IO\\\\xpy.txt");
       if(!f7.exists())
       {
           try {
               f7.createNewFile(); //创建新文件
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
        f7.delete();//删除文件
    }
}


创建单层目录,多级目录

        File  f7=new File("D:\\\\IO\\\\dhy");
        f7.mkdir();//创建单层目录,如果使用这一方法来创建多层目录,就得一层一层的执行mkdir方法

        File  f7=new File("D:\\\\IO\\\\dhy\\\\a\\\\b\\\\c");
        f7.mkdirs();//创建多层目录


返回当前文件的子集

        File  f7=new File("D:\\\\IO");
        String[] list = f7.list();//返回当前文件夹的子集的名称,包括目录和文件
        for(String s:list)
        {
            System.out.println(s);
        }

        File  f7=new File("D:\\\\IO");
        File[] fs = f7.listFiles();//返回的是当前文件夹的子集的file对象,包括目录和文件
        for(File f:fs)
        {
            System.out.println(f);
        }


流的分类


文件字节输入流FileInputStream ----将文件中的数据读取出来

        FileInputStream in=new FileInputStream("D:\\\\IO\\\\dhy.txt");
         //设置一个byte数组接收读取的文件的内容
        byte[] b=new byte[10];
        //设置一个读取数据的长度
        int len=0;
        //read方法有一个返回值,返回值是读取的数据的长度,如果读取到最后一个数据,还会向后读取一个,这时候返回值就是-1
        //所以当read的返回值是-1时,整个文件就读取完毕了
       // in.read(b);
        //不断从文件中读取数据,返回读取长度,直到等于-1时,说明读取结束
          while((len=in.read(b))!=-1)
          {
              //第一个参数: 缓冲数据的数组  第二个参数:从数组的哪个位置开始转化字符串  第三个参数:总共转化几个字节
              System.out.println(new String(b,0,len));
          }
        in.close();//流在使用完毕之后一定要关闭


文件字节输出流FileOutputStream—将数据写入文件中

        //指定向dhy.txt里面输出数据
        //如果当前文件夹下面没有对应的.txt,那么会帮我们创建出来一个
        FileOutputStream out=new FileOutputStream("D:\\\\IO\\\\xpy.txt");
         String str="大忽悠";
         out.write(str.getBytes(StandardCharsets.UTF_8));//把数据写到内存中,这里是以字节方式写入的
        out.flush();//把内存中的数据刷写到硬盘上
        out.close();//关闭流


文件字节输入输出流复制图片案例

import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
    public static void main(String[] args) {
         CopyData("D:\\\\image\\\\long.jpg","D:\\\\IO\\\\dhy.jpg");
    }
    //inPath: 从哪个文件中读取数据      outPath:将读取出来的对应的数据写入到哪个文件中
    public static void CopyData(String inPath,String outPath)
    {
        try {
            FileInputStream in=new FileInputStream(inPath);
            FileOutputStream out=new FileOutputStream(outPath);
            byte[] bytes=new byte[1024];
           int len=0;
           while((len=in.read(bytes))!=-1)
           {
               //读取到内存中
                 out.write(bytes,0,len);//参数一是缓冲数组,参数2是从数组中的哪个位置开始读取,参数3是读取的长度
           }
           //将读取数据刷新到硬盘上
            out.flush();
           //安装逆序的顺序关闭流
            out.close();
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


文件字节流非常通用,可以用来操作字符的文档,还可以用来操作其他任何文件(图片,压缩包等),因为字节流使用的是二进制


文件字符输入流FileReader----将文件中的数据读取出来

public class test {
    public static void main(String[] args) {
         CopyData("D:\\\\IO\\\\dhy.txt");
    }
    public static void CopyData(String inPath)
    {
        try {
            //创建文件字符输入流对象
            FileReader fr=new FileReader(inPath);
            //创建临时存数据的字符数组
            char[] ch=new char[10];
            //定义一个输入流的读取长度
            int len=0;
            while((len=fr.read(ch))!=-1)
            {
                System.out.println(new String(ch,0,len));
            }
            fr.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


文件字符输出流FileWriter----向文件中写入字符数据

import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
    public static void main(String[] args) {
         CopyData("D:\\\\IO\\\\dpy.txt","大忽悠和小朋友");
    }
    //outPath:将读取出来的对应的数据写入到哪个文件中   text:输出的内容
     public static void CopyData(String outpath,String text)
    {
        try {
            FileWriter fw=new FileWriter(outpath);
            fw.write(text);//写到内存中
            fw.flush();//把内存的数据刷到硬盘
            fw.close();//关闭流
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}


字符流完成拷贝文件—只能拷贝文本文档

import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
    public static void main(String[] args) {
         CopyData("D:\\\\IO\\\\dpy.txt","D:\\\\IO\\\\copy\\\\copy.txt");
    }
    //outPath:将读取出来的对应的数据写入到哪个文件中   text:输出的内容
     public static void CopyData(String inpath,String outpath)
    {
        try {
            FileReader fr=new FileReader(inpath);
            FileWriter fw=new FileWriter(outpath);
            char[] c=new char[10];
            int len=0;
            //边读边写
            while((len=fr.read(c))!=-1)
            {
                fw.write(c,0,len);//写到内存中
            }
            fw.flush();//把内存的数据刷到硬盘
            fw.close();//关闭流
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}


字节流和字符流共同需要注意的问题


处理流之一缓冲流

字节缓冲输入流–BufferedInputStream

public class test {
    public static void main(String[] args) {
        try {
            CopyData();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

     public static void CopyData() throws IOException {
         //文件字节输入流对象
        FileInputStream in=new FileInputStream("D:\\\\IO\\\\dpy.txt");
        //把文件字节输入流放到缓冲字节输入流对象中
         BufferedInputStream br=new BufferedInputStream(in);
          byte[] b=new byte[100];
          int len=0;
          while((len=br.read(b))!=-1)
          {
              System.out.println(new String(b,0,len));
          }
          //关闭流的时候,按照最晚开的最关
         br.close();
          in.close();
    }
}


字节缓冲输出流–BufferedOutputStream

public class test {
    public static void main(String[] args) {
        try {
            CopyData();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

     public static void CopyData() throws IOException {
        //创建字节输出流对象
         FileOutputStream out=new FileOutputStream("D:\\\\IO\\\\dpy.txt");
         //把字节输出流对象放到缓冲字节输出流中
         BufferedOutputStream bo=new BufferedOutputStream(out);
         String s="hello world";
         //写到内存上
         bo.write(s.getBytes(StandardCharsets.UTF_8));
         //刷到硬盘上
         bo.flush();
         //关闭流的时候,最晚开的最早关闭,依次关
         bo.close();
         out.close();
    }
}


缓冲流实现文件的复制

import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
    public static void main(String[] args) {
        try {
            CopyData("D:\\\\image\\\\long.jpg","D:\\\\IO\\\\dhy.jpg");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

     public static void CopyData(String inpath,String outpath) throws IOException {
        //字节缓冲输入流
         BufferedInputStream bi=new BufferedInputStream(new FileInputStream(inpath));
         //字节缓冲输出流
         BufferedOutputStream bo=new BufferedOutputStream(new FileOutputStream(outpath));
         //用于存储数据的字节缓冲数组
         byte[] b=new byte[1024];
         //设置一个读取到的数组长度,直到读取到最后一个数据后面,返回-1
         int len=0;
         while((len=bi.read(b以上是关于JAVA之IO流的主要内容,如果未能解决你的问题,请参考以下文章

java基础之 IO 流(输入/出字符流)

java基础之 IO 流(RandomAccessFile类)

java基础之 IO 流(InputStream/OutputStream)

Java之IO流总结

java基础之IO流

Java 之IO流及应用