Java 检索两条记录的差异时未获得预期的输出_Java_Linux

Java 检索两条记录的差异时未获得预期的输出

java linux

Java 检索两条记录的差异时未获得预期的输出,java,linux,Java,Linux,问题我有文件1在一个文件中有20000个数字，文件2在另一个文件中有9997个数字。我想要文件2中没有的数字，即10003数字解决方案我已经创建了3个HashMap 1）第一个HashMap存储第一个文件的记录，第二个HashMap存储第二个文件的记录，第三个HashMap存储文件记录差异的记录 2）我应用了contains方法来搜索file1中的file2记录。若file1记录不存在，我将放入第三个hashmap public class ReadFromFile { static

问题

我有文件1在一个文件中有20000个数字，文件2在另一个文件中有9997个数字。我想要文件2中没有的数字，即10003数字

解决方案

我已经创建了3个HashMap

1）第一个HashMap存储第一个文件的记录，第二个HashMap存储第二个文件的记录，第三个HashMap存储文件记录差异的记录

2）我应用了contains方法来搜索file1中的file2记录。若file1记录不存在，我将放入第三个hashmap

public class ReadFromFile {
static HashMap hm=null;
static HashMap hm1=null;
static HashMap hm2=null;

private static final String FILENAME = "/home/jalaj/Download/PrimaryBase";
private static final String FILENAME1 = "/home/jalaj/Downloads/logsBase";

public static void main(String[] args) {
    hm2=new HashMap<>();
    int count=0;
     hm=readFromFile(FILENAME);

     hm1=readFromFile(FILENAME1);
     Set s=hm.keySet();
     Iterator it=s.iterator();
     while(it.hasNext()){    
         String me=(String)(it.next());
if(!(hm1.containsKey(me))){
             hm2.put(me,0);
             count++;
         }   
     }  
     System.out.println(count);
 }

 public static HashMap readFromFile(String FILENAME){
    int count=0; 
    hm=new HashMap();
    BufferedReader br = null;
    FileReader fr = null;

    try {

        fr = new FileReader(FILENAME);
        br = new BufferedReader(fr);

        String sCurrentLine;

        br = new BufferedReader(new FileReader(FILENAME));

        while ((sCurrentLine = br.readLine()) != null) {
            hm.put(sCurrentLine, 0);
            count++;
        }

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        try {

            if (br != null)
                br.close();

            if (fr != null)
                fr.close();

        } catch (IOException ex) {

            ex.printStackTrace();

        }

    }
    System.out.println(count);
    return hm;
}

}

公共类ReadFromFile{
静态HashMap hm=null；
静态HashMap hm1=null；
静态HashMap hm2=null；
私有静态最终字符串FILENAME=“/home/jalaj/Download/PrimaryBase”；
私有静态最终字符串FILENAME1=“/home/jalaj/Downloads/logsBase”；
公共静态void main（字符串[]args）{
hm2=新的HashMap（）；
整数计数=0；
hm=readFromFile（文件名）；
hm1=readFromFile（FILENAME1）；
设置s=hm.keySet（）；
迭代器it=s.Iterator（）；
而（it.hasNext（））{
String me=（String）（it.next（））；
如果（！（hm1.containsKey（me）））{
hm2.put（me，0）；
计数++；
}   
}  
系统输出打印项次（计数）；
}
公共静态HashMap readFromFile（字符串文件名）{
整数计数=0；
hm=新的HashMap（）；
BufferedReader br=null；
FileReader fr=null；
试一试{
fr=新文件读取器（文件名）；
br=新的缓冲读取器（fr）；
弦电流线；
br=新的BufferedReader（新的文件读取器（文件名））；
而（（sCurrentLine=br.readLine（））！=null）{
hm.put（sCurrentLine，0）；
计数++；
}
}捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
试一试{
如果（br！=null）
br.close（）；
如果（fr！=null）
fr.close（）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
系统输出打印项次（计数）；
返回hm；
}
}

输出获取

两万

9997

预期产量

两万

9997

10003查看您的代码。在

readFromFile（字符串名称）

中，您将

hm

属性重新声明为

hm=newhashmap（）

并在初始化后返回它。这导致

hm

和

hm1

具有相同的值，因此

hm2

不存储差异

更改此行

hm=newhashmap（）

到这个

HashMap hm=newhashmap（）卷
PD:此外，您应该使用size（）
而不是计数变量，并按照Michael Markidis的建议使用HashSet

编辑：在阅读迈克尔·马基迪斯的评论之前，我意识到了和他一样的事情，所以伟大的迈克尔·马基迪斯
 查看您的代码。在readFromFile（字符串名称）
中，您将hm
属性重新声明为hm=newhashmap（）
并在初始化后返回它。这导致hm
和hm1
具有相同的值，因此hm2
不存储差异
更改此行hm=newhashmap（）
到这个HashMap hm=newhashmap（）卷
PD:此外，您应该使用size（）
而不是计数变量，并按照Michael Markidis的建议使用HashSet

编辑：在阅读迈克尔·马基迪斯的评论之前，我意识到了和他一样的事情，所以伟大的迈克尔·马基迪斯
 我假设file1和file2中的数字是唯一的。如果是这种情况，代码需要在逻辑上进行修改，同时也需要考虑详细性。我将其重构为：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class ReadFromFile {

    private static final String FILENAME = "/home/jalaj/Download/PrimaryBase";
    private static final String FILENAME1 = "/home/jalaj/Downloads/logsBase";

    public static void main(String[] args) {
        ArrayList<Integer> firstList = readFromFile(FILENAME);
        ArrayList<Integer> secondList = readFromFile(FILENAME1);
        ArrayList<Integer> outputList = new ArrayList<>();

        for (Integer number : firstList) {
            if(!secondList.contains(number)) {
                outputList.add(number);
            }
        }

        System.out.println(outputList.size());
    }

    public static ArrayList<Integer> readFromFile(String FILENAME){
        ArrayList<Integer> list = new ArrayList<>();
        try {
            FileReader fr = new FileReader(FILENAME);
            String sCurrentLine;
            BufferedReader br = new BufferedReader(new FileReader(FILENAME));
            while ((sCurrentLine = br.readLine()) != null) {
                list.add(Integer.parseInt(sCurrentLine.trim()));
            }
            br.close();
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
        return list;
    }
}

导入java.io.BufferedReader；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
公共类ReadFromFile{
私有静态最终字符串FILENAME=“/home/jalaj/Download/PrimaryBase”；
私有静态最终字符串FILENAME1=“/home/jalaj/Downloads/logsBase”；
公共静态void main（字符串[]args）{
ArrayList firstList=readFromFile（文件名）；
ArrayList secondList=readFromFile（FILENAME1）；
ArrayList outputList=新的ArrayList（）；
for（整数：firstList）{
如果（！secondList.contains（number））{
输出列表。添加（编号）；
}
}
System.out.println（outputList.size（））；
}
公共静态ArrayList readFromFile（字符串文件名）{
ArrayList=新建ArrayList（）；
试一试{
FileReader fr=新的FileReader（文件名）；
弦电流线；
BufferedReader br=新的BufferedReader（新文件读取器（文件名））；
而（（sCurrentLine=br.readLine（））！=null）{
add（Integer.parseInt（sCurrentLine.trim（））；
}
br.close（）；
fr.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
System.out.println（list.size（））；
退货清单；
}
}

这段代码应该会产生预期的输出。
我假设file1和file2中的数字是唯一的。如果是这种情况，代码需要在逻辑上进行修改，同时也需要考虑详细性。我将其重构为：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class ReadFromFile {

    private static final String FILENAME = "/home/jalaj/Download/PrimaryBase";
    private static final String FILENAME1 = "/home/jalaj/Downloads/logsBase";

    public static void main(String[] args) {
        ArrayList<Integer> firstList = readFromFile(FILENAME);
        ArrayList<Integer> secondList = readFromFile(FILENAME1);
        ArrayList<Integer> outputList = new ArrayList<>();

        for (Integer number : firstList) {
            if(!secondList.contains(number)) {
                outputList.add(number);
            }
        }

        System.out.println(outputList.size());
    }

    public static ArrayList<Integer> readFromFile(String FILENAME){
        ArrayList<Integer> list = new ArrayList<>();
        try {
            FileReader fr = new FileReader(FILENAME);
            String sCurrentLine;
            BufferedReader br = new BufferedReader(new FileReader(FILENAME));
            while ((sCurrentLine = br.readLine()) != null) {
                list.add(Integer.parseInt(sCurrentLine.trim()));
            }
            br.close();
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
        return list;
    }
}

导入java.io.BufferedReader；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
公共类ReadFromFile{
私有静态最终字符串FILENAME=“/home/jalaj/Download/PrimaryBase”；
私有静态最终字符串FILENAME1=“/home/jalaj/Downloads/logsBase”；
公共静态void main（字符串[]args）{
ArrayList firstList=readFromFile（文件名）；
ArrayList secondList=readFromFile（FILENAME1）；
ArrayList outputList=新的ArrayList（）；
for（整数：firstList）{
如果（！secondList.contains（number））{
输出列表。添加（编号）；