Java，双精度数及其索引的排序数组

Question

我在这个论坛和其他论坛上阅读了很多关于此的内容，但我仍然无法得到具体的答案。无论如何，我决定这样做：

这是一个保存字符串和整数的类：

public class Tuple{

    private String token;
    private int docID;



    public Tuple(String token, int docID) {
        this.token = token;
        this.docID = docID;
    }

    public String getToken() {
        return token;
    }
    public void setToken(String token) {
        this.token = token;
    }
    public int getDocID() {
        return docID;
    }
    public void setDocID(int docID) {
        this.docID = docID;
    }

}

然后，我创建一个数组列表来放置这些元组private ArrayList<Tuple> temps = new ArrayList<>();

然后我像这样填充数组列表：

for ( int i = 0; i < numberOfDocs; i++ )
{
    Tuple cat = new Tuple(Double.toString(vect[i]),i);
    temps.add(cat);
}

最终，我将数组排序如下：

public void sortTmp() 
{
    Collections.sort(temps, new Comparator<Tuple>() 
    {
        @Override
        public int compare(Tuple tr2, Tuple tr1)
        {
            return tr2.getToken().compareTo(tr1.getToken());
        }
    });
}

java 和 doubles 存在一些问题，我不能直接使用我的 double 矩阵，所以我必须这样做 Double.toString() 。结果已排序，但并不完全正确，因为从 double 计算的字符串在 double 数字排序方面不是很准确。

有什么想法吗？

Answer 1

如果您按字典顺序比较doubles，通过他们的String 表示，您可能确实会发现一些意想不到的结果。

你可以：

• 重构Tuple，使token 成为double（或包装Double，如果您想在实例上调用compareTo）
• 否则，在您的Comparator 中，您可以在您的Strings 上调用Double.parseDouble（这应该是相对安全的，因为Strings 首先来自doubles），然后调用@返回的 Double 包装器上的 987654333@。

最后一个选项听起来很丑，因为在Double 和String 之间有一堆看似不必要的来回转换，反之亦然。

这也意味着性能下降，因为在对集合进行排序时会多次调用compareTo。

Answer 2

您可以在Tuple 中将令牌存储为双精度并实现Comparable 接口。在getToken 中，您可以以您实际需要的形式返回双精度字符串表示形式。

public class Tuple implements Comparable<Tuple>{

    private double token;
    private int docID;

    public Tuple(double token, int docID) {
        this.token = token;
        this.docID = docID;

    }

    public String getToken() {
        return String.valueOf(token);
    }
    public void setToken(double token) {
        this.token = token;
    }
    public int getDocID() {
        return docID;
    }
    public void setDocID(int docID) {
        this.docID = docID;
    }

    @Override
    public int compareTo(Tuple o) {
        return Double.compare(this.token, o.token);
    }
}

Answer 3

如果你真的需要将双精度转换成字符串，使用起来会更安全

BigDecimal.valueOf(vect[i])).toString(); 

因为它处理双重不可预测性。

Answer 4

我和 Vlad Bochenin 有同样的想法：

您只需实现Comparable 并覆盖compareTo：

public class Tuple implements Comparable<Tuple> {

    public Double token;
    public int docID;

    public Tuple(final double token, final int docID) {
        this.token = token;
        this.docID = docID;
    }

    @Override
    public int compareTo(final Tuple o) {
        return this.token.compareTo(o.token);
    }
}

还有一个单元测试：

public class TestTuple {

    @Test
    public void testSort() {
        final Random r = new Random(System.currentTimeMillis());
        final int numberOfDocs = 100;
        final ArrayList<Tuple> temp = new ArrayList<Tuple>();
        for (int i = 0; i < numberOfDocs; i++) {
            temp.add(new Tuple(r.nextDouble(), i));
        }
        Collections.sort(temp);

        Tuple old = temp.get(0);
        // test if sorted
        for (final Tuple next : temp) {
            Assert.assertTrue(next.token >= old.token);
            old = next;
        }
    }
}

Answer 5

您可以在 Tuple 中将令牌存储为 double 并实现 Comparable 接口。在 getToken 中，您可以返回实际需要的 double 形式的字符串表示形式。

private double token;
private int docID;

public Tuple(double token, int docID) {
    this.token = token;
    this.docID = docID;

}

public String getToken() {
    return String.valueOf(token);
}
public void setToken(double token) {
    this.token = token;
}
public int getDocID() {
    return docID;
}
public void setDocID(int docID) {
    this.docID = docID;
}

@Override
public int compareTo(Tuple o) {
    return Double.compare(this.token, o.token);
}

}

To see More about CompareTo