tout d'abord merci fred pour la reponse

quand je mets egalite.trierTableau(egalite) comme tu me le conseille l'erreur change et devient :

Jeu.java:242: cannot find symbol
symbol : method trierTableau(int[])
location: class int[]
egalite.trierTableau(egalite);

voici l'integralité de mon code, si ca peut t'aider pour m'aider!

public class Jeu extends Main{
	private Main J1, J2;
	private int jeudistribue;

/** constructeur */
    public Jeu(Main M1, Main M2) {
    	this.J1=M1;
    	J2=M2;
    	jeudistribue=0 ;/** pour qu'on ne puisse pas commencer a jouer sans avoir distribué ! */
    }
    
    public Jeu(){
    	this.J1=new Main();
    	J2=new Main();
    	jeudistribue=0;
    }
public Jeu distribuer_hasard(){
		int[]T;
		int n=20;
		T=new int[n];

		/** on crée le sabot qui est trié */
		int i,a;
		for(i=0;i<4;i++)
			T[i]=1;
		for(i=4;i<8;i++)
			T[i]=2;
		for(i=8;i<12;i++)
			T[i]=3;
		for(i=12;i<16;i++)
			T[i]=4;
		for(i=16;i<20;i++)
			T[i]=5;

		/** on crée les 2 joueurs et leurs mains de 10 cartes */
		Main J1=new Main(); /** on cree la file de taille 20, car si le joueur gagne il aura alors 20 cartes en main */
		Main J2=new Main();
		Jeu J1J2;
		J1J2=new Jeu(J1,J2); /** J1J2 est le regroupement des 2 mains distribuées pour le retour */
	
		i=0;
		while(i!=10) /** tant que la file n'est pas entierement rempli*/
		{
			a=(int)(Math.random()*20);  /** on utilise random pour reproduire le hasard*/
				if(T[a]!=0)
				{
					System.out.print(" a="+a); // verif de a
					System.out.print(" T[a]="+T[a]); // verif de la carte a enfiler
					J1.enfiler(T[a]);
					T[a]=0;/** pour qu'une carte ne soit utilisée qu'une fois*/
					
					i++;
					
				}
			
		}
		System.out.println("\n");
		/** on met les cartes restantes du sabot a J2 en parcourant le tableau est en enfilant si T[i] est diff de null*/
		i=0;
		
		while(i!=10) /** tant que la file n'est pas entierement rempli*/
		{
			a=(int)(Math.random()*20);  /** on utilise random pour reproduire le hasard */
				if(T[a]!=0)
				{
					System.out.print(" a="+a); // verif de a
					System.out.print(" T[a]="+T[a]); // verif de la carte a enfiler
					J2.enfiler(T[a]);
					T[a]=0; /** pour qu'une carte ne soit utilisée qu'une fois */
					i++;
					
				}
			
		}
		System.out.println(" \n");
		jeudistribue=1;
	return J1J2;
	}// fin de la distribution

public void trierTableau(int tbl[]){
		int i,j,taille,tmp;
		taille=tbl.length;
	
			while(taille>1)
			{
				for(i=0; i<taille-1; i++){
					if(tbl[i]>tbl[i+1]){
						tmp=tbl[i];
						tbl[i]=tbl[i+1];
						tbl[i+1]=tmp;
					}	
				}
				taille=taille-1;
			}
		
	}
	
	
	public void jouonstout(){ /** jeu ou on voit tout le deroulemnt de la partie */
		
		int[] egalite=new int[20]; /** on crée un tableau spécial pour les cas d'egalité, de taille 20 au cas ou tous les tours sont égaux 
		on utilise un tableau pour pouvoir le parcourir afin de ranger ensuite les cartes dans l'ordre des valeurs*/
		int e=0;
		if(jeudistribue==0) /** on ne peut jouer que si les cartes ont été distribuées */
			System.out.println("le jeu n\'a pas été distribué");
			
		else
		{
			while((J1.estVide()!=true)&&(J2.estVide()!=true)){ /** tant que les deux mains ont des cartes, on joue. Si un joueur a sa main vide, on stoppe le jeu */
				System.out.print("le joueur 1 pose : "+J1.tete());
				System.out.println("le joueur 2 pose : "+J2.tete());
				
				/** on "pose" la tete de la file representant la main */
				
				if(J1.tete()==J2.tete()){ /** on teste en premier l'egalité des cartes en jeu */
					/** il faut stocker les cartes en attente du prochain tour */
					egalite[e]=(J1.tete());
					J1.defiler();
					e++;
					egalite[e]=(J2.tete());
					J2.defiler();
					e++;					
					
				}
				else{
					if(J1.tete()>J2.tete()){ /** joueur 1 mène */
					
						if(e!=0){ /** si le tableau "egalité" contient qqch il faut le vider dans la main du gagnant de ce tour, ici le joueur 1 */
							
							egalite[e]=J1.tete();
							J1.defiler();
							e++;
							egalite[e]=J2.tete();
							J2.defiler();
							e++;
							
							egalite.trierTableau(egalite); /** on trie le tableau dans l ordre croissant */
							
							while(e>=0){
								J1.enfiler(egalite[e]);
								e--;
							}
						}
						
					
						else{ /** dans le cas simple ou il n'y a pas eu d'egalité precedemment */
							System.out.println("le joueur 1 remporte le tour");
							J1.enfiler(J1.tete()); /** on met dans la file la carte la plus forte en premier */
							J1.defiler(); /** on la retire de la file */
							J1.enfiler(J2.tete()); /** puis on met la plus faible */
							J2.defiler();
						}
						

					} // fin du "si le premier joueur gagne
					else { 
/** joueur 2 mene : */						
					
						if(e!=0){ /** si le tableau "egalité" contient qqch il faut le vider dans la main du gagnant de ce tour, ici le joueur 2 */
							
							egalite[e]=J1.tete();
							J1.defiler();
							e++;
							egalite[e]=J2.tete();
							J2.defiler();
							e++;
							
							egalite.trierTableau(egalite); /** on trie le tableau dans l ordre croissant */
							
							while(e>=0){
								J2.enfiler(egalite[e]);
								e--;
							}
						}					
					
					
						else{
						
							System.out.println("le joueur 2 remporte le tour");
							J2.enfiler(J2.tete()); /** on met dans la file la carte la plus forte en premier */
							J2.defiler(); /** on la retire de la file (on la retire apres sinon on ne pourrait pas l'enfiler)*/
							J2.enfiler(J1.tete()); /** puis on met la plus faible */
							J1.defiler();
						}
					}
				}// fin du else allant au if d'egalité
			}// fin du while
			
			if ((J1.estVide()==true) && (J2.estVide()==true) ) /** si on sort de la boucle while ac les 2 mains vides */
				System.out.println ( "\n les deux joueurs ont perdu la partie ");
				
			else {
				if(J1.estVide()==true) /** si on sort de la boucle while avec le joueur 1 ayant une main vide */
					System.out.println("\n Le Joueur 2 est le vainqueur de cette partie");
				else
					System.out.println("\n Le Joueur 1 est le vainqueur de cette partie");
			}
		}// fin du else
	} /** fin du jouonstout */

desolé pour la longueur !

je reste a dispo et connecter pour plus d'information

encore merci

Moustik

je dois donc creer une nouvelle classe Tableau?
il n'y a pas d'autre moyen?

je voulais juste appeler une fonction toute simple triant mon tableau

merci merci beaucoup, je n'ai plus de probleme a la compilation, ca a donc l'air de marcher :)
c'est tres gentil de m'avoir aidé.

Tu as l'air doué en Java, est ce que je peux encore abuser de ton aide?
je comprendrai si tu refuse, mais la je suis tombé sur une perle de forum !
personne ne m'avait aidé

mille merci

Morgane

toujours en référence au code posté, j'ai un probleme dans "jouonstout"
Je n'arrive pas à entrer dans la boucle while.
J'ai mis cette ligne de code en commentaire (juste pour tester la suite !) et j'ai un deuxieme souci avec mes J1.tete(); qui me retoune a chaque fois la valeur 0, qui est la valeur par defaut dans ma class file
je m'en suis apercu en changeant le code de ma file et en mettant -7 !

A cause de cela, tout mon code est faux -snif-

Merci a qui m'aidera de nouveau

voici le code de ma file (un peu long encore une fois )

class FileTabC {

 // partie statique
    private static final int capaDefaut = 100;

 // attributs (d'instance)
    private int nb, t; // nb est un compteur du nb de valeurs presentes dans le tableau
    private int[] tab;

 // constructeurs  
    public FileTabC(int capa){
	if (capa < 0) 
	        capa = 0;
	tab = new int[capa];
	nb = 0; 
	t = 0; 
    }
   
   public FileTabC(){
       this(capaDefaut);
   }

    public boolean estBornee(){
	return true;
    }

    public int capacite(){
	return tab.length;
    }
    public boolean estPleine(){
	return (nb == tab.length);
    }
    public boolean estVide(){
	return (nb == 0);
   }
    
 
 	public void enfiler(int o){
		if ( ! estPleine() ){
	    	tab[(t+nb)%tab.length] = o;
	    	nb++;
		}
    }
    
    public void defiler(){
	if ( ! estVide() ){
	       t = (t+1) % tab.length;
	       nb--;
	}
    }
    public int tete(){
	int o = 0; 
	if ( ! estVide())
	    o = tab[t];
	return o;
    }
} // fin de la classe FileTabC