コード例 #1
0
 public ImmutableSortedSet<Pair<T, Integer>> zipWithIndex() {
   Comparator<? super T> comparator = this.comparator();
   if (comparator == null) {
     TreeSortedSet<Pair<T, Integer>> pairs =
         TreeSortedSet.newSet(
             Comparators.<Pair<T, Integer>, T>byFunction(
                 Functions.<T>firstOfPair(), Comparators.<T>naturalOrder()));
     return Iterate.zipWithIndex(this, pairs).toImmutable();
   }
   return Iterate.zipWithIndex(
           this, TreeSortedSet.<Pair<T, Integer>>newSet(Comparators.<T>byFirstOfPair(comparator)))
       .toImmutable();
 }
コード例 #2
0
 public <S> ImmutableSortedSet<Pair<T, S>> zip(Iterable<S> that) {
   Comparator<? super T> comparator = this.comparator();
   if (comparator == null) {
     TreeSortedSet<Pair<T, S>> pairs =
         TreeSortedSet.newSet(
             Comparators.<Pair<T, S>, T>byFunction(
                 Functions.<T>firstOfPair(), Comparators.<T>naturalOrder()));
     return Iterate.zip(this, that, pairs).toImmutable();
   }
   return Iterate.zip(
           this, that, TreeSortedSet.<Pair<T, S>>newSet(Comparators.<T>byFirstOfPair(comparator)))
       .toImmutable();
 }
コード例 #3
0
 public ImmutableSortedSet<T> newWithout(T element) {
   if (this.contains(element)) {
     TreeSortedSet<T> result = TreeSortedSet.newSet(this);
     result.remove(element);
     return result.toImmutable();
   }
   return this;
 }
コード例 #4
0
 public ImmutableSortedSet<T> newWithoutAll(Iterable<? extends T> elements) {
   TreeSortedSet<T> result = TreeSortedSet.newSet(this);
   this.removeAllFrom(elements, result);
   return result.toImmutable();
 }
コード例 #5
0
 public ImmutableSortedSet<T> newWithAll(Iterable<? extends T> elements) {
   TreeSortedSet<T> result = TreeSortedSet.newSet(this);
   result.addAllIterable(elements);
   return result.toImmutable();
 }
コード例 #6
0
 public ImmutableSortedSet<T> newWith(T element) {
   if (!this.contains(element)) {
     return TreeSortedSet.newSet(this).with(element).toImmutable();
   }
   return this;
 }
コード例 #7
0
 public ImmutableSortedSet<T> symmetricDifference(SetIterable<? extends T> setB) {
   return SetIterables.symmetricDifferenceInto(
           this, setB, TreeSortedSet.<T>newSet(this.comparator()))
       .toImmutable();
 }
コード例 #8
0
 public ImmutableSortedSet<T> difference(SetIterable<? extends T> subtrahendSet) {
   return SetIterables.differenceInto(
           this, subtrahendSet, TreeSortedSet.<T>newSet(this.comparator()))
       .toImmutable();
 }
コード例 #9
0
 public ImmutableSortedSet<T> intersect(SetIterable<? extends T> set) {
   return SetIterables.intersectInto(this, set, TreeSortedSet.<T>newSet(this.comparator()))
       .toImmutable();
 }
コード例 #10
0
 public ImmutableSortedSet<T> filterNot(Predicate<? super T> predicate) {
   TreeSortedSet<T> result = TreeSortedSet.newSet(this.comparator());
   this.forEach(new FilterNotProcedure<T>(predicate, result));
   return result.toImmutable();
 }
コード例 #11
0
 @Override
 protected MutableCollection<T> newMutable(int size) {
   return TreeSortedSet.newSet(this.comparator());
 }