Java，double的排序数组及其索引

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

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

下面是一个用于保存字符串和整数的类：

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 temps=new ArrayList（）

然后我像这样填充arraylist：

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

for（int i=0；i

最后，我对数组进行如下排序：

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

public void sortTmp（）
{
Collections.sort（temps，newcomparator（）
{
@凌驾
公共整数比较（元组tr2，元组tr1）
{
返回tr2.getToken（）.compareTo（tr1.getToken（））；
}
});
}

java和double有一些问题，我不能直接使用我的double矩阵，所以我必须执行
double.toString（）
。结果已排序，但并不完全正确，因为从double计算的字符串在double数字排序方面不是很准确

有什么想法吗
 如果您按字典顺序比较
double
s的
String
表示，您可能确实会发现一些意想不到的结果

你可以：


重构
元组
，使
标记
是一个
double
（如果您想在实例上调用
compareTo
，则可以使用包装器
double
）
否则，在
比较器
中，您可以在
字符串
s上调用
Double.parseDouble
（这应该是相对安全的，因为
字符串
s首先来自
Double
s），并在返回的
Double
包装器上调用
compareTo


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

这也意味着性能下降，因为排序集合时会多次调用
compareTo
。
如果您按字典顺序比较
double
s，根据它们的
String
表示，您可能确实会发现一些意外的结果

你可以：


重构
元组
，使
标记
是一个
double
（如果您想在实例上调用
compareTo
，则可以使用包装器
double
）
否则，在
比较器
中，您可以在
字符串
s上调用
Double.parseDouble
（这应该是相对安全的，因为
字符串
s首先来自
Double
s），并在返回的
Double
包装器上调用
compareTo


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

这也意味着性能下降，因为排序集合时会多次调用
compareTo
。
如果确实需要将double转换为字符串，则使用它更安全

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

因为它处理双重不可预测性。
如果您真的需要将双重转换为字符串，那么使用它更安全

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

因为它处理双重不可预测性。
您可以在
元组中将令牌存储为双重，并实现
可比较的
接口。在
getToken
中，可以以实际需要的形式返回double的字符串表示形式

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);
    }
}

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);
}

公共类元组实现了可比较的{
私人双令牌；
私人文件；
公共元组（双令牌，int-docID）{
this.token=token；
this.docID=docID；
}
公共字符串getToken（）{
返回字符串.valueOf（令牌）；
}
公共无效设置令牌（双令牌）{
this.token=token；
}
public int getDocID（）{
返回docID；
}
公共无效setDocID（int docID）{
this.docID=docID；
}
@凌驾
公共整数比较（元组o）{
返回Double.compare（this.token，o.token）；
}
}
您可以在
元组中以双精度存储令牌
，并实现
可比
接口。在
getToken
中，可以以实际需要的形式返回double的字符串表示形式

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);
    }
}

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);
}

公共类元组实现了可比较的{
私人双令牌；
私人文件；
公共元组（双令牌，int-docID）{
this.token=token；
this.docID=docID；
}
公共字符串getToken（）{
返回字符串.valueOf（令牌）；
}
公共无效设置令牌（双令牌）{
this.token=token；
}
public int getDocID（）{
返回docID；
}
公共无效setDocID（int docID）{
this.docID=docID；
}
@凌驾
公共整数比较（元组o）{
返回Double.compare（this.token，o.token）；
}
}
我和弗拉德·博切宁有着同样的想法：

您只需实现
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);
    }
}

公共类元组实现了可比较的{
公共双令牌；
公共内部文档ID；
公共元组（最终双标记，最终int docID）{
this.token=token；
this.docID=docID；
}
@凌驾
公共整数比较（最终元组o）{
返回此.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;
        }
    }
}

公共类TestTuple{
@试验
公共void testSort（）{
最终随机r=新随机（System.currentTimeMillis（））；
最终int numberOfDocs=100；
最终ArrayList温度=新ArrayList（）；
对于（int i=0；i