Tri d un vector en java

import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Vector;

public class SortableVectorOfString extends Vector implements Comparator{

	/*
	 * Numéro du caractère sur lequel on va trier
	 * (Attention, les indices commencent à 0)
	 */
	int numChar = 0;
	
	/*
	 * fonction de tri
	 */
	private void sortStringVector(int numChar){
		/*
		 * On précise le numéro du caractère à partir duquel doit se faire
		 * le tri
		 */ 
		this.numChar = numChar;
		/*
		 * Le 1er paramètre est le Vecteur à trier (moi-même)
		 * Le 2ème paramètre est le Comparator à utiliser pour cela...
		 * ... et c'est encore moi-même car j'implémente Comparator (ce
		 * qui m'oblige à remplir le contrat de Comparator qui stipule 
		 * que je dois fournir une méthode 'compare') 
		 */
		Collections.sort(this, this);
	}

	/* 
	 * Fonction de comparaison
	 * @param arg0 1er String à comparer
	 * @param arg1 2ème String à comparer
	 * @see java.util.Comparator#compare()
	 */
	public int compare(Object arg0, Object arg1) {
		String s0 = (String)arg0;
		String s1 = (String)arg1;
		/*
		 * Le plus pénible est de prendre en compte les cas où une des chaînes
		 * n'a pas la longueur minimum requise pour le tri à partir du n-ième
		 * caractère...
		 */
		if (s0.length() <= numChar) {
			// Si le 1er String n'a pas la longueur minimum requise
			if (s1.length() <= numChar) {
				// ... ni le 2ème : on dit qu'elles sont égales
				return 0;
			} else {
				// ... si le 2ème est à la maille : 
				//     on dit que le 1er est plus petite
				return -1;
			}
		} else {
			// Si le 1er String est assez grand
			if (s1.length() <= numChar) {
				// ... mais pas le 2ème : on dit que le 1er est plus grand
				return 1;
			} else {
				// Mais une fois ces cas traités, String fournit ce qu'il faut
				return s0.substring(numChar).compareTo(s1.substring(numChar));
			}
		}
	}

	/*
	 * Simple méthode d'affichage pour le test
	 */
	public void display(){
		System.out.println("===============================");
		System.out.println("Tri sur le car. " + numChar + ":");
		for (Iterator iterator = iterator(); iterator.hasNext();) {
			System.out.println(iterator.next());
		}
	}
	
	
	public static void main(String[] args) {
		// On crée l'objet
		SortableVectorOfString svs = new SortableVectorOfString();
		// On l'alimente un peu
		svs.add("QsDfghjklm");
		svs.add("AzErtyu");
		svs.add("WxCvbn");
		// 1er tri sur les chaînes complètes
		svs.sortStringVector(0);
		svs.display();
		// 2ème tri ne distingue pas "AzErtyu" de "WxCvbn"
		svs.sortStringVector(8);
		svs.display();
		// 3ème tri sur le 3ème car.
		svs.sortStringVector(2);
		svs.display();
		// 4ème tri ne distingue toujours pas "AzErtyu" de "WxCvbn"
		svs.sortStringVector(8);
		svs.display();
	}

	
}

===============================
Tri sur le car. 0:
AzErtyu
QsDfghjklm
WxCvbn
===============================
Tri sur le car. 8:
AzErtyu
WxCvbn
QsDfghjklm
===============================
Tri sur le car. 2:
WxCvbn
QsDfghjklm
AzErtyu
===============================
Tri sur le car. 8:
WxCvbn
AzErtyu
QsDfghjklm

import java.util.Collections;
Collections.sort(tonTableau);

int i = 0;
vecteur tmp;
while (i< length)
{
//listevect -> tableau de vecteurs
//listevect[i] -> vecteur à l'indice i du tableau de vecteur listevect
//listevect[i][2] -> 3eme cordonnées du vecteur à l'indice i.....

//tu peux remplacer listevect[i][2] par une fonction genre listevect[i].getz(); qui te renverrais ta 3 eme coordonnées.


if(listevect[i][2] > listevect[i+1][2]){
tmp = listevect[i][2];
listevect[i][2] = listevect[i+1][2];
listevect[i+1][2] = tmp;
i = i - 1;
}
i++;
}