如何在java中对文本文件进行排序和排列以对行进行分组

真的很难解决这个问题

我有一个文本文件，上面有这样的数据（17000行）

我要做的是对文本文件进行排序（使用java），这样，如果右值为1，则所有左边的数字都将分组。 或者，如果右侧不等于1，则左侧值为group（即任何其他数字）。 例如（但不一定要这样）

我知道我可能需要使用数组？还是什么？但我就是想不出来：'(

任何帮助、代码或建议-非常感谢

---

谢谢！

我会使用地图来存储数据：

Map<Integer, Set<Integer>> map = new TreeSet<Integer, Set<Integer>>();

Map Map=newtreeset（）；

键是第一行的值，由于它不是唯一的，所以“贴图”值是一个集合，它保存第二列中的各种值

private void addLine(String line) {
  String[] fields = line.split("\\s*");
  Integer key = Integer.parseInt(fields[0]);
  Integer value = Integer.parseInt(fields[1]);
  Set<Integer> set = map.get(value);
  if (set == null) {
     set = new HashSet<Integer>();
     map.put(key, set);
  }
  set.add(value);
}

private void addLine（字符串行）{
字符串[]字段=行。拆分（\\s*）；
整数键=Integer.parseInt（字段[0]）；
整数值=Integer.parseInt（字段[1]）；
Set=map.get（值）；
if（set==null）{
set=新的HashSet（）；
地图。放置（键，集合）；
}
增加（价值）；
}

读取文件后，您可以获得每个数字的结果，如下所示：

private String getResult(Integer key) {
  Set<Integer> values = map.get(key);
  if (values == null) {
     return null;  // key not in map (unknown number)
  } else if (values.size() == 1) {
     return values.iterator().next().toString();
  } else {
    return "MIXED";
  }
}

私有字符串getResult（整数键）{
设置值=map.get（键）；
如果（值==null）{
返回null；//键不在映射中（未知编号）
}else if（values.size（）==1）{
返回值。迭代器（）.next（）.toString（）；
}否则{
返回“混合”；
}
}

我将生成两个映射，一个用于当右边为1时，另一个用于所有其他右边值。每个映射将左边值映射为出现次数的计数。然后可以通过循环数据填充映射。在伪Java中：

Map<Integer, Integer> onesMap = new HashMap<Integer, Integer>();
Map(Integer, Integer> otherMap = new HashMap<Integer, Integer>();

for (each left/right pair) {
    Map<Integer, Integer> map = right == 1 ? onesMap : otherMap;
    Integer count = map.get(left);
    map.put(left, count == null ? 1 : (1 + count));
}

Map onesMap=newhashmap（）；
Map（Integer，Integer>otherMap=newhashmap（）；
用于（每对左/右）{
Map Map=right==1？onesMap:otherMap；
整数计数=map.get（左）；
put（左，count==null？1:（1+count））；
}

最后，键/值对为每个左值提供所需的计数。

Map map1=new HashMap（）；
Map<Integer, Integer> map1=new HashMap<Integer, Integer>();
Map<Integer, Integer> mapMixed=new HashMap<Integer, Integer>();

void addValues(int value, int num){
   if (num==1){
     if (map1.get(value)==null) map1.put(value,0);
     map1.put(value,map1.get(value)+1);
   } else {
     if (mapMixed.get(value)==null) mapMixed.put(value,0);
     mapMixed.put(value,mapMixed.get(value)+1);
   }
}

Map mapMixed=新HashMap（）；
void addValues（int值，int num）{
如果（num==1）{
如果（map1.get（value）==null）map1.put（value，0）；
map1.put（值，map1.get（值）+1）；
}否则{
如果（mapMixed.get（value）==null）mapMixed.put（value，0）；
mapMixed.put（值，mapMixed.get（值）+1）；
}
}

之后，您必须打印地图：

void printIt(){
   Set<Integer> keys=map1.keySet();
   keys.AddAll(mapMixed.keySet());
   for (int key:keys){
       if (map1.get(key)!=null) println(map1.get(key)+"x"+key+" 1");
       if (mapMixed.get(key)!=null) println(mapMixed.get(key)+"x"+key+" MIXED"); 
   }

}

void printIt（）{
Set keys=map1.keySet（）；
AddAll（mapMixed.keySet（））；
for（int键：键）{
如果（map1.get（key）！=null）println（map1.get（key）+“x”+key+“1”）；
如果（mapMixed.get（key）！=null）println（mapMixed.get（key）+“x”+key+“MIXED”）；
}
}

我的代码：

public class Sort {


private static class Counter {

    private int one;
    private int mixed;

    public void incrementOne() {
        one++;
    }

    public void incrementMixed() {
        mixed++;
    }
}

public static void main(String[] args) throws IOException {
    Map<String, Counter> map = new LinkedHashMap<String, Counter>();
    String fileName = "input.txt";
    BufferedReader reader = new BufferedReader(new FileReader(fileName));

    for (String line = reader.readLine(); line != null; line = reader.readLine()) {
        StringTokenizer tokenizer = new StringTokenizer(line);
        String key = tokenizer.nextToken();
        String value = tokenizer.nextToken();
        Counter counter = map.get(key);
        if (counter == null) {
            counter = new Counter();
            map.put(key, counter);
        }
        if (value.equals("1")) {
            counter.incrementOne();
        } else {
            counter.incrementMixed();
        }
    }
    reader.close();
    BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
    for(Map.Entry<String, Counter>entry:map.entrySet()){
        Counter counter = entry.getValue();
        if(counter.one>0){
            writer.write(String.valueOf(counter.one));
            writer.write(" x ");
            writer.write(entry.getKey());
            writer.write("   1");
            writer.newLine();
        }
        if(counter.mixed>0){
            writer.write(String.valueOf(counter.mixed));
            writer.write(" x ");
            writer.write(entry.getKey());
            writer.write("   MIXED");
            writer.newLine();
        }
    }
    writer.close();

}

公共类排序{
专用静态类计数器{
私人int one；
私人机构；
公共void incrementOne（）{
1++；
}
public void incrementMixed（）{
混合++；
}
}
公共静态void main（字符串[]args）引发IOException{
Map Map=newlinkedhashmap（）；
字符串fileName=“input.txt”；
BufferedReader reader=新的BufferedReader（新文件读取器（文件名））；
for（String line=reader.readLine（）；line！=null；line=reader.readLine（））{
StringTokenizer标记器=新的StringTokenizer（行）；
String key=tokenizer.nextToken（）；
String value=tokenizer.nextToken（）；
计数器=map.get（键）；
if（计数器==null）{
计数器=新计数器（）；
地图放置（钥匙、计数器）；
}
如果（值等于（“1”））{
counter.incrementOne（）；
}否则{
counter.incrementMixed（）；
}
}
reader.close（）；
BufferedWriter=newbufferedwriter（newfilewriter（“output.txt”）；
for（Map.Entryentry:Map.entrySet（））{
计数器计数器=entry.getValue（）；
如果（计数器1>0）{
writer.write（String.valueOf（counter.one））；
作者：写（“x”）；
writer.write（entry.getKey（））；
作者：写（“1”）；
writer.newLine（）；
}
如果（计数器混合>0）{
writer.write（String.valueOf（counter.mixed））；
作者：写（“x”）；
writer.write（entry.getKey（））；
作家。写（“混合”）；
writer.newLine（）；
}
}
writer.close（）；
}

---

}

我建议您使用两个实例，一个用于“混合”值，另一个用于“1”值。毕竟，您只需要计算值的数量，而这正是

Multiset

所提供的

所以你会使用类似于：

final Multiset<Integer> mixed = new HashMultiset<Integer>();
final Multiset<Integer> one = new HashMultiset<Integer>();

Files.readLines(new File(...), Charsets.UTF8,

    new LineProcessor<Void>() {
      @Override Void getResult() { return null; }

      @Override void processLine(String line) {
          // TODO: Split line into two integers
          int value = ...;
          int type = ...;

          Multiset<Integer> set = type == 1 ? one : mixed;
          set.add(value);
      }
    });

final Multiset mixed=new HashMultiset（）；
final Multiset one=新HashMultiset（）；
Files.readLines（新文件（…）、Charsets.UTF8、，
新的LineProcessor（）{
@重写Void getResult（）{return null；}
@重写无效进程行（字符串行）{
//TODO:将行拆分为两个整数
int值=。。。；
int类型=。。。；
多集集合=类型==1？一：混合；
增加（价值）；
}
});

---

然后，您可以迭代这两个集合，并找到每个条目的值和计数。

您必须从所有文件还是从序列进行分组？即：45226 1；45227 1；45226 1；必须是2x45226 1；1x452727 1或1x452261；1x452727 1；1x452266 1？对不起，我看到了：）从整个文件来看，2X452226 1；1x455227 1是正确的方法

public class Sort {


private static class Counter {

    private int one;
    private int mixed;

    public void incrementOne() {
        one++;
    }

    public void incrementMixed() {
        mixed++;
    }
}

public static void main(String[] args) throws IOException {
    Map<String, Counter> map = new LinkedHashMap<String, Counter>();
    String fileName = "input.txt";
    BufferedReader reader = new BufferedReader(new FileReader(fileName));

    for (String line = reader.readLine(); line != null; line = reader.readLine()) {
        StringTokenizer tokenizer = new StringTokenizer(line);
        String key = tokenizer.nextToken();
        String value = tokenizer.nextToken();
        Counter counter = map.get(key);
        if (counter == null) {
            counter = new Counter();
            map.put(key, counter);
        }
        if (value.equals("1")) {
            counter.incrementOne();
        } else {
            counter.incrementMixed();
        }
    }
    reader.close();
    BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
    for(Map.Entry<String, Counter>entry:map.entrySet()){
        Counter counter = entry.getValue();
        if(counter.one>0){
            writer.write(String.valueOf(counter.one));
            writer.write(" x ");
            writer.write(entry.getKey());
            writer.write("   1");
            writer.newLine();
        }
        if(counter.mixed>0){
            writer.write(String.valueOf(counter.mixed));
            writer.write(" x ");
            writer.write(entry.getKey());
            writer.write("   MIXED");
            writer.newLine();
        }
    }
    writer.close();

}

final Multiset<Integer> mixed = new HashMultiset<Integer>();
final Multiset<Integer> one = new HashMultiset<Integer>();

Files.readLines(new File(...), Charsets.UTF8,

    new LineProcessor<Void>() {
      @Override Void getResult() { return null; }

      @Override void processLine(String line) {
          // TODO: Split line into two integers
          int value = ...;
          int type = ...;

          Multiset<Integer> set = type == 1 ? one : mixed;
          set.add(value);
      }
    });