1
// バイトストリームをバッファ付きストリームへ拡張
2
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));

1
System.out.print("Hello！");
2
System.out.println("Hello！");

1
public class PrintStream extends FilterOutputStream
2
    implements Appendable, Closeable {
3
}
4
public class PrintWriter extends Writer {
5
}

1
// openAndDelete パラメータはデフォルト falseで、ファイルを開くが削除はされない
2
public RandomAccessFile(File file, String mode)
3
    throws FileNotFoundException {
4
    this(file, mode, false);
5
}
6
// プライベートメソッド
7
private RandomAccessFile(File file, String mode, boolean openAndDelete)  throws FileNotFoundException{
8
  // 省略
9
}

1
RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
2
System.out.println("読み取り前のオフセット：" + randomAccessFile.getFilePointer() + ",現在読み取り済みの文字" + (char) randomAccessFile.read() + "，読み取り後のオフセット：" + randomAccessFile.getFilePointer());
3
// ポインタの現在のオフセットは6
4
randomAccessFile.seek(6);
5
System.out.println("読み取り前のオフセット：" + randomAccessFile.getFilePointer() + ",現在読み取った文字" + (char) randomAccessFile.read() + "，読み取り後のオフセット：" + randomAccessFile.getFilePointer());
6
// オフセット7の位置からバイトデータを書き込む
7
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});
8
// ポインタは現在0、先頭へ戻る
9
randomAccessFile.seek(0);
10
System.out.println("読み取り前のオフセット：" + randomAccessFile.getFilePointer() + ",現在読み取った文字" + (char) randomAccessFile.read() + "，読み取り後のオフセット：" + randomAccessFile.getFilePointer());

1
RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
2
randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});

1
public BufferedInputStream(InputStream in) {
2
    this(in, DEFAULT_BUFFER_SIZE);
3
}
4

5
public BufferedInputStream(InputStream in, int size) {
6
    super(in);
7
    if (size <= 0) {
8
        throw new IllegalArgumentException("Buffer size <= 0");
9
    }
10
    buf = new byte[size];
11
}

1
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.txt"))) {
2
    int content;
3
    long skip = bis.skip(2);
4
    while ((content = bis.read()) != -1) {
5
        System.out.print((char) content);
6
    }
7
} catch (IOException e) {
8
    e.printStackTrace();
9
}

1
BufferedFileInputStream bfis = new BufferedFileInputStream("input.txt");

1
// InputStreamReader はアダプター、FileInputStream は被適合のクラス
2
InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");
3
// BufferedReader が InputStreamReader の機能を拡張（デコレーター方式）
4
BufferedReader bufferedReader = new BufferedReader(isr);

1
public class InputStreamReader extends Reader {
2
    //デコード用オブジェクト
3
    private final StreamDecoder sd;
4
    public InputStreamReader(InputStream in) {
5
        super(in);
6
        try {
7
            // StreamDecoder オブジェクトを取得
8
            sd = StreamDecoder.forInputStreamReader(in, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // StreamDecoder オブジェクトを用いて具体的な読み取りを実装
14
    public int read() throws IOException {
15
        return sd.read();
16
    }
17
}

1
public class OutputStreamWriter extends Writer {
2
    // エンコード用オブジェクト
3
    private final StreamEncoder se;
4
    public OutputStreamWriter(OutputStream out) {
5
        super(out);
6
        try {
7
           // StreamEncoder オブジェクトを取得
8
            se = StreamEncoder.forOutputStreamWriter(out, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // 書き込み作業を行うために StreamEncoder オブジェクトを用いる
14
    public void write(int c) throws IOException {
15
        se.write(c);
16
    }
17
}

1
// InputStreamReader はアダプター、FileInputStream は適合元のクラス
2
InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");
3
// BufferedReader は InputStreamReader の機能を拡張するデコレーター
4
BufferedReader bufferedReader = new BufferedReader(isr);

1
public class InputStreamReader extends Reader {
2
    //デコード用のオブジェクト
3
    private final StreamDecoder sd;
4
    public InputStreamReader(InputStream in) {
5
        super(in);
6
        try {
7
            // StreamDecoder オブジェクトを取得
8
            sd = StreamDecoder.forInputStreamReader(in, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // デコード用オブジェクトで具体的な読み取りを実行
14
    public int read() throws IOException {
15
        return sd.read();
16
    }
17
}

1
public class OutputStreamWriter extends Writer {
2
    // エンコード用オブジェクト
3
    private final StreamEncoder se;
4
    public OutputStreamWriter(OutputStream out) {
5
        super(out);
6
        try {
7
           // StreamEncoder オブジェクトを取得
8
            se = StreamEncoder.forOutputStreamWriter(out, this, (String)null);
9
        } catch (UnsupportedEncodingException e) {
10
            throw new Error(e);
11
        }
12
    }
13
    // 書き込み作業を行う
14
    public void write(int c) throws IOException {
15
        se.write(c);
16
    }
17
}

1
public FutureTask(Runnable runnable, V result) {
2
    // Executors クラスの callable メソッドを呼ぶ
3
    this.callable = Executors.callable(runnable, result);
4
    this.state = NEW;
5
}

1
// 実際には Executors の内部クラス RunnableAdapter のコンストラクタが呼ばれる
2
public static <T> Callable<T> callable(Runnable task, T result) {
3
    if (task == null)
4
        throw new NullPointerException();
5
    return new RunnableAdapter<T>(task, result);
6
}
7
// アダプター
8
static final class RunnableAdapter<T> implements Callable<T> {
9
    final Runnable task;
10
    final T result;
11
    RunnableAdapter(Runnable task, T result) {
12
        this.task = task;
13
        this.result = result;
14
    }
15
    public T call() {
16
        task.run();
17
        return result;
18
    }
19
}

1
InputStream is = Files.newInputStream(Paths.get(generatorLogoPath))

1
public interface Path
2
    extends Comparable<Path>, Iterable<Path>, Watchable{
3
}
4

5
public interface Watchable {
6
    WatchKey register(WatchService watcher,
7
                      WatchEvent.Kind<?>[] events,
8
                      WatchEvent.Modifier... modifiers)
9
        throws IOException;
10
}

1
// WatchService オブジェクトを作成
2
WatchService watchService = FileSystems.getDefault().newWatchService();
3

4
// 監視対象のディレクトリの Path を初期化
5
Path path = Paths.get("workingDirectory");
6
// この path を WatchService の監視対象として登録
7
WatchKey watchKey = path.register(
8
watchService, StandardWatchEventKinds...);

1
WatchKey register(WatchService watcher,
2
                  WatchEvent.Kind<?>... events)
3
    throws IOException;

1
WatchKey key;
2
while ((key = watchService.take()) != null) {
3
    for (WatchEvent<?> event : key.pollEvents()) {
4
      // WatchEvent オブジェクトのメソッドを呼んで、イベントの具体的情報を出力するなど
5
    }
6
    key.reset();
7
}

1
class PollingWatchService
2
    extends AbstractWatchService
3
{
4
    // daemon thread を用意してファイルの変更をポーリング
5
    private final ScheduledExecutorService scheduledExecutor;
6

7
    PollingWatchService() {
8
        scheduledExecutor = Executors
9
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
10
                 @Override
11
                 public Thread newThread(Runnable r) {
12
                     Thread t = new Thread(r);
13
                     t.setDaemon(true);
14
                     return t;
15
                 }});
16
    }
17

18
  void enable(Set<? extends WatchEvent.Kind<?>> events, long period) {
19
    synchronized (this) {
20
      // 監視イベントを更新
21
      this.events = events;
22

23
        // 定期的なポーリングを開始
24
      Runnable thunk = new Runnable() { public void run() { poll(); }};
25
      this.poller = scheduledExecutor
26
        .scheduleAtFixedRate(thunk, period, period, TimeUnit.SECONDS);
27
    }
28
  }
29
}