Ordenar objetos por 2 o mas atributos

        int resultado = Integer.compare( a.getEdad(), b.getEdad());
        if ( resultado != 0 ) { return resultado;}
       

        resultado = a.getNombre().compareTo(b.getNombre());
        if ( resultado != 0 ) { return resultado; }

        return resultado;

    }

};
// no se como utilizarlo luego para que me ordene

    private String pais;

    private int edad;

   
   
    public Usuario(){
       
        this.nombre="";
        this.edad=0;
        this.pais="";
       
       
    }
 
   
        public  void  nUsuario(String nombre,int edad,String pais){
         this.nombre=nombre;
         this.edad=edad;
         this.pais=pais;
           
     
     }
     
   

    public String getNombre() {
        return nombre;
    }

   
   
      public int getEdad() {
        return edad;
    }

      public String getPais() {
        return pais;
    }
     
   

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class almacenUsuarios {
   
    public static ArrayList<Usuarios> vectorUsuarios=new ArrayList<Usuario>();
 
    public void altaProducto(Alumno nuevoAlumno){
       
         this.vectorAlumno.add(nuevoAlumno);
         
       
    }

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/**
 *
 * @author Usuario
 */
public class OrdenarArrayList {
 

 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
 
         almacenNotasAlumnos vectorProductos=new almacenNotasAlumnos();
   
          Alumno altaProducto;
     
             
         
               
             
                      altaProducto=new Alumno();
                altaProducto.nAlumno("JOSE",23,"ESPAÑA");
                vectorProductos.altaProducto(altaProducto);
                altaProducto=null;
                      altaProducto=new Alumno();
                altaProducto.nAlumno("Aaron",22,"ESPAÑA");
                vectorProductos.altaProducto(altaProducto);
                altaProducto=null;
                     altaProducto=new Alumno();
                   altaProducto.nAlumno("JOSE",23,"ESPAÑA");
                vectorProductos.altaProducto(altaProducto);
                altaProducto=null;
           

  Collections.sort( almacenNotasAlumnos.vectorAlumno, new OrdenaCod());
 
 
   for(int x=0;x<almacenNotasAlumnos.vectorAlumno.size();x++){
           System.out.println("Nombre: "+ almacenNotasAlumnos.vectorAlumno.get(x).getNombre()+
                   " Edad: "+ almacenNotasAlumnos.vectorAlumno.get(x).getEdad()+
                     " Pais: "+ almacenNotasAlumnos.vectorAlumno.get(x).getPais());
             
        }
 
 
   
}    

       
        class OrdenaCod  implements Comparator{

    public int compare(Object o1, Object o2) {
        Alumno otroproducto= (Alumno)o1;
        Alumno otroproducto2=(Alumno)o2;

        return otroproducto.getEdad.compareTo(otroproducto2.getEdad);
    }}}

//

public class leer {

    //--------------------------------------------- Recoje un dato tipo String.

    public static String dato() {

        String sdato="";

        try{
            InputStreamReader isr=new InputStreamReader(System.in);
            BufferedReader FlujoE=new BufferedReader(isr);
            sdato=FlujoE.readLine();

        }

        catch (IOException e){
           System.err.println("Error: "+ e.getMessage());
        }
        return sdato;
    }

           
            //------------------------------------Recoje un dato de tipo Int.
   
    public static int entero(){
        boolean sw=true;
        int x=0;

        while(sw){

            try{
                x=Integer.parseInt(dato());
                sw=false;
            }
            catch (Exception ex){
                System.out.println("ERROR: Vuelva a introducir el dato.");
            }
        }
        return x;
    }

        public static int enteroProducto(){
            boolean sw=true;
            int x=0;

            while(sw){

                try{
                    x=Integer.parseInt(dato());
                    if(x>=1&&x<=20)
                        sw=false;
                    else
                        System.out.println("El numero no es correcto, (Del 1 al 20).");
                }
                catch (Exception ex){
                    System.out.println("ERROR: Vuelva a introducir el dato.");
                }
            }
        return x;
    }

        public static int enteroMinimo(){
            boolean sw=true;
            int x=0;

            while(sw){

                try{
                    x=Integer.parseInt(dato());
                    if(x>0)
                        sw=false;
                    else
                        System.out.println("El numero no es correcto, (Del 1 al 20).");
                }
                catch (Exception ex){
                    System.out.println("ERROR: Vuelva a introducir el dato.");
                }
            }
        return x;
    }

        public static double doublePrecio(){
            boolean sw=true;
            double x=0;

            while(sw){

                try{
                    x=Double.parseDouble(leer.dato());
                    if(x>0)
                        sw=false;
                    else
                        System.out.println("Precio no es correcto.");
                }
                catch (Exception ex){
                    System.out.println("ERROR: Vuelva a introducir el dato.");
                }
            }
        return x;
    }
        //-------------------------------------- Recoje un dato tipo dooble.

    public static double decimal(){
        boolean sw=true;
        double x=0;

        while(sw){

            try{
                x=Double.parseDouble(dato());
                sw=false;
            }
            catch (Exception ex){
                System.out.println("ERROR: Vuelva a introducir el dato.");
            }
        }
        return x;

    }

       //--------------------------------------- Recoje cualquier caracter tipo char

    public static char unCaracter(){
        boolean sw=true;
        int tamaño;
        char x=' ';
        String charDato;

        while (sw){

            try{
                charDato=dato();
                tamaño=charDato.length();
                if(tamaño>1)
                    throw new error ("Tamaño excedido.");
                x=charDato.charAt(0);
                sw=false;
            }
            catch(error ex){
                System.out.println(ex.getMessage());
            }
        }
        return x;
    }

    //------------------------------------------Recoje un char pero solo letra.

    public static char CharLetra(){
        boolean sw=true;
        boolean esLetra=false;
        char x=' ';
        while (sw){
           
            try{
                x=unCaracter();
                esLetra=Character.isLetter(x);
                if(esLetra==false)
                    throw new error("No es una letra");
                sw=false;
            }
            catch(error ex){
                System.out.println(ex.getMessage());
            }
        }
        return x;
    }

    //-----------------------------------------Recoje un char pero solo numero.
        public static char charNum(){
        boolean sw=true;
        boolean esLetra=false;
        char x=' ';
        while (sw){

            try{
                x=unCaracter();
                esLetra=Character.isDigit(x);
                if(esLetra==false)
                    throw new error("No es un número");
                sw=false;
            }
            catch(error ex){
                System.out.println(ex.getMessage());
            }
        }
        return x;
    }

}//llave de fin de la clase leer

class error extends Exception{
    error (String msg){
        super (msg);
    }
}