Fixed comment typo, added the rest of the operators

Author: akarnokd

src/main/java/rx/Observable.java

@@ -2419,7 +2419,7 @@ public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Combining-Observables#switchonnext">RxJava wiki: switchOnNext</a>
      */
     public final static <T> Observable<T> switchOnNext(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
-        return sequenceOfSequences.lift(new OperatorSwitch<T>());
+        return sequenceOfSequences.lift(OperatorSwitch.<T>instance());
     }
 
     /**
@@ -5113,7 +5113,7 @@ public final Observable<T> onBackpressureBuffer(long capacity, Action0 onOverflo
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Backpressure">RxJava wiki: Backpressure</a>
      */
     public final Observable<T> onBackpressureDrop() {
-        return lift(new OperatorOnBackpressureDrop<T>());
+        return lift(OperatorOnBackpressureDrop.<T>instance());
     }
 
     /**
@@ -6463,7 +6463,7 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Observable-Utility-Operators#serialize">RxJava wiki: serialize</a>
      */
     public final Observable<T> serialize() {
-        return lift(new OperatorSerialize<T>());
+        return lift(OperatorSerialize.<T>instance());
     }
 
     /**
@@ -8370,7 +8370,7 @@ public final BlockingObservable<T> toBlocking() {
      * @see <a href="https://github.com/ReactiveX/RxJava/wiki/Mathematical-and-Aggregate-Operators#tolist">RxJava wiki: toList</a>
      */
     public final Observable<List<T>> toList() {
-        return lift(new OperatorToObservableList<T>());
+        return lift(OperatorToObservableList.<T>instance());
     }
 
     /**

src/main/java/rx/internal/operators/OperatorAsObservable.java

@@ -31,12 +31,13 @@ private static final class Holder {
         static final OperatorAsObservable<Object> INSTANCE = new OperatorAsObservable<Object>();
     }
     /**
-     * @return an singleton instance of this stateless operator.
+     * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorAsObservable<T> instance() {
         return (OperatorAsObservable<T>)Holder.INSTANCE;
     }
+    private OperatorAsObservable() { }
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> s) {
         return s;

src/main/java/rx/internal/operators/OperatorConcat.java

@@ -43,13 +43,13 @@ private static final class Holder {
         static final OperatorConcat<Object> INSTANCE = new OperatorConcat<Object>();
     }
     /**
-     * @return an singleton instance of this stateless operator.
+     * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorConcat<T> instance() {
         return (OperatorConcat<T>)Holder.INSTANCE;
     }
-    
+    private OperatorConcat() { }
     @Override
     public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super T> child) {
         final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);

src/main/java/rx/internal/operators/OperatorDematerialize.java

@@ -36,12 +36,13 @@ private static final class Holder {
         static final OperatorDematerialize<Object> INSTANCE = new OperatorDematerialize<Object>();
     }
     /**
-     * @return an singleton instance of this stateless operator.
+     * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings({ "rawtypes" })
     public static OperatorDematerialize instance() {
         return Holder.INSTANCE; // using raw types because the type inference is not good enough
     }
+    private OperatorDematerialize() { }
     @Override
     public Subscriber<? super Notification<T>> call(final Subscriber<? super T> child) {
         return new Subscriber<Notification<T>>(child) {

src/main/java/rx/internal/operators/OperatorMaterialize.java

@@ -35,12 +35,13 @@ private static final class Holder {
         static final OperatorMaterialize<Object> INSTANCE = new OperatorMaterialize<Object>();
     }
     /**
-     * @return an singleton instance of this stateless operator.
+     * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorMaterialize<T> instance() {
         return (OperatorMaterialize<T>)Holder.INSTANCE;
     }
+    private OperatorMaterialize() { }
     @Override
     public Subscriber<? super T> call(final Subscriber<? super Notification<T>> child) {
         return new Subscriber<T>(child) {

src/main/java/rx/internal/operators/OperatorMerge.java

@@ -69,7 +69,7 @@ private static final class HolderDelayErrors {
     }
     /**
      * @param delayErrors should the merge delay errors?
-     * @return an singleton instance of this stateless operator.
+     * @return a singleton instance of this stateless operator.
      */
     @SuppressWarnings("unchecked")
     public static <T> OperatorMerge<T> instance(boolean delayErrors) {

src/main/java/rx/internal/operators/OperatorOnBackpressureDrop.java

@@ -22,7 +22,19 @@
 import rx.Subscriber;
 
 public class OperatorOnBackpressureDrop<T> implements Operator<T, T> {
-
+    /** Lazy initialization via inner-class holder. */
+    private static final class Holder {
+        /** A singleton instance. */
+        static final OperatorOnBackpressureDrop<Object> INSTANCE = new OperatorOnBackpressureDrop<Object>();
+    }
+    /**
+     * @return a singleton instance of this stateless operator.
+     */
+    @SuppressWarnings({ "unchecked" })
+    public static <T> OperatorOnBackpressureDrop<T> instance() {
+        return (OperatorOnBackpressureDrop<T>)Holder.INSTANCE;
+    }
+    private OperatorOnBackpressureDrop() { }
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         final AtomicLong requested = new AtomicLong();

src/main/java/rx/internal/operators/OperatorSerialize.java

@@ -20,7 +20,19 @@
 import rx.observers.SerializedSubscriber;
 
 public final class OperatorSerialize<T> implements Operator<T, T> {
-
+    /** Lazy initialization via inner-class holder. */
+    private static final class Holder {
+        /** A singleton instance. */
+        static final OperatorSerialize<Object> INSTANCE = new OperatorSerialize<Object>();
+    }
+    /**
+     * @return a singleton instance of this stateless operator.
+     */
+    @SuppressWarnings({ "unchecked" })
+    public static <T> OperatorSerialize<T> instance() {
+        return (OperatorSerialize<T>)Holder.INSTANCE;
+    }
+    private OperatorSerialize() { }
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> s) {
         return new SerializedSubscriber<T>(new Subscriber<T>(s) {

src/main/java/rx/internal/operators/OperatorSwitch.java

@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Producer;
@@ -33,7 +34,19 @@
  * @param <T> the value type
  */
 public final class OperatorSwitch<T> implements Operator<T, Observable<? extends T>> {
-
+    /** Lazy initialization via inner-class holder. */
+    private static final class Holder {
+        /** A singleton instance. */
+        static final OperatorSwitch<Object> INSTANCE = new OperatorSwitch<Object>();
+    }
+    /**
+     * @return a singleton instance of this stateless operator.
+     */
+    @SuppressWarnings({ "unchecked" })
+    public static <T> OperatorSwitch<T> instance() {
+        return (OperatorSwitch<T>)Holder.INSTANCE;
+    }
+    private OperatorSwitch() { }
     @Override
     public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super T> child) {
         return new SwitchSubscriber<T>(child);

src/main/java/rx/internal/operators/OperatorToObservableList.java

@@ -37,7 +37,19 @@
  * as you do not have the option to unsubscribe.
  */
 public final class OperatorToObservableList<T> implements Operator<List<T>, T> {
-
+    /** Lazy initialization via inner-class holder. */
+    private static final class Holder {
+        /** A singleton instance. */
+        static final OperatorToObservableList<Object> INSTANCE = new OperatorToObservableList<Object>();
+    }
+    /**
+     * @return a singleton instance of this stateless operator.
+     */
+    @SuppressWarnings({ "unchecked" })
+    public static <T> OperatorToObservableList<T> instance() {
+        return (OperatorToObservableList<T>)Holder.INSTANCE;
+    }
+    private OperatorToObservableList() { }
     @Override
     public Subscriber<? super T> call(final Subscriber<? super List<T>> o) {
         return new Subscriber<T>(o) {