Overview | Package | Class | Use | Tree | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.lucene.util
Class CollectionUtil

    java.lang.Object
      org.apache.lucene.util.CollectionUtil

    public final class CollectionUtil

extends Object

Methods for manipulating (sorting) collections. Sort methods work directly on the supplied lists and don't copy to/from arrays before/after. For medium size collections as used in the Lucene indexer that is much more efficient.

NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

Method Summary
`static
`<T extends Comparable<? super T>> void`
` | `binarySort(List<T> list)` Sorts the given random access `List` in natural order.
`static
`<T> void`
` | `binarySort(List<T> list, Comparator<? super T> comp)` Sorts the given random access `List` using the `Comparator`.
`static
`<T extends Comparable<? super T>> void`
` | `insertionSort(List<T> list)` Sorts the given random access `List` in natural order.
`static
`<T> void`
` | `insertionSort(List<T> list, Comparator<? super T> comp)` Sorts the given random access `List` using the `Comparator`.
`static
`<T extends Comparable<? super T>> void`
` | `mergeSort(List<T> list)` Sorts the given random access `List` in natural order.
`static
`<T> void`
` | `mergeSort(List<T> list, Comparator<? super T> comp)` Sorts the given random access `List` using the `Comparator`.
`static
`<T extends Comparable<? super T>> void`
` | `quickSort(List<T> list)` Sorts the given random access `List` in natural order.
`static
`<T> void`
` | `quickSort(List<T> list, Comparator<? super T> comp)` Sorts the given random access `List` using the `Comparator`.
`static
`<T extends Comparable<? super T>> void`
` | `timSort(List<T> list)` Sorts the given random access `List` in natural order.
`static
`<T> void`
` | `timSort(List<T> list, Comparator<? super T> comp)` Sorts the given random access `List` using the `Comparator`.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

### quickSort

    public static <T> void quickSort(List<T> list,
                                     Comparator<? super T> comp)

  Sorts the given random access `List` using the `Comparator`. The list must implement `RandomAccess`. This method uses the quick sort algorithm, but falls back to insertion sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### quickSort

    public static <T extends Comparable<? super T>> void quickSort(List<T> list)

  Sorts the given random access `List` in natural order. The list must implement `RandomAccess`. This method uses the quick sort algorithm, but falls back to insertion sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### mergeSort

    public static <T> void mergeSort(List<T> list,
                                     Comparator<? super T> comp)

  Sorts the given random access `List` using the `Comparator`. The list must implement `RandomAccess`. This method uses the merge sort algorithm, but falls back to insertion sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### mergeSort

    public static <T extends Comparable<? super T>> void mergeSort(List<T> list)

  Sorts the given random access `List` in natural order. The list must implement `RandomAccess`. This method uses the merge sort algorithm, but falls back to insertion sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### timSort

    public static <T> void timSort(List<T> list,
                                   Comparator<? super T> comp)

  Sorts the given random access `List` using the `Comparator`. The list must implement `RandomAccess`. This method uses the TimSort algorithm, but falls back to binary sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### timSort

    public static <T extends Comparable<? super T>> void timSort(List<T> list)

  Sorts the given random access `List` in natural order. The list must implement `RandomAccess`. This method uses the TimSort algorithm, but falls back to binary sort for small lists.

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### insertionSort

    public static <T> void insertionSort(List<T> list,
                                         Comparator<? super T> comp)

  Sorts the given random access `List` using the `Comparator`. The list must implement `RandomAccess`. This method uses the insertion sort algorithm. It is only recommended to use this algorithm for partially sorted small lists!

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### insertionSort

    public static <T extends Comparable<? super T>> void insertionSort(List<T> list)

  Sorts the given random access `List` in natural order. The list must implement `RandomAccess`. This method uses the insertion sort algorithm. It is only recommended to use this algorithm for partially sorted small lists!

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### binarySort

    public static <T> void binarySort(List<T> list,
                                      Comparator<? super T> comp)

  Sorts the given random access `List` using the `Comparator`. The list must implement `RandomAccess`. This method uses the binary sort algorithm. It is only recommended to use this algorithm for small lists!

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

### binarySort

    public static <T extends Comparable<? super T>> void binarySort(List<T> list)

  Sorts the given random access `List` in natural order. The list must implement `RandomAccess`. This method uses the insertion sort algorithm. It is only recommended to use this algorithm for small lists!

  Throws:
    `IllegalArgumentException` - if list is e.g. a linked list without random access.

Overview | Package | Class | Use | Tree | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.