Implemented distinctUntilChanged operation

[jmhofer]

This is the implementation for distinctUntilChanged as described in #39.

I haven't implemented the two methods from .NET that are using an IEqualityComparator because I don't think it would be idiomatic Java to define an interface like this and use that here. - Or does somebody want that?

[cloudbees-pull-request-builder]

RxJava-pull-requests #269 SUCCESS
This pull request looks good

[cloudbees-pull-request-builder]

RxJava-pull-requests #271 SUCCESS
This pull request looks good

[abersnaze]

What about a method that takes a java.util.Comparator?

[jmhofer]

@abersnaze I don't know. It's possible (and easy), of course. I just don't see much of a use case. But maybe that's just me.

[abersnaze]

If there was an Observable of some object and they either didn't implement equals correctly or a different criteria for equality was needed then (in Java) this operator couldn't be used as is. I work around be to use map before to wrap the object that implements a different equals then a map after it to unwrap it.

[jmhofer]

You could also use the distinctUntilChanged version with the keySelector to work around that. Then there's not even the need for unwrapping anymore.

[abersnaze]

The point I was trying to make was that I think it would be inconvenient and not in line with most of the other java APIs that involve comparing values.

This brings up another concern that I have is how to deal with instance operators that require some additional constraints on the values emitted. In this case it only works if equals is implemented correctly. Then there is the no arg version toSortedList() that casts the values to Comparable. Some of the other method only operate on Observable<Observable>. The only way to ensure that is to have them as static where the generics can be specific to that method. I thought about making a toComparableObservable(Comparator) where the sorting APIs could live or a toObservableOfObservable() where zip and merge could be instance methods. There are many problems with this idea.

• discoverability of operators.
• inability to mix sorted observable of observables.
• it still isn't type safe.

[benjchristensen]

I tend to agree that we should have the Comparator overloads, but those can be added later. Merging ...