# Java for C# Programmers 11: Algorithms

## Algorithms

In Java, there are many algorithms available as static methods of the `Collections` class. I’m giving here examples for the most important ones.

``````    import java.util.Collections;
List numbers = new ArrayList();
Collections.sort(numbers);      // 1 4 5
Collections.reverse(numbers);   // 5 4 1
Collections.shuffle(numbers);   // 4 1 5
Collections.swap(numbers, 0, 2);   // 5 1 4
Collections.fill(numbers, 7);      // 7 7 7

List num2 = new ArrayList();
Collections.addAll(num2,  2, 6, 5);    // 2 6 5

Collections.copy(numbers, num2);    // numbers is 2 6 5
Collections.sort(num2);     // 2 5 6
num2.add(7);            // 2 5 6 7
Collections.rotate(num2, 1);     // 7 2 5 6
Collections.rotate(num2, -1);    // 2 5 6 7
``````
``````    int pos = Collections.binarySearch(num2, 5);    // pos is 1

pos = Collections.binarySearch(num2, 3);
// -> pos is -2. pos is (-(insertion_point) - 1), if the
// element is not contained in the collection.
// Therefore you can add an element to a collection
// with a line like the following.
num2.add(-pos-1, 3);        //  2 3 5 6 7

pos = Collections.binarySearch(num2, -8);   // pos is -1
num2.add(-pos-1, -8);           //  -8 2 3 5 6 7

Collections.shuffle(num2);      // 2 3 -8 5 7 6
int n = Collections.min(num2);  // -8
int m = Collections.max(num2);  // 7
``````
``````    boolean b = num2.contains(3);   // true

b = num2.contains(4);           // false
b = num2.containsAll(numbers);      // true;
b = num2.containsAll(numbers);      // false;

b = Collections.disjoint(num2, numbers); // false
numbers.clear();        // numbers is empty
Collections.addAll(numbers, 11, 9, 1);  // 11 9 1
b = Collections.disjoint(num2, numbers);    // true

numbers.add(11);                            // 11 9 1 11
n = Collections.frequency(numbers, 11);     // 2

Collections.copy(numbers, num2);
// -> IndexOutOfBoundsException: Source does not fit in dest
``````

### UnsupportedOperationException

Gotcha: In Java, it may be that a collection has the `Collection` interface but does not really implement it. This is true especially for unmodifiable collections. In these cases, it is common practice that all methods that are not really implemented throw `UnsupportedOperationException`.

## Converting Arrays to Lists And Vice Versa

As arrays and `Iterables` do not have a common base, you sometimes will need to convert an array to an `Iterable` and vice versa.

### Array to Iterable

To use an array in a function, where a `List` or an `Iterable` is required, you can create a fixed-size `List` from the array. Such a fixed-size `List` is no real `List`, it is just a wrapper around the array and has a `List` interface.

Gotcha: This interface is not implemented out. Only reading functions are implemented. All the others throw `UnsupportedOperationException`.

``````void a(Iterable list)
{
for(int i: ll)
System.out.printf(" %d", i);
}

Integer[] h4 = {4, 5, 11, 46};
a(h4);      // Compile error: The method a(Iterable)
// is not applicable for the arguments (Integer[])

List ll = Arrays.asList(h4);
a(ll);      // ok,   4 5 11 46

``````

Probably it is safer to use only the `Iterable` interface with
the `asList` function:

``````Iterable l2 = Arrays.asList(h4);
a(l2);       // ok,   4 5 11 46

// undefined for the type Iterable
``````

If you need a `List` with variable size, use the following construct. This will copy the array into a `List` and not only create a wrapper.

``````List ll = new ArrayList(Arrays.asList(h4));
a(ll);     // 4 5 11 46 4711
``````

### List to Array

#### ToArray Method

Sometimes, you may need an array but you have a List. Imagine you must use this function:

``````static void b(Integer[] ll)
{
for (int i : ll)
System.out.printf("%d ", i);
}
``````

And you have a `List`.

``````List h5 = new ArrayList();
``````

Then you can create an array of Integer like this.

``````Integer[] h6 = new Integer[h5.size()];
h5.toArray(h6);

b(h6);  // 89 76
``````

#### Manual Method

If you have got a function which needs an int[] array like this

``````    static void a(int[] ll)
{
for (int i : ll)
System.out.printf("%d ", i);
}
``````

And you have a `List` like above, then you can of course create an array of int like this:

``````    int[] h7 = new int[ts.size()];
for (int i = 0; i < ts.size(); ++i)
h7[i] = ts.get(i);

a(h7);    // 89 76
``````