@Override <E> int resultIndex( Comparator<? super E> comparator, E key, List<? extends E> list, int foundIndex) { // Of course, we have to use binary search to find the precise // breakpoint... int lower = 0; int upper = foundIndex; // Of course, we have to use binary search to find the precise breakpoint... // Everything between lower and upper inclusive compares at <= 0. while (lower < upper) { int middle = (lower + upper) >>> 1; int c = comparator.compare(list.get(middle), key); if (c < 0) { lower = middle + 1; } else { // c == 0 upper = middle; } } return lower; } },
/** * Returns an array containing only elements found in {@code first} and also in {@code * second}. The returned elements are in the same order as in {@code first}. */ public static String[] intersect( Comparator<? super String> comparator, String[] first, String[] second) { List<String> result = new ArrayList<>(); for (String a : first) { for (String b : second) { if (comparator.compare(a, b) == 0) { result.add(a); break; } } } return result.toArray(new String[result.size()]); }
@Override public int compare(Iterable<T> leftIterable, Iterable<T> rightIterable) { Iterator<T> left = leftIterable.iterator(); Iterator<T> right = rightIterable.iterator(); while (left.hasNext()) { if (!right.hasNext()) { return LEFT_IS_GREATER; // because it's longer } int result = elementOrder.compare(left.next(), right.next()); if (result != 0) { return result; } } if (right.hasNext()) { return RIGHT_IS_GREATER; // because it's longer } return 0; }
@Override public List<T> apply(List<T> a, List<T> b) throws Exception { int n = a.size() + b.size(); if (n == 0) { return new ArrayList<T>(); Iterator<T> bt = b.iterator(); T s1 = at.hasNext() ? at.next() : null; T s2 = bt.hasNext() ? bt.next() : null; if (comparator.compare(s1, s2) < 0) { // s1 comes before s2 both.add(s1); s1 = at.hasNext() ? at.next() : null; } else { both.add(s2);
VersionedIntervalTimeline<String, DataSegment> timeline, Period skipOffset, @Nullable List<Interval> skipIntervals .map(PartitionChunk::getObject) .filter(segment -> lookupInterval.contains(segment.getInterval())) .sorted((s1, s2) -> Comparators.intervalsByStartThenEnd().compare(s1.getInterval(), s2.getInterval())) .collect(Collectors.toList()); searchIntervals.add( new Interval( segments.get(0).getInterval().getStart(), segments.get(segments.size() - 1).getInterval().getEnd()
private boolean compareElementsOf(Iterable<T> actual, Iterable<T> other) { if (sizeOf(actual) != sizeOf(other)) return false; // compare their elements with elementComparator Iterator<T> iterator = other.iterator(); for (T actualElement : actual) { T otherElement = iterator.next(); if (elementComparator.compare(actualElement, otherElement) != 0) return false; } return true; }
/** * Returns {@code true} if each element in {@code iterable} after the first is greater than or * equal to the element that preceded it, according to the specified comparator. Note that this is * always true when the iterable has fewer than two elements. */ public static <T> boolean isInOrder(Iterable<? extends T> iterable, Comparator<T> comparator) { checkNotNull(comparator); Iterator<? extends T> it = iterable.iterator(); if (it.hasNext()) { T prev = it.next(); while (it.hasNext()) { T next = it.next(); if (comparator.compare(prev, next) > 0) { return false; } prev = next; } } return true; }
public static<E> List<E> mergeSort(Collection<E> a, Collection<E> b, Comparator<E> comp) { Iterator<E> itera = a.iterator(), iterb = b.iterator(); E heada = itera.hasNext()?itera.next():null; E headb = iterb.hasNext()?iterb.next():null; List<E> result = new ArrayList(a.size()+b.size()); while (heada!=null || headb!=null) { E next; if (heada==null) { next=headb; headb = null; } else if (headb==null) { next=heada; heada=null; } else if (comp.compare(heada,headb)<=0) { next=heada; heada=null; } else { next=headb; headb=null; } assert next!=null; Preconditions.checkArgument(result.isEmpty() || comp.compare(result.get(result.size()-1),next)<=0, "The input collections are not sorted"); result.add(next); if (heada==null) heada=itera.hasNext()?itera.next():null; if (headb==null) headb=iterb.hasNext()?iterb.next():null; } return result; }
/** * Returns an array containing only elements found in {@code first} and also in {@code * second}. The returned elements are in the same order as in {@code first}. */ @SuppressWarnings("unchecked") public static String[] intersect( Comparator<? super String> comparator, String[] first, String[] second) { List<String> result = new ArrayList<>(); for (String a : first) { for (String b : second) { if (comparator.compare(a, b) == 0) { result.add(a); break; } } } return result.toArray(new String[result.size()]); }
private boolean compareElementsOf(Iterable<T> actual, Iterable<T> other) { if (sizeOf(actual) != sizeOf(other)) return false; // compare their elements with elementComparator Iterator<T> iterator = other.iterator(); for (T actualElement : actual) { T otherElement = iterator.next(); if (elementComparator.compare(actualElement, otherElement) != 0) return false; } return true; }
@Override <E> int resultIndex( Comparator<? super E> comparator, E key, List<? extends E> list, int foundIndex) { // Of course, we have to use binary search to find the precise // breakpoint... int lower = foundIndex; int upper = list.size() - 1; // Everything between lower and upper inclusive compares at >= 0. while (lower < upper) { int middle = (lower + upper + 1) >>> 1; int c = comparator.compare(list.get(middle), key); if (c > 0) { upper = middle - 1; } else { // c == 0 lower = middle; } } return lower; } },
@Override protected C computeNext() { while (merged.hasNext()) { C next = merged.next(); boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0; // Keep looping till we find a non-duplicate value. if (!duplicate) { lastValue = next; return lastValue; } } lastValue = null; // clear reference to unused data return endOfData(); } };
@Override public List<T> apply(List<T> a, List<T> b) throws Exception { int n = a.size() + b.size(); if (n == 0) { return new ArrayList<T>(); Iterator<T> bt = b.iterator(); T s1 = at.hasNext() ? at.next() : null; T s2 = bt.hasNext() ? bt.next() : null; if (comparator.compare(s1, s2) < 0) { // s1 comes before s2 both.add(s1); s1 = at.hasNext() ? at.next() : null; } else { both.add(s2);
private T dequeue() { if (elements.size() == 0) { return null; } T smallest = elements.remove(0); ListIterator<T> iterator = elements.listIterator(); while (iterator.hasNext()) { T next = iterator.next(); if (comparator.compare(smallest, next) > 0) { iterator.set(smallest); smallest = next; } } return smallest; }