Question

问题：编写一个Java程序，它接受来自命令行参数的现有文本文件列表，并连接“Master.txt”中所有文件的内容。

我的代码在测试4 endsWith(".txt")时出错。请让我知道如何纠正它。

import java.io.*;
class FileConcat
{
 public static void main(String[] args)
 {
  FileOutputStream fout;
  FileInputStream fin,fin1;
  File f;
  int b; 
  try
  {
   //open Master file
   try
   {
    fout=new FileOutputStream("Master.txt"); 
   }
   catch(Exception e)
   {
    System.out.print(e.getMessage());
   }
   //traverse all args, check if valid text file, if yes, concatinate
   for(int j=0;j<args.length;j++)
   {
    f=new File(args[j]);
    if(f.isFile()==true)
    {
     if((args[j].endsWith(".txt"))==true)
     {
      try
      {
       fin=new FileInputStream(args[j]);
      }
      catch(Exception e)
      {
       System.out.print("Error Opening "+args[j]);
      }
      while((b=fin.read())!=-1)
      {
       char ch=(char) b;
       fout.write(ch);
      }
     }
    fin.close();
    }
   }
   fout.close();
   fin1=new FileInputStream("Master.txt"); 
   while((b=fin1.read())!=-1)
   {
    char ch=(char) b;
    System.out.print(ch);
   }
   fin1.close();
  }
  catch(Exception e)
  {
   System.out.println(e.getMessage());
  }
 }
}

输出：

C:\j2sdk1.4.1_01\bin>javac FileConcat.java
FileConcat.java:38: variable fin might not have been initialized
                                                while((b=fin.read())!=-1)
                                                         ^
FileConcat.java:41: variable fout might not have been initialized
                                                        fout.write(ch);
                                                        ^
FileConcat.java:44: variable fin might not have been initialized
                                fin.close();
                                ^
FileConcat.java:47: variable fout might not have been initialized
                        fout.close();
                        ^
4 errors

如何检查是否为fin分配了值？

Answer 1

问题是当你声明它们时你根本没有给fin和fout分配任何东西，你只在try {}块中分配它们，随后使用它们的代码在try {}块之外;因此，如果在try {}块中抛出异常，程序将继续运行，并尝试使用未初始化的值。

您的选择是：

将尝试在try {}块中使用这些变量的代码移动到初始化位置
在声明这些变量时将null分配给这些变量，并将试图在if (variable != null) {}块中使用它们的代码放置。
使catch（）子句执行一些操作，以保证否则尝试使用未初始化的变量的代码不会执行，例如退出程序
摆脱try .. catch子句并将整个方法声明为抛出异常

Answer 2

没有必要说：

if (b == true)

当b有些boolean时。这相当于：

if (b)

这不能回答你的问题（正如其他人已有的那样），但无论如何都可能对你有用

Answer 3

您的问题与以下部分（以及其他类似部分）有关：

try
{
  fin=new FileInputStream(args[j]);
}
catch(Exception e)
{
  System.out.print("Error Opening "+args[j]);
}

如果抛出异常，则fin将不会使用值初始化。但是，如果抛出异常，那么可以说你的程序无法继续。因此，我认为您应该删除try / catch并声明您的main方法throws IOException。

Answer 4

如果fout = new FileOutputStream("Master.txt");抛出异常，则fout未定义，但您仍在尝试写入该文件。

同样，如果fin = new FileInputStream(args[j]);抛出异常，则fin未定义，但您仍尝试从该文件中读取。

您可以将整个循环括在try块中，或者只声明main以抛出IOException。

我还建议将close()的呼叫移至finally个阻止，并移除多余的"==true" from some of the tests.

import java.io.*;
public class FileConcat
{
  public static void main(String[] args)
  {
    FileOutputStream fout;
    FileInputStream fin,fin1;
    File f;
    int b; 

    //open Master file
    try
    {
      fout=new FileOutputStream("Master.txt"); 
      try
      {
        //traverse all args, check if valid text file, if yes, concatinate
        for(int j=0;j<args.length;j++)
        {
          f=new File(args[j]);
          if(f.isFile())
          {
            if(args[j].endsWith(".txt"))
            {
              try
              {
                fin=new FileInputStream(args[j]);
                try
                {
                  while((b=fin.read())!=-1)
                  {
                    char ch=(char) b;
                    fout.write(ch);
                  }
                }
                catch (IOException e)
                {
                  e.printStackTrace();
                }
                finally
                {
                  fin.close();
                }
              }
              catch(Exception e)
              {
                System.err.println("Error opening "+args[j]+" for input");
              }
            }
          }
        }
      }
      finally
      {
        fout.close();
      }
      fin1=new FileInputStream("Master.txt"); 
      while((b=fin1.read())!=-1)
      {
        char ch=(char) b;
        System.out.print(ch);
      }
      fin1.close();
    }
    catch(Exception e)
    {
      System.err.println("Error opening Master.txt for output");
    }
  }
}

Answer 5

要以面值回答您的问题，您可以使用

检查是否为fin分配了值

if (null == fin)

但实际原因是因为如果抛出异常，你将继续执行。

 try
  {
   fin=new FileInputStream(args[j]);
  }
  catch(Exception e)
  {
   System.out.print("Error Opening "+args[j]);
  }

如果抛出异常，则上面的块不会设置fin，但是您在下一行中访问fin。这也适用于fout和fin1。

您可以在try块中嵌套其他代码;如果您使用的资源在访问时可能会抛出异常，则实际建议使用。

Answer 6

只需在方法的开头设置变量：

public static void main(String[] args) {
    FileOutputStream fout = null;
    FileInputStream fin = null;
    FileInputStream fin1 = null;
    ...

Answer 7

初始化变量：

FileOutputStream fout = null;
FileInputStream fin = null, fin1 = null;

Answer 8

import java.io.BufferedWriter; <br>
import java.io.File;<br>
import java.io.FileWriter;<br>
import java.util.Scanner;<br>

public class ConcatFiles
{
    public static String masterFile;


public static void main(String[] args) throws Exception
{
    MasterFile();
}

public static void MasterFile() throws Exception
{
    System.out.println("Enter Master File Name:");
    Scanner readMasterFileName = new Scanner(System.in);
    masterFile = readMasterFileName.next();
    if (new File(masterFile).exists() && masterFile.contains(".txt"))
    readFileName();
    else
    {
        if (masterFile.contains(".txt"))
        {
            new File(masterFile).createNewFile();
            System.out.println("Master File Created");
            readFileName();
        }
        else
        {
            System.out.println("Invalid File or Input");
            MasterFile();
        }
    }
}
public static void readFileName() throws Exception
{
    System.out.println("Enter File Names:");
    Scanner readOtherFiles = new Scanner(System.in);
    String cmd = readOtherFiles.next();

    if (cmd.equalsIgnoreCase("Exit"))
        System.exit(0);
    else
        if (cmd.equalsIgnoreCase("New"))
            MasterFile();
        else
            if (cmd.contains(".txt") && new File(cmd).exists())
            concatFile(cmd);
            else
            {
                System.out.println("Invalid Input or File");
                readFileName();
            }
}
public static void concatFile(String otherFiles)throws Exception
{
    BufferedWriter out = new BufferedWriter(new FileWriter(masterFile, true));
    File readFiles = new File(otherFiles);
    Scanner reader = new Scanner(readFiles);
    while(reader.hasNext())
    {
        out.write(reader.nextLine()+"\n");
    }
    out.close();
    readFileName();
}
}

Answer 9

你在catch块中添加return语句...休息很好.... 例如：

尝试{

} catch（ExcepttionName exObject） { 报表; 返回;

}

你必须在每个catch（）块中添加return。

Java程序，它接受来自命令行参数的现有文本文件列表

9 个答案: