流表示可以按顺序访问的对象序列(通常是字节，但不一定是这样)。流的典型操作:

read one byte. Next time you read, you'll get the next byte, and so on. read several bytes from the stream into an array seek (move your current position in the stream, so that next time you read you get bytes from the new position) write one byte write several bytes from an array into the stream skip bytes from the stream (this is like read, but you ignore the data. Or if you prefer it's like seek but can only go forwards.) push back bytes into an input stream (this is like "undo" for read - you shove a few bytes back up the stream, so that next time you read that's what you'll see. It's occasionally useful for parsers, as is: peek (look at bytes without reading them, so that they're still there in the stream to be read later)

一个特定的流可能支持读(在这种情况下，它是一个“输入流”)，写(“输出流”)或两者都支持。并不是所有的溪流都是可搜索的。

Push back is fairly rare, but you can always add it to a stream by wrapping the real input stream in another input stream that holds an internal buffer. Reads come from the buffer, and if you push back then data is placed in the buffer. If there's nothing in the buffer then the push back stream reads from the real stream. This is a simple example of a "stream adaptor": it sits on the "end" of an input stream, it is an input stream itself, and it does something extra that the original stream didn't.

Stream is a useful abstraction because it can describe files (which are really arrays, hence seek is straightforward) but also terminal input/output (which is not seekable unless buffered), sockets, serial ports, etc. So you can write code which says either "I want some data, and I don't care where it comes from or how it got here", or "I'll produce some data, and it's entirely up to my caller what happens to it". The former takes an input stream parameter, the latter takes an output stream parameter.

我能想到的最好的比喻是，溪流是一条传送带，向你走来或离开你(有时两者兼而有之)。你从输入流中取出东西，你把东西放到输出流中。有些传送带你可以认为是从墙上的一个洞里出来的——它们是不可寻找的，阅读或写作是一次性的交易。一些传送带就摆在你面前，你可以在溪流中选择你想读/写的位置——这就是寻找。

As IRBMe says, though, it's best to think of a stream in terms of the operations it offers (which vary from implementation to implementation, but have a lot in common) rather than by a physical analogy. Streams are "things you can read or write". When you start connecting up stream adaptors, you can think of them as a box with a conveyor in, and a conveyor out, that you connect to other streams and then the box performs some transformation on the data (zipping it, or changing UNIX linefeeds to DOS ones, or whatever). Pipes are another thorough test of the metaphor: that's where you create a pair of streams such that anything you write into one can be read out of the other. Think wormholes :-)

把流看作是抽象的数据源(字节、字符等)。它们抽象了具体数据源的实际读写机制，可以是网络套接字、磁盘上的文件或来自web服务器的响应。

流的目的是在您和后台存储之间提供一个抽象层。因此，使用流的给定代码块不需要关心后台存储是磁盘文件、内存等等…

我所见过的关于流的最好解释是SICP的第3章。(你可能需要阅读前两章才能理解，但无论如何你都应该这样做。: -)

它们对字节根本不使用sterams，而是整数。我从中得到的要点是:

流是延迟列表 在某些情况下，急于提前计算所有内容的计算开销是惊人的 我们可以用流来表示无限长的序列

The answers given so far are excellent. I'm only providing another to highlight that a stream is not a sequence of bytes or specific to a programming language since the concept is universal (while its implementation may be unique). I often see an abundance of explanations online in terms of SQL, or C or Java, which make sense as a filestream deals with memory locations and low level operations. But they often address how to create a filestream and operate on the potential file in their given language rather than discuss the concept of a stream.

这个比喻

如前所述，流是一种隐喻，是更复杂事物的抽象。为了激发你的想象力，我提供了一些其他的比喻:

你想把一个空池子装满水。实现这一目的的一种方法是将软管连接到水龙头上，将软管的一端放在水池中，然后打开水。

软管就是溪流

类似地，如果你想给你的车加油，你会走到加油站，把喷嘴插入油箱，然后通过挤压锁杆打开阀门。

软管，喷嘴和相关的机构，让气体流入你的油箱是流

如果你需要去上班，你会开始从家开车走高速公路到办公室。

高速公路就是溪流

如果你想和某人交谈，你会用耳朵听，用嘴巴说。

你的耳朵和眼睛是溪流

希望你在这些例子中注意到，流的隐喻只存在于允许某些东西通过它(或者在高速公路的情况下在它上面)，而并不总是表示它们正在传输的东西。这是一个重要的区别。我们不认为耳朵是一连串的单词。如果没有水流经，软管仍然是软管，但我们必须将其连接到水龙头上，才能正确地工作。汽车并不是唯一一种可以穿越高速公路的交通工具。

因此，一个流可以存在，只要它连接到一个文件，它就没有数据通过它。

去除抽象

接下来，我们需要回答几个问题。我要用文件来描述流什么是文件?我们如何读取文件?我将尝试在保持一定抽象级别以避免不必要的复杂性的同时回答这个问题，并将使用相对于linux操作系统的文件概念，因为它的简单性和可访问性。

什么是文件?

文件是抽象的:)

或者，我可以简单地解释，一个文件是描述文件的一部分数据结构和实际内容的一部分数据。

数据结构部分(在UNIX/linux系统中称为inode)标识关于内容的重要信息，但不包括内容本身(或文件的名称)。它保留的信息之一是内容开始位置的内存地址。因此，有了文件名(或linux中的硬链接)、文件描述符(操作系统关心的数字文件名)和内存中的起始位置，我们就有了可以称为文件的东西。

(关键是“文件”是由操作系统定义的，因为最终必须处理它的是操作系统。是的，文件要复杂得多)。

到目前为止一切顺利。但我们怎么拿到文件的内容，比如给你男友的情书，这样我们就能打印出来了?

读取文件

如果我们从结果开始并向后移动，当我们在计算机上打开一个文件时，它的全部内容都会显示在屏幕上供我们阅读。但如何?答案是非常有条理。文件本身的内容是另一种数据结构。假设有一个字符数组。我们也可以把它看成一个字符串。

那么我们如何“读取”这个字符串呢?通过找到它在内存中的位置并遍历我们的字符数组，一次一个字符，直到到达文件字符的末尾。换句话说就是一个程序。

当流的程序被调用时，流就被“创建”了，并且它有一个可以附加到或连接到的内存位置。就像我们的水管的例子一样，如果软管没有连接到水龙头上，它是无效的。在流的情况下，它必须连接到文件才能存在。

Streams can be further refined, e.g, a stream to receive input or a stream to send a files contents to standard output. UNIX/linux connects and keeps open 3 filestreams for us right off the bat, stdin (standard input), stdout (standard output) and stderr (standard error). Streams can be built as data structures themselves or objects which allows us to perform more complex operations of the data streaming through them, like opening the stream, closing the stream or error checking the file a stream is connected to. C++'s cin is an example of a stream object.

当然，如果您愿意，您可以编写自己的流。

定义

流是一段可重用的代码，它抽象了处理数据的复杂性，同时提供了对数据执行的有用操作。

我使用的可视化是传送带，不是在真实的工厂里，因为我对此一无所知，而是在卡通工厂里，物品沿着线移动，被盖章、装箱、计数和检查，由一系列愚蠢的设备完成。

你有做一件事的简单组件，例如一个把樱桃放在蛋糕上的设备。这个设备有一个无樱桃蛋糕的输入流，和一个有樱桃蛋糕的输出流。用这种方式组织处理有三个优点值得一提。

首先，它简化了组件本身:如果你想把巧克力糖衣放在蛋糕上，你不需要一个复杂的设备，知道蛋糕的一切，你可以创造一个愚蠢的设备，把巧克力糖衣粘在任何东西上(在漫画中，这甚至不知道下一个东西不是蛋糕，而是怀尔E.大狼)。

其次，你可以通过将这些设备按不同的顺序排列来创造不同的产品:也许你想让你的蛋糕在樱桃上放糖衣，而不是樱桃在糖衣上，你可以简单地通过在生产线上交换设备来做到这一点。

Thirdly, the devices don't need to manage inventory, boxing, or unboxing. The most efficient way of aggregating and packaging things is changeable: maybe today you're putting your cakes into boxes of 48 and sending them out by the truckload, but tomorrow you want to send out boxes of six in response to custom orders. This kind of change can be accommodated by replacing or reconfiguring the machines at the start and end of the production line; the cherry machine in the middle of the line doesn't have to be changed to process a different number of items at a time, it always works with one item at a time and it doesn't have to know how its input or output is being grouped.