Java HashMap put不会为一维超过128的点添加值，没有溢出错误

我定义了一个类Point，它表示整数晶格上的一个点。我已经重写了hashCode（）和equals（Object）的方法

使用HashMap.put（Point，Double）处理坐标值>=128的点时，HashMap似乎没有任何作用。不会引发错误，但尝试从HashMap访问点将导致找不到密钥。我在INTEGER.MAX_值以下，内存充足

以下是我的重点课程：

import java.util.ArrayList;

public class Point {
    protected int dimension;
    protected ArrayList<Integer> coordinates;

    public Point(int[] coordinates){
        this.coordinates = convertArray(coordinates);
        dimension = coordinates.length;
    }

    private ArrayList<Integer> convertArray(int[] array){
        ArrayList<Integer> newArray = new ArrayList<Integer>();
        for(int i = 0; i < array.length; i++){
            newArray.add(array[i]);
        }
        return newArray;
    }

    @Override
    public int hashCode(){
        // Some arbitrary quick hash
        return coordinates.get(0);
    }

    @Override
    public boolean equals(Object o){
        Point p = (Point)o;
        if(dimension != p.coordinates.size())
            return false;
        for(int i = 0; i < p.coordinates.size(); i++){
            if(coordinates.get(i) != p.coordinates.get(i)){
                return false;
            }
        }
        return true;
    }
}

import java.util.ArrayList；
公共课点{
保护整数维；
受保护的阵列列表坐标；
公共点（int[]坐标）{
this.coordinates=convertArray（坐标）；
尺寸=坐标。长度；
}
专用ArrayList convertArray（int[]数组）{
ArrayList newArray=新ArrayList（）；
for（int i=0；i

我做的测试是：

import java.util.*;
public class random {

    public static void main(String[] args) {
        HashMap<Point, Double> weight = new HashMap<Point, Double>((int)(150 * 150 * .75 + 1));
        for(int i = 0; i < 150; i++){
            for(int j = 0; j < 150; j++){
                int [] tmpArray = {i, j};
                weight.put(new Point(tmpArray), Math.random());
            }
        }

        for(int i = 0; i < 150; i++){
            for(int j = 0; j < 150; j++){
                int [] tmpArray = {i, j};
                if(weight.get(new Point(tmpArray)) == null){
                    System.out.println("[" + i + ", " + j + "]: ");
                    System.out.println(weight.containsKey(new Point(tmpArray)));
                }
            }
        }
    }
}

import java.util.*；
公共类随机{
公共静态void main（字符串[]args）{
HashMap权重=新的HashMap（（int）（150*150*.75+1））；
对于（int i=0；i<150；i++）{
对于（int j=0；j<150；j++）{
int[]tmpArray={i，j}；
weight.put（新点（tmpArray），Math.random（））；
}
}
对于（int i=0；i<150；i++）{
对于（int j=0；j<150；j++）{
int[]tmpArray={i，j}；
if（weight.get（新点（tmpArray））==null）{
System.out.println（“[”+i+“，“+j+”]：”）；
系统输出打印LN（重量集装箱箱（新点（tmpArray））；
}
}
}
}
}

任何想法都会有帮助。谢谢

@Override
    public boolean equals(Object o){
        Point p = (Point)o;
        if(dimension != p.coordinates.size())
            return false;
        for(int i = 0; i < p.coordinates.size(); i++){
            if(coordinates.get(i) != p.coordinates.get(i)){
                return false;
            }
        }
        return true;
    }

您可以简单地使用提供的列表方法，而不是循环列表

当且仅当指定的对象也是一个列表时返回true，并且 列表具有相同的大小，并且中所有对应的元素对都相同 这两个列表是相等的

另外，在

散列值映射

可变对象中，不应使用as

键

如果对象的hashCode（）值可以根据其状态进行更改，那么 在基于哈希的应用程序中使用此类对象作为键时必须小心 集合，以确保在 它们被用作散列键。所有基于哈希的集合都假定 对象的哈希值在用作 输入集合中的键。如果密钥的散列码在 在一个集合中，一些不可预测和混乱的结果 我可以跟着

Integer a = 1000, b = 1000;  
System.out.println(a == b); // false  
Integer c = 100, d = 100;  
System.out.println(c == d); // true
Integer e=5 , f= new Integer(5);
System.out.println(e == f) // false