在Java中如何将数组值作为输出返回给方法

我是

Java

新手。我正在写上一篇文章

我想返回目录下的特定扩展名（如

.txt

）文件名

为此，我编写了以下带有2个参数的方法

  public void ListOfFileNames(String directoryPath,String fileType)
  {
    //Creating Object for File class
File fileObject=new File(directoryPath);
//Fetching all the FileNames under given Path
File[] listOfFiles=fileObject.listFiles();
//Creating another Array for saving fileNames, which are satisfying as far our requirments
String[] fileNames;
for (int fileIndex = 0; fileIndex < listOfFiles.length; fileIndex++) 
{
    if (listOfFiles[fileIndex].isFile())
    {
        //True condition,Array Index value is File
        if (listOfFiles[fileIndex].getName().endsWith(fileType)) 
        {
            //System.out.println(listOfFiles[fileIndex].getName());
        }
    }
}

public void列表文件名（String directoryPath，String fileType）
{
//为文件类创建对象
File fileObject=新文件（directoryPath）；
//获取给定路径下的所有文件名
File[]listOfFiles=fileObject.listFiles（）；
//创建另一个用于保存文件名的数组，以满足我们的要求
字符串[]文件名；
对于（int fileIndex=0；fileIndex

}

在这里，我面临两个问题

函数返回类型

将文件名添加到

文件名

数组中

我怎样才能解决这个问题

谢谢。

试试这个：

public List<String> getListOfFileNames(String directoryPath, String fileType) {
    List<String> result = new ArrayList<String>();
    // add the code to loop over the director list and add them to the result
    return result;
}

public List getListOfFileNames（字符串目录路径，字符串文件类型）{
列表结果=新建ArrayList（）；
//添加代码以循环到控制器列表，并将其添加到结果中
返回结果；
}

更好的解决方案是使用

文件

类中内置的

list（）

方法。给它传递一个

FilenameFilter

---

最好的做法是重用代码，而不是再次编写代码。

返回类型应为

String[]

或

List

，您需要将遇到的符合条件的每个文件名放入列表或数组中，并最终返回相同的文件名

在这部分代码中

如果您使用的是数组

String[] fileNames;
int count = 0;

if (listOfFiles[fileIndex].getName().endsWith(fileType)) 
{
     fileNames[count] = listOfFiles[fileIndex].getName();
     count++;
}

return fileNames;

代码的其余部分保持不变

如果您想使用列表执行此操作

List<String> fileNames = new ArrayList<String>();

if (listOfFiles[fileIndex].getName().endsWith(fileType)) 
{
     fileNames.add(listOfFiles[fileIndex].getName());
}

return fileNames;

List fileNames=new ArrayList（）；
if（listOfFiles[fileIndex].getName（）.endsWith（fileType））
{
添加（listOfFiles[fileIndex].getName（））；
}
返回文件名；

对于返回类型，请将第一行更改为

public String[] ListOfFileNames(String directoryPath,String fileType)

至于在数组中添加一个项目，您可能需要考虑使用ARARYLIST。像这样：

List<String> stringList = new ArrayList<String>();
stringList.add("string")

List-stringList=new-ArrayList（）；
stringList.add（“字符串”）

公共列表文件名（字符串目录路径，字符串文件类型）{
//为文件类创建对象
File fileObject=新文件（directoryPath）；
//获取给定路径下的所有文件名
File[]listOfFiles=fileObject.listFiles（）；
//创建另一个用于保存文件名的数组，以满足我们的要求
列表文件名=新的ArrayList（）；
对于（int fileIndex=0；fileIndex

您想从方法中返回几个字符串。例如，它应该返回字符串[]或

列表

您还希望遵守Java命名约定，因此该方法应声明为：

public String[] listOfFileNames(String directoryPath, String fileType)

如果您阅读了

java.io.File

的javadoc，您会注意到有一个方法正是这样做的。您只需要传递一个

FilenameFilter

，它告诉您应该返回哪些文件名的方法：

public String[] listOfFileNames(String directoryPath, final String fileType) {
    return new File(directoryPath).list(new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
            return name.endsWith(fileType);
        } 
    });
}

---

上面的代码使用匿名内部类，该类实现FilenameFilter接口。阅读以了解它们。

最好使用列表而不是数组
像这样更改代码

public void FileMoving()   
{  
   //created object for Class   
   ExternalFileExecutions ExternalFileExecutionsObject=new ExternalFileExecutions();  
   //calling Method from class object
   List<String> fileNames = ExternalFileExecutionsObject.ListOfFileNames("C:/Documents and Settings/mahesh/Desktop/InputFiles",".txt");    
   //to find out the length of list
   System.out.println(fileNames.size());  
}
public List<String> ListOfFileNames(String directoryPath,String fileType)
{
    //Creating Object for File class
    File fileObject=new File(directoryPath);
    //Fetching all the FileNames under given Path
    File[] listOfFiles=fileObject.listFiles();
    //Creating another Array for saving fileNames, which are satisfying as far our requirments
    List<String> fileNames = new ArrayList<String>();
    for (int fileIndex = 0; fileIndex < listOfFiles.length; fileIndex++) 
    {
        if (listOfFiles[fileIndex].isFile())
        {
          //True condition,Array Index value is File
          if (listOfFiles[fileIndex].getName().endsWith(fileType)) 
          {
              //System.out.println(listOfFiles[fileIndex].getName());
              fileNames .add(listOfFiles[fileIndex].getName());
          }
       }
     }  
     return fileNames ;

  }

public void FileMoving（）
{  
//已为类创建对象
ExternalFileExecutions ExternalFileExecutionsObject=新建ExternalFileExecutions（）；
//从类对象调用方法
List fileNames=ExternalFileExecutionsObject.ListOfFileNames（“C:/Documents and Settings/mahesh/Desktop/InputFiles”，“.txt”）；
//找出列表的长度
System.out.println（fileNames.size（））；
}
公共列表ListOfFileNames（字符串目录路径、字符串文件类型）
{
//为文件类创建对象
File fileObject=新文件（directoryPath）；
//获取给定路径下的所有文件名
File[]listOfFiles=fileObject.listFiles（）；
//创建另一个用于保存文件名的数组，以满足我们的要求
列表文件名=新的ArrayList（）；
对于（int fileIndex=0；fileIndex

我通常更喜欢返回

文件

，而不是

字符串

。这样，您就不必每次使用新文件时都创建新文件，您可以根据需要访问文件名（

.getName（）

foo.txt

）或整个路径（

getPath（）

）

文件

已经具有内置的筛选功能，可以作为

字符串

（

FileNameFilter

）处理文件，也可以处理

文件本身（
FileFilter
）。如上所述，我更喜欢处理
文件

实现
FileFilter
非常简单

private static class ExtensionFilter implements FileFilter {
    private final String extension;

    public ExtensionFilter(String extension) {
        // store ".TXT"
        this.extension = "." + extension.toUpperCase(Locale.ROOT);
    }

    @Override
    public boolean accept(File pathname) {
        // return true if it is a file and it ends with .TXT
        return pathname.isFile() && pathname.getName().toUpperCase(Locale.ROOT).endsWith(extension);
    }
}

现在添加一些使用这种过滤器的方法，您就完成了<
private static class ExtensionFilter implements FileFilter {
    private final String extension;

    public ExtensionFilter(String extension) {
        // store ".TXT"
        this.extension = "." + extension.toUpperCase(Locale.ROOT);
    }

    @Override
    public boolean accept(File pathname) {
        // return true if it is a file and it ends with .TXT
        return pathname.isFile() && pathname.getName().toUpperCase(Locale.ROOT).endsWith(extension);
    }
}

// internal method that lists files, converts them into a List and makes sure it does not return null
private static List<File> listFilesWithExtension(File directory, ExtensionFilter filter) {
    File[] files = directory.listFiles(filter);
    return files != null ? Arrays.asList(files) : Collections.<File>emptyList();
}

/** use like listFilesWithExtension(directory, "txt") */    
public static List<File> listFilesWithExtension(File directory, String extension) {
    return listFilesWithExtension(directory, new ExtensionFilter(extension));
}

/** lists only .txt files */
private static final ExtensionFilter TXT_FILES = new ExtensionFilter("txt");
public static List<File> listTxtFiles(File directory) {
    return listFilesWithExtension(directory, TXT_FILES);
}

public static String[] getFileNamesFromFiles(List<File> files) {
    String[] result = new String[files.size()];
    for (int i = 0; i < files.size(); i++) {
        File file = files.get(i);
        result[i] = file.getName();
    }
    return result;
}

    public List<String> ListOfFileNames1(final String directoryPath,
            final String fileType) {
        List<String> result = new ArrayList<String>();
        // Creating Object for File class
        File root = new File(directoryPath);
        for (File f : root.listFiles()) {
            if (f.isFile() && f.getName().endsWith(fileType)) {
                result.add(f.getName());
            } // if
        } // for
        return result;
    } // ListOfFileNames1

    public List<File> ListOfFileNames2(final String directoryPath,
            final String fileType) {
        // Creating Object for File class
        File root = new File(directoryPath);
        return Arrays.asList(root.listFiles(new FileFilter() {

            @Override
            public boolean accept(File pathname) {
                return pathname.isFile()
                        && pathname.getName().endsWith(fileType);
            }
        }));
    } // ListOfFileNames2