Related on SO:
TCP, UDP and SCTP aren't streams - they are transport protocols. A Stream might be implemented using any of those transport protocols, or indeed may be implemented using a named pipe, a shared memory buffer, an MQ technology...
A stream is an abstraction which hides that kind of low-level detail and presents your program with a mechanism to transmit or receive some series of objects or bytes.
A stream is a solution for problems related to communication. This can include network communication, inter-process communication, inter-thread communication, or even communication with a hardware device or file.
The term reactive is referring to the Reactive Programming Model, which is focused on how to structure code responsible for receiving data asynchronously.
At the simplest level, streams are typically presented to a recipient via some kind of buffer, often with a thread-safety mechanism to ensure that reading/writing happens atomically.
Receiving data from a stream without a reactive abstraction typically involves techniques such as "polling" (periodic inspection) or blocking a thread and waiting for data - Often the solution results in creating your own reactive abstraction around that stream.
A reactive stream may use a different model such as an event signal, or may be an abstraction around a polling and/or "waiting thread". The term 'reactive' implies data is received asynchronously (note: that doesn't necessarily mean concurrently) - A reactive abstraction usually requires you attach a callback, observer or event handler to handle inbound data from that stream.
A stream may or may not be responsible for ordering, reliable delivery, buffering, etc; these are concerns which are generally tied up in the implementation detail of the stream (or perhaps the underlying transport).
On a specific note about the Java Reactive Streams library; the concept is clearly nothing new. Reactive streams in Java have always been possible.
The rationale for Java's new library is explained at the top of this page: http://www.reactive-streams.org/
Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.
In other words, it looks as if Java is attempting to provide a set of standard interfaces and workflows for reactive streams; which (I assume, I am not a Java Programmer..) probably means that current support for reactive stream abstractions is inconsistent and fragmented.
In simple terms, it looks as if the Reactive Streams library is attempting to solve another important problem for Java programmers - consistency.