Java 比较HastSet中的值

我的父目录中有三个文件，分别是

c:/test/abc.png
c:/test/gibby.png
c:/test/cisco.doc

FileVisitResult

将访问我的父目录以查找目录中的任何文件，它将拾取具有完整路径的文件并将其发送到我的

子函数

类以进行进一步处理。但是我发现，

cisco.doc

已经被发送到

子函数

类两次了。如果文件数量开始增长，就会出现问题

这是我的源代码

            while(true)
            {
                        try {
                            Files.walkFileTree(ParentDir, new FileVisitor<Path>()
                                    {

                                        @Override
                                        public FileVisitResult postVisitDirectory(Path sub, IOException exc) throws IOException
                                        {
                                              return FileVisitResult.CONTINUE;
                                        }

                                        @Override
                                        public FileVisitResult preVisitDirectory(Path sub, BasicFileAttributes attrs) throws IOException 
                                        {
                                            return FileVisitResult.CONTINUE;
                                        }

                                        @Override
                                        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException 
                                        {
                                            Path tempPath1;
                                            System.out.println("@The abs path of the file is"+file);
                                            java.util.Iterator<Path> it = MyFileList.iterator();
                                            while(it.hasNext())
                                            {
                                                tempPath1 = it.next();
                                                if(tempPath1 == null)  //first round
                                                {
                                                    System.out.println("empty list");
                                                    MyFileList.add(file);
                                                }
                                                else if(tempPath1 == file) //after first round
                                                {
                                                    System.out.println("same in the list : "+file);
                                                }
                                                else if(tempPath1 != file) //after first round
                                                {
                                                    System.out.println("not same in the list : "+file); 
                                                    x = true;
                                                }

                                            }
                                            System.out.println(x);
                                            if(x = true)
                                            {
                                                MyFileList.add(file);
                                                subfunction sb1 = new subfunction ();
                                                sb1.send(file);
                                            }

                                            return FileVisitResult.CONTINUE;
                                        }

                                        @Override
                                        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException 
                                        {
                                            return FileVisitResult.CONTINUE;
                                        }

                                    });
                        } 
                        catch (IOException e) 
                        {

                            e.printStackTrace();
                        }
            }

while（true）
{
试一试{
walkFileTree（ParentDir，newfilevisitor（））
{
@凌驾
公共文件VisitResult postVisitDirectory（路径子目录，IOException exc）引发IOException
{
返回FileVisitResult.CONTINUE；
}
@凌驾
公共文件VisitResult preVisitDirectory（路径子目录，基本文件属性属性属性）引发IOException
{
返回FileVisitResult.CONTINUE；
}
@凌驾
公共文件VisitResult visitFile（路径文件，基本文件属性属性属性）引发IOException
{
路径1；
System.out.println（“@文件的abs路径为”+文件）；
java.util.Iterator it=MyFileList.Iterator（）；
while（it.hasNext（））
{
tempPath1=it.next（）；
if（tempPath1==null）//第一轮
{
System.out.println（“空列表”）；
添加（文件）；
}
else if（tempPath1==file）//在第一轮之后
{
System.out.println（“列表中相同：+文件）；
}
else if（tempPath1！=文件）//在第一轮之后
{
System.out.println（“列表中不相同：+文件）；
x=真；
}
}
系统输出println（x）；
如果（x=真）
{
添加（文件）；
子函数sb1=新的子函数（）；
sb1.发送（文件）；
}
返回FileVisitResult.CONTINUE；
}
@凌驾
公共文件VisitResult visitFileFailed（路径文件，IOException exc）引发IOException
{
返回FileVisitResult.CONTINUE；
}
});
} 
捕获（IOE异常）
{
e、 printStackTrace（）；
}
}

如您所见，在检查条件时有一个

循环，如果条件为真，则
FileVisitResult
将开始遍历父目录并选择文件路径，我将把文件路径存储到
哈希集
，并且
发送（）
将发送到我的
子函数
类。我将文件路径存储到哈希集中的原因是用于比较
FileVisitResult
发现的新文件路径和存储在
HashSet
中的以前发现的路径，以避免传递给
send（）
的任何重复文件路径，但它无法按预期工作


1） 如何确保每个文件路径只传递给
send（）
一次？


2） 确保
FileVisitResult
只会发现一次文件，并且在第二次迭代期间不会接触到同一个文件的任何想法
put每个分析的文件名都是一个集合，以便进一步迭代，首先检查候选文件是否在集合中。您可能应该将
Path
相等与
equals（）
，而不是
=
进行比较。