Java基础 输入输出流

最新推荐文章于 2020-09-04 18:08:39 发布
最新推荐文章于 2020-09-04 18:08:39 发布
阅读量321 收藏 1
点赞数
分类专栏： Java基础 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cudiannei3568/article/details/79321064
版权

笔者由于身体不适，这次就草草的整理了一下

第九章 输入输出流

9.1 文件

  • File(String filename)
  • File(String directoryPath , String filename)
  • File(File f, string filename)
    • filename:文件名
    • directoryPath:文件路径
    • f:目录

9.1.1 文件的属性

  • public String getName()
  • public boolean canRead()
  • public boolean canWrite()
  • public boolean exist()
  • public long length()
  • public String getAbsolutePath()
  • public getParent()
  • public boolean isFile()
  • public boolean isDirectory()
  • public boolean isHidden()
  • public long lastModified()

9.1.2 目录

  • 创建目录
    • public boolean mkdir()
  • 列出目录中的文件
    • public String[] list()
    • public File[] listFile()
    • public String[] list(FilenameFliter obj)
    • public File[] listFile(FilenameFliter obj)
      • FilenameFliter是一个接口
      • 有一个方法是public boolean accept(File dir , String name)
      • 接口回调机制

9.1.3 文件的创建与删除

  • public boolean creatNewFile()
    • File f = new File(“C:\myletter”,”letter.txt”);
    • f.createNewFile()
    • f.delete()

9.1.4 运行可执行文件

  • RunTime ec = RunTime.getRunTime()
  • ec.exec(String command)

9.2 文件字节流

9.2.1 FileInputStream类

  • 该类的所有方法都是从inputStream中继承来的
  • 称为文件字节输入流
  • 构造函数的参数称为输入流的源
    • FileInputStream(String name)
    • FileInputStream(File file)
  • 异常类
    • IOException
  • 从输入流中读取数据
    • read方法
      • int read()
        • 从输入流中顺序读取单个字节的数据，返回0～255，读到末尾则返回-1
      • 将多个字节读到一个字节数组中
        • int read(byte [])
        • int read(byte [] , int off, int length)
          • byte[] 表示读取后存储的地方
          • int off表示偏移单位
          • int length指定读取的最大字节数
          • 返回的数字是实际读取的字节数字，读到末尾则返回-1

9.2.2 FileOutputStream类

  • 从outputStream的子类
  • 称为文件输出字节流
  • 构造方法的参数称为输出流的目的
    • FileOutputStream(String name)
    • FileOutputStream(File file)
  • 不存在还创建
  • 存在会刷新(默认)，即重写
    • 可选择
      • FileOutputStream(File file , boolean append)
      • FileOutputStream(String name , boolean append)
        • true <==>不刷新
    • 用write()方法把数据写入输出流到达目的
      • public void write(byte[])
        • 把b.length个字节数据写入到输出流
      • public void write(byte[] , int off , int length)
        • 从给定字节数组中起始位置偏移off个位子写入length个字节到输出流
    • 只要不关闭流，每次调用write()就顺序写入到输出流中，直至流被关闭

Example3.java

package example3;
import java.io.*;
public class Example3 {
    public static void main(String args[]) {
        File file = new File("hello.txt");
        byte [] b = "欢迎,welcom".getBytes();
        try {
            FileOutputStream out = new FileOutputStream(file);
            out.write(b);
            out.close();
            FileInputStream in = new FileInputStream(file);
            int n = 0;
            do {
                n = in.read(b , 0 , 2);
                String str = new String(b,0,n);
                System.out.println(str);
            }
            while(n != -1);
        }
        catch(IOException e) {
            System.out.println(e);
        }
    }
}

9.3 文件字符流

9.3.1 FileReader类

  • 是Reader的子类
  • 其余几乎和FileInputStream一样
    • 构造方法
    • read()方法
      • 只不过把byte[ ] 换成 char[ ]
9.3.2 FileWriter类
  • 是Writer的子类
  • 其余几乎和FileOutputStream一样
    • 构造方法
    • write()方法
      • 只不过把byte[ ] 换成 char[ ]
      • 也有新的参数
        • public void writer(String str)
        • public void writer(String str , int off , int length)

Example4.java

package example4;
import java.io.*;
public class Example4 {
    public static void main(String args[]) {
        File file = new File("hello.txt");
        char b[] =  "欢迎 welcome".toCharArray();
        try {
            FileWriter writer = new FileWriter(file);
            writer.write(b);
            writer.write("欢迎来到北京");
            writer.close();
            FileReader r = new FileReader(file);
            int n = 0;
            do {
                n = r.read(b , 0 , 2);
                String str = new String(b,0,2);
                System.out.println(str);
            }
            while(n != -1);
        }
        catch(IOException e) {
            System.out.println(e);
        }
    }
}

Remark
* 对于Writer流，write方法将数据首先写入到缓冲区中，每当缓冲区溢出是，缓冲区的内容被自动写入到目的地，如果关闭流，换抽取的内容会被立刻写入到目的地。流调用flush()可以立刻冲洗当前缓冲区，即将当前缓冲区中的内容写入目的

9.4 缓冲流

可以读行

Example5.java

package example5;
import java.io.*;
public class Example5 {
    public static void main(String args[]) {
        File readFile = new File("Student.txt");
        File writeFile = new File("Hello.txt");
        try {
            FileReader inOne = new FileReader(readFile);
            BufferedReader inTwo = new BufferedReader(inOne);
            FileWriter tofile = new FileWriter(writeFile);
            BufferedWriter out =  new BufferedWriter(tofile);
            String s = null;
            int i = 0;
            do {
                s = inTwo.readLine();
                i++;
                out.write(i + " " + s);
                out.newLine();
            }
            while(s != null);
            out.flush();
            out.close();
            tofile.close();
            inOne = new FileReader(writeFile);
            inTwo = new BufferedReader(inOne);
            do {
                s = inTwo.readLine();
                System.out.println(s);
            }
            while(s != null);
            inOne.close();
            inTwo.close();
        }
        catch(IOException e) {
            System.out.println(e);
        }
    }
}

Example6.java

package example6;
import java.io.*;
import java.util.*;
public class Example6 {
    public static void main(String args[]) {
        Scanner inputAnswer = new Scanner(System.in);
        int score = 0;
        StringBuffer answer = new StringBuffer();
        String result = "ACDD";
        try {
            FileReader inOne = new FileReader("test.txt");
            BufferedReader inTwo = new BufferedReader(inOne);
            String s = null;
            do {
                s = inTwo.readLine();
                if(s == null) {
                    break;
                }
                if(!s.startsWith("*"))
                    System.out.println(s);
                if(s.startsWith("*")) {
                    System.out.println("输入选择的答案(A,B,C,D):");
                    String str = inputAnswer.nextLine();
                    try {
                        char c = str.charAt(0);
                        answer.append(c);
                    }
                    catch(StringIndexOutOfBoundsException exp) {
                        answer.append("*");
                    }
                }
            }
            while(s != null);
            inOne.close();
            inTwo.close();
        }
        catch(IOException exp) {}
        for(int i = 0 ; i < result.length() ; i++) {
            if(result.charAt(i) == answer.charAt(i) || result.charAt(i) == answer.charAt(i)
 - 32) {
        score ++;       
            }
        }
        System.out.printf("最后得分：%d\n",score);
    }
}

9.5 数据流

读取和写入指定数据类型的数据

Example7.java

package example7;
import java.io.*;
public class Example7 {
    public static void main(String args[]) {
        try {
            FileOutputStream fos = new FileOutputStream("jerry.txt");
            DataOutputStream out_data = new DataOutputStream(fos);
            out_data.writeInt(100);
            out_data.writeLong(123456);
            out_data.writeFloat(3.1415926f);
            out_data.writeBoolean(true);
            out_data.writeBoolean(false);
            out_data.writeChars("I am OK");
            out_data.close();
            fos.close();
        }
        catch(IOException e) {}
        try {
            FileInputStream fis = new FileInputStream("jerry.txt");
            DataInputStream in_data = new DataInputStream(fis);
            System.out.println(":" + in_data.readInt());
            System.out.println(":" + in_data.readLong());
            System.out.println(":" + in_data.readFloat());
            System.out.println(":" + in_data.readBoolean());
            System.out.println(":" + in_data.readBoolean());
            char c = '\0';
            do {
                c = in_data.readChar();
                System.out.print(c);
            }
            while(c != '\0') ;
            in_data.close();
            fis.close();
        }
        catch(IOException e) {}
    }
}

9.6 对象流

对象流进行读写操作
顺序的
* 自定义类要实现Serializable接口
* implements接口就行，不用具体实现接口的方法

TV.java

```
package example8;
import java.io.*;
public class TV implements Serializable{
    String name;
    int price;
    public void setName(String name) {this.name = name;}
    public void setPrice(int price) {this.price = price;}
    public String getName() {
        return name;
    }
    public int getPrice() {
        return price;
    }
}

```

Example8.java

    package example8;
    import java.io.*;
    public class Example8 {
        public static void main(String args[]) {
            TV changhong = new TV();
            changhong.setName("changhong");
            changhong.setPrice(5678);
            File file =  new File("television.txt");
            try {
                FileOutputStream fos = new FileOutputStream(file);
                ObjectOutputStream objectOut = new ObjectOutputStream(fos);
                objectOut.writeObject(changhong);
                objectOut.close();
                TV xinfei =  new TV();
                xinfei.setName("xinfei");
                xinfei.setPrice(6666);
                System.out.println(changhong.getName() + "的价格：" + changhong.getPrice()); 
                System.out.println(xinfei.getName() + "的价格:" + xinfei.getPrice());
            }
            /*
            catch(ClassNotFoundException e) {
                System.out.println("不能读出对象");
            }
            */
            catch(IOException e) {
                System.out.println(e);
            }
        }
    }

9.7 随机读写流

可以定位
* 构造方法
* RandomAccessFile(String name ,String mode)
* RandomAccessFile(File file , String mode)

  • seek(long pos)方法
  • getFilePointer()方法获得所在位置，字节数，返回long

Example9.java

package example9;
import java.io.*;
public class Example9 {
    public static void main(String args[]) {
        RandomAccessFile inAndOut = null;
        int data[] = {20,30,40,50,60};
        try {
            inAndOut = new RandomAccessFile("a.dat","rw");
            try {
                for(int i = 0 ; i < data.length ; i++)
                    inAndOut.writeInt(data[i]);
                for(long i = data.length - 1 ; i>=0 ;i--) {
                    inAndOut.seek(4*i);
                    System.out.printf("\t%d", inAndOut.readInt());
                }
            }
            catch(IOException e) {}
        }
        catch(Exception e) {}

    }
}

9.8 使用Scanner解析文件

  • Scanner(File file)
  • 默认分隔标志符
  • 正则表达式分隔标志符
    • useDelimiter(String regex)方法

Example10.java

package example10;
import java.io.*;
import java.util.*;
public class Example10 {
    public static void main(String args[]) {
        File file = new File("cost.txt");
        Scanner sc = null;
        int sum = 0;
        try {
            sc = new Scanner(file);
            while(sc.hasNext()) {
                try {
                    int price = sc.nextInt();
                    sum += price;
                    System.out.println(price);
                }
                catch(InputMismatchException e) {
                    String t = sc.next();
                }
            }
            System.out.println("The total costs is " + sum + " dolars");
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Example11.java

package example11;
import java.io.*;
import java.util.*;
public class Example11 {
    public static void main(String args[]) {
        File file = new File("communicate.txt");
        double sum = 0;
        Scanner sc = null;
        try {
            sc = new Scanner(file);
            String regex = "[^0123456789.]+";
            sc.useDelimiter(regex);
            while(sc.hasNext()) {
                double price = sc.nextDouble();
                System.out.println(price);
                sum += price;
            }
        }
        catch(Exception e){
            System.out.println(e);
        }
        System.out.println("the total cost is " + sum + "CNY");
    }
}

Example12.java

package example12;
import java.util.*;
import java.io.*;
public class Example12 {
    public static void main(String args[]) {
        File file = new File("english.txt");
        TestWord test = new TestWord();
        test.setFile(file);
        test.setStopTime(5);
        test.startTest();
    }
}
class TestWord{
    File file;
    int stopTime;
    public void setFile(File file) {
        this.file = file;
    }
    public void setStopTime(int stopTime) {
        this.stopTime = stopTime;
    }
    public void startTest() {
        Scanner sc = null;
        Scanner read = new Scanner(System.in);
        int isRightNumber = 0;
        int wordNumber = 0;
        try {
            sc = new Scanner(file);
            while(sc.hasNext()) {
                wordNumber++;
                String word = sc.next();
                System.out.printf("给%d秒的时间背单词%s\n", stopTime,word);
                Thread.sleep(stopTime * 1000);
                System.out.printf("\r");        //将光标移动到本行开头
                for(int i = 0 ; i < 50 ; i++) {
                    System.out.print("*");
                }
                System.out.printf("\n请输入显示的单词:");
                String input = read.nextLine();
                if(input == null) {
                    input = "****";
                }
                if(input.equals(word)) {
                    isRightNumber++;
                }
                System.out.printf("当前正确率:%5.2f \n", 100*(float)isRightNumber / wordNumber);
            }
            System.out.printf("正确率:%5.2f \n", 100*(float)isRightNumber / wordNumber);
        }
        catch(Exception exp) {
            System.out.println(exp);
            System.out.println(exp.getMessage());
            exp.printStackTrace();
        }
    }
}

9.9 小结

  1. 输入流的指向称作源，程序从指向源的输入流中读取源中的数据；输出流的指向称作目的地，程序通过向输出流中写入数据把信息传递到目的地
  2. InputStream的子类创建的对象称作字节输入流。字节输入流按字节读取源中的数据，只要不关闭流，每次调用读取方法就顺序地读取源中的其余内容
  3. Reader类创建的子类称为字符输入流，按字符读取数据，其余几乎同上
  4. OutputStream的子类的对象称作字节输出流。将数据写入指向输出流指向的目的中
  5. Writer的子类的对象称作字符出书流，按照字符，其余几乎同上

以上内容均根据《Java基础教程(第三版)》整理而成

wings0571to010
关注
专栏目录
java 输入输出流
qq_44676409的博客
07-18 718
使用输入流通常包括4个基本步骤: ●设定输入流的源 ●创建指向源的输入流 ●让输入流读取源中的数据; ●关闭输入流 如果对文件读取需求比较简单，那么可以使用FileInputStream 类(文件字节输入流)，该类是InputStream类的子类(以字节为单位读取文件)，该类的实例方法都是从InputStream类继承来的。 构造方法 可以使用FileInputStream 类的下列构造方法创建指向文件的输入流。 FileInputStream(String name) ; FileInputStream(
java IO(输入输出) 字符流
坚韧的小白杨
05-09 386
//读取文件中的字符package zhi_jie_liu; import java.io.*; public class Example08 { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub //创建一个FileReader对象来读取文件中的
JavaSE BufferedReader（字符输入缓冲流）
Lv Zejiang
09-04 274
Java自我学习路线缓冲流BufferedReader（字符输入缓冲流）构造方法1. BufferedReader(Reader in)2. public BufferedReader(Reader in, int sz)测试用例 缓冲流 缓冲流主要是为了提高效率而存在的，减少物理读取次数，缓冲流主要有：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter 由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流
Java序列化
wx123456wx的专栏
10-21 416
前些天看 sun 关于 java.io.Serializable 接口的文档,居然半天都没有看懂，感慨于自己的E文越来越没有水准的同时，又仔细翻了一些资料，终于有点眉目了，便整理出来，以资记录。一、什么是序列化？“对象序列化”（Object Serialization）是 Java1.1就开始有的特性。 简单地说，就是可以将一个对象及其状态转换为字节码，保存起来（可以保存在数据库，内存，文
教你完全理解IO流里的 read(),read(byte[]),read(byte[],int off,int len)以及write
农展飞的博客
07-01 2万+
len的作用 write(bytes);不严谨,后续有空的 write(bytes,0,len);严谨,和原来一模一样
实验9 Java输入输出流.doc
05-02
Java输入输出流是Java编程中一个非常重要的概念，主要用于数据的读取和写入操作，包括文本文件和二进制文件。在实验9中，主要目的是理解和掌握I/O流的分类，以及如何进行文本和二进制文件的读写。 I/O流在Java中被...
Java学习资料-输入输出流
最新发布
06-15
总之，Java的输入/输出流是程序与外部世界交换数据的基础。理解并熟练掌握这些流的概念和用法，对于开发任何涉及数据读写的Java应用程序都是至关重要的。无论是读取配置文件、处理用户输入，还是与其他程序交换数据...
java基础代码_java_输入输出流_接口_多线程_异常_
09-29
总结一下，Java基础代码的学习涵盖了输入输出流的使用，如何通过接口定义和实现类的行为规范，多线程的创建与管理，以及异常处理的策略。这些内容构成了Java程序员的基本技能，对于初学者来说至关重要。深入理解并...
Java IO输入输出流
12-22
Java IO输入输出流是Java平台中用于数据传输的基础框架，它是程序与外部设备之间交互数据的主要途径，包括读取和写入数据。IO流的概念基于“流”的思想，即数据以有序的方式从起点（源）流向终点（目的地）。在Java...
Java中对象的序列化与反序列化
lmm0513的博客
11-24 302
一、对象的序列化，就是将Object转换成byte序列，反之叫对象的反序列化 二、序列化流（ObjectOutStream）是过滤流——writeObject 反序列化流（ObjectInputStream）——readObject 三、序列化接口（Serializable） 对象必须实现序列化接口，才能进行序列化，否则将出现异常 这个接口，没有任何方法，只是一个标
流媒体开发之-音悦台TV解析特定条件下的所有TV视频
jwzhangjie的专栏
12-08 3万+
整合流媒体开发之-音悦台TV解析和流媒体开发之-音悦台TV页码链接解析这两部分来实现解析音乐台特定条件的所有TV视频链接。 package com.pigvideo.parser.yinyuetai; import com.pigvideo.model.YinYueTaiModel; import com.pigvideo.model.YinYueTaiPageModel; import o
java.io.FileInputStream.read(byte[] b, int off, int len)方法实例
dodod2012的专栏
06-21 4702
原文地址：https://www.yiibai.com/java/io/fileinputstream_read_byte_len.htmljava.io.FileInputStream.read(byte[] b, int off, int len) 读取从此输入流中的数据len个字节到字节数组，开始在目标数组b的偏移。声明以下是方法java.io.FileInputStream.read(by...
BufferedReader的用法
热门推荐
htyy521的专栏
09-12 3万+
 java---由键盘输入数据,字符串-BufferedReader的用法范例一:有键盘输入一串字符串,import java.io.*;public class bufferedreader{ public static void main(String args[]) throws IOException {  String mystring;  Buf
Java I/O 教程（十 一） BufferedWriter和BufferedReader
老徐的博客只有干货
01-13 673
Java BufferedWriter 类 Java BufferedWriter class 继承了Writer类，为Writer实例提供缓冲。 提升了写字符和字符串性能。 类定义： public class BufferedWriter extends Writer   构造函数： BufferedReader(Reader in) Creates a
JAVA实验报告五
qq_44939000的博客
07-29 274
JAVA实验报告五 1.利用BufferedReader、BufferedWriter等流类的相关方法，编程实现如下功能： （1）把字符串“C”、“C++”、“Java”分三行写入文本文件A.txt； （2）从A.txt中读出字符串，分行输出； （3）编写main方法，测试上述代码的功能。 2.利用文件流的相关操作，编程实现如下功能： （1）输出C:\Windows\System32\drivers\etc目录下的文件数目； （2）统计并输出每个文件拥有文本的行数； （3）编写main方法，测试上述代码的功
《Java 2 实用教程》课程学习(8)——第8章 常用实用类
qq_34573534的博客
04-04 1770
8.1 Double类和Float类 二、常量 public class E {public static void main(String[] args) { System.out.println(Double.MAX_VALUE); System.out.println(Double.MIN_VALUE); System.out.println...
自定义BufferedReader的两个方法
每天进步一点点
10-11 1093
展示read(),和readLine()方法public class MyBufferedReader { private FileReader f; // 定义一个数组作为缓冲区 private char[] buf = new char[1024]; // 定义一个指针用来操作数组中的元素，当操作到最后一个元素后指针归零 private int pos = 0; // 定义一个
Java输入输出流详解：掌握基础与实践应用
本资源详细介绍了Java语言中的输入输出流处理，主要包括以下几个关键知识点： 1. 数据流基础：Java中的流被分为输入流（InputStream）和输出流（OutputStream），它们之间的界限并非绝对，如文件在写入数据时被视为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值