在Java中基于值数组更新索引

我正在尝试根据另一个值数组（ms）更新（逐字排序）手动索引

输入 预期产量

String indx[]={“0”、“1”、“3”、“2”}；//更新后

输入（在新输入上） 预期产量

字符串indx[]={“0”、“1”、“4”、“2”、“3”}

如何在Java中实现这一点。
我尝试了树映射、排序、比较程序impl。但所有这些都给出了排序数组

但是我需要一些东西来更新索引，而不是排序。
您所需要做的就是使一个类实现的毫秒和索引与私有字段相当。将该类的任何实例放入某种排序数据结构（如树集）中，就可以了。或者只需将实例添加到列表并调用Collections.sort（）。下面是一个完整的课堂和工作示例

import java.util.Set;
import java.util.TreeSet;

public class Milli implements Comparable<Milli> {
    private int ms, index;

    public Milli (int ms, int index) {
        this.ms = ms;
        this.index = index;
    }

    @Override
    public String toString () {
        return Integer.toString(index);
    }

    @Override
    public int compareTo (Milli o) {
        return Integer.compare(ms, o.ms);
    }
}

class Test {
    public static void main (String[] args) {
        Set<Milli> set = new TreeSet<>();
        String ms[] = { "10","11","14","12"};
        String indx[]={ "0", "1", "2", "3" }; // Manual index based on ms values
        for (int i=0; i<ms.length; i++)
            set.add(new Milli(Integer.parseInt(ms[i]), Integer.parseInt(indx[i])));
        System.out.println(set);
    }
}

import java.util.Set；
导入java.util.TreeSet；
公共类Milli实现可比较{
私有int-ms，索引；
公共毫（整数毫秒，整数索引）{
这个.ms=ms；
这个指数=指数；
}
@凌驾
公共字符串toString（）{
返回整数.toString（索引）；
}
@凌驾
公共国际比较（百万）{
返回整数。比较（ms，o.ms）；
}
}
课堂测试{
公共静态void main（字符串[]args）{
Set=新树集（）；
字符串ms[]={“10”、“11”、“14”、“12”}；
字符串indx[]={“0”、“1”、“2”、“3”}；//基于ms值的手动索引
对于（int i=0；i，感谢大家的回答。不知何故，我通过使用以下代码实现了它。这与预期一样有效，但性能方面我不确定

请评论

long lastMsValue = Long.valueOf(ms[ms.length-1]);
int crntIndx = 65350; //Assuming not more than 1000 records.

    if(ms.length == indx.length){
        if(ms.length == 2 && Long.valueOf(ms[0]) > lastMsValue){
            indx[0]="1";
            indx[1]="0";                
        }else if(ms.length > 2){
            for(int m=0;m<ms.length-1;m++){
                if (Long.valueOf(ms[m]) > lastMsValue){
                    if(crntIndx > m)
                        crntIndx = m;
                }else if(Long.valueOf(ms[m]) == lastMsValue){
                    crntIndx = m;
                }
            }

            indx[indx.length-1] = String.valueOf(crntIndx);
            System.out.println("Crnt Indx = " + crntIndx + "   And Indx Array Value ");
            for(int m=0;m<ms.length-1;m++){
                if (Long.valueOf(ms[m]) > lastMsValue)
                    indx[m] = String.valueOf(Integer.valueOf(indx[m])+1);
            }
        }
    }else{
        System.out.println("Lengths are not equal and sorting is not done");
    }

long lastMsValue=long.valueOf（ms[ms.length-1]）；
int crntidx=65350；//假设不超过1000条记录。
如果（ms.length==indx.length）{
如果（ms.length==2&&Long.valueOf（ms[0]）>lastMsValue）{
indx[0]=“1”；
indx[1]=“0”；
}否则如果（毫秒长度>2）{
对于（int m=0；m lastMsValue）{
如果（CRNTIDX>m）
crntIndx=m；
}else if（Long.valueOf（ms[m]）==lastMsValue）{
crntIndx=m；
}
}
indx[indx.length-1]=字符串.valueOf（crntIndx）；
System.out.println（“Crnt Indx=“+crntIndx+”和Indx数组值”）；
对于（int m=0；m lastMsValue）
indx[m]=String.valueOf（Integer.valueOf（indx[m]）+1）；
}
}
}否则{
System.out.println（“长度不相等，未进行排序”）；
}
我不理解第二个示例。如果顺序不是
{0,1,2,4,3}
，请创建一个
类t
，该类
实现Comparable@TimBiegeleisen.第二个例子是我们收到的新记录。对于我们收到的每一条记录，我们都会根据ms[]更新索引值数组。为了更好地理解，我给出了两个示例。希望我能让您理解。如果
ms[]
有重复的值，在这种情况下，TreeSet不会添加这些重复的值，正如下面给出的@saka129解决方案中所示，这不会发生。您必须更新compareTo（）要返回类似这样的内容
int compare=Integer.compare（ms，o.ms）；return compare==0？1:compare；
感谢@WillSherwood提供您的答案。您可以在下面看到我的答案并帮助改进。
import java.util.Set;
import java.util.TreeSet;

public class Milli implements Comparable<Milli> {
    private int ms, index;

    public Milli (int ms, int index) {
        this.ms = ms;
        this.index = index;
    }

    @Override
    public String toString () {
        return Integer.toString(index);
    }

    @Override
    public int compareTo (Milli o) {
        return Integer.compare(ms, o.ms);
    }
}

class Test {
    public static void main (String[] args) {
        Set<Milli> set = new TreeSet<>();
        String ms[] = { "10","11","14","12"};
        String indx[]={ "0", "1", "2", "3" }; // Manual index based on ms values
        for (int i=0; i<ms.length; i++)
            set.add(new Milli(Integer.parseInt(ms[i]), Integer.parseInt(indx[i])));
        System.out.println(set);
    }
}

long lastMsValue = Long.valueOf(ms[ms.length-1]);
int crntIndx = 65350; //Assuming not more than 1000 records.

    if(ms.length == indx.length){
        if(ms.length == 2 && Long.valueOf(ms[0]) > lastMsValue){
            indx[0]="1";
            indx[1]="0";                
        }else if(ms.length > 2){
            for(int m=0;m<ms.length-1;m++){
                if (Long.valueOf(ms[m]) > lastMsValue){
                    if(crntIndx > m)
                        crntIndx = m;
                }else if(Long.valueOf(ms[m]) == lastMsValue){
                    crntIndx = m;
                }
            }

            indx[indx.length-1] = String.valueOf(crntIndx);
            System.out.println("Crnt Indx = " + crntIndx + "   And Indx Array Value ");
            for(int m=0;m<ms.length-1;m++){
                if (Long.valueOf(ms[m]) > lastMsValue)
                    indx[m] = String.valueOf(Integer.valueOf(indx[m])+1);
            }
        }
    }else{
        System.out.println("Lengths are not equal and sorting is not done");
    }