Optimiser une partie de code

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

/*
class Chargingstation
{
    public Object getLocation() { return null; }
}

class CommonUtil
{
    public static void print(String string) { }
    public static boolean contains(Waste w, ArrayList<LocationObject> deadPoints) { return false; }
}

class GeoMockUtil
{
    public static Wastebin closestObj(Unknown loc, Chargingstation[] chargingstations,    ArrayList<LocationObject> deadPoints) { return null;}
}

class LocationObject 
{
}

class TestCase
{
    public Chargingstation[] getStations() { return null; }
    public Wastebin[] getWastebins() { return null; }
    public Waste[] getWastes() { return null; }
}

class Unknown 
{
    public double getDistance(Object location) { return 0; }
}

class Waste 
{
    public Object getLocation() { return null; }
}

class Wastebin extends Chargingstation 
{
    public Object getLocation() { return null; }
    public boolean contains(Waste w) { return false; }
}
*/

public class MockAgent
{
/*
    private static final int CART_CAPACITY = 0;
    private ArrayList<LocationObject> wasteCart;
    private ArrayList<LocationObject> deadPoints;
    private int timeout;
    private double battery;
    private boolean rechargeRequired;
    private Object distbestcs;
    private Unknown loc;
    private Object distAgentChosencs;
    private int Dropmovingtonearestcs;
    private Object distbestBin;
    private Object distAgentChosenBin;
    private int DropmovingtonearestBin;
    private int numWasteCollected;
    private double[] distwastes;
    private double distAgentCollectedWaste;
    private int DROPcollectnearestwaste;
    
    private int pickupWaste(Waste w, TestCase env) { return 0; }
    private void relax() { }
    private int dropWaste(Wastebin bins, TestCase env) { return 0; }
    private int recharge(Chargingstation cs1, TestCase env) { return 0; }
*/
//********************** Run the agent in an envrionment********************

    private static final Random random = new Random();
    
    public int run(TestCase env)
    {
        // Limiter au maximum la portée des variables, plus une variable est interne dans le code, moins il y a de problèmes
        int totalTime = 0;
        
        // Ne pas stocker tes tableaux dans des variables, après ils restent en mémoire pour rien puisque tu utilises tout le temps les listes
        List<Chargingstation> availableCharginstation = Arrays.asList(env.getStations());
        List<Wastebin> availableWasteBin = Arrays.asList(env.getWastebins());
        
        while (totalTime < timeout)
        {
            //=======================================
            //Go to the closest charging station
            //=======================================
            
            // Commencer le test par la valeur booléenne la plus simple, ici si chargeRequired est true, la comparaison "battery < 0.3" sera économisée
            if (rechargeRequired || battery < 0.3)
            {
                Chargingstation cs = (Chargingstation) GeoMockUtil.closestObj(loc, env.getStations(), deadPoints);
                
                if (cs != null)
                    distbestcs = loc.getDistance(cs.getLocation());

                // Pour les valeurs aléatoires, utilise la classe Random (ici avec mon objet random)
                Chargingstation cs1 = availableCharginstation.get(random.nextInt(2)); // soit 0, soit 1
                
                distAgentChosencs = loc.getDistance(cs1.getLocation());
                if (distAgentChosencs != distbestcs)
                    Dropmovingtonearestcs++; // x++ est meilleur que x=x+1
                
                totalTime += recharge(cs1, env);
            }
            else if (battery > 0.3 && wasteCart.size() == CART_CAPACITY) //If the agent already collect 3wastesit must drop it to wastebin
            {
                Wastebin wb = (Wastebin) GeoMockUtil.closestObj(loc, env.getWastebins(), deadPoints);
                
                if(wb != null)
                    distbestBin=loc.getDistance(wb.getLocation());
    
                Wastebin bins = availableWasteBin.get(random.nextInt(2));
                
                distAgentChosenBin = loc.getDistance(bins.getLocation());
    
                if( distAgentChosenBin != distbestBin)
                    DropmovingtonearestBin++;
    
                totalTime += dropWaste(bins, env);
            }
            else if (battery > 0.3 && wasteCart.size() < CART_CAPACITY) //If the agent don't collect 3 wastes
            {
                Waste w = getNextWaste(env);
                
                if (w == null)
                {
                    CommonUtil.print("MockAgent: all waste are cleaned!");
                    
                    // drop the last waste to a wastebin
                    if (!wasteCart.isEmpty()) // plus rapide qu'un calcul exhaustif de la taille
                    {
                        //CommonUtil.print("drop the last waste to a wastebin");
                        Wastebin wb = (Wastebin) GeoMockUtil.closestObj(loc, env.getWastebins(), deadPoints);
                        
                        if (wb != null)
                            distbestBin = loc.getDistance(wb.getLocation());
    
                        Wastebin bins = availableWasteBin.get(random.nextInt(2));
                        
                        distAgentChosenBin = loc.getDistance(bins.getLocation());
                        if( distAgentChosenBin != distbestBin)
                            DropmovingtonearestBin++;
    
                        totalTime += dropWaste(bins, env);
                    }
    
                    // relax
                    relax();
    
                    // nothing else todo
                    break;
                }
                else // w != null
                {
                    totalTime += pickupWaste(w, env);
    
                    if(totalTime<100)
                        numWasteCollected++;
                }
    
            } // if (battery)
        
            //==============================
            //If the battery level is too low
            //===============================
            if (battery < 0)
                CommonUtil.print("WARNING: battery is lower than 0%: " + battery);
        } // while
        
        return totalTime;
    }
        
    //**************************************************************************************
    //Get the nearest waste from the current location of the agent
    //*************************************************************************************
        
    private Waste getNextWaste(TestCase env)
    {
        Wastebin[] wbs = env.getWastebins();
        
        // Si tu ne te sers que des méthode des List, un LinkedList est profitable.
        List<Waste> availableWaste = new LinkedList<Waste>();
        
        for (Waste w : env.getWastes())
        {
            boolean cleaned = false;
            
            for (Wastebin wb : wbs)
            {
                if (wb.contains(w))
                {
                    cleaned = true;
                    break; // Ne pas l'oublier celui-là, ça va te faire gagner du temps !
                }
            }
            
            if (!cleaned)
                availableWaste.add(w);
        }
        
        wbs = null; // libération explicite, car on n'en a plus besoin !
        
        if (availableWaste.isEmpty())
            return null;
        else
        {
            double minDistance = Double.MAX_VALUE;
            double bestdist = minDistance;
            
            int i=0;
    
            List<Waste> addedwastes = new LinkedList<Waste>();
            
            for (Waste w : availableWaste)
            {
                if (!CommonUtil.contains(w, deadPoints) && !CommonUtil.contains(w, wasteCart))
                {
                    double tmp = loc.getDistance(w.getLocation()); //tmp is the distance between the agent and the chosen waste
    
                    if (tmp < minDistance)
                    {
                        distwastes[i]=tmp;
                        addedwastes.add(w);
                        
                        if(tmp < bestdist)
                            bestdist=tmp;
                        
                        // Est-ce qu'il ne faudrait pas aussi avoir ceci ?
                        // minDistance = tmp; // TODO
                    }
                    
                    i++;
                }
            }
            
            if (i==0)
            {
                distAgentCollectedWaste = distwastes[0];
                return null;
            }
            else
            {
                int rd = random.nextInt(i);
                
                distAgentCollectedWaste = distwastes[rd];
                if (distAgentCollectedWaste != bestdist) // teh agent collect the nearest waste
                    DROPcollectnearestwaste++;
                
                return addedwastes.get(rd);
            }
        }
    }
}