面试官：为什么不能将实数作为 HashMap 的 key？

import java.util.HashMap;import java.util.Map;//class Point {//    int x;//    int y;//    Point(int a, int b) { x = a; y = b; }//}
public class Solution {    public int maxPoints(Point[] points) {        if (points.length <= 2) {            return points.length;        }        int max = 2;        for (int i = 0; i < points.length - 1; i++) {            Map<Float, Integer> map = new HashMap<>(16);            // 记录垂直点数; 当前和Points[i]在一条线上的最大点数; 和Points[i]垂直的点数            int ver = 0, cur, dup = 0;            for (int j = i + 1; j < points.length; j++) {                if (points[j].x == points[i].x) {                    if (points[j].y != points[i].y) {                        ver++;                    } else {                        dup++;                    }                } else {                    float d = (float)((points[j].y - points[i].y) / (double) (points[j].x - points[i].x));                    map.put(d, map.get(d) == null ? 1 : map.get(d) + 1);                }            }            cur = ver;            for (int v : map.values()) {                cur = Math.max(v, cur);            }            max = Math.max(max, cur + dup + 1);        }        return max;    }}

public static void main(String[] args) {    int[][] vals = {{2,3},{3,3},{-5,3}};    Point[] points = new Point[3];    for (int i=0; i<vals.length; i++){        points[i] = new Point(vals[i][0], vals[i][1]);    }    Solution solution = new Solution();    System.out.println(solution.maxPoints(points));}

System.out.println(0.0 == -0.0);

map.put(d, map.get(d) == null ? 1 : map.get(d) + 1);

public V get(Object key) {    Node<K,V> e;    return (e = getNode(hash(key), key)) == null ? null : e.value;}

static final int hash(Object key) {    int h;    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

public native int hashCode();

public static void main(String[] args) {        System.out.println(0.0 == -0.0);        System.out.println(new Float(0.0).hashCode() ==             new Float(-0.0).hashCode());    }

System.out.println(new Float(0.0).equals(0.0f));System.out.println(new Float(0.0).equals((float) -0.0));

public boolean equals(Object obj) {    return (obj instanceof Float)           && (floatToIntBits(((Float)obj).value) ==                    floatToIntBits(value));}

/*** Returns a representation of the specified floating-point value* according to the IEEE 754 floating-point "single format" bit* layout.** <p>Bit 31 (the bit that is selected by the mask* {@code 0x80000000}) represents the sign of the floating-point* number.* Bits 30-23 (the bits that are selected by the mask* {@code 0x7f800000}) represent the exponent.* Bits 22-0 (the bits that are selected by the mask* {@code 0x007fffff}) represent the significand (sometimes called* the mantissa) of the floating-point number.** <p>If the argument is positive infinity, the result is* {@code 0x7f800000}.** <p>If the argument is negative infinity, the result is* {@code 0xff800000}.** <p>If the argument is NaN, the result is {@code 0x7fc00000}.** <p>In all cases, the result is an integer that, when given to the* {@link #intBitsToFloat(int)} method, will produce a floating-point* value the same as the argument to {@code floatToIntBits}* (except all NaN values are collapsed to a single* "canonical" NaN value).** @param   value   a floating-point number.* @return the bits that represent the floating-point number.*/public static int floatToIntBits(float value) {    int result = floatToRawIntBits(value);    // Check for NaN based on values of bit fields, maximum    // exponent and nonzero significand.    if (((result & FloatConsts.EXP_BIT_MASK) ==          FloatConsts.EXP_BIT_MASK) &&         (result & FloatConsts.SIGNIF_BIT_MASK) != 0)        result = 0x7fc00000;    return result;}

System.out.println(Float.floatToIntBits((float) 0.0));System.out.println(Float.floatToIntBits((float) -0.0));System.out.println(Float.floatToRawIntBits(0.0f));System.out.println(Float.floatToRawIntBits((float)-0.0));

0-21474836480-2147483648