Q:

A* (A star) algorithm optimization

I'm a student and me and my team have to make a simulation of student's behaviour in a campus (like making "groups of friends") walking etc.  For finding path that student has to go, I used A* algorithm (as I found out that its one of fastest path-finding algorithms).  Unfortunately our simulation doesn't run fluently (it takes like 1-2 sec between successive iterations).  I wanted to optimize the algorithm but I don't have any idea what I can do more.  Can you guys help me out and share with me information if its possible to optimize my A* algorithm?  Here goes code:
  public LinkedList<Field> getPath(Field start, Field exit) {

    LinkedList<Field> foundPath = new LinkedList<Field>();
    LinkedList<Field> opensList= new LinkedList<Field>();
    LinkedList<Field> closedList= new LinkedList<Field>();
    Hashtable<Field, Integer> gscore = new Hashtable<Field, Integer>();
    Hashtable<Field, Field> cameFrom = new Hashtable<Field, Field>();
    Field x = new Field();
    gscore.put(start, 0);
    opensList.add(start);
    while(!opensList.isEmpty()){

        int min = -1;
        //searching for minimal F score
        for(Field f : opensList){
            if(min==-1){
                min = gscore.get(f)+getH(f,exit);
                x = f;
            }else{
                int currf = gscore.get(f)+getH(f,exit);
                if(min > currf){
                    min = currf;
                    x = f;
                }
            }
        }
        if(x == exit){
            //path reconstruction
            Field curr = exit;
            while(curr ! = start){
                foundPath.addFirst(curr);
                curr = cameFrom.get(curr);
            }
            return foundPath;
        }
        opensList.remove(x);
        closedList.add(x);
        for(Field y : x.getNeighbourhood()){
            if(!(y.getType()==FieldTypes. PAVEMENT ||y.getType() == FieldTypes. GRASS) || closedList.contains(y) || !( y.getStudent()==null))
                            {
                continue;
            }
            int tentGScore = gscore.get(x) + getDist(x,y);
            boolean distIsBetter = false;
            if(!opensList.contains(y)){
                opensList.add(y);
                distIsBetter = true;
            }else if(tentGScore < gscore.get(y)){
                distIsBetter = true;
            }
            if(distIsBetter){
                cameFrom.put(y, x);
                gscore.put(y, tentGScore);
            }               
        }
    }

    return foundPath;
}

 private int getH(Field start, Field end){
    int x;
    int y;
    x = start.getX()-end.getX();
    y = start.getY() - end.getY();
    if(x<0){
        x = x* (-1);
    }
    if(y<0){
        y = y * (-1);
    }
    return x+y;
}
private int getDist(Field start, Field end){
    int ret = 0;
    if(end.getType() == FieldTypes. PAVEMENT){
        ret = 8;
    }else if(start.getX() == end.getX() || start.getY() == end.getY()){
        ret = 10;
    }else{
        ret = 14;
    }

    return ret;
}

//EDIT
This is what i got from jProfiler:

So getH is a bottlneck yes?  Maybe remembering H score of field would be a good idea? 

A:

You can optimize the problem by using a different algorithm, the following page illustrates and compares many different aglorihms and heuristics:

A* 
IDA*
Djikstra
JumpPoint
...

http://qiao.github.io/PathFinding.js/visual/

A:

A linked list is not a good data structure for the open set.  You have to find the node with the smallest F from it, you can either search through the list in O(n) or insert in sorted position in O(n), either way it's O(n).  With a heap it's only O(log n).  Updating the G score would remain O(n) (since you have to find the node first), unless you also added a HashTable from nodes to indexes in the heap. 
A linked list is also not a good data structure for the closed set, where you need fast "Contains", which is O(n) in a linked list.  You should use a HashSet for that.