x+=x++;

Der Code für das Syntax-Highlighting dieser Seite :)

<script language="javascript" type="text/javascript">
 var keywords = new Array(
  'abstract','continue','for','new','switch','assert','default',
  'if','package','synchronized','boolean','do','goto','private',
  'this','break','double','implements','protected','throw','byte',
  'else','import','public','throws','case','enum','instanceof',
  'return','transient','catch','extends','int','short','try',
  'char','final','interface','static','void','class','finally',
  'long','strictfp','volatile','const','float','native','super','while',
  'null','true','false');
 
 function parseKeywords(str)
 {
  for (var j = 0; j<keywords.length;j++)
  {
   var r = new RegExp('\\b'+reg(keywords[j])+'\\b','g');
   str = str.replace(r,keywords[j].fontcolor('#7F0055').bold());
  }
  return str;
 }
 
 function reg(str)
 {
  return str.replace(/\(/g,'\\\(').replace(/\)/g,'\\\)')
            .replace(/\{/g,'\\\{').replace(/\}/g,'\\\}')
            .replace(/\[/g,'\\\[').replace(/\]/g,'\\\]');
 }
 
 var pretags = document.getElementsByTagName('pre');
 for (var i = 0;i<pretags.length;i++)
 {
  var dat = pretags[i].innerHTML;
  dat = dat.replace(/\n/g,'<br>');
  dat = dat.replace(/ /g,'&nbsp;');
  dat = dat.replace(/ /g,'&nbsp;&nbsp;&nbsp;&nbsp;');
  dat = parse(dat);          
  pretags[i].innerHTML = dat;
 }
</script>

Generischer Quicksort

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

/**
 * @author <a href="http://mineraliccodesnippets.blogspot.com">MineralicCodeSnippets</a>
 */


public class Quick {
 private static <T extends List<E>,E> void  exchange(T data, int a, int b) {
  E temp = data.get(a);
  data.set(a, data.get(b));
  data.set(b, temp);
 }
 
 private static <T extends List<E>, C extends Comparator<E>, E> int split(T data,C comparator, int left, int right) 
 {
  int index = left;
   for (int pointer = left; pointer < right; pointer++) 
   {
    if (comparator.compare(data.get(pointer), data.get(right)) < 0 ) {
     exchange(data, index, pointer);
     index++;
    }
   }
   exchange(data, index, right);
  return index;
 }
 public static <T extends List<E>,E extends Comparable<E>> void sort(T data)
 {
  sort(data,false);
 }
 public static <T extends List<E>,E extends Comparable<E>> void sort(T data,boolean reverse)
 {
  Comparator<E> comparator;
  if (reverse)
   comparator = new Comparator<E>()
   {
    public int compare(E arg0, E arg1) 
    {
     return -arg0.compareTo(arg1);
    }
   };
  else
   comparator = new Comparator<E>()
   {
    public int compare(E arg0, E arg1) 
    {
     return arg0.compareTo(arg1);
    }
   };
  sort(data,comparator,0,data.size()-1);
 }
 public static <T extends List<E>, C extends Comparator<E>,E> void sort(T data,C comparator)
 {
  sort(data,comparator,0,data.size()-1);
 }

 private static <T extends List<E>, C extends Comparator<E>,E> void sort(T data,C comparator, int left, int right) 
 {
  if (right > left) 
  {
   int splitIndicator = split(data, comparator, left, right);
   sort(data, comparator, left, splitIndicator - 1);
   sort(data, comparator, splitIndicator + 1, right);
  }
 }
 
 public static void main(String[] args)
 {
  System.out.println("Test der Quick-Klasse\nSortierung eines String-Vektors");

  Vector<String> v = new Vector<String>();
  v.add("werner");
  v.add("alf");
  v.add("zorax");
  v.add("Alf");
  v.add("bert");
  v.add("alf");
  
  System.out.println("Vor der Sortierung:");
  System.out.println(v);
  
  Quick.sort(v);
  
  System.out.println("Nach der Sortierung:");
  System.out.println(v);

  Quick.sort(v,true);
  
  System.out.println("Nach der umgekehrten Sortierung:");
  System.out.println(v);
  
  System.out.println("\n\nSortierung einer Integer-Liste");
  
  int[] a = new int[]{4,1,76,2,3,7,34,3,52,32,5};
  LinkedList<Integer> l = new LinkedList<Integer>();
  for (int i:a)
   l.add(i);
  
  System.out.println("Vor der Sortierung:");
  System.out.println(l);
  
  Quick.sort(l);
  
  System.out.println("Nach der Sortierung:");
  System.out.println(l);

  Quick.sort(l,true);
  
  System.out.println("Nach der umgekehrten Sortierung:");
  System.out.println(l);
 }
}

Comparator zum Vergleich von Maps

import java.util.Comparator;
import java.util.List;
import java.util.Map;


public class MapComparator<M extends Map<E,F>,E,F extends Comparable<F>> implements Comparator<M>
{
 List<SortKey<E>> keys;
 int keyCount;
 int factor;
 
 public MapComparator(List<SortKey<E>> keys)
 {
  this(keys,false);
 }
 public MapComparator(List<SortKey<E>> keys, boolean reverse)
 {
  factor = reverse?-1:1;
  this.keys = keys;
  keyCount = keys.size(); //zugriff beschleunigen
 }

 public int compare(M map1, M map2) {
  if (keys.size()>0)
   return compareByKey(map1,map2,0);
  return 0;
 }
 
 private int compareByKey(M map1, M map2, int key)
 {
  if (key<keyCount)
  {
   SortKey skey = keys.get(key); 
   int factor = skey.isReverse()?-1:1;
   F val1 = map1.get(skey.getKey());
   F val2 = map2.get(skey.getKey());
   if (val1!=null&&val2!=null)
   {
    int ret = val1.compareTo(val2)*factor;
    return ret==0?compareByKey(map1,map2,key+1):ret;
   }
  }
  return 0;
 }
}

Sortierschlüssel (Map sortieren)

public class SortKey<E> 
{
 private E key;
 private boolean reverse;
 public SortKey(E key)
 {
  this(key,false);
 }
 public SortKey(E key,boolean reverse)
 {
  this.key=key;
  this.reverse=reverse;
 }
 public E getKey() 
 {
  return key;
 }
 public void setKey(E key) 
 {
  this.key = key;
 }
 public boolean isReverse() 
 {
  return reverse;
 }
 public void setReverse(boolean reverse) 
 {
  this.reverse = reverse;
 }
 public String toString()
 {
  return (reverse?"-":"+")+key;
 }
}