IO

Author: turingfly

Java-8/src/io/FileClass.java

@@ -0,0 +1,43 @@
+package io;
+
+import java.io.File;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 13, 2017 10:33:04 PM
+ *
+ */
+public class FileClass {
+
+	public void creat() {
+		System.out.println(java.io.File.separator); // /
+		File parent = new File("/home/smith");
+		File child = new File(parent, "data/zoo.txt");
+	}
+
+	public void fileObject() {
+		File file = new File("/usr/local");
+		System.out.println("File Exists: " + file.exists());
+		if (file.exists()) {
+			System.out.println("Absolute Path: " + file.getAbsolutePath());
+			System.out.println("Is Directory: " + file.isDirectory());
+			System.out.println("Parent Path: " + file.getParent());
+			if (file.isFile()) {
+				System.out.println("File size: " + file.length());
+				System.out.println("File LastModified: " + file.lastModified());
+			} else {
+				for (File subfile : file.listFiles()) {
+					System.out.println("\t" + subfile.getName());
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		FileClass fc = new FileClass();
+		fc.creat();
+		fc.fileObject();
+	}
+
+}

Java-8/src/io/Streams.java

@@ -0,0 +1,56 @@
+package io;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 13, 2017 10:41:57 PM
+ * 
+ *         The java.io API defines two sets of classes for reading and writing
+ *         streams: those with Stream in their name and those with Reader /
+ *         Writer in their name.
+ * 
+ *         Differences between Streams and Readers/Writers 
+ *         1. The stream classes are used for inputting and outputting all 
+ *         types of binary or byte data. 
+ *         2. The reader and writer classes are used for inputting and
+ *         outputting only character and String data.
+ */
+public class Streams {
+
+	/**
+	 * 
+	 * A low-level stream connects directly with the source of the data, such as
+	 * a file, an array, or a String
+	 */
+	public void lowLevelStreams() {
+
+	}
+
+	/**
+	 * A high-level stream is built on top of another stream using wrapping.
+	 * Wrapping is the process by which an instance is passed to the constructor
+	 * of another class and operations on the resulting instance are filtered
+	 * and applied to the original instance.
+	 */
+	public void highLevelStreasm() {
+
+	}
+
+	/**
+	 * The java.io library defines four abstract classes that are the parents of
+	 * all stream classes defined within the API: InputStream , OutputStream ,
+	 * Reader , and Writer .
+	 * 
+	 * The constructors of high-level streams often take a reference to the
+	 * abstract class. For example, BufferedWriter takes a Writer object as
+	 * input, which allows it to take any subclass of Writer .
+	 */
+	public void streamBaseClasses() {
+
+	}
+
+	public static void main(String[] args) {
+		Streams stream = new Streams();
+
+	}
+}

Java-8/src/io/StreamsContinue.java

@@ -0,0 +1,85 @@
+package io;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 13, 2017 11:03:58 PM
+ *
+ */
+public class StreamsContinue {
+	// FileInputStream
+	// FileOutputStream
+	public void fileInputOutputStream() throws IOException {
+		File source = new File("Zoo.class");
+		File destination = new File("ZooCopy.class");
+		try (InputStream in = new FileInputStream(source); 
+				OutputStream out = new FileOutputStream(destination)) {
+			int b;
+			while ((b = in.read()) != -1) {
+				out.write(b);
+			}
+		}
+	}
+
+	/**
+	 * Instead of reading the data one byte at a time, we use the underlying
+	 * read(byte[]) method of BufferedInputStream , which returns the number of
+	 * bytes read into the provided byte array.
+	 * 
+	 * Why use the buffered classes?
+	 * 
+	 * The BufferedInputStream class is capable of retrieving and storing in
+	 * memory more data than you might request with a single read() call. For
+	 * successive calls to the read() method with small byte arrays, this would
+	 * be faster in a wide variety of situations, since the data can be returned
+	 * directly from memory without going to the file system.
+	 */
+	public void bufferedInputOutputStream() throws IOException {
+		File source = new File("Zoo.class");
+		File destination = new File("ZooCopy.class");
+		try (InputStream in = new BufferedInputStream(new FileInputStream(source));
+				OutputStream out = new BufferedOutputStream(new FileOutputStream(destination))) {
+			byte[] buffer = new byte[1024];
+			int lengthRead;
+			while ((lengthRead = in.read(buffer)) > 0) {
+				out.write(buffer, 0, lengthRead);
+				// Ensure that the written data actually makes it to disk before
+				// the next buffer of data is read.
+				out.flush();
+			}
+		}
+	}
+
+	public void fileReaderWiter() throws IOException {
+
+	}
+
+	// BufferedReader
+	public static List<String> readFile(File source) throws IOException {
+		List<String> data = new ArrayList<String>();
+		try (BufferedReader reader = new BufferedReader(new FileReader(source))) {
+			String s;
+			while ((s = reader.readLine()) != null) {
+				data.add(s);
+			}
+		}
+		return data;
+	}
+
+	// BufferedWriter
+	public static void writeFile(List<String> data, File destination) throws IOException {
+		try (BufferedWriter writer = new BufferedWriter(new FileWriter(destination))) {
+			for (String s : data) {
+				writer.write(s);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+
+	}
+}