어떻게 스칼라의 하위 디렉토리에있는 모든 파일을 나열 하는가?

좋은 "스칼라 - 억양은"(내가 기능을 의미 추측) 재귀 적 디렉토리에있는 파일을 나열하는 방법이 있습니까? 어떤 특정 패턴과 일치 어떻습니까?

\ TEMP : C의 "* .foo"를 일치 재귀 적으로 모든 파일은 예를 들어.

해결법

==============================
1.스칼라 코드는 일반적으로 읽는 디렉토리를 포함하여, I / O를 처리하기위한 자바 클래스를 사용합니다. 당신처럼 뭔가를해야 그래서 :

스칼라 코드는 일반적으로 읽는 디렉토리를 포함하여, I / O를 처리하기위한 자바 클래스를 사용합니다. 당신처럼 뭔가를해야 그래서 :
```
import java.io.File
def recursiveListFiles(f: File): Array[File] = {
  val these = f.listFiles
  these ++ these.filter(_.isDirectory).flatMap(recursiveListFiles)
}
```
당신은 정규식을 사용하여 모든 파일과 다음 필터를 수집 할 수 있습니다 :
```
myBigFileArray.filter(f => """.*\.html$""".r.findFirstIn(f.getName).isDefined)
```
아니면 재귀 검색에 정규식을 통합 할 수 있습니다 :
```
import scala.util.matching.Regex
def recursiveListFiles(f: File, r: Regex): Array[File] = {
  val these = f.listFiles
  val good = these.filter(f => r.findFirstIn(f.getName).isDefined)
  good ++ these.filter(_.isDirectory).flatMap(recursiveListFiles(_,r))
}
```
==============================
2.당신은 무한 파일 시스템 (스트림 게으른 평가 모음) 반복 할 수 있기 때문에 나는 스트림과 솔루션을 선호하는 것

당신은 무한 파일 시스템 (스트림 게으른 평가 모음) 반복 할 수 있기 때문에 나는 스트림과 솔루션을 선호하는 것
```
import scala.collection.JavaConversions._

def getFileTree(f: File): Stream[File] =
        f #:: (if (f.isDirectory) f.listFiles().toStream.flatMap(getFileTree) 
               else Stream.empty)
```
검색을위한 예
```
getFileTree(new File("c:\\main_dir")).filter(_.getName.endsWith(".scala")).foreach(println)
```
==============================
3.
```
for (file <- new File("c:\\").listFiles) { processFile(file) }
```
http://langref.org/scala+java/files
==============================
4.자바 1.7로 모두가있는 java.nio를 사용해야합니다. 그것은 제공 확대에 네이티브 성능 (java.io이 매우 느립니다) 및 유용한 도우미가 있습니다

자바 1.7로 모두가있는 java.nio를 사용해야합니다. 그것은 제공 확대에 네이티브 성능 (java.io이 매우 느립니다) 및 유용한 도우미가 있습니다

당신이 찾고있는 정확하게 그러나 자바 1.8을 소개합니다 :
```
import java.nio.file.{FileSystems, Files}
import scala.collection.JavaConverters._
val dir = FileSystems.getDefault.getPath("/some/path/here") 

Files.walk(dir).iterator().asScala.filter(Files.isRegularFile(_)).foreach(println)
```
또한 파일 매칭 물었다. java.nio.file.Files.find 또한 java.nio.file.Files.newDirectoryStream 시도

여기 문서를 참조하십시오 : http://docs.oracle.com/javase/tutorial/essential/io/walk.html
==============================
5.스칼라는 다중 패러다임 언어입니다. 디렉토리를 반복하는 좋은 "스칼라 - 억양"방법은 기존의 코드를 재사용하는 것입니다!

스칼라는 다중 패러다임 언어입니다. 디렉토리를 반복하는 좋은 "스칼라 - 억양"방법은 기존의 코드를 재사용하는 것입니다!

나는 디렉토리를 반복하는 완벽 스칼라 - 억양 방법 IO 공유지를-사용하는 것이 좋습니다 것입니다. 당신은 그것을 쉽게하기 위해 몇 가지 암시 적 변환을 사용할 수 있습니다. 처럼
```
import org.apache.commons.io.filefilter.IOFileFilter
implicit def newIOFileFilter (filter: File=>Boolean) = new IOFileFilter {
  def accept (file: File) = filter (file)
  def accept (dir: File, name: String) = filter (new java.io.File (dir, name))
}
```
==============================
6.유라의 스트림 솔루션과 같은 I,하지만 (나머지는) 숨겨진 디렉토리로 재귀. 우리는 또한 때 listFiles 반환이 아닌 디렉토리를 null한다는 사실을 이용하여 단순화 할 수 있습니다.

유라의 스트림 솔루션과 같은 I,하지만 (나머지는) 숨겨진 디렉토리로 재귀. 우리는 또한 때 listFiles 반환이 아닌 디렉토리를 null한다는 사실을 이용하여 단순화 할 수 있습니다.
```
def tree(root: File, skipHidden: Boolean = false): Stream[File] = 
  if (!root.exists || (skipHidden && root.isHidden)) Stream.empty 
  else root #:: (
    root.listFiles match {
      case null => Stream.empty
      case files => files.toStream.flatMap(tree(_, skipHidden))
  })
```
이제 우리는 파일을 나열 할 수 있습니다
```
tree(new File(".")).filter(f => f.isFile && f.getName.endsWith(".html")).foreach(println)
```
이상 처리 전체의 흐름을 실현
```
tree(new File("dir"), true).toArray
```
==============================
7.아파치 코 몬즈 이오의 Fileutils의의 한 줄에 맞는, 꽤 읽을 수 :

아파치 코 몬즈 이오의 Fileutils의의 한 줄에 맞는, 꽤 읽을 수 :
```
import scala.collection.JavaConversions._ // important for 'foreach'
import org.apache.commons.io.FileUtils

FileUtils.listFiles(new File("c:\temp"), Array("foo"), true).foreach{ f =>

}
```

==============================

8.아무도 언급하지 아직 https://github.com/pathikrit/better-files있다

아무도 언급하지 아직 https://github.com/pathikrit/better-files있다

val dir = "src"/"test"
val matches: Iterator[File] = dir.glob("**/*.{java,scala}")
// above code is equivalent to:
dir.listRecursively.filter(f => f.extension == 
                      Some(".java") || f.extension == Some(".scala"))

==============================
9.scala.tools.nsc.io에서보세요

scala.tools.nsc.io에서보세요

깊은 디렉토리 클래스에 기능을 나열 포함이 매우 유용한 유틸리티가 있습니다.

나는이 강조되었다 정확히 기억 경우 retronym에 의해 (아마도 기여) 및 IO 표준 라이브러리의 신선하고보다 완벽한 구현을 취득하기 전에 임시 변통으로 볼 수 있었다.

==============================

10.그리고 여기에서 필터 @DuncanMcGregor에서 스트림 솔루션의 혼합물이다 @ 릭-777 :

그리고 여기에서 필터 @DuncanMcGregor에서 스트림 솔루션의 혼합물이다 @ 릭-777 :

  def tree( root: File, descendCheck: File => Boolean = { _ => true } ): Stream[File] = {
    require(root != null)
    def directoryEntries(f: File) = for {
      direntries <- Option(f.list).toStream
      d <- direntries
    } yield new File(f, d)
    val shouldDescend = root.isDirectory && descendCheck(root)
    ( root.exists, shouldDescend ) match {
      case ( false, _) => Stream.Empty
      case ( true, true ) => root #:: ( directoryEntries(root) flatMap { tree( _, descendCheck ) } )
      case ( true, false) => Stream( root )
    }   
  }

  def treeIgnoringHiddenFilesAndDirectories( root: File ) = tree( root, { !_.isHidden } ) filter { !_.isHidden }

이것은 당신에게 스트림 [파일] 대신 (잠재적 거대하고 매우 느린) 목록 [파일] 당신이 디렉토리의 종류는 descendCheck () 함수에 재귀을 결정시키는 동안 제공합니다.

==============================

11.방법에 대한

방법에 대한

   def allFiles(path:File):List[File]=
   {    
       val parts=path.listFiles.toList.partition(_.isDirectory)
       parts._2 ::: parts._1.flatMap(allFiles)         
   }

==============================
12.스칼라 실험으로 간주 라이브러리 'scala.reflect.io'을 가지고 있지만 작업을 수행합니다

스칼라 실험으로 간주 라이브러리 'scala.reflect.io'을 가지고 있지만 작업을 수행합니다
```
import scala.reflect.io.Path
Path(path) walkFilter { p => 
  p.isDirectory || """a*.foo""".r.findFirstIn(p.name).isDefined
}
```

==============================

13.나는 개인적으로 @Rex 커의 제안 솔루션의 정밀함과 단순함있다. 그러나 여기 꼬리 재귀 버전이 어떻게 보이는지입니다 :

나는 개인적으로 @Rex 커의 제안 솔루션의 정밀함과 단순함있다. 그러나 여기 꼬리 재귀 버전이 어떻게 보이는지입니다 :

def listFiles(file: File): List[File] = {
  @tailrec
  def listFiles(files: List[File], result: List[File]): List[File] = files match {
    case Nil => result
    case head :: tail if head.isDirectory =>
      listFiles(Option(head.listFiles).map(_.toList ::: tail).getOrElse(tail), result)
    case head :: tail if head.isFile =>
      listFiles(tail, head :: result)
  }
  listFiles(List(file), Nil)
}

==============================
14.여기에 비슷한 렉스 커의 해결책하지만, 파일 필터를 통합입니다 :

여기에 비슷한 렉스 커의 해결책하지만, 파일 필터를 통합입니다 :
```
import java.io.File
def findFiles(fileFilter: (File) => Boolean = (f) => true)(f: File): List[File] = {
  val ss = f.list()
  val list = if (ss == null) {
    Nil
  } else {
    ss.toList.sorted
  }
  val visible = list.filter(_.charAt(0) != '.')
  val these = visible.map(new File(f, _))
  these.filter(fileFilter) ++ these.filter(_.isDirectory).flatMap(findFiles(fileFilter))
}
```
방법은 배열 [파일]보다 약간 더 편리 목록 [파일]을 반환합니다. 또한 숨겨져있는 모든 디렉토리 무시합니다 (예.로 시작을 '.').

그것은 부분적으로 예를 들어, 사용자가 선택한 파일 필터를 사용하여 적용된 :
```
val srcDir = new File( ... )
val htmlFiles = findFiles( _.getName endsWith ".html" )( srcDir )
```
==============================
15.가장 간단한 스칼라 전용 솔루션 (당신이 스칼라 컴파일러 라이브러리를 필요로 괜찮다면)

가장 간단한 스칼라 전용 솔루션 (당신이 스칼라 컴파일러 라이브러리를 필요로 괜찮다면)
```
val path = scala.reflect.io.Path(dir)
scala.tools.nsc.io.Path.onlyFiles(path.walk).foreach(println)
```
그렇지 않으면, 르노의 솔루션 (아파치 커먼즈 Fileutils의 당기는 괜찮다면) 짧고 달콤한 @ :
```
import scala.collection.JavaConversions._  // enables foreach
import org.apache.commons.io.FileUtils
FileUtils.listFiles(dir, null, true).foreach(println)
```
어디 DIR은 java.io.File에 있습니다 :
```
new File("path/to/dir")
```
==============================
16.아무도 스칼라 - incubrator에서 스칼라-IO 라이브러리를 언급하지 보인다 ...

아무도 스칼라 - incubrator에서 스칼라-IO 라이브러리를 언급하지 보인다 ...
```
import scalax.file.Path

Path.fromString("c:\temp") ** "a*.foo"
```
또는 암시 적으로
```
import scalax.file.ImplicitConversions.string2path

"c:\temp" ** "a*.foo"
```
또는 명시 적으로 암시하려는 경우 ...
```
import scalax.file.Path
import scalax.file.ImplicitConversions.string2path

val dir: Path = "c:\temp"
dir ** "a*.foo"
```
문서는 여기에 있습니다 : http://jesseeichar.github.io/scala-io-doc/0.4.3/index.html#!/file/glob_based_path_sets

==============================

17.이 주문은 나를 위해 작동합니다 :

이 주문은 나를 위해 작동합니다 :

  def findFiles(dir: File, criterion: (File) => Boolean): Seq[File] = {
    if (dir.isFile) Seq()
    else {
      val (files, dirs) = dir.listFiles.partition(_.isFile)
      files.filter(criterion) ++ dirs.toSeq.map(findFiles(_, criterion)).foldLeft(Seq[File]())(_ ++ _)
    }
  }

==============================

18.당신은 그것을 위해 꼬리 재귀를 사용할 수 있습니다 :

당신은 그것을 위해 꼬리 재귀를 사용할 수 있습니다 :

object DirectoryTraversal {
  import java.io._

  def main(args: Array[String]) {
    val dir = new File("C:/Windows")
    val files = scan(dir)

    val out = new PrintWriter(new File("out.txt"))

    files foreach { file =>
      out.println(file)
    }

    out.flush()
    out.close()
  }

  def scan(file: File): List[File] = {

    @scala.annotation.tailrec
    def sc(acc: List[File], files: List[File]): List[File] = {
      files match {
        case Nil => acc
        case x :: xs => {
          x.isDirectory match {
            case false => sc(x :: acc, xs)
            case true => sc(acc, xs ::: x.listFiles.toList)
          }
        }
      }
    }

    sc(List(), List(file))
  }
}

==============================

19.왜 자바의 파일 대신 스칼라의 AbstractFile를 사용하고 있습니까?

왜 자바의 파일 대신 스칼라의 AbstractFile를 사용하고 있습니까?

스칼라의 AbstractFile로, 반복자 지원은 제임스 무어의 솔루션을보다 간결 버전을 작성 허용 :

import scala.reflect.io.AbstractFile  
def tree(root: AbstractFile, descendCheck: AbstractFile => Boolean = {_=>true}): Stream[AbstractFile] =
  if (root == null || !root.exists) Stream.empty
  else
    (root.exists, root.isDirectory && descendCheck(root)) match {
      case (false, _) => Stream.empty
      case (true, true) => root #:: root.iterator.flatMap { tree(_, descendCheck) }.toStream
      case (true, false) => Stream(root)
    }

from https://stackoverflow.com/questions/2637643/how-do-i-list-all-files-in-a-subdirectory-in-scala by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] Build.scala, %와 의미 %% 문자 (0)	2019.11.11
[SCALA] 구문 분석 CSV 파일을 사용 스칼라 파서 콤비 (0)	2019.11.11
[SCALA] `def` 스칼라에서 게으른 val` 평가`대 val``대 (0)	2019.11.11
[SCALA] 스파크 : 불꽃 쉘에서 스파크 파일을 실행하는 방법 (0)	2019.11.10
[SCALA] 스칼라 : 하나의 문에서 파일에 쓰기 문자열 (0)	2019.11.10

복붙노트

[SCALA] 어떻게 스칼라의 하위 디렉토리에있는 모든 파일을 나열 하는가?

어떻게 스칼라의 하위 디렉토리에있는 모든 파일을 나열 하는가?

해결법

1.스칼라 코드는 일반적으로 읽는 디렉토리를 포함하여, I / O를 처리하기위한 자바 클래스를 사용합니다. 당신처럼 뭔가를해야 그래서 :

2.당신은 무한 파일 시스템 (스트림 게으른 평가 모음) 반복 할 수 있기 때문에 나는 스트림과 솔루션을 선호하는 것

3.

4.자바 1.7로 모두가있는 java.nio를 사용해야합니다. 그것은 제공 확대에 네이티브 성능 (java.io이 매우 느립니다) 및 유용한 도우미가 있습니다

5.스칼라는 다중 패러다임 언어입니다. 디렉토리를 반복하는 좋은 "스칼라 - 억양"방법은 기존의 코드를 재사용하는 것입니다!

6.유라의 스트림 솔루션과 같은 I,하지만 (나머지는) 숨겨진 디렉토리로 재귀. 우리는 또한 때 listFiles 반환이 아닌 디렉토리를 null한다는 사실을 이용하여 단순화 할 수 있습니다.

7.아파치 코 몬즈 이오의 Fileutils의의 한 줄에 맞는, 꽤 읽을 수 :

8.아무도 언급하지 아직 https://github.com/pathikrit/better-files있다

9.scala.tools.nsc.io에서보세요

10.그리고 여기에서 필터 @DuncanMcGregor에서 스트림 솔루션의 혼합물이다 @ 릭-777 :

11.방법에 대한

12.스칼라 실험으로 간주 라이브러리 'scala.reflect.io'을 가지고 있지만 작업을 수행합니다

13.나는 개인적으로 @Rex 커의 제안 솔루션의 정밀함과 단순함있다. 그러나 여기 꼬리 재귀 버전이 어떻게 보이는지입니다 :

14.여기에 비슷한 렉스 커의 해결책하지만, 파일 필터를 통합입니다 :

15.가장 간단한 스칼라 전용 솔루션 (당신이 스칼라 컴파일러 라이브러리를 필요로 괜찮다면)

16.아무도 스칼라 - incubrator에서 스칼라-IO 라이브러리를 언급하지 보인다 ...

17.이 주문은 나를 위해 작동합니다 :

18.당신은 그것을 위해 꼬리 재귀를 사용할 수 있습니다 :

19.왜 자바의 파일 대신 스칼라의 AbstractFile를 사용하고 있습니까?

'SCALA' 카테고리의 다른 글

티스토리툴바