Fatal编程技术网
  • java/
  • Java 为什么我的程序在运行时给了我错误的输出？

Java 为什么我的程序在运行时给了我错误的输出？

java

Java 为什么我的程序在运行时给了我错误的输出？,java,Java,我正在制作一个程序，在这个程序中，我浏览一个包含11个名字的文本文件，检查文件中是否有某个名字，添加新名字，删除名字，然后关闭文件进行更新 这是directory.txt中的数据：（每个名称位于新行上） 迈克 吉姆 巴里 克里斯蒂安 文森特 成军 苏珊 ng 瑟琳娜 这是我的助手类目录，其中包含了我们可以对名称执行的所有可能操作 import java.util.*; import java.io.*; public class Directory { //public static vo

我正在制作一个程序，在这个程序中，我浏览一个包含11个名字的文本文件，检查文件中是否有某个名字，添加新名字，删除名字，然后关闭文件进行更新

这是directory.txt中的数据：（每个名称位于新行上）

迈克
吉姆
巴里
克里斯蒂安
文森特
成军
苏珊
ng
瑟琳娜

这是我的助手类目录，其中包含了我们可以对名称执行的所有可能操作

import java.util.*;
import java.io.*;
public class Directory {
   //public static void main(String[] args) {
   final int maxDirectorySize = 1024;
   String directory[] = new String[maxDirectorySize];
   int directorySize = 0;
   File directoryFile = null;
   Scanner directoryDataIn = null;

   public Directory(String directoryFileName) {
      directoryFile = new File(directoryFileName);
      try {
         directoryDataIn = new Scanner(directoryFile);
      }
      catch (FileNotFoundException e) {
         System.out.println("File is not found, exiting!" + directoryFileName);
         System.exit(0);
      }
      while (directoryDataIn.hasNext()) {
         directory[directorySize++] = directoryDataIn.nextLine();
      }
   }
   public boolean inDirectory(String name) {
      boolean inDir = true;
      for (int i = 0; i < directory.length; i++) {
         if (name.equalsIgnoreCase(directory[i])) {
            inDir = true;
            break;
         }
         else {
            inDir = false;
            break;
         }
      }
      return inDir;
   }
   public boolean add(String name) {
   if (directory.length == 1024)
      return false;
      boolean added = true;
      for (int i = 0; i < directory.length; i++) {
         if (directory[i].equalsIgnoreCase(name)) {
            added = false;
            break;
         }
         else {
            directory[directorySize++] = name;
            added = true;
            break;
         }
      }
      return added;
   }          

   public boolean delete(String name) {
      for (int i = 0; i < directory.length; i++) {
         if (directory[i].equalsIgnoreCase(name)) {
            directory[i] = null;
            return true;
         }   
         else
            return false;
      }
      return false;
   }

   public void closeDirectory() {
      directoryDataIn.close();
      PrintStream directoryDataOut = null;
      try {
          directoryDataOut = new PrintStream(directoryFile);
      }
      catch (FileNotFoundException e) {
         System.out.printf("File %s not found, exiting!", directoryFile);
         System.exit(0);
      }
      String originalDirectory[] = {"Mike","Jim","Barry","Cristian","Vincent","Chengjun","susan","ng","serena"};
      if (originalDirectory == directory)
         System.exit(0);
      else
         for (int i = 0; i < directorySize; i++)
            directoryDataOut.println(directory[i]);
         directoryDataOut.close();
   }
}
最后，这里是我得到的错误输出：

 ----jGRASP exec: java DirectoryWithObjectDesign

Directory Server is Ready!
Format: command name
Enter ^Z to end
find mike
mike is in the directory
find serena
serena is NOT in the directory
find susan
susan is NOT in the directory
find barry
barry is NOT in the directory
add melissa
melissa added
add joey
joey added
delete joey
joey NOT in directory
delete ng
ng NOT in directory
delete serena
serena NOT in directory
<eof>

 ----jGRASP: operation complete.

---jGRASP exec:java DirectoryWithObjectDesign
目录服务器准备好了！
格式：命令名
输入^Z结束
找到迈克
迈克在电话簿里
找到瑟琳娜
瑟琳娜不在通讯录里
找到苏珊
苏珊不在电话簿上
找到巴里
巴里不在目录里
加上梅丽莎
梅丽莎补充道
加上乔伊
乔伊补充道
删除乔伊
乔伊不在电话簿里
删除ng
ng不在目录中
删除瑟琳娜
瑟琳娜不在电话簿上
----jGRASP：操作完成。
我试图找出如何修复它，并尝试了一些不同的方法，但仍然得到了错误的输出。我不知道问题在哪里，也不知道如何解决。有人能帮忙吗？

这个逻辑有问题：

   public boolean inDirectory(String name) {
      boolean inDir = true;
      for (int i = 0; i < directory.length; i++) {
         if (name.equalsIgnoreCase(directory[i])) {
            inDir = true;
            break;
         }
         else {
            inDir = false;
            break;
         }
      }
      return inDir;
   }

public boolean目录（字符串名称）{
布尔inDir=true；
for（int i=0；i
只有当名称是目录中的第一个名称时，才能找到该名称

只有在找到匹配项或检查目录中的所有名称后，才能中断循环：

   public boolean inDirectory(String name) {
      boolean inDir = false;
      for (int i = 0; i < directory.length; i++) {
         if (name.equalsIgnoreCase(directory[i])) {
            inDir = true;
            break;
         }
      }
      return inDir;
   }

public boolean目录（字符串名称）{
布尔inDir=false；
for（int i=0；i
卡佩勒，也许这个程序会对你有所帮助。我使用新的java.nioapi设计了这个程序。看一看：）。进行必要的修改以满足您的需要


import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.file.LinkOption;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.FileOutputStream;

import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.LinkedHashSet;

import static java.lang.System.*;

public final class NameSearcher{
    private String sourceFile;
    private final Collection <String> fileContent   = new LinkedHashSet<>();
    private Thread EXISTENCE_WATCHER                = null;
    private Path sourcePath                         = null;

    public String getSourceFile(){ return this.sourceFile; }

    public void   setSourceFile(final String value){ 
        this.sourceFile = value; 

        sourcePath = Paths.get(sourceFile);

        if(Files.exists(sourcePath,LinkOption.NOFOLLOW_LINKS)){
            //Setting up the file watcher thread !!!
            EXISTENCE_WATCHER = new Thread(()->{ 
                try{
                    if(!Files.exists(sourcePath,LinkOption.NOFOLLOW_LINKS)) {
                        EXISTENCE_WATCHER.join();
                        System.exit(-2);
                    }
                    Thread.sleep(5000);
                }catch(InterruptedException cause){ cause.printStackTrace();}
            });

            //Reading from the file
            try(Scanner reader = new Scanner(sourcePath.toFile())){

                while(reader.hasNext()) fileContent.add(reader.next());

            }catch(IOException cause){cause.printStackTrace();}
        }else{
            out.println("Sorry, the specified source file cannot be found !!!. Program exits now !!!");
            System.exit(-1);
        }
    }

    public Boolean contains(final String key){
        return fileContent.contains(key);
    }
    public void addName(final String name){

        if(!fileContent.contains(name))
                fileContent.add(name);
    }
    public Boolean deleteName(final String name){
        return fileContent.remove(name);
    }
    @Override
    public void finalize(){
        out.println("\nInvoked finalization ....");
        out.println("\nFile Buffer up on finalize entry");
        fileContent.stream().forEach(out::println);
        out.println("--------------------------------");
        try(    PrintWriter writer = new PrintWriter(new FileOutputStream(sourcePath.toFile()));
                Scanner     comparisonReader = new Scanner(sourcePath.toFile());
            ){      

            while(comparisonReader.hasNext()){
                String file_token = comparisonReader.next();
                 if(fileContent.contains(file_token)) fileContent.remove(file_token);               
            }

            fileContent.parallelStream().forEachOrdered(token -> {writer.append(token); writer.println(); out.println("Elem -> "+token);});

        }catch(IOException cause){
            cause.printStackTrace();
        }finally{
            if(EXISTENCE_WATCHER.isAlive()){
                try{
                    EXISTENCE_WATCHER.join();                   
                }catch(Exception cause){ cause.printStackTrace();}
            }
            fileContent.clear();            
            sourcePath  = null;
        }
    }
    public static void main(String[] args) {
        NameSearcher obj = new NameSearcher();
        obj.setSourceFile("test.txt");
        out.printf("Contains check for Line1 : %b",obj.contains("Line1"));
        obj.addName("Jai");
        obj.addName("Matha");
        obj.finalize();
    }
}



import java.nio.file.Path；
导入java.nio.file.path；
导入java.nio.file.Files；
导入java.nio.file.LinkOption；
导入java.io.IOException；
导入java.io.PrintWriter；
导入java.io.InputStreamReader；
导入java.io.FileOutputStream；
导入java.util.Collection；
导入java.util.ArrayList；
导入java.util.Scanner；
导入java.util.LinkedHashSet；
导入静态java.lang.System.*；
公共最终类名称搜索器{
私有字符串源文件；
私有最终集合fileContent=new LinkedHashSet（）；
私有线程存在\u观察者=null；
私有路径sourcePath=null；
公共字符串getSourceFile（）{返回this.sourceFile；}
public void setSourceFile（最终字符串值）{
this.sourceFile=值；
sourcePath=path.get（sourceFile）；
if（Files.exists（sourcePath，LinkOption.NOFOLLOW_LINKS））{
//正在设置文件监视程序线程！！！
存在性\观察者=新线程（（）->{
试一试{
如果（！Files.exists（sourcePath，LinkOption.NOFOLLOW_LINKS））{
存在观察者。加入（）；
系统出口（-2）；
}
睡眠（5000）；
}catch（中断异常原因）{cause.printStackTrace（）；}
});
//从文件中读取
尝试（扫描仪阅读器=新扫描仪（sourcePath.toFile（））{
while（reader.hasNext（））fileContent.add（reader.next（））；
}catch（IOException原因）{cause.printStackTrace（）；}
}否则{
out.println（“对不起，找不到指定的源文件！！！。程序现在退出！！！”；
系统退出（-1）；
}
}
公共布尔包含（最终字符串键）{
返回fileContent.contains（键）；
}
public void addName（最终字符串名）{
如果（！fileContent.contains（name））
fileContent.add（名称）；
}
公共布尔deleteName（最终字符串名）{
返回fileContent.remove（名称）；
}
@凌驾
公共图书馆{
out.println（“\nInvoked finalization…”）；
out.println（“\n文件缓冲区在完成条目时向上”）；
fileContent.stream（）.forEach（out:：println）；
out.println（“-------------------------------------”）；
try（PrintWriter=newprintwriter（newfileoutputstream（sourcePath.toFile（）））；
Scanner comparisonReader=新扫描仪（sourcePath.toFile（））；
){      
while（comparisonReader.hasNext（））{
字符串文件_token=comparisonReader.next（）；
if（fileContent.contains（file_-token））fileContent.remove（file_-token）；
}
fileContent.parallelStream（）.forEachOrdered（标记->{writer.append（标记）；writer.println（）；out.println（“Elem->”+标记）；}）；
}捕获（异常原因）{
cause.printStackTrace（）；
}最后{
if（存在\u WATCHER.isAlive（））{
试一试{
存在观察者。加入（）；
}catch（异常原因）{cause.printStackTrace（）；}
}
fileContent.clear（）；
sourcePath=null；
}
}
公共静态void main（字符串[]args）{
NameSearcher obj=新的NameSearcher（）；
obj.setSourceFile（“test.txt”）；
out.printf（“包含对第1行：%b的检查”，对象包含（“第1行”）；
对象地址名称（“Jai”）；
对象地址名称（“Matha”）；
obj.finalize（）；
}
}

我只是这样修复了它，但仍然得到了相同的错误输出。它只读取文本文件的第一行（mike）和everythi

import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.nio.file.LinkOption;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.FileOutputStream;

import java.util.Collection;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.LinkedHashSet;

import static java.lang.System.*;

public final class NameSearcher{
    private String sourceFile;
    private final Collection <String> fileContent   = new LinkedHashSet<>();
    private Thread EXISTENCE_WATCHER                = null;
    private Path sourcePath                         = null;

    public String getSourceFile(){ return this.sourceFile; }

    public void   setSourceFile(final String value){ 
        this.sourceFile = value; 

        sourcePath = Paths.get(sourceFile);

        if(Files.exists(sourcePath,LinkOption.NOFOLLOW_LINKS)){
            //Setting up the file watcher thread !!!
            EXISTENCE_WATCHER = new Thread(()->{ 
                try{
                    if(!Files.exists(sourcePath,LinkOption.NOFOLLOW_LINKS)) {
                        EXISTENCE_WATCHER.join();
                        System.exit(-2);
                    }
                    Thread.sleep(5000);
                }catch(InterruptedException cause){ cause.printStackTrace();}
            });

            //Reading from the file
            try(Scanner reader = new Scanner(sourcePath.toFile())){

                while(reader.hasNext()) fileContent.add(reader.next());

            }catch(IOException cause){cause.printStackTrace();}
        }else{
            out.println("Sorry, the specified source file cannot be found !!!. Program exits now !!!");
            System.exit(-1);
        }
    }

    public Boolean contains(final String key){
        return fileContent.contains(key);
    }
    public void addName(final String name){

        if(!fileContent.contains(name))
                fileContent.add(name);
    }
    public Boolean deleteName(final String name){
        return fileContent.remove(name);
    }
    @Override
    public void finalize(){
        out.println("\nInvoked finalization ....");
        out.println("\nFile Buffer up on finalize entry");
        fileContent.stream().forEach(out::println);
        out.println("--------------------------------");
        try(    PrintWriter writer = new PrintWriter(new FileOutputStream(sourcePath.toFile()));
                Scanner     comparisonReader = new Scanner(sourcePath.toFile());
            ){      

            while(comparisonReader.hasNext()){
                String file_token = comparisonReader.next();
                 if(fileContent.contains(file_token)) fileContent.remove(file_token);               
            }

            fileContent.parallelStream().forEachOrdered(token -> {writer.append(token); writer.println(); out.println("Elem -> "+token);});

        }catch(IOException cause){
            cause.printStackTrace();
        }finally{
            if(EXISTENCE_WATCHER.isAlive()){
                try{
                    EXISTENCE_WATCHER.join();                   
                }catch(Exception cause){ cause.printStackTrace();}
            }
            fileContent.clear();            
            sourcePath  = null;
        }
    }
    public static void main(String[] args) {
        NameSearcher obj = new NameSearcher();
        obj.setSourceFile("test.txt");
        out.printf("Contains check for Line1 : %b",obj.contains("Line1"));
        obj.addName("Jai");
        obj.addName("Matha");
        obj.finalize();
    }
}