How to get second biggest distance from a Hashmap?

I am trying to get the biggest and second biggest distance in a Hashmap in Java.

Basically, from a hashmap populated with (x,y) values, I plan to pick a point, set it as a fixed point and calculate distance with this point in relation to all the other points. After all possible distances are calculated, I change the fixed point to the next element in the HashMap. With this process, I aim to get the biggest and second biggest value in a hashmap distance-wise.

 HashMap<Integer, Integer> corners = getPotentialCorners(image);
        HashMap<Integer, Integer> extremeCorners = new HashMap<>();
        int Blue = new Color(0, 0, 255).getRGB();
        int currentNumberX;
        int currentNumberY;
        int pivotVarX;
        int pivotVarY;
        double distance;
        double Highest = 0;
        double Highest2 = 1;
        int xHighest = 0;
        int yHighest = 0;
        int xHighest2 = 0;
        int yHighest2 = 0;
        for (int i : corners.keySet()) {
            currentNumberX = (i);
            currentNumberY = corners.get(currentNumberX);
            for (int j : corners.keySet()) {
                pivotVarX = j;
                pivotVarY = corners.get(pivotVarX);
                distance = Math.abs(Math.sqrt(Math.pow((pivotVarX - currentNumberX), 2) + Math.pow((pivotVarY - currentNumberY), 2)));
                if (pivotVarX != currentNumberX) {
                    if ((Highest > Highest2)) {
                        xHighest = currentNumberX;
                        yHighest = currentNumberY;
                        Highest2 = distance;
                    }
                    if (distance > Highest2) {
                        Highest2 = distance;
                        xHighest2 = currentNumberX;
                        yHighest2 = currentNumberY;
                    }


                }
            }


        }

With this code, I debugged it, and I always get one correct point, and another point is ALWAYS (0,0). I know the issue lies with my process of getting the second highest point (Highest2, XHighest2,YHighest2), but I do not know how to fix it.

As others pointed out, instead of a HashMap, it is better to use List<Point> which you can easily iterate as:

for (Point p: myList) {
...
}

or if you need more control on which elements to iterate over you can use an integer counter:

for (int j = i+1; j < corners.size(); j++) {
Point p = corners.get(j);
...
}

instead of having to use keySet() and get() and all the problems with identical x-values mapping on the same bin.

Also, there are some trivial speed improvements possible:

• No need to use the slow Math.sqrt() function (or Math.abs() as square root is always positive) since you are only comparing larger/smaller distances. You can just compare the squared distances.
• The latest Java compiler knows how to optimize Math.pow(int, 2), but to make sure you don't get the overhead of a function call, you can help the compiler by writing: (p.x-q.x)*(p.x-q.x) + (p.y-q.y)*(p.x-q.y)

Renaming current and pivot to p and q for conciseness, your code would look like:

List<Point> corners = getPotentialCorners(image);
Double highest = null;
Double highest2 = null;
Point highestP = null, highestQ = null;
Point highestP2 = null, highestQ2 = null;
for (int i = 0; i < corners.size()-1; i++) {
Point p = corners.get(i);
for (int j = i+1; j < corners.size(); j++) {
Point q = corners.get(j);
double distanceSq = (p.x-q.x)*(p.x-q.x) + (p.y-q.y)*(p.y-q.y);
if (highest == null || distanceSq >= highest) {
// shift highest to second highest
highest2 = highest;
highestP2 = highestP;
highestQ2 = highestQ;
highest = distanceSq;
highestP = p;
highestQ = q;
} else if (highest2 == null || distanceSq > highest2) {
highest2 = distanceSq;
highestP2 = p;
highestQ2 = q;
}
}
}