投稿
  1. 首页
  2. java

Java输入输出流

code • 2022-5-16 • java • 阅读 30

Java输入输出流,第1张

Java输入输出流

文章目录
  • Java输入输出流
  • File类的使用
  • 字节流
  • 缓冲流
  • 字符流
  • 对象序列化
  • 作业 01
  • 作业 02
  • 作业 03

File类的使用
  • 什么是文件?
    • 文件可认为是相关记录或放在一起的数据的集合
    • 在Java中，使用java.io.File类对文件进行 *** 作。
package may10;
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        // 创建File对象(3中方式)
        /**
         * c:\JavaTest\IO 绝对路径
         * IO 相对路径
         * File file1=new File("IO\1");表示当前目录开始
         * “。。\”表示跳上一级目录
         */
        //File file=new File("c:\JavaTest\IO\1.txt");
        //File file=new File("c:\JavaTest","IO\1.txt");
        File file=new File("c:\JavaTest");
        File file1=new File(file,"IO\1");
        /**
         * 判断是文件还是目录
         */
        System.out.println("content:"+file1.isDirectory());
        System.out.println("File:"+file1.isFile());

        // 创建目录
        File file2=new File("c:\JavaTest\Set","HashSet");
        if (!file2.exists()){
            // 创建单目录 mkdir 多级目录mkdirs
            //file2.mkdir();
            file2.mkdirs();
        }
        // 创建文件
        if (!file1.exists()){
            try {
                file1.createNewFile();
                /**
                 * 判断是否是绝对路径isAbsolute()
                 * 获取相对路径：getPath()
                 * 获取绝对路径：getAbsolutePath（）
                 * 获取文件名：getName（）
                 */
                System.out.println(file1.isAbsolute());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(file1.getAbsolutePath());
        System.out.println(file1.getPath());
    }
}
字节流 

package may10;

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

public class Test2 {
    /**
     * 字节流
     * 字节输入流：InputStream
     * FileInputStream
     * BufferedInputStream
     * 字节输出流：OutputStream
     * FileOutputStream
     * BufferedOutputStream 缓冲
     */
    public static void main(String[] args) {
        /**
         * FileInputStream.
         * 从文件中获取字节
         * 用于读取图像原始字节流
         */
//        // 创建FileInputStream对象
//        try {
//            FileInputStream fis=new FileInputStream("src\may10\imooc.txt");
//            //int n=fis.read();
//            // read -1:end
            int n=0;
            while (n!=-1){
                System.out.print((char) n);
                n= fis.read();
            }
//            int n=0;
//            while ((n=fis.read())!=-1){
//                System.out.print((char) n);
//            }
//            fis.close();
//            System.out.println((char) n);
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }catch (IOException e){
//            e.printStackTrace();
//        }
        // 创建FileInputStream对象
        try {
            FileInputStream fis = new FileInputStream("src\may10\imooc.txt");
            byte[] b=new byte[100];
//            fis.read(b);
//            System.out.println(new String(b));
            fis.read(b,0,5);
            System.out.println(new String(b));
            // read 读取过后在读取不会在从头开始
            int n=fis.read();
            System.out.println((char) n);
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 文件写入 拷贝
package may10;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test3 {
   /* public static void main(String[] args) {
        // FileOutputSream
        FileOutputStream fos;
        FileInputStream fis;
        try {
            // append:true 不覆盖源文件
            fos=new FileOutputStream("src\may10\imooc.txt",true);
            fis=new FileInputStream("src\may10\imooc.txt");
            fos.write(50);
            fos.write('a');
            System.out.println(fis.read());
            System.out.println((char) fis.read());
            fos.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }*/

    public static void main(String[] args) {
        // 文件拷贝
        FileInputStream fis;
        FileOutputStream fos;
        try {
            fis=new FileInputStream("src\image\happy.gif");
            fos=new FileOutputStream("src\image\happycopy.gif");
            int n=0;
            byte[] b=new byte[1024];
            while ((n=fis.read(b))!=-1){
                fos.write(b,0,n);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
缓冲流 
package may10;

import java.io.*;

/**
 * 缓冲流
 */
public class Test4 {
    public static void main(String[] args) {
        FileOutputStream fos;
        FileInputStream fis;
        BufferedOutputStream bos;
        BufferedInputStream bis;
        try {
            // 加入缓冲流速度更快
            fos = new FileOutputStream("src\may10\imooc.txt");
            bos = new BufferedOutputStream(fos);
            fis = new FileInputStream("src\may10\imooc.txt");
            bis = new BufferedInputStream(fis);
            long startTime=System.currentTimeMillis();
            bos.write(50);
            bos.write('a');
            bos.flush(); //强制清空，写入
            System.out.println(bis.read());
            System.out.println((char) bis.read());
            long endTime=System.currentTimeMillis();
            System.out.println(endTime-startTime);
            bos.close(); //数据也写进去了
            bis.close();
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
字符流 
package may10;

import java.io.*;

/**
 * 字符流 不是二进制流
 * Reader
 * writer
 * 字节字符转换流
 * InputStreamReader
 */
public class Test5 {
    public static void main(String[] args) {
        FileInputStream fis;
        InputStreamReader isr;
        FileOutputStream fos;
        OutputStreamWriter osw;
        // 加入缓冲区提高转换效率
        BufferedReader br;
        BufferedWriter bw;
        try {
            // 读写要保持编码一致
            fis = new FileInputStream("src\may10\imooc.txt");
            isr = new InputStreamReader(fis,"GBK");
            fos = new FileOutputStream("src\may10\imooc1.txt");
            osw = new OutputStreamWriter(fos,"GBK");
            br=new BufferedReader(isr);
            bw=new BufferedWriter(osw);
            int n = 0;
            char[] cbuf = new char[10];
            //1
//            while ((n=isr.read())!=-1){
//                System.out.print((char) n);
            }
//            2
            while ((n = br.read(cbuf)) != -1) {
                //String s=new String(cbuf,0,n);
                // System.out.print(s);
                bw.write(cbuf, 0, n);
                bw.flush();
            }
            fis.close();
            fos.close();
            isr.close();
            osw.close();
            br.close();
            bw.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
对象序列化 
package may10;

import java.io.*;

/**
 * 对象序列化:将Java对象转换成字节序列化的过程 反序列化：就是转成Java对象
 *  创建一个类，继承Serializable接口
 *  创建对象
 *  将对象写入文件
 *  从文件读取对象信息
 *
 *  对象输入流与输出流
 */
public class Test6 {
    public static void main(String[] args) {
        // 定义Goods对象
        Goods goods=new Goods("s01","电脑",3000);
        try {
            FileOutputStream fos=new FileOutputStream("src\may10\imooc.txt");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            FileInputStream fis=new FileInputStream("src\may10\imooc.txt");
            ObjectInputStream ois=new ObjectInputStream(fis);
            // 将对象信息写入文件
            oos.writeObject(goods);
            oos.writeBoolean(true);
            oos.flush();
            // 读取文件信息
            Goods goods1=(Goods) ois.readObject();
            System.out.println(goods1);
            System.out.println(ois.readBoolean());
            oos.close();
            fos.close();
            fis.close();
            ois.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}
作业 01

  • 创建一个File类对象，判断指定文件或目录是否存在，若存在判断其是文件还是目录，是否可读、可写。

  • 效果图:

  • 任务要求:

  • 1、先在File文件下创建一个Monday.docx的文件。 判断文件是否创建成功，若成功返回文件名称和父目录。

  • 2、先判断文件是否存在，若存在就先获取其路径或名称。

  • 3、再判断其是文件还是目录;判断文件是否可读、可写:
    方法:请用适当的方法创建文件，判断是文件还是目录;以及判断文件的可读性。

package homework.File;

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

public class Test {
    public static void main(String[] args) {
        // 创建文件
        File file=new File("src\homework\file\Monday.docx");

        if (!file.exists()){
            try {
                file.createNewFile();
                System.out.println("文件创建成功！");
                System.out.println("文件名称："+file.getName());
                System.out.println("文件上一级目录："+file.getParent());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (file.exists()){
            System.out.println("文件绝对路径"+file.getAbsolutePath());
        }
        System.out.print("文件/目录：");
        if (file.isFile()){
            System.out.println("这是文件");
        }else if (file.isDirectory()){
            System.out.println("这是目录");
        }
        if (file.canRead() && file.canWrite()){
            System.out.println("文件是可读、可写");
        }else if (file.canRead()){
            System.out.println("文件是可读");
        }else if (file.canWrite()){
            System.out.println("文件是可写");
        }
    }
}
  • 效果图
作业 02
  • 老师让程序员小马统计英文演讲稿speech.txt文件中共有多少个字符，并显示所有内容以便在演讲开始前
    有个准备，假如你是小马，请完成老师教给你的任务。
  • 文本内容: abcdefghijklmnopqrst
  • 统计结果: speech. txt文件中共有20个字节。
  • 任务要求:
    • 1、实例化FileInputStream对象
    • 2、设置while循环读取speech.txt文件内容
    • 3、在循环中设置计数器count, 每读取一个字节，count加1
package homework.File;

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

public class test02 {
    public static void main(String[] args) {
        FileInputStream fis ;
        try {
            fis =new FileInputStream("src\homework\file\speech.txt");
            int n,count=0;
            System.out.print("文件内容：");
            while ((n=fis.read())!=-1){
                count++;
                System.out.print((char) n);
            }
            System.out.println();
            System.out.print("统计结果：speech有多少"+count+"字节");
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }

    }
}
  • 效果图
作业 03
  • 编写一个Java程序，将100000个字符分别写入文件one.txt和文件two.txt, one用不加缓冲的文件输出流
    来写，two用缓冲文件输出流来写，比较用时的多少。
  • 效果图:
  • one . txt不使用缓冲流来写
  • 用时为: 98
  • two. txt使用缓冲流来写
  • 用时为: 2
  • 节省时间: 96ms
  • 任务要求:
    • 1、用FileOutputStream写one;
    • 2、用BufferedOutputStream写two;
    • 3、写100000个字符，可以使用for循环一次写入一 个。
package homework.File;

import java.io.*;

public class test03 {
    public static void main(String[] args) {
        int i=0;
        FileOutputStream fos;
        BufferedOutputStream bos;
        System.out.println("one.txt不使用缓冲流来写");
        try {
            long startTime=System.currentTimeMillis();
            fos =new FileOutputStream("src\homework\file\1.txt");
            while (i<10000){
                fos.write(i++);
            }
            long endTime=System.currentTimeMillis();
            System.out.println("用时："+(endTime-startTime));
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
        System.out.println("one.txt使用缓冲流来写");
        try {
            long startTime=System.currentTimeMillis();
            fos=new FileOutputStream("src\homework\file\1.txt");
            bos=new BufferedOutputStream(fos);
            while (i<10000){
                bos.write(i++);
            }
            bos.flush();
            long endTime=System.currentTimeMillis();
            System.out.println("用时："+(endTime-startTime));
            fos.close();
            bos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }

    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/920174.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-16
下一篇 2022-05-16

发表评论

登录后才能评论

评论列表（0条）

保存