Java 从边删除值

我有以下格式的数据

String [] data = new String[]{"-166444026   0   file    20130801",
"-166444026 0   file    20130802",
"-166444027 0   file    20130802"};

这些是制表符分隔的字符串。 现在。。 所以我们有 键、值、类型、日期

我想要的是在列表中保留最新的唯一键。 比如说。。。 此操作的输出应为

["-166444026    0   file    20130802",
"-166444027 0   file    20130802"];

因为-166444026出现了两次，但我删除的那个日期是20130801，而这个日期更晚

我写的代码。。但这只是返回所有内容。（我原以为它应该删除..但它不是..）

有什么线索吗

package org.random_scripts;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.json.simple.JSONObject;

public class Regex {
    private static boolean alreadyExists(Map<String, Long> dict, String key) {
        if(dict.containsKey(key))
            return true;
        return false;
    }
    private static void removeEdge(ArrayList<JSONObject>edgeList, String key) {

        for(JSONObject edge:edgeList) {
            if (edge.get("destination").equals(key))
                edge.remove(key);
        }
    }

    public static void main(String[] args) {

        String [] data = new String[]{"-166444026   0   file    20130801",
                                    "-166444026 0   file    20130802",
                                    "-166444026 0   file    20130802"};

        try {
            String key = "185479485";
            JSONObject jsn = new JSONObject();
            jsn.put("source", key.toString());

            ArrayList<JSONObject> edges = new ArrayList<JSONObject>();
            Map<String, Long> tracker = new HashMap<String, Long>();
            for (int i=0; i < data.length; i++) {
                String value = data[i];
                //edgeString+= value.toString()+",";
                String[] typeChunks = value.toString().split("\t");

                String destination = typeChunks[0];
                Double reputation = Double.parseDouble(String.valueOf(typeChunks[1]));
                System.out.println(tracker.values().toString());
                JSONObject edgeJson = new JSONObject();
                Long date = Long.valueOf(typeChunks[3]);
                if(alreadyExists(tracker,destination)) {
                    Long prev_date = tracker.get(destination);
                    System.out.println(true);
                    if (date > prev_date) {
                        //remove edge
                        removeEdge(edges,destination);
                        System.out.println("edges are" + edges.toString());

                    }
                }
                else {
                    tracker.put(destination, date);

                }


                edgeJson.put("destination", destination);
                edgeJson.put("reputation", reputation);
                edgeJson.put("type", typeChunks[2]);
                edges.add(edgeJson);

            }
            jsn.put("edgelist", edges);
            System.out.println(jsn.toJSONString());
            //context.write(NullWritable.get(), new Text(jsn.toJSONString()));
            //edgeString = edgeString.substring(0,edgeString.length()-1);
            //edgeString+="]";
            }
            catch (Exception e) {
                System.out.println("Exceptiom");
                //context.write(NullWritable.get(),new Text(s) );
            }




        }

}

package org.random_脚本；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
导入org.apache.hadoop.io.NullWritable；
导入org.apache.hadoop.io.Text；
导入org.json.simple.JSONObject；
公共类正则表达式{
私有静态布尔值alreadyExists（映射dict，字符串键）{
if（dict.containsKey（键））
返回true；
返回false；
}
私有静态void removedge（ArrayListEdge，字符串键）{
用于（JSONObject边：edgeList）{
if（edge.get（“destination”）.equals（key））
边缘。移除（键）；
}
}
公共静态void main（字符串[]args）{
字符串[]数据=新字符串[]{“-166444026 0文件20130801”，
“-166444026 0文件20130802”，
“-166444026 0文件20130802”}；
试一试{
String key=“185479485”；
JSONObject jsn=新的JSONObject（）；
put（“source”，key.toString（））；
ArrayList Edge=新的ArrayList（）；
Map tracker=newhashmap（）；
对于（int i=0；i上一个日期）{
//去除边缘
移除（边缘、目标）；
System.out.println（“边是”+边.toString（））；
}
}
否则{
tracker.put（目的地、日期）；
}
edgeJson.put（“目的地”，目的地）；
edgeJson.put（“声誉”，声誉）；
put（“type”，typeChunks[2]）；
添加（edgeJson）；
}
jsn.put（“边缘列表”，边缘）；
System.out.println（jsn.toJSONString（））；
//write（NullWritable.get（），新文本（jsn.toJSONString（））；
//edgeString=edgeString.substring（0，edgeString.length（）-1）；
//边缘线+=“]”；
}
捕获（例外e）{
系统输出打印项次（“例外”）；
//write（NullWritable.get（），新文本）；
}
}
}

使用a，然后将每一行分配给

HashMap

中的一个键

HashMap

将只保留最新分配的值，因此您可以根据其日期决定是否重新分配

如果需要保留行的原始顺序，可以使用保留插入顺序的

---

希望有帮助。

用regexp搜索最后一个单词，然后迭代数组

    String key = data[data.length - 1].replaceAll(".*\\s", "");
    for (int i = 0; i < data.length; i++) {
        if (data[i].endsWith(key)) {
            System.out.println(data[i]);
        }
    }

-166444026 0   file    20130802
-166444027 0   file    20130802