| java.lang.Object
 net.sf.cglib.util.SorterTemplate
net.sf.cglib.util.ParallelSorter
| ParallelSorter | | abstract public class ParallelSorter extends SorterTemplate (Code) | | For the efficient sorting of multiple arrays in parallel.
Given two arrays of equal length and varying types, the standard
technique for sorting them in parallel is to create a new temporary
object for each row, store the objects in a temporary array, sort the
array using a custom comparator, and the extract the original values
back into their respective arrays. This is wasteful in both time and
memory.
This class generates bytecode customized to the particular set of
arrays you need to sort, in such a way that both arrays are sorted
in-place, simultaneously.
Two sorting algorithms are provided.
Quicksort is best when you only need to sort by a single column, as
it requires very few comparisons and swaps. Mergesort is best used
when sorting multiple columns, as it is a "stable" sort--that is, it
does not affect the relative order of equal objects from previous sorts.
The mergesort algorithm here is an "in-place" variant, which while
slower, does not require a temporary array.
author:
Chris Nokleberg |
| Inner Class :interface Comparer | |
| Inner Class :static class ComparatorComparer implements Comparer | |
| Inner Class :static class ObjectComparer implements Comparer | |
| Inner Class :static class IntComparer implements Comparer | |
| Inner Class :static class LongComparer implements Comparer | |
| Inner Class :static class FloatComparer implements Comparer | |
| Inner Class :static class DoubleComparer implements Comparer | |
| Inner Class :static class ShortComparer implements Comparer | |
| Inner Class :static class ByteComparer implements Comparer | |
| Method Summary | |
| protected int | compare(int i, int j)
| | public static ParallelSorter | create(Object[] arrays)
Create a new ParallelSorter object for a set of arrays. | | public void | mergeSort(int index)
| | public void | mergeSort(int index, int lo, int hi)
Sort the arrays using an in-place merge sort. | | public void | mergeSort(int index, Comparator cmp)
Sort the arrays using an in-place merge sort. | | public void | mergeSort(int index, int lo, int hi, Comparator cmp)
Sort the arrays using an in-place merge sort. | | abstract public ParallelSorter | newInstance(Object[] arrays)
| | public void | quickSort(int index)
Sort the arrays using the quicksort algorithm. | | public void | quickSort(int index, int lo, int hi)
Sort the arrays using the quicksort algorithm. | | public void | quickSort(int index, Comparator cmp)
Sort the arrays using the quicksort algorithm. | | public void | quickSort(int index, int lo, int hi, Comparator cmp)
Sort the arrays using the quicksort algorithm. |
| ParallelSorter | | protected ParallelSorter()(Code) | | |
| compare | | protected int compare(int i, int j)(Code) | | |
| create | | public static ParallelSorter create(Object[] arrays)(Code) | | Create a new ParallelSorter object for a set of arrays. You may
sort the arrays multiple times via the same ParallelSorter object.
Parameters:
arrays - An array of arrays to sort. The arrays may be a mixof primitive and non-primitive types, but should all be the samelength.
Parameters:
loader - ClassLoader for generated class, uses "current" if null |
| mergeSort | | public void mergeSort(int index)(Code) | |
Parameters:
index - array (column) to sort by |
| mergeSort | | public void mergeSort(int index, int lo, int hi)(Code) | | Sort the arrays using an in-place merge sort.
Parameters:
index - array (column) to sort by
Parameters:
lo - starting array index (row), inclusive
Parameters:
hi - ending array index (row), exclusive |
| mergeSort | | public void mergeSort(int index, Comparator cmp)(Code) | | Sort the arrays using an in-place merge sort.
Parameters:
index - array (column) to sort by
Parameters:
lo - starting array index (row), inclusive
Parameters:
hi - ending array index (row), exclusive |
| mergeSort | | public void mergeSort(int index, int lo, int hi, Comparator cmp)(Code) | | Sort the arrays using an in-place merge sort.
Parameters:
index - array (column) to sort by
Parameters:
lo - starting array index (row), inclusive
Parameters:
hi - ending array index (row), exclusive
Parameters:
cmp - Comparator to use if the specified column is non-primitive |
| quickSort | | public void quickSort(int index)(Code) | | Sort the arrays using the quicksort algorithm.
Parameters:
index - array (column) to sort by |
| quickSort | | public void quickSort(int index, int lo, int hi)(Code) | | Sort the arrays using the quicksort algorithm.
Parameters:
index - array (column) to sort by
Parameters:
lo - starting array index (row), inclusive
Parameters:
hi - ending array index (row), exclusive |
| quickSort | | public void quickSort(int index, Comparator cmp)(Code) | | Sort the arrays using the quicksort algorithm.
Parameters:
index - array (column) to sort by
Parameters:
cmp - Comparator to use if the specified column is non-primitive |
| quickSort | | public void quickSort(int index, int lo, int hi, Comparator cmp)(Code) | | Sort the arrays using the quicksort algorithm.
Parameters:
index - array (column) to sort by
Parameters:
lo - starting array index (row), inclusive
Parameters:
hi - ending array index (row), exclusive
Parameters:
cmp - Comparator to use if the specified column is non-primitive |
|
|