RxJava StringObservable

1. Introduction to StringObservable

Working with String sequences in RxJava may be challenging; luckily RxJavaString provides us with all necessary utilities.

In this article, we’ll cover StringObservable which contains some helpful String operators. Therefore, before getting started, it’s advised to have a look at the Introduction to RxJava first.

2. Maven Setup

To get started, let’s include RxJavaString amongst our dependencies:

<dependency>
  <groupId>io.reactivex</groupId>
  <artifactId>rxjava-string</artifactId>
  <version>1.1.1</version>
</dependency>

The latest version of rxjava-string is available over on Maven Central.

3. StringObservable

StringObservable is a handy operator for representing a potentially infinite sequence of encoded Strings.

The operator from reads an input stream creating an Observable which emits character-bounded sequences of byte arrays:

We can create an Observable straight from an InputStream using a from operator:

TestSubscriber testSubscriber = new TestSubscriber();
ByteArrayInputStream is = new ByteArrayInputStream("Lorem ipsum loream, Lorem ipsum lore".getBytes());
Observable<byte[]> observableByteStream = StringObservable.from(is);

// emits 8 byte array items
observableByteStream.subscribe(testSubscriber);

4. Converting Bytes into Strings

Encoding/decoding infinite sequences from different charsets can be done using decode and encode operators.

As their name may suggest, these will simply create an Observable that emits an encoded or decoded sequence of byte arrays or Strings, therefore, we could use it if we need to handle Strings in different charsets:

Decoding a byte array Observable:

TestSubscriber testSubscriber = new TestSubscriber();
ByteArrayInputStream is = new ByteArrayInputStream(
  "Lorem ipsum loream, Lorem ipsum lore".getBytes());
Observable<byte[]> byteArrayObservable = StringObservable.from(is);
Observable<String> stringObservable = StringObservable
  .decode(byteArrayObservable, StandardCharsets.UTF_8);

// emits UTF-8 decoded strings,"Lorem ipsum loream, Lorem ipsum lore"
stringObservable.subscribe(testSubscriber);

5. Splitting Strings

StringObservable has also some convenient operators for splitting String sequences: split and byLine, both create a new Observable which chunks input data outputting items following a pattern:

TestSubscriber testSubscriber = new TestSubscriber();
Observable<String> sourceObservable = Observable.just("Lorem ipsum loream,Lorem ipsum ", "lore");
Observable<String> splittedObservable = StringObservable.split(sourceObservable, ",");

// emits 2 strings "Lorem ipsum loream", "Lorem ipsum lore"
splittedObservable.subscribe(testSubscriber);

6. Joining Strings

Complementary to previous section’s operators are join and stringConcat which concatenate items from a String Observable emitting a single string given a separator.

Also, note that these will consume all items before emitting an output.

TestSubscriber testSubscriber = new TestSubscriber();
Observable<String> sourceObservable = Observable.just("Lorem ipsum loream", "Lorem ipsum lore");
Observable<String> joinedObservable = StringObservable.join(sourceObservable, ",");

// emits single string "Lorem ipsum loream,Lorem ipsum lore"
joinedObservable.subscribe(testSubscriber);

7. Conclusion

This brief introduction to StringObservable demonstrated a few use cases of String manipulation using RxJavaString.

Examples in this tutorial and other examples on how to use StringObservable operators can be found over on Github.