Java Language
파일 I / O

소개

모든 바이트를 byte []에 읽어들입니다.

Java 7은 매우 유용한 Files 클래스를 도입했습니다.

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

Path path = Paths.get("path/to/file");

try {
    byte[] data = Files.readAllBytes(path);
} catch(IOException e) {
    e.printStackTrace();
}

파일에서 이미지 읽기

import java.awt.Image;
import javax.imageio.ImageIO;

...

try {
    Image img = ImageIO.read(new File("~/Desktop/cat.png"));
} catch (IOException e) {
    e.printStackTrace();
}

파일에 바이트 []를 쓰는 중

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

try(FileOutputStream stream = new FileOutputStream("Hello world.txt")) {
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
}

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

FileOutputStream stream = null;
try {
    stream = new FileOutputStream("Hello world.txt");
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
} finally {
    if (stream != null) {
        try {
            stream.close();
        } catch (IOException ignored) {}
    }
}

대부분의 java.io 파일 API는 String 과 File 모두 인수로 받아 들일 수 있으므로

File file = new File("Hello world.txt");
FileOutputStream stream = new FileOutputStream(file);

Stream vs Writer / Reader API

스트림은 바이너리 컨텐트에 가장 직접적인 액세스를 제공하므로 모든 InputStream / OutputStream 구현은 항상 int 및 byte 에서 작동합니다.

// Read a single byte from the stream
int b = inputStream.read();
if (b >= 0) { // A negative value represents the end of the stream, normal values are in the range 0 - 255
    // Write the byte to another stream
    outputStream.write(b);
}

// Read a chunk
byte[] data = new byte[1024];
int nBytesRead = inputStream.read(data);
if (nBytesRead >= 0) { // A negative value represents end of stream
    // Write the chunk to another stream
    outputStream.write(data, 0, nBytesRead);
}

몇 가지 예외가 있습니다. 특히 PrintStream 은 "다양한 데이터 값의 표현을 편리하게 인쇄 할 수있는 기능"을 추가합니다. 이를 통해 System.out 이진 InputStream 및 System.out.println() 과 같은 메서드를 사용하여 텍스트 출력으로 사용할 수 있습니다.

또한, 일부 스트림 구현은 Java 객체 (직렬화 참조) 또는 원시 유형 (예 : DataOutputStream / DataInputStream )과 같은 상위 수준 내용에 대한 인터페이스로 작동합니다.

Writer 및 Reader 클래스를 사용하여 Java는 명시 적 문자 스트림을위한 API도 제공합니다. 대부분의 응용 프로그램은 이러한 구현을 스트림에서 기반으로하지만 문자 스트림 API는 바이너리 콘텐츠에 대한 메서드를 노출하지 않습니다.

// This example uses the platform's default charset, see below
// for a better implementation.

Writer writer = new OutputStreamWriter(System.out);
writer.write("Hello world!");

Reader reader = new InputStreamReader(System.in);
char singleCharacter = reader.read();

문자를 이진 데이터로 인코딩해야 할 때마다 (예 : InputStreamWriter / OutputStreamWriter 클래스를 사용할 때) 플랫폼의 기본 charset에 의존하지 않으려면 charset을 지정해야합니다. 의심스러운 경우 모든 Java 플랫폼에서 지원되는 UTF-8과 같은 유니 코드 호환 인코딩을 사용하십시오. 따라서 FileWriter 및 FileReader 와 같은 클래스는 항상 기본 플랫폼 문자 FileReader 을 사용하므로 사용하지 않아야합니다. 문자 스트림을 사용하여 파일에 액세스하는 더 좋은 방법은 다음과 같습니다.

Charset myCharset = StandardCharsets.UTF_8;

Writer writer = new OutputStreamWriter( new FileOutputStream("test.txt"), myCharset );
writer.write('Ä');
writer.flush();
writer.close();

Reader reader = new InputStreamReader( new FileInputStream("test.txt"), myCharset );
char someUnicodeCharacter = reader.read();
reader.close();

가장 일반적으로 사용되는 Reader 중 하나는 다른 리더에서 전체 텍스트 행을 읽는 방법을 제공하는 BufferedReader 이며 아마도 문자 스트림을 한 줄씩 읽는 가장 간단한 방법 일 수 있습니다.

// Read from baseReader, one line at a time
BufferedReader reader = new BufferedReader( baseReader );
String line;
while((line = reader.readLine()) != null) {
  // Remember: System.out is a stream, not a writer!
  System.out.println(line);
}

한 번에 전체 파일 읽기

File f = new File(path);
String content = new Scanner(f).useDelimiter("\\Z").next();

\ Z는 EOF (파일 끝) 기호입니다. 구분 기호로 설정하면 스캐너는 EOF 플래그에 도달 할 때까지 채우기를 읽습니다.

스캐너로 파일 읽기

파일을 한 줄씩 읽음

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNextLine())
            {
                String line = scanner.nextLine();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

단어 단어별로

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNext())
            {
                String line = scanner.next();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

scanner.useDelimeter () 메서드를 사용하여 delimeter를 변경할 수도 있습니다

디렉토리 및 필터를 파일 확장자로 반복 처리

    public void iterateAndFilter() throws IOException {
        Path dir = Paths.get("C:/foo/bar");
        PathMatcher imageFileMatcher =
            FileSystems.getDefault().getPathMatcher(
                "regex:.*(?i:jpg|jpeg|png|gif|bmp|jpe|jfif)");

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,
                entry -> imageFileMatcher.matches(entry.getFileName()))) {

            for (Path path : stream) {
                System.out.println(path.getFileName());
            }
        }
    }

java.io.File에서 Java 7 NIO (java.nio.file.Path)로 마이그레이션하기

이 예제들은 여러분이 이미 Java 7의 NIO가 일반적으로 무엇인지를 알고 있고 java.io.File 사용하여 코드를 작성하는 데 익숙하다고 가정합니다. 이 예제를 활용하여 마이그레이션을위한 NIO 중심 문서를 빠르게 찾을 수 있습니다.

메모리 맵 파일 이나 FileSystem을 사용하여 ZIP 또는 JAR 파일을 여는 것과 같은 Java 7의 NIO에는 훨씬 더 많은 기능이 있습니다. 이 예제는 제한된 수의 기본 사용 사례만을 다룹니다.

기본적으로 java.io.File 인스턴스 메소드를 사용하여 파일 시스템 읽기 / 쓰기 작업을 수행하는 데 사용되는 경우 java.nio.file.Files 내에서 정적 메소드로 사용됩니다.

경로를 가리 키십시오.

// -> IO
File file = new File("io.txt");

// -> NIO
Path path = Paths.get("nio.txt");

다른 경로와 관련된 경로

// Forward slashes can be used in place of backslashes even on a Windows operating system
// -> IO
File folder = new File("C:/");
File fileInFolder = new File(folder, "io.txt");

// -> NIO
Path directory = Paths.get("C:/");
Path pathInDirectory = directory.resolve("nio.txt");

라이브러리와 함께 사용하기 위해 파일을 경로에서 /로 변환

// -> IO to NIO
Path pathFromFile = new File("io.txt").toPath();

// -> NIO to IO
File fileFromPath = Paths.get("nio.txt").toFile();

파일이 있는지 확인하고 파일이 있으면 삭제하십시오.

// -> IO
if (file.exists()) {
    boolean deleted = file.delete();
    if (!deleted) {
        throw new IOException("Unable to delete file");
    }
}

// -> NIO
Files.deleteIfExists(path);

OutputStream을 통해 파일에 쓰기

FileChannel , Files.write(Path path, byte\[\] bytes, OpenOption... options) 등 다양한 성능 및 메모리 제약 조건, 가독성 및 사용 사례에 대해 NIO를 사용하여 파일을 읽고 쓰는 여러 가지 방법이 Files.write(Path path, byte\[\] bytes, OpenOption... options) . ..이 예제에서는 OutputStream 만 다루지 만 java.nio.file.Files 에서 사용할 수있는 메모리 매핑 파일과 다양한 정적 메서드에 대해 배우는 것이 좋습니다.

List<String> lines = Arrays.asList(
        String.valueOf(Calendar.getInstance().getTimeInMillis()),
        "line one",
        "line two");

// -> IO
if (file.exists()) {
    // Note: Not atomic
    throw new IOException("File already exists");
}
try (FileOutputStream outputStream = new FileOutputStream(file)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

// -> NIO
try (OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.CREATE_NEW)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

폴더 내의 각 파일 반복

// -> IO
for (File selectedFile : folder.listFiles()) {
    // Note: Depending on the number of files in the directory folder.listFiles() may take a long time to return
    System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
}

// -> NIO
Files.walkFileTree(directory, EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});

재귀 폴더 반복

// -> IO
recurseFolder(folder);

// -> NIO
// Note: Symbolic links are NOT followed unless explicitly passed as an argument to Files.walkFileTree
Files.walkFileTree(directory, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});


private static void recurseFolder(File folder) {
    for (File selectedFile : folder.listFiles()) {
        System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
        if (selectedFile.isDirectory()) {
            // Note: Symbolic links are followed
            recurseFolder(selectedFile);
        }
    }
}

FileInputStream / FileOutputStream을 사용하여 파일 읽기 / 쓰기

파일에 쓰십시오 test.txt :

String filepath ="C:\\test.txt";
FileOutputStream fos = null;
try {
      fos = new FileOutputStream(filepath);
      byte[] buffer = "This will be written in test.txt".getBytes();
      fos.write(buffer, 0, buffer.length);
      fos.close();
} catch (FileNotFoundException e) {
      e.printStackTrace();
} catch (IOException e) {
      e.printStackTrace();
} finally{
      if(fos != null)
        fos.close();
}

test.txt 파일에서 읽기 :

String filepath ="C:\\test.txt";        
FileInputStream fis = null;
try {
   fis = new FileInputStream(filepath);
   int length = (int) new File(filepath).length();
   byte[] buffer = new byte[length];
   fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
     e.printStackTrace();
} catch (IOException e) {
     e.printStackTrace();
} finally{
   if(fis != null)
     fis.close();
}

Java 1.7부터 try-with-resources 문이 도입되어 읽기 / 쓰기 작업의 구현이 훨씬 간단 해졌습니다.

파일에 쓰십시오 test.txt :

String filepath ="C:\\test.txt";
try (FileOutputStream fos = new FileOutputStream(filepath)){
    byte[] buffer = "This will be written in test.txt".getBytes();
    fos.write(buffer, 0, buffer.length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

test.txt 파일에서 읽기 :

String filepath ="C:\\test.txt";
try (FileInputStream fis = new FileInputStream(filepath)){
    int length = (int) new File(filepath).length();
    byte[] buffer = new byte[length];
    fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

바이너리 파일에서 읽기

최신 Java 모든 버전에서 다음 코드를 사용하여 이진 파일을 읽을 수 있습니다.

File file = new File("path_to_the_file");
byte[] data = new byte[(int) file.length()];
DataInputStream stream = new DataInputStream(new FileInputStream(file));
stream.readFully(data);
stream.close();

Java 7 이상을 사용하는 경우 nio API 사용하는 더 간단한 방법이 있습니다.

Path path = Paths.get("path_to_the_file");
byte [] data = Files.readAllBytes(path);

잠금

파일은 입력 출력 streams 및 readers 에서 가져올 수있는 FileChannel API를 사용하여 잠글 수 있습니다.

streams 예

// 파일 스트림 열기 FileInputStream ios = new FileInputStream (filename);

    // get underlying channel
    FileChannel channel = ios.getChannel();

    /*
     * try to lock the file. true means whether the lock is shared or not i.e. multiple processes can acquire a
     * shared lock (for reading only) Using false with readable channel only will generate an exception. You should
     * use a writable channel (taken from FileOutputStream) when using false. tryLock will always return immediately
     */
    FileLock lock = channel.tryLock(0, Long.MAX_VALUE, true);

    if (lock == null) {
        System.out.println("Unable to acquire lock");
    } else {
        System.out.println("Lock acquired successfully");
    }

    // you can also use blocking call which will block until a lock is acquired.
    channel.lock();

    // Once you have completed desired operations of file. release the lock
    if (lock != null) {
        lock.release();
    }

    // close the file stream afterwards
    // Example with reader
    RandomAccessFile randomAccessFile = new RandomAccessFile(filename,  "rw");
    FileChannel channel = randomAccessFile.getChannel();
    //repeat the same steps as above but now you can use shared as true or false as the channel is in read write mode

InputStream 및 OutputStream을 사용하여 파일 복사

루프를 사용하여 소스의 데이터를 데이터 싱크에 직접 복사 할 수 있습니다. 이 예에서는 InputStream에서 데이터를 읽는 동시에 OutputStream에 데이터를 쓰고 있습니다. 우리가 읽기와 쓰기를 마친 후에는 자원을 폐쇄해야합니다.

public void copy(InputStream source, OutputStream destination) throws IOException {
    try {
        int c;
        while ((c = source.read()) != -1) {
            destination.write(c);
        }
    } finally {
        if (source != null) {
            source.close();
        }
        if (destination != null) {
            destination.close();
        }
    }
}

채널 및 버퍼를 사용하여 파일 읽기

Channel 은 Buffer 를 사용하여 데이터를 읽거나 씁니다. 버퍼는 고정 된 크기의 컨테이너로 한 번에 한 블록의 데이터를 쓸 수 있습니다. Channel 은 스트림 기반 I / O보다 상당히 빠릅니다.

Channel 을 사용하여 파일에서 데이터를 읽으려면 다음 단계가 필요합니다.

1. 우리는 FileInputStream 의 인스턴스가 필요합니다. FileInputStream 에는 채널을 반환하는 getChannel() 메서드가 있습니다.
2. FileInputStream의 getChannel() 메서드를 호출하고 Channel을 가져옵니다.
3. ByteBuffer를 작성합니다. ByteBuffer는 고정 크기의 바이트 컨테이너입니다.
4. 채널에는 read 메소드가있어,이 read 메소드의 인수로서 ByteBuffer를 제공 할 필요가 있습니다. ByteBuffer에는 읽기 전용 기분과 쓰기 전용 기분의 두 가지 모드가 있습니다. flip() 메서드 호출을 사용하여 모드를 변경할 수 있습니다. 버퍼에는 위치, 제한 및 용량이 있습니다. 버퍼가 고정 된 크기로 생성되면 버퍼의 크기와 용량은 크기와 동일하며 위치는 0부터 시작합니다. 버퍼에 데이터가 쓰여지는 동안 버퍼의 위치가 서서히 증가합니다. 모드 변경은 위치를 변경하는 것을 의미합니다. 버퍼의 처음부터 데이터를 읽으려면 위치를 0으로 설정해야합니다. flip () 메서드는 위치를 변경합니다.
5. Channel 의 read 메소드를 호출하면 데이터를 사용하여 버퍼를 채 웁니다.
6. ByteBuffer 에서 데이터를 읽어야 할 경우 버퍼를 뒤집어서 읽기 전용 모드로 쓰기 전용 모드로 변경 한 다음 버퍼에서 데이터를 계속 읽어야합니다.
7. 더 이상 읽을 데이터가 없으면 채널의 read() 메서드는 0 또는 -1을 반환합니다.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileChannelRead {
 
public static void main(String[] args) {
  
   File inputFile = new File("hello.txt");
  
   if (!inputFile.exists()) {
    System.out.println("The input file doesn't exit.");
    return;
   }

  try {
   FileInputStream fis = new FileInputStream(inputFile);
   FileChannel fileChannel = fis.getChannel();
   ByteBuffer buffer = ByteBuffer.allocate(1024);

   while (fileChannel.read(buffer) > 0) {
    buffer.flip();
    while (buffer.hasRemaining()) {
     byte b = buffer.get();
     System.out.print((char) b);
    }
    buffer.clear();
   }

   fileChannel.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

채널을 사용하여 파일 복사하기

Channel 을 사용하여 파일 내용을 더 빠르게 복사 할 수 있습니다. 이를 위해 FileChannel transferTo() 메소드를 사용할 수 있습니다.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

public class FileCopier {
    
    public static void main(String[] args) {
        File sourceFile = new File("hello.txt");
        File sinkFile = new File("hello2.txt");
        copy(sourceFile, sinkFile);
    }

    public static void copy(File sourceFile, File destFile) {
        if (!sourceFile.exists() || !destFile.exists()) {
            System.out.println("Source or destination file doesn't exist");
            return;
        }


        try (FileChannel srcChannel = new FileInputStream(sourceFile).getChannel();
             FileChannel sinkChanel = new FileOutputStream(destFile).getChannel()) {

            srcChannel.transferTo(0, srcChannel.size(), sinkChanel);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedInputStream을 사용하여 파일 읽기

기본 입력 스트림에서 읽은 바이트를 저장하는 내부 버퍼를 유지하므로 일반적으로 FileInputStream 보다 빠르게 BufferedInputStream 사용하여 파일을 읽습니다.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;


public class FileReadingDemo {

    public static void main(String[] args) {
        String source = "hello.txt";
        
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source))) {
            byte data;
            while ((data = (byte) bis.read()) != -1) {
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

채널 및 버퍼를 사용하여 파일 쓰기

Channel 을 사용하여 파일에 데이터를 쓰려면 다음 단계가 필요합니다.

1. 먼저 FileOutputStream 객체를 FileOutputStream
2. FileOutputStream 로부터 getChannel() 메소드를 호출하는 FileChannel 취득
3. ByteBuffer 를 만든 다음 데이터로 채 웁니다.
4. 그런 다음 ByteBuffer 의 flip() 메서드를 호출하고이를 FileChannel 의 FileChannel write() 메서드 인수로 전달해야합니다.
5. 우리가 글쓰기를 마쳤 으면 자원을 닫아야한다.

import java.io.*;
import java.nio.*;
public class FileChannelWrite {

 public static void main(String[] args) {

  File outputFile = new File("hello.txt");
  String text = "I love Bangladesh.";

  try {
   FileOutputStream fos = new FileOutputStream(outputFile);
   FileChannel fileChannel = fos.getChannel();
   byte[] bytes = text.getBytes();
   ByteBuffer buffer = ByteBuffer.wrap(bytes);
   fileChannel.write(buffer);
   fileChannel.close();
  } catch (java.io.IOException e) {
   e.printStackTrace();
  }
 }
}  

PrintStream을 사용하여 파일 쓰기

PrintStream 클래스를 사용하여 파일을 쓸 수 있습니다. 그것은 모든 데이터 유형 값을 인쇄하게 해주는 몇 가지 메소드를 가지고 있습니다. println() 메소드는 새로운 라인을 추가합니다. 인쇄가 끝나면 PrintStream 을 플러시해야 PrintStream .

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.time.LocalDate;

public class FileWritingDemo {
    public static void main(String[] args) {
        String destination = "file1.txt";

        try(PrintStream ps = new PrintStream(destination)){
            ps.println("Stackoverflow documentation seems fun.");
            ps.println();
            ps.println("I love Java!");
            ps.printf("Today is: %1$tm/%1$td/%1$tY", LocalDate.now());

            ps.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}

그 안에 하위 디렉토리를 인쇄하는 디렉토리를 반복합니다.

  public void iterate(final String dirPath) throws IOException {
    final DirectoryStream<Path> paths = Files.newDirectoryStream(Paths.get(dirPath));
    for (final Path path : paths) {
      if (Files.isDirectory(path)) {
        System.out.println(path.getFileName());
      }
    }
  }

디렉토리 추가하기

File 인스턴스에서 새 디렉토리를 만들려면 mkdirs() 또는 mkdir() 의 두 가지 방법 중 하나를 사용해야합니다.

• mkdir() -이 추상 경로명에 의해 명명 된 디렉토리를 생성합니다. ( 소스 )
• mkdirs() - 존재하지 않는 부모 디렉토리를 포함하여이 추상 경로명에 의해 명명 된 디렉토리를 생성합니다. 이 작업이 실패하면 필요한 상위 디렉터리를 만드는 데 성공했을 수 있습니다. ( 소스 )

참고 : createNewFile() 은 파일 만 새 디렉토리를 만들지 않습니다.

File singleDir = new File("C:/Users/SomeUser/Desktop/A New Folder/");
    
File multiDir = new File("C:/Users/SomeUser/Desktop/A New Folder 2/Another Folder/");

// assume that neither "A New Folder" or "A New Folder 2" exist

singleDir.createNewFile(); // will make a new file called "A New Folder.file"
singleDir.mkdir(); // will make the directory
singleDir.mkdirs(); // will make the directory

multiDir.createNewFile(); // will throw a IOException
multiDir.mkdir(); // will not work
multiDir.mkdirs(); // will make the directory

표준 출력 / 오류 차단 또는 리디렉션

가끔 제대로 설계되지 않은 타사 라이브러리가 원하지 않는 진단을 System.out 또는 System.err 스트림에 작성합니다. 권장되는 해결책은 더 나은 라이브러리를 찾거나 (오픈 소스의 경우) 문제를 수정하고 개발자에게 패치를 제공하는 것입니다.

위의 솔루션을 사용할 수없는 경우 스트림 리디렉션을 고려해야합니다.

명령 줄에서 리디렉션

유닉스, 리눅스 또는 MacOSX 시스템에서는 > 리디렉션을 사용하여 쉘에서 수행 할 수 있습니다. 예 :

$ java -jar app.jar arg1 arg2 > /dev/null 2>&1
$ java -jar app.jar arg1 arg2 > out.log 2> error.log

첫 번째 것은 표준 출력과 표준 오류를 "/ dev / null"로 리디렉션합니다. "/ dev / null"은 해당 스트림에 기록 된 모든 것을 버립니다. 두 번째는 표준 출력을 "out.log"로, 표준 오류를 "error.log"로 리디렉션합니다.

리디렉션에 대한 자세한 내용은 사용중인 명령 셸의 설명서를 참조하십시오. 비슷한 조언은 Windows에 적용됩니다.

또는 Java 응용 프로그램을 시작하는 배치 파일이나 배치 파일에서 리디렉션을 구현할 수 있습니다.

Java 애플리케이션 내 리다이렉션

System.setOut() 및 System.setErr() 사용하여 Java 응용 프로그램 내 에서 스트림을 재 처리 할 수도 있습니다. 예를 들어 다음 코드 조각은 표준 출력과 표준 오류를 2 개의 로그 파일로 리디렉션합니다.

System.setOut(new PrintStream(new FileOutputStream(new File("out.log"))));
System.setErr(new PrintStream(new FileOutputStream(new File("err.log"))));

출력을 완전히 버리려면 잘못된 파일 설명자를 "쓰는"출력 스트림을 만들면됩니다. 이것은 기능상으로 UNIX에서 "/ dev / null"에 쓰는 것과 같습니다.

System.setOut(new PrintStream(new FileOutputStream(new FileDescriptor())));
System.setErr(new PrintStream(new FileOutputStream(new FileDescriptor())));

주의 : setOut 과 setErr 어떻게 사용하는지주의하십시오.

1. 리디렉션은 전체 JVM에 영향을줍니다.
2. 이렇게하면 사용자가 명령 줄에서 스트림을 리디렉션 할 수 없게됩니다.

ZIP 파일의 내용에 액세스하기

Java 7의 FileSystem API는 다른 파일 시스템에서 작동하는 것과 같은 방법으로 Java NIO 파일 API를 사용하여 Zip 파일에서 항목을 읽고 추가 할 수 있습니다.

FileSystem은 사용 후 제대로 닫아야하는 리소스이므로 try-with-resources 블록을 사용해야합니다.

기존 파일에서 읽기

Path pathToZip = Paths.get("path/to/file.zip");
try(FileSystem zipFs = FileSystems.newFileSystem(pathToZip, null)) {
  Path root = zipFs.getPath("/");
  ... //access the content of the zip file same as ordinary files
} catch(IOException ex) {
  ex.printStackTrace();
}

새 파일 만들기

Map<String, String> env = new HashMap<>();  
env.put("create", "true"); //required for creating a new zip file
env.put("encoding", "UTF-8"); //optional: default is UTF-8
URI uri = URI.create("jar:file:/path/to/file.zip");
try (FileSystem zipfs = FileSystems.newFileSystem(uri, env)) {
  Path newFile = zipFs.getPath("/newFile.txt");
  //writing to file
  Files.write(newFile, "Hello world".getBytes());
} catch(IOException ex) {
  ex.printStackTrace();
}