java常用数据流应用实例解析

2024-02-26 21:22:36

这篇文章主要介绍了java常用数据流应用实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

按操作单位的不同分为：字节流（8bit）（InputStream、OuputStream）、字符流（16bit）（Reader、Writer）

按数据流的流向不同分为：输入流、输出流

按角色的不同分为：节点流、处理流

一、不带缓冲的流

1.文件字节输入流、文件字节输出流

package anno;

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

public class Test2 {
  public static void main(String[] args) {
    test1FileInputStream();
    test2FileInputStream();
    testFileOutputStream();
  }
  public static void test1FileInputStream() {
    String path = "F:\\test.txt";
    try {
      FileInputStream fs = new FileInputStream(path);
      //设置一个数组接收文件的内容
      //需要注意的是，如果数组设置的太小，那么可能出现读取的数据不完整或者乱码等情况
      byte[] b = new byte[30];
      //文件输入流对象有一个返回值，返回的是读取数据的长度，如果读取到一个数据了，还会向后读一个，
      //当读取完毕时会返回-1
      int len = 0;
      while((len=fs.read(b))!=-1) {
        //参数1是缓冲数据数组，参数2是从哪个位置开始转换成字符串，参数3是总共转换的长度
        System.out.println(new String(b, 0, len));
      }
      fs.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void test2FileInputStream() {
    String path = "F:\\test.txt";
    File f = new File(path);
    int l = (int) f.length();
    try {
      FileInputStream fs = new FileInputStream(path);
      byte[] b = new byte[l];
      //将读取的数据存入到b中
      fs.read(b);
      //将b转换成字符串并输出
      System.out.println(new String(b));
      fs.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void testFileOutputStream() {    //如果不存在该文件，则系统会新建一个
    String path1 = "F:\\test2.txt";
    try {
      FileOutputStream fo = new FileOutputStream(path1);
      String str = "这是我测试的输入";
      fo.write(str.getBytes());//将数据写到byte中
      fo.flush();//将内存中的数据写到文件中
      fo.close();//关闭
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

在运行的过程中会遇到一些问题，比如说设置的byte数组来接收读取的数据，如果初始化长度给的比较小，那么读取的数据就不全，在进行test1FileInputStream()的实验中，即使按照：

      int len = 0;
      while((len=fs.read(b))!=-1) {
        //参数1是缓冲数据数组，参数2是从哪个位置开始转换成字符串，参数3是总共转换的长度
        System.out.println(new String(b, 0, len));
      }

进行输出，如果byte设置的还是太小，就会出现：

这是我新建的test.txt�
��件

这种乱码问题，于是进行了第二种方法的尝试，即在传入数据之前首先获得要接收多少字节的数据，然后在进行接收（借鉴之前在golang中文件读取并显示的思想），然后就没有问题了，即test2FileInputStream()。

输出结果：

这是我新建的test.txt文件

2.使用字节流将一个文件复制到指定的文件夹下

public static void copyFile() {
    String path = "F:\\test.txt";
    String path2 = "F:\\test2.txt";
    try {
      FileInputStream fi = new FileInputStream(path);
      FileOutputStream fo = new FileOutputStream(path2);
      File f = new File(path);
      int l = (int) f.length();
      byte[] b = new byte[l];
      int len = 0;
      while((len=fi.read(b))!=-1) {
        fo.write(b,0,len);
      }
      fo.flush();
      fo.close();
      fi.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

综合使用之前读取的方式。

3.文件字符输入流、文件字符输出流

public static void testFileReader() {
    String path = "F:\\test.txt";
    try {
      FileReader fr = new FileReader(path);
      //注意这里是char类型的数组了
      char[] c = new char[20];
      int len = 0;
      while((len=fr.read(c))!=-1) {
        System.out.println(new String(c, 0, len));
      }
      fr.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void testFileWriter() {
    String path1 = "F:\\test2.txt";
    try {
      FileWriter fw = new FileWriter(path1);
      String str = "这是我测试的输入";
      //注意这里可以直接写入字符串
      fw.write(str);
      fw.flush();//将内存中的数据写到文件中
      fw.close();//关闭
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

需要注意的是定义char数组时仍然是需要知道数据是有多少字符的，不然长度不够，显示不全或者写入不全。（这里暂时还未了解怎么处理）

4.使用字符流将一个文件复制到指定的文件夹下

public static void copyFile2() {
    String path = "F:\\test.txt";
    String path2 = "F:\\test2.txt";
    try {
      FileReader fr = new FileReader(path);
      FileWriter fw = new FileWriter(path2);
      char[] c = new char[30];
      int len = 0;
      while((len=fr.read(c))!=-1) {
        fw.write(c,0,len);
      }
      fw.flush();
      fw.close();
      fr.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }

二、带缓冲的流

为了提高数据的读写速度，java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。

根据数据操作单位可以把缓冲流分为：BufferedInputStream/BufferedOutputStream和BufferedReader/BufferedWriter。

缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了些新方法。对于输出的缓冲流，写出的数据都会先在内存中缓存，使用flush()会将在内存中的数据立即写出。

1.缓冲字节输入流、缓冲字节输出流

package anno;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test4 {
  public static void main(String[] args) throws IOException {
    testBufferedInputStream();
    testBufferedOutputStream();
    copyFile();
  }
  public static void testBufferedInputStream() throws IOException {
    FileInputStream fi = new FileInputStream("F:\\test.txt");
    //把文件字节输入流放入到缓冲输入流中
    BufferedInputStream bi = new BufferedInputStream(fi);
    byte[] b = new byte[35];
    int len = 0;
    while((len=bi.read(b))!=-1) {
      System.out.println(new String(b, 0, len));
    }
    bi.close();
    fi.close();
  }
  public static void testBufferedOutputStream() throws IOException {
    FileOutputStream fo = new FileOutputStream("F:\\test3.txt");
    //把文件字节输入流放入到缓冲输入流中
    BufferedOutputStream bo = new BufferedOutputStream(fo);
    String str = "这是我测试的内容";
    bo.write(str.getBytes());
    bo.flush();
    bo.close();
    fo.close();
  }

  public static void copyFile() {
    String path = "F:\\test.txt";
    String path2 = "F:\\test2.txt";
    try {
      FileInputStream fi = new FileInputStream(path);
      BufferedInputStream bi = new BufferedInputStream(fi);
      FileOutputStream fo = new FileOutputStream(path2);
      BufferedOutputStream bo = new BufferedOutputStream(fo);
      File f = new File(path);
      int l = (int) f.length();
      byte[] b = new byte[l];
      int len = 0;
      while((len=bi.read(b))!=-1) {
        bo.write(b,0,len);
      }
      bo.flush();
      bo.close();
      fo.close();
      bi.close();
      fi.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }
}

2.缓冲字符输入流、缓冲字符输出流

package anno;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test3 {

  public static void main(String[] args) {
    testBufferedReader();
    testBufferedWriter();
    copyFile();
  }

  public static void testBufferedReader() {
    String path = "F:\\test.txt";
    try {
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      char[] c = new char[17];
      int len = 0;
      while((len=br.read(c))!=-1) {
        System.out.println(new String(c, 0, len));
      }
      br.close();
      fr.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void testBufferedWriter() {
    String path1 = "F:\\test2.txt";
    try {
      FileWriter fw = new FileWriter(path1);
      BufferedWriter bw = new BufferedWriter(fw);
      String str = "这是我测试的输入";
      bw.write(str);//将数据写到chars中
      bw.flush();//将内存中的数据写到文件中
      bw.close();
      fw.close();//关闭
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  public static void copyFile() {
    String path = "F:\\test.txt";
    String path2 = "F:\\test2.txt";
    try {
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      FileWriter fw = new FileWriter(path2);
      BufferedWriter bw = new BufferedWriter(fw);
      char[] c = new char[30];
      int len = 0;
      while((len=br.read(c))!=-1) {
        bw.write(c,0,len);
      }
      bw.flush();
      bw.close();
      fw.close();
      br.close();
      fr.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }

}

三、转换流：用于字节流和字符流之间的转换

java Api提供了两个转换流：InputStreamReader和OutputSreamWriter。

当字节流中的数据都是字符时，转换成字符流操作更高效

package anno;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Test5 {
  public static void main(String[] args) throws IOException {
    testInputStreamReader();
    testOutputStreamWriter();
  }
  public static void testInputStreamReader() throws IOException {
    FileInputStream fi = new FileInputStream("F:\\test.txt");
    //字节流转换成字符流
    //注意转换成的编码要和读取的文件一致
    InputStreamReader ir = new InputStreamReader(fi,"utf-8");
    char[] c = new char[17];
    int len = 0;
    while((len=ir.read(c))!=-1) {
      System.out.println(new String(c, 0, len));
    }
    ir.close();
    fi.close();
  }
  public static void testOutputStreamWriter() throws IOException {
    FileOutputStream fo = new FileOutputStream("F:\\test3.txt");
    //转换字节输出流为字符输出流
    OutputStreamWriter ow = new OutputStreamWriter(fo,"utf-8");
    String str = "这是我测试的内容";
    ow.write(str);
    ow.flush();
    ow.close();
    fo.close();
  }

  public static void copyFile() {
    String path = "F:\\test.txt";
    String path2 = "F:\\test2.txt";
    try {
      FileInputStream fi = new FileInputStream(path);
      BufferedInputStream bi = new BufferedInputStream(fi);
      FileOutputStream fo = new FileOutputStream(path2);
      BufferedOutputStream bo = new BufferedOutputStream(fo);
      File f = new File(path);
      int l = (int) f.length();
      byte[] b = new byte[l];
      int len = 0;
      while((len=bi.read(b))!=-1) {
        bo.write(b,0,len);
      }
      bo.flush();
      bo.close();
      fo.close();
      bi.close();
      fi.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }
}

四、标准输入输出流

package anno;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test6 {
  public static void main(String[] args) throws IOException {
//    testSystemIn();
    testWriterToTxt();
  }
  public static void testSystemIn() throws IOException {
    //创建一个获取键盘输入的输入流
    InputStreamReader ir = new InputStreamReader(System.in);
    //将输入流放在缓冲中
    BufferedReader br = new BufferedReader(ir);
    String str = "";
    while((str = br.readLine())!=null) {
      System.out.println(str);
    }
  }
  //将控制台的输入写入到txt文件中
  public static void testWriterToTxt() throws IOException {
    //创建一个获取键盘输入的输入流
    InputStreamReader ir = new InputStreamReader(System.in);
    //将输入流放在缓冲中
    BufferedReader br = new BufferedReader(ir);
    BufferedWriter bw = new BufferedWriter(new FileWriter("F:\\test5.txt"));
    String line = "";
    while((line = br.readLine())!=null) {
      if (line.equals("over")) {
        break;
      }
      bw.write(line);
    }
    bw.flush();
    bw.close();
    br.close();
    ir.close();
  }
}

五、数据流

package anno;

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

public class Test7 {
  public static void main(String[] args) throws IOException {
    testDataOutputStream();
    testDataInputStream();
  }
  //用数据输出流写到文件中的基本类型数据是乱码，不能辨认出来，需要数据输入流读取
  public static void testDataOutputStream() throws IOException {
    DataOutputStream ds = new DataOutputStream(new FileOutputStream("F:\\test6.txt"));
    ds.writeDouble(1.35d);
    ds.flush();
    ds.close();
  }
  public static void testDataInputStream() throws IOException {
    DataInputStream ds = new DataInputStream(new FileInputStream("F:\\test6.txt"));
    System.out.println(ds.readDouble());
    ds.close();
  }
}

六、对象流

用于存储和读取对象的处理流，它的强大之处就是可以把java中对象写入到数据源中，也能把对象从数据源中还原出来。

序列化：用ObjectOutputStream类将一个对象下入io流中；

反序列化：用ObjectInputStream类从io流中恢复对Java对象；

package anno;

import java.io.Serializable;

public class Person implements Serializable{
  //用来标识的UID
  private static final long serialVersionUID = 1L;
  String name;
  int age;
}

package anno;

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

public class Test8 {
  public static void main(String[] args) throws IOException, ClassNotFoundException {
//    testSerializable();
    testDeSerializable();
  }
  //序列化
  public static void testSerializable() throws IOException {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:\\test7.txt"));
    Person p = new Person();
    p.name = "tom";
    p.age = 12;
    oos.writeObject(p);
    oos.flush();
    oos.close();
  }
  //反序列化
  public static void testDeSerializable() throws IOException, ClassNotFoundException {
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\test7.txt"));
    Person p = null;
    Object obj = null;
    obj = ois.readObject();
    p = (Person) obj;
    System.out.println(p.name);
    System.out.println(p.age);
    ois.close();
  }
}

七、RandomAccessFile

支持随机访问的方式，程序可以直接跳转到文件的任意位置地方来进行读写。支持只访问文件的部分内容，可以向已存在的文件后追加内容。

RandomAccessFile对象包含一个记录指针，用以标记当前读写的位置。

RandomAccessFile类对象可以自由地移动和记录指针：

long getFilePoint()：获取文件记录指针的当前位置；
void seek(long pos)：将文件记录指针移动到指定位置；

package anno;

import java.io.IOException;
import java.io.RandomAccessFile;

public class Test9 {
  public static void main(String[] args) throws IOException {
//    testRandomAccessFileRead();
    testRandomAccessFileWrite();
  }
  public static void testRandomAccessFileRead() throws IOException {
    //构造方法有两个参数，参数一为路径，参数二为访问方式
    //r:只读
    //rw:可写可读
    //rwd:可写可读，同步内容跟新
    //rws:可写可读，同步内容和元数据跟新；
    RandomAccessFile acf = new RandomAccessFile("F:\\test7.txt","r");
    //设置文件起始的读取位置
    acf.seek(5);
    byte[] b = new byte[35];
    int len = 0;
    while((len=acf.read(b))!=-1) {
      System.out.println(new String(b, 0, len));
    }
    acf.close();
  }
  public static void testRandomAccessFileWrite() throws IOException {
    //构造方法有两个参数，参数一为路径，参数二为访问方式
    //r:只读
    //rw:可写可读
    //rwd:可写可读，同步内容跟新
    //rws:可写可读，同步内容和元数据跟新；
    RandomAccessFile acf = new RandomAccessFile("F:\\test7.txt","rw");
    //设置文件起始的写入位置，0代表开头，acf.length代表文件末尾
    acf.seek(acf.length());
    acf.write("你好".getBytes());
    acf.close();
  }
}

总结：

流适用于处理数据的。

处理数据时，一定要明确数据源，与数据目的地：数据源可以是文件，也可以是键盘；数据目的地可以是文件、显示器或其它设备。

流只是帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

java编程常用技术(推荐)

一:将String字符串放在最前面防止发生NullPointerException异常,我们通常把String字符串放在equals方法的左边来比较,这样可以有效的避免空指针异常的发生. 第一种情况,如果variable为Null,则会发生空指针异常情况:第二种情况即使variable为Null,也不会发生空指针异常,而且不会丢失任何数据.所以建议大家编程时把直接量放在左边. 二:不要相信早期的JDK API 在早期编程中,JDK API还不是很成熟,例如下面代码块: File file=
Java的常用包

java.lang: 这个包下包含了Java语言的核心类,如String.Math.Sytem和Thread类等,使用这个包无需使用import语句导入,系统会自动导入这个包中的所有类. java.util: 这个包下包含java的大量工具类/接口和集合框架类/接口.如Arrays和List.Set等. java.net: 这个包下包含了一些Java网络编程相关的类/接口. java.io: 这个包含了一些Java输入/输出编程相关的类/接口. java.text: 这个包下包含一些Java格
Linux中Java开发常用软件安装方法总结

开发工具下载: Tomcat下载: wget http://learning.happymmall.com/tomcat/apache-tomcat-7.0.73.tar.gz JDK下载: wget http://download.oracle.com/otn-pub/java/jdk/8u144-b01/090f390dda5b47b9b721c7dfaa008135/jdk-8u144-linux-x64.tar.gz?AuthParam=1501498355_bbac4f122e06aa
Java常用类库Apache Commons工具类说明及使用实例详解

Apache Commons包含了很多开源的工具,用于解决平时编程经常会遇到的问题,减少重复劳动.下面是我这几年做开发过程中自己用过的工具类做简单介绍. 组件功能介绍 BeanUtils 提供了对于JavaBean进行各种操作,克隆对象,属性等等. Betwixt XML与Java对象之间相互转换. Codec 处理常用的编码方法的工具类包例如DES.SHA1.MD5.Base64等. Collections java集合框架操作. Compress java提供文件打包压缩类库. Con
JAVA开发常用类库UUID、Optional、ThreadLocal、TimerTask、Base64使用方法与实例详解

1.UUID类库 UUID 根据时间戳实现自动无重复字符串定义 // 获取UUID public static UUID randomUUID() // 根据字符串获取UUID public static UUID fromString(String name) 应用:对文件进行自动命名处理 import java.util.UUID; class Demo { public static void main(String[] args) { System.out.println(UUID.ra
java中的常用集合类整理

一.Set集合其主要实现类有HashSet.TreeSet存放对象的引用,不允许有重复对象. 实例代码: public class SetTest { public static void main(String[] args) { Set set=new HashSet(); //添加数据 set.add("abc"); set.add("cba"); set.add("abc");//故意重复 set.add(123); set.add(t
java常用工具类 Date日期、Mail邮件工具类

本文实例为大家分享了java常用工具类的具体实现代码,供大家参考,具体内容如下 package com.jarvis.base.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * * * @Title: DateHelper.java * @Package com.jarvis.base.u
Java并发编程之常用的多线程实现方式分析

本文实例讲述了Java并发编程之常用的多线程实现方式.分享给大家供大家参考,具体如下: 概述常用的多线程实现方式有2种: 1. 继承Thread类 2. 实现Runnable接口之所以说是常用的,是因为通过还可以通过JUC(java.util.concurrent)包中的线程池来实现多线程.关于线程池的内容,我们以后会详细介绍:现在,先对的Thread和Runnable进行了解. Thread简介 Thread 是一个类.Thread本身就实现了Runnable接口.它的声明如下: publ
基于Java中最常用的集合类框架之HashMap(详解)

一.HashMap的概述 HashMap可以说是Java中最常用的集合类框架之一,是Java语言中非常典型的数据结构. HashMap是基于哈希表的Map接口实现的,此实现提供所有可选的映射操作.存储的是对的映射,允许多个null值和一个null键.但此类不保证映射的顺序,特别是它不保证该顺序恒久不变. 除了HashMap是非同步以及允许使用null外,HashMap 类与 Hashtable大致相同. 此实现假定哈希函数将元素适当地分布在各桶之间,可为基本操作(get 和 put)提供稳定的性
Java常用类库StringBuffer，Runtime，日期操作类等类库总结

1):StringBuffer类: String.StringBuffer.StringBuilder的区别 1.String一旦声明,不可改变,StringBuffer与StringBuilder声明的内容可以改变 2.StringBuffer类中提供的方法都是同步方法,属于安全的线程操作,而StringBuilder类中大的方法都是属于异步方法,属于非线程安全的操作. 2):Runtime类 Runtime类是Java中与运行时环境有关的操作类,利用此类可以取得系统的内存信息,也可以利用此类
Java常用命令汇总

这篇文章就主要向大家展示了Java编程中常用的命令,下面看下具体内容. 1.javac 将文件编译成.class文件用法: javac <options> <source files> 其中, 可能的选项包括: -g 生成所有调试信息 -g:none 不生成任何调试信息 -g:{lines,vars,source} 只生成某些调试信息 -nowarn 不生成任何警告 -verbose 输出有关编译器正在执行的操作的消息 -deprecation 输出使用已过时的 API 的源位置

java常用数据流应用实例解析

相关推荐

随机推荐