Нужен совет по поводу оптимизации

private ArrayList<Bees> ylei;
    private HashMap<Float, Bees> timeOfBirth;
    private TreeSet<Integer> identifys;
    private final int rabTime, trutTime;
    private final float rabProbability, trutPercent;
    private int rabSum = 0, trutSum=  0;
    private int rabPereiod = 0, trutPereiod=  0;
    private int rabLifeTime = 0, trutLifeTime = 0;
    private int simulationTime = 0;
    private DrawingPanel paintPanel;
    public int rabSpeed = 0;
    public int trutSpeed = 0;
    public int beesChangeDestinationTime = 0;
 
    public Habitat(
            int N1, float K,
            int N2, float P,
            int nLT, int dLT,
            DrawingPanel d)
    {
        trutTime = N1;
        trutPercent = K;
 
        rabTime = N2;
        rabProbability = P;
 
        ylei = new ArrayList();
        timeOfBirth = new HashMap<Float, Bees>();
        identifys = new TreeSet<Integer>();
        rabLifeTime = nLT;
        trutLifeTime = dLT;
 
        paintPanel = d;
    }
 
    public boolean AddBees(Class c, int t)
    {
        if (c == Light.class)
        {
 
            ylei.add(new Light(
                    this.GetPointOnPanel(paintPanel)));
            trutSum++;
        }
        else if (c == Heavy.class)
        {
 
            ylei.add(new Heavy(
                    this.GetPointOnPanel(paintPanel)));
            rabSum++;
        }
        else
        {
            return false;
        }
 
        timeOfBirth.put(
                timeOfBirth.containsKey((float) t)
                ? (float) (t + 0.1)
                : (float) t,
                ylei.get(ylei.size() - 1));
        
        identifys.add(new Integer(ylei.get(ylei.size()-1).hashCode()));
        
        return true;
    }
 
    public void Update()
    {
        simulationTime++;
 
        if (++rabPereiod >= rabTime)
        {
            Random r = new Random();
            if (r.nextFloat() <= rabProbability)
            {
                AddBees(Heavy.class, simulationTime);
                rabPereiod = 0;
            }
        }
        if ((float) (GetSum() == 0 ? 0 : trutSum / GetSum()) < trutPercent)
        {
            if (++trutPereiod >= trutTime)
            {
                AddBees(Light.class, simulationTime);
                trutPereiod = 0;
            }
        }
 
        ArrayList<Float> remove = new ArrayList();
        for (Float i : timeOfBirth.keySet())
        {
            if ((simulationTime - i)
                    >= (timeOfBirth.get(i) instanceof Heavy
                    ? rabLifeTime
                    : trutLifeTime)
                    - 0.1)
            {
                remove.add(i);
            }
        }
        for (Float i : remove)
        {
            ylei.remove(timeOfBirth.get(i));
            timeOfBirth.remove(i);
        }
    }
 
    public ArrayList<Bees> GetYlei()
    {
        return ylei;
    }
 
    public HashMap<Float, Bees> GetCurrent()
    {
        return timeOfBirth;
    }
 
    public int GetSum()
    {
        return ylei.size();
    }
 
    public int GetRabSum()
    {
        return rabSum;
    }
 
    public int GetTrutSum()
    {
        return trutSum;
    }
 
    public int GetSimulationTime()
    {
        return simulationTime;
    }
 
    public void Restart()
    {
        ylei.clear();
        rabSum = 0;
        trutSum = 0;
        trutPereiod = 0;
        rabPereiod = 0;
        simulationTime = 0;
    }
 
    public static Point GetPointOnPanel(DrawingPanel p)
    {
        int xRange = (p.getWidth() - 100) - 100 + 1;
        int yRange = (p.getHeight() - 100) - 100 + 1;
 
        return new Point(
                (int) (Math.floor(Math.random() * xRange) + 100),
                (int) (Math.floor(Math.random() * yRange) + 100));
    }
 
    public void SetSpeeds(int nS, int dS, int dT)
    {
        this.rabSpeed = nS;
        this.trutSpeed = dS;
        this.beesChangeDestinationTime = dT;
    }
}