Buenas amigo, por lo que entiendo quieres ordenar personas, de menor a mayor, y de mayor a menor. (En el siguiente ejemplo, ordeno de menor a mayor por edad, y luego hago lo mismo por nombre, después de mayor a menor por nombre ^^)

Clase Persona:

package net.elhacker;
 
public class Person {
 
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
}

MainClass (En donde se ordena todo):

package net.elhacker;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
 
public class MainClass {
 
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList();
        list.add(new Person("cName",22));
        list.add(new Person("Bname",2));
        list.add(new Person("Cname",5));
        list.add(new Person("Aname",0));
        list.add(new Person("Aname",2));
        list.add(new Person("aName",15));
        list.add(new Person("Ename",12));
 
         // ORDENO POR EDAD DE MENOR A MAYOR
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object person1, Object person2) {
                return new Integer(((Person)person1).getAge()).compareTo(((Person)person2).getAge());
            }
        });
 
        for(Person p:list){
            System.out.println(p.getName() + " " + p.getAge());
        }
 
        System.out.println("\n-------------------\n");
 
         // ORDENO POR NOMBRE DE MENOR A MAYOR
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object person1, Object person2) {
                return new Integer(((Person)person1).getName().charAt(0)).compareTo((int)((Person)person2).getName().charAt(0));
            }
        });
 
        for(Person p:list){
            System.out.println(p.getName() + " " + p.getAge());
        }
 
        System.out.println("\n-------------------\n");
 
        // ORDENO POR NOMBRE DE MAYOR A MENOR
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object person1, Object person2) {
                return new Integer(((Person)person2).getName().charAt(0)).compareTo((int)((Person)person1).getName().charAt(0));
            }
        });
 
        for(Person p:list){
            System.out.println(p.getName() + " " + p.getAge());
        }
 
    }
 
}
 

La magia ocurre acá:

Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object person1, Object person2) {
                return new Integer(((Person)person1).getName().charAt(0)).compareTo((int)((Person)person2).getName().charAt(0));
            }
        });

Exacto, como dices es necesario redefinir Comparator, usualmente esto se hace con números, pero si haces .getName().charAt(0) y lo casteas a int, obtendrás el código ascci y podrás ordenar los nombres mediante a su primera letra (primero mayusculas luego minusculas). Esto lo podrías mejorar si también comparas por la segunda letra..., pero eso te lo dejo a ti.

Lo único diferente entre mayor y menor || menor y mayor, seria que cambio la posición de la variable person1 y person2. Si quiero que sea de menor a mayor pongo person1 compareTo person2, pero si quiero de mayor a menor pongo person2 compareTo person1.

Por cierto, no me preocupe de leer tu codigo porque no utilizaste las etiquetas Code. Para hacer esto modifica tu mensaje, selecciona el codigo y en el combobox que dice GeSHi, pon Java. Recuerdalo para la proxima  

---

Si solo buscas ordenar para imprimir, y no quieres modificar el ArrayList, te recomendaría que la solución mas fácil es crear un ArrayList en un método y copiar el contenido del real. Luego ordenar tu ArrayList nuevo e imprimir con un foreach. Suerte ^^

A ver hay dos clases de variables que se pueden declaran , globales y locales :

Las globales se declaran en la clase y se pueden acceder en cualquier parte de la clase.
Las locales son aquellos que se declaran dentro de un metodo , al acabar ese metodo la variable creada desaparece.

Supongo que es con eso con lo que estas liado.

para hacer el arrayList temporal seria algo asi:

Variables globales? wut?

Nose, pero yo tengo entendido que las variables Globales no existen en java. Quizás las clases, pero no variables.

Si quieres definir que existen clases de variables, entonces yo diría que existen 3 clases de variables.

Variables "locales": Se declaran dentro de métodos, cuando el método finaliza la ejecución, entonces la variable desaparece.

public void myMethod(){
    int number = 5;
    System.out.println(number);
} // Cuando el método termina de ejecutarse (después de imprimir number) entonces la variable number desaparece.

Variables de "objetos", mas bien le diría atributos (o algún otro nombre real): Son variables que se crean al inicializar un objeto. una vez el objeto es eliminado, la variable desaparece.

public class Class {
 
    private int number; // variable de objeto
 
    public Class() {
        this.number = 5;
    }
 
}

Y tercero, (las que creo que confunde nuestro amigo), son las variables de clase: Las variables de clase se crean cuando inicia la ejecución del programa y finalizan cuando finaliza la ejecución del programa. (No son variables globales por el simple hecho de que pertenecen a una clase):

public class Class {
 
    public static int number = 5;  // Variable de clase (la diferencias de una de objetos porque tiene un "static")
 
    public Class() {
    }
 
}

A estas variables accedes poniendo el nombre de la Clase (por convención, no utilices un objeto para acceder a ella) y luego el nombre de la variable.

Clase.number = 12;

En respuesta a tu pregunta, tu necesitarías una variable "local"