import java.util.*; class G24 { public static void swap( ArrayList<?> list, int i, int j ){ swapGen(list,i,j); // wildcard capture } private static <T> void swapGen( ArrayList<T> list, int i, int j ){ T list_i = list.get(i); list.set(i,list.get(j)); list.set(j,list_i); } private static <E extends Comparable<? super E>> E maxGen( Collection<E> c ){ Iterator<E> it = c.iterator(); E m = it.next(); while( it.hasNext() ){ E e = it.next(); if( m.compareTo(e) < 0 ){ m = e; } } return m; } public static <E extends Comparable<? super E>> E max( Collection<? extends E> c ){ return maxGen(c); } private static <T> T maxGen( Collection<T> c, Comparator<? super T> comp ){ Iterator<T> it = c.iterator(); T m = it.next(); while( it.hasNext() ){ T e = it.next(); if( comp.compare(m,e) < 0 ){ m = e; } } return m; } public static <T> T max( Collection<? extends T> c, Comparator<? super T> comp ){ return maxGen(c,comp); } private static <E extends Comparable<? super E>> int indexOfMax( ArrayList<E> c, int size ){ int mi = 0; E m = size > 0 ? c.get(mi) : null; for( int i=1; i<size; ++i ){ E e = c.get(i); if( m.compareTo(e) < 0 ){ m = e; mi = i; } } return mi; } private static <T extends Comparable<? super T>> void sortGen( ArrayList<T> list ){ for( int i = list.size(); i > 1; --i ){ int mi = indexOfMax(list,i); swap(list,mi,i-1); } } public static <T extends Comparable<? super T>> void sort( ArrayList<? extends T> list ){ sortGen(list); } public static void main( String[] args ){ ArrayList<String> list = fromArrayToList(args); sort(list); printCollection(list); } public static <T> ArrayList<T> fromArrayToList( T[] a ){ ArrayList<T> list = new ArrayList<T>(a.length); for( T o: a ){ list.add(o); } return list; } public static void printCollection( Collection<?> c ){ for( Object o: c ){ System.out.println(o); } } }