举例讲解Java中的Stream流概念_java

1、基本的输入流和输出流
流是 Java 中最重要的基本概念之一。文件读写、网络收发、进程通信，几乎所有需要输入输出的地方，都要用到流。

流是做什么用的呢？就是做输入输出用的。为什么输入输出要用“流”这种方式呢？因为程序输入输出的基本单位是字节，输入就是获取一串字节，输出就是发送一串字节。但是很多情况下，程序不可能接收所有的字节之后再进行处理，而是接收一点处理一点。比方你下载魔兽世界，不可能全部下载到内存里再保存到硬盘上，而是下载一点就保存一点。这时，流这种方式就非常适合。

在 Java 中，每个流都是一个对象。流分为两种：输入流(InputStream)和输出流(OutputStream)。对于输入流，你只要从流当中不停地把字节取出来就是了；而对于输出流，你只要把准备好的字节串传给它就行。

流对象是怎么获得的呢？不同的外部系统，获取流的方式也不同。例如，文件读写就要创建 FileInputStream/FileOutputStream 对象，而网络通信是通过 Socket 对象来获取输入输出流的。一般来说，如果一个类有 getInputStream() 或 getOutputStream() 这样的方法，就表明它是通过流对象来进行输入输出的。
 
InputStream 是输入流，下面是一个通过 InputStream 读取文件的例子：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileNotFoundException;
import java.util.Arrays; 

/**
 * 通过流读取文件
 */
public class ReadFileDemo { 

 // 程序入口
 public static void main(String[] args) {
  String path = "c:/boot.ini";
  File file = new File(path); 

  // 创建输入流
  InputStream is;
  try {
   is = new FileInputStream(file);
  } catch (FileNotFoundException e) {
   System.err.println("文件 " + path + " 不存在。");
   return;
  } 

  // 开始读取
  byte[] content = new byte[0];  // 保存读取出来的文件内容
  byte[] buffer = new byte[10240]; // 定义缓存 

  try {
   int eachTime = is.read(buffer); // 第一次读取。如果返回值为 -1 就表示没有内容可读了。
   while (eachTime != -1) {
    // 读取出来的内容放在 buffer 中，现在将其合并到 content。
    content = concatByteArrays(content, buffer, eachTime);
    eachTime = is.read(buffer); // 继续读取
   }
  } catch (IOException e) {
   System.err.println("读取文件内容失败。");
   e.printStackTrace();
  } finally {
   try {
    is.close();
   } catch (IOException e) {
    // 这里的异常可以忽略不处理
   }
  } 

  // 输出文件内容
  String contentStr = new String(content);
  System.out.println(contentStr);
 } 

 /**
  * 合并两个字节串
  *
  * @param bytes1  字节串1
  * @param bytes2  字节串2
  * @param sizeOfBytes2 需要从 bytes2 中取出的长度
  *
  * @return bytes1 和 bytes2 中的前 sizeOfBytes2 个字节合并后的结果
  */
 private static byte[] concatByteArrays(byte[] bytes1, byte[] bytes2, int sizeOfBytes2) {
  byte[] result = Arrays.copyOf(bytes1, (bytes1.length + sizeOfBytes2));
  System.arraycopy(bytes2, 0, result, bytes1.length, sizeOfBytes2);
  return result;
 }
}

虽然写得很啰嗦，但这确实是 InputStream 的基本用法。注意，这只是一个例子，说明如何从输入流中读取字节串。实际上，Java 提供更简单的方式来读取文本文件。以后将会介绍。

相比从流中读取，使用 OutputStream 输出则是非常简单的事情。下面是一个例子：

import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.Date; 

/**
 * 将当前日期保存到文件
 */
public class SaveFileDemo { 

 public static void main(String[] args) throws IOException {
  String path = "c:/now.txt"; 

  File file = new File(path);
  if (!file.exists() && !file.createNewFile()) {
   System.err.println("无法创建文件。");
   return;
  } 

  OutputStream os = new FileOutputStream(file); // 创建输出流（前提是文件存在）
  os.write(new Date().toString().getBytes());  // 将当前时间写入文件
  os.close();          // 必须关闭流，内容才会写入文件。
  System.out.println("文件写入完成。");
 }
}

 
Java 还提供其它的流操作方式，但它们都是对 InputStream 和 OutputStream 进行扩展或包装。所以这两个类是基础，必须要理解它们的使用。

2、Reader 和 Writer
介绍了 InputStream 和 OutputStream，接下来介绍 Reader 和 Writer。这两个类其实就是将 InputStream 和 OutputStream 包装了一下。不过它们处理的不是字节(byte)，而是字符(char)。如果一个流当中的内容都是文本，那么用 Reader/Writer 处理起来会简单些。下面是一个用 Reader 读取文本文件的例子：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader; 

/**
 * 读取文本文件
 */
public class ReadTextFileDemo { 

 // 程序入口
 public static void main(String[] args) {
  String path = "c:/boot.ini";
  String content = ""; 

  try {
   Reader reader = new FileReader(path);
   char[] buffer = new char[10240];
   int count; 

   while ((count = reader.read(buffer)) != -1) {
    content += new String(buffer, 0, count);
   }
  } catch (IOException e) {
   System.err.println("读取文件失败。");
   e.printStackTrace();
  } 

  System.out.println(content);
 } 

}

至于如何用 Writer 将文本内容写入文件，这里就不给出例子了，看官自己试着写一下吧。

上面这个例子，仍然不是读取文本文件最常用的方式。Java 提供 BufferedReader，我们通常用它来读取文本文件。下面是一个例子：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; 

/**
 * 用 BufferedReader 读取文本文件
 */
public class ReadTextDemo2 { 

 public static void main(String[] args) {
  String path = "c:/boot.ini";
  String content = ""; 

  try {
   BufferedReader reader = new BufferedReader(new FileReader(path));
   String line;
   while ((line = reader.readLine()) != null) {
    content += line + "/n";
   }
  } catch (IOException e) {
   System.err.println("读取文件失败。");
   e.printStackTrace();
  } 

  System.out.println(content);
 }
}

3、对象序列化
对象序列化也是流应用的一个重要方面。序列化就是把一个对象转换成一串字节，既可以保存起来，也可以传给另外的 Java 程序使用。ObjectOutputStream 和 ObjectInputStream 就是专门用来进行序列化和反序列化的。下面就是一个简单的例子：

import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.FileInputStream;
import java.io.EOFException; 

/**
 * ObjectOutputStream/ObjectInputStream 示例。
 * 这两个类分别用于序列化和反序列化。
 */
public class SerializationDemo { 

  public static void main(String[] args) throws Exception {
    String path = "c:/persons.data";
    File f = new File(path);
    if (!f.exists()) {
      f.createNewFile();
    } 

    writePersons(path);
    readPersons(path);
  } 

  // 从指定的文件中读取 Person 对象
  private static void readPersons(String path) throws IOException, ClassNotFoundException {
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path)); 

    Person p;
    while (true) {
      try {
        p = (Person) ois.readObject();
        System.out.println(p);
      } catch (EOFException e) {
        break;
      }
    }
  } 

  // 将 Person 对象保存到指定的文件中
  private static void writePersons(String path) throws IOException {
    Person[] persons = new Person[]{
        new Person("张三", 23),
        new Person("李四", 24)
    }; 

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
    for (Person person : persons) {
      oos.writeObject(person);
    }
    oos.close();
  } 

  /////////////////////////////////////////////////////////// 

  private static class Person implements Serializable { 

    private String name; 

    private int age; 

    public Person() {
    } 

    public Person(String name, int age) {
      this.name = name;
      this.age = age;
    } 

    public String getName() {
      return name;
    } 

    public void setName(String name) {
      this.name = name;
    } 

    public int getAge() {
      return age;
    } 

    public void setAge(int age) {
      this.age = age;
    } 

    @Override
    public String toString() {
      return "Person{" +
          "name='" + name + '/'' +
          ", age=" + age +
          '}';
    }
  }
}

这个例子里面看不到字节和字符的读写，因为这两个类都包装好了。上面只是一个简单的例子，序列化要写好的话还是有不少讲究的。想深入了解序列化，可以看看这里。本文只关注跟流有关的部分。其实序列化用的很少，因为序列化降低了灵活性，所以可以不用的话一般都不会用。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索java
stream
集合和非集合概念举例、产品整体概念举例、举例说明产品整体概念、概念模型举例、概念操作化举例，以便于您获取更多的相关知识。

时间： 2025-01-30 22:26:37

举例讲解Java中的Stream流概念_java的相关文章

Java中的stream流的概念解析及实际运用总结_java

流是字节序列的抽象概念. 文件是数据的静态存储形式,而流是指数据传输时的形态. 流类分为两个大类:节点流类和过滤流类(也叫处理流类). 程序用于直接操作目标设备所对应的类叫节点流类,程序也可以通过一个间接流类去调用节点流类,以达到更加灵活方便地读取各种类型的数据,这个间接流类就是过滤流类(也叫处理流类),或者称为包装类. 包装类的调用过程如下图: 流分类的关系不管流的分类是多么的丰富和复杂,其根源来自于四个基本的类.这个四个类的关系如下: 字节流 字符流 输入流 InputStream Read

举例讲解Java中的多线程编程_java

Java创建线程(Runnable接口和Thread类) 大多数情况,通过实例化一个Thread对象来创建一个线程.Java定义了两种方式: 实现Runnable 接口: 可以继承Thread类. 下面的依次介绍了每一种方式.实现Runnable接口 创建线程的最简单的方法就是创建一个实现Runnable 接口的类.Runnable抽象了一个执行代码单元.你可以通过实现Runnable接口的方法创建每一个对象的线程.为实现Runnable 接口,一个类仅需实现一个run()的简单方法,该方法声明

举例讲解Java中数组和字符串类型的使用方法_java

Java数组 数组是具有相同数据类型的一组数据的集合,Java支持多为数组,一维数组的每个基本单元都是基本数据类型的数据,二维数组就是每个基本单元是一维数组的一维数组,以此类推,n维数组的每个基本单元都是n-1为数组的n-1维数组.下面以一维数组为例说明Java数组的用法. 1.数组声明 数组声明有如下两种形式(方括号的位置不同): int arr[]; int[] arr2; 2.数组初始化 数组初始化也有两种形式,如下(使用new或不使用new): int arr[] = new int[]

剖析Java中线程编程的概念_java

Java线程的概念 和其他多数计算机语言不同,Java内置支持多线程编程(multithreaded programming). 多线程程序包含两条或两条以上并发运行的部分.程序中每个这样的部分都叫一个线程(thread),每个线程都有独立的执行路径.因此,多线程是多任务处理的一种特殊形式. 你一定知道多任务处理,因为它实际上被所有的现代操作系统所支持.然而,多任务处理有两种截然不同的类型:基于进程的和基于线程的.认识两者的不同是十分重要的. 对很多读者,基于进程的多任务处理是更熟悉的形式.进程

io流-java中的IO流使用情况

问题描述 java中的IO流使用情况 java中有很多读取和写入文件的操作 像FileWirter Writer Reader BufferWriter 等 我一直区分不清这几个的特点,有没有大神帮忙处理下,通常什么情况使用什么比较好.各有那些优点和缺点 解决方案 你可以上网搜索哦下,很多的 解决方案二: 有的有缓冲区,有的没有,有的没有:有的可以操纵字符文件,有的可以操纵字节文件,你可以按照这个进行分类 解决方案三: 这是我自己整理的,你可以参考下http://blog.csdn.net/ev

java中方法的重写概念是相对于父类和子类的，那么同一个类到底有没有重写的概念呢

问题描述 java中方法的重写概念是相对于父类和子类的,那么同一个类到底有没有重写的概念呢 java中方法的重写概念是相对于父类和子类的,那么同一个类到底有没有重写的概念呢 解决方案 重写是在有继承关系的多个类之间,子类有与父类相同声明的方法但是方法体不同,即子类重写了父类的某些方法. 所以同一个类中显然是没有重写的概念的. 解决方案二: 没有,重写是在有继承关系的两个类中发生的. 解决方案三: 同一个类中只有重载,继承关系之间的类叫重写 解决方案四: 没有的,本类只有重载方法. 解决方案五:

举例讲解Java设计模式编程中Decorator装饰者模式的运用_java

概念 装饰者模式动态地将责任附加到对象上.若要扩展功能,装饰者提供了比继承更有弹性的替代方案. 装饰者和被装饰对象有相同的超类型. 你可以用一个或多个装饰者包装一个对象. 既然装饰者和被装饰对象有相同的超类型,所以在任何需要原始对象(被包装的)的场合 ,可以用装饰过的对象代替它. 装饰者可以在所委托被装饰者的行为之前与/或之后,加上自己的行为,以达到特定的目的. 对象可以在任何时候被装饰,所以可以在运行时动态地.不限量地用你喜欢的装饰者来装饰 对象. 在Java中,io包下的很多类就是典型的装饰

举例讲解Java编程中this关键字与super关键字的用法_java

this总要有个事物来代表类的当前对象,就像C++中的this指针一样,Java中的this关键字就是代表当前对象的引用. 它有三个主要的作用: 1.在构造方法中调用其他构造方法.       比如有一个Student类,有三个构造函数,某一个构造函数中调用另外构造函数,就要用到this(),而直接使用Student()是不可以的. 2.返回当前对象的引用. 3.区分成员变量名和参数名. 看下面的例子: public class Student { private String name; pr

举例讲解Java的RTTI运行时类型识别机制_java

1.RTTI:运行时类型信息可以让你在程序运行时发现和使用类型信息. 在Java中运行时识别对象和类的信息有两种方式:传统的RTTI,以及反射.下面就来说下RTTI. RTTI:在运行时,识别一个对象的类型.但是这个类型在编译时必须已知. 下面通过一个例子来看下RTTI的使用.这里涉及到了多态的概念:让代码只操作基类的引用,而实际上调用具体的子类的方法,通常会创建一个具体的对象(Circle,Square,或者Triangle,见下例),把它向上转型为Shape(忽略了对象的具体类型),并在后面