测试mybatis

Author: gitking

src/com/yale/test/io/ByteArrayInputStreamDemo.java

@@ -24,5 +24,14 @@ public static void main(String[] args) throws IOException {
 		System.out.println(output);//直接输出对象,调用toString()方法
 		input.close();
 		output.close();
+		
+		//ByteArrayInputStream实际上是把一个byte[]数组在内存中变成一个InputStream
+		byte[] data = {72, 101, 108, 108, 111, 33};
+		try(InputStream inpub = new ByteArrayInputStream(data)) {
+			int n;
+			while ((n = inpub.read()) != -1) {
+				System.out.println("一次读一个字节byte:" + (char)n);
+			}
+		}
 	}
 }

src/com/yale/test/io/FileTest.java

@@ -5,17 +5,50 @@
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 public class FileTest {
 	public static void main (String[] args) throws IOException {
 
-	
+		/*
+		 * 注意Windows平台使用\作为路径分隔符，在Java字符串中需要用\\表示一个\。Linux平台使用/作为路径分隔符：
+		 * 可以用.表示当前目录，..表示上级目录。
+		 * File对象有3种形式表示的路径，一种是getPath()，返回构造方法传入的路径，一种是getAbsolutePath()，返回绝对路径，
+		 * 一种是getCanonicalPath，它和绝对路径类似，但是返回的是规范路径。
+		 */
+		
+		File wf = new File("C:\\Windows\\notepad1.exe");
+		System.out.println("删除文件:" + wf.delete());
+		
+		File linuxF = new File("/usr/bin/javac");
+		
+		File ff = new File("..");
+		System.out.println("..:" + ff.getPath());
+		System.out.println("绝对路径:" + ff.getAbsolutePath());
+		System.out.println("规范路径:" + ff.getCanonicalPath());
+		
+		System.out.println("文件是否可读:" + ff.canRead());
+		System.out.println("文件是否可写(对目录而言，是否可执行表示能否列出它包含的文件和子目录。):" + ff.canWrite());
+		System.out.println("文件是否执行:" + ff.canExecute());
+		System.out.println("文件字节大小:" + ff.length());
+		
+		File f = File.createTempFile("temp-", ".txt");//创建一个临时文件
+		f.deleteOnExit();//VM退出时自动删除
+		System.out.println("临时文件的路径:" + f.getAbsolutePath());
+		
+		//因为Windows和Linux的路径分隔符不同，File对象有一个静态变量用于表示当前平台的系统分隔符：
+		System.out.println("根据当前平台打印" + File.separator);// 根据当前平台打印"\"或"/"
+		
 		File file = new File("file.txt");
 		System.out.println("判断路径是否是一个文件" + file.isFile());
 
+		
+		
 		//下面这个俩个构造方法是一个意思
 		//File file = new File("d:\\javaio\\file.txt");
 		//File file = new File("fd:\\javaio", "file.txt");
@@ -65,5 +98,43 @@ public static void main (String[] args) throws IOException {
 			in.close();
 			System.out.println(file.getAbsolutePath() + "存在");
 		}
+		
+		//当File对象表示一个目录时，可以使用list()和listFiles()列出目录下的文件和子目录名。listFiles()提供了一系列重载方法，可以过滤不想要的文件和目录：
+		File flist = new File("C:\\Windows");
+		File[] fs1 = flist.listFiles();
+		printFiles(fs1);
+		
+		File[] fs2 = flist.listFiles(new FilenameFilter(){
+			@Override
+			public boolean accept(File dir, String name){
+				return name.endsWith(".exe");
+			}
+		});
+		printFiles(fs2);
+		
+		//Java标准库还提供了一个Path对象，它位于java.nio.file包。Path对象和File对象类似，但操作更加简单：
+		//如果需要对目录进行复杂的拼接、遍历等操作，使用Path对象更方便。
+		Path p1 = Paths.get(".", "project", "strudy");// 构造一个Path对象
+		System.out.println("Paht:" + p1);
+		Path p2 = p1.toAbsolutePath();//转换为绝对路径
+		System.out.println(p2);
+		Path p3 = p2.normalize();// 转换为规范路径
+		System.out.println(p3);
+		File fp = p3.toFile();//转换为File对象
+		System.out.println(fp);
+		for (Path p: Paths.get("..").toAbsolutePath()) {
+			System.out.println("可以直接遍历p:" + p);
+		}
+		
+	}
+	
+	static void printFiles(File[] files) {
+		System.out.println("=============");
+		if (files != null) {
+			for (File f: files) {
+				System.out.println(f);
+			}
+		}
+		System.out.println("=============");
 	}
 }

src/com/yale/test/io/file/Copy.java

@@ -57,6 +57,8 @@ public static void copyHandle(InputStream in, OutputStream output) throws IOExce
 		int temp = 0;//读取到的数据长度
 		do {
 			temp = in.read();//一次读一个字节,效率极低,工作中绝对不用
+			
+			//这个方法会写入一个字节到输出流。要注意的是，虽然传入的是int参数，但只会写入一个字节，即只写入int最低8位表示字节的部分（相当于b & 0xff）。
 			output.write(temp);
 		} while(temp != -1);
 		long end = System.currentTimeMillis();

src/com/yale/test/io/file/FileInputStreamDeom.java

@@ -6,6 +6,9 @@
 import java.io.IOException;
 import java.io.InputStream;
 
+/*
+ * 如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。
+ */
 public class FileInputStreamDeom {
 
 	public static void main(String[] args) throws IOException {

src/com/yale/test/io/file/FileOutputStreamDemo.java

@@ -33,6 +33,16 @@ public static void main(String[] args) throws IOException {
 			String msg = "www.mldn.cn";
 			os.write(msg.getBytes());//将msg转换为字节,写入文件
 			//flush会把内容,立马写到硬盘里面去,如果你开发servlet,往浏览器里面输出东西,你不能调用flush方法,因为你flush的时候,代码还不知道把内容写往哪里,浏览器不是你本地文件
+			/*
+			 * 要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。
+			 * 为什么要有flush()？因为向磁盘、网络写入数据的时候，出于效率的考虑，操作系统并不是输出一个字节就立刻写入到文件或者发送到网络，而是把输出的字节先放到内存的一个缓冲区里（本质上就是一个byte[]数组），等到缓冲区写满了，再一次性写入文件或者网络。对于很多IO设备来说，一次写一个字节和一次写1000个字节，花费的时间几乎是完全一样的，所以OutputStream有个flush()方法，能强制把缓冲区内容输出。
+			 * 通常情况下，我们不需要调用这个flush()方法，因为缓冲区写满了OutputStream会自动调用它，并且，在调用close()方法关闭OutputStream之前，也会自动调用flush()方法。
+			 * 但是，在某些情况下，我们必须手动调用flush()方法。举个栗子：
+			 * 小明正在开发一款在线聊天软件，当用户输入一句话后，就通过OutputStream的write()方法写入网络流。小明测试的时候发现，发送方输入后，接收方根本收不到任何信息，怎么肥四？
+			 * 原因就在于写入网络流是先写入内存缓冲区，等缓冲区满了才会一次性发送到网络。如果缓冲区大小是4K，则发送方要敲几千个字符后，操作系统才会把缓冲区的内容发送出去，这个时候，接收方会一次性收到大量消息。
+			 * 解决办法就是每输入一句话后，立刻调用flush()，不管当前缓冲区是否已满，强迫操作系统把缓冲区的内容立刻发送出去。
+			 * 实际上，InputStream也有缓冲区。例如，从FileInputStream读取一个字节时，操作系统往往会一次性读取若干字节到缓冲区，并维护一个指针指向未读的缓冲区。然后，每次我们调用int read()读取下一个字节时，可以直接返回缓冲区的下一个字节，避免每次读一个字节都导致IO操作。当缓冲区全部读完后继续调用read()，则会触发操作系统的下一次读取并再次填满缓冲区。
+			 */
 			os.flush();//即使下面的代码报错,也能把内容写到硬盘里面
 			//int sdf = 1/0;
 			msg = "www.mldn.cn\r\n";//换行

src/com/yale/test/io/file/ReaderDemo.java

@@ -6,6 +6,9 @@
 import java.io.IOException;
 import java.io.Reader;
 
+/*
+ * 如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。
+ */
 public class ReaderDemo {
 	public static void main(String[] args) throws IOException {
 		File file = new File("d:" + File.separator + "JavaDemo" + File.separator + "Writer.txt");

src/com/yale/test/io/file/TestAutoCloseable.java

@@ -1,5 +1,12 @@
 package com.yale.test.io.file;
 
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
 class Message implements AutoCloseable{
 	public Message() {
 		System.out.println("AutoCloseable接口是JDK1.7才有的接口");
@@ -17,10 +24,25 @@ public void close() throws Exception {
 public class TestAutoCloseable {
 
 	public static void main(String[] args) {
+		/*
+		 * 编译器只看try(resource = ...)中的对象是否实现了java.lang.AutoCloseable接口，如果实现了，就自动加上finally语句并调用close()方法。
+		 * InputStream和OutputStream都实现了这个接口，因此，都可以用在try(resource)中。
+		 */
 		try (Message msg = new Message()){//必须在try语句里面定义对象
 			msg.print();
 		} catch (Exception e) {
 			 e.printStackTrace();
 		}
+		
+		// 同时操作多个AutoCloseable资源时，在try(resource) { ... }语句中可以同时写出多个资源，用;隔开。例如，同时读写两个文件：
+		try (InputStream input = new FileInputStream("input.txt");
+		     OutputStream output = new FileOutputStream("output.txt"))
+		{
+		    input.read(); // transferTo的作用是?
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
 	}
 }

src/com/yale/test/io/file/ZipInputStreamDemo.java

@@ -0,0 +1,87 @@
+package com.yale.test.io.file;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+/*
+ * ZipInputStream是一种FilterInputStream，它可以直接读取zip包的内容：
+ * ┌───────────────────┐
+│    InputStream    │
+└───────────────────┘
+          ▲
+          │
+┌───────────────────┐
+│ FilterInputStream │
+└───────────────────┘
+          ▲
+          │
+┌───────────────────┐
+│InflaterInputStream│
+└───────────────────┘
+          ▲
+          │
+┌───────────────────┐
+│  ZipInputStream   │
+└───────────────────┘
+          ▲
+          │
+┌───────────────────┐
+│  JarInputStream   │
+└───────────────────┘
+
+另一个JarInputStream是从ZipInputStream派生，它增加的主要功能是直接读取jar文件里面的MANIFEST.MF文件。
+因为本质上jar包就是zip包，只是额外附加了一些固定的描述文件。
+ * 
+ */
+public class ZipInputStreamDemo {
+
+	public static void main(String[] args) {
+		/*
+		 * 读取zip包
+		 * 我们要创建一个ZipInputStream，通常是传入一个FileInputStream作为数据源，然后，循环调用getNextEntry()，直到返回null，表示zip流结束。
+		 * 一个ZipEntry表示一个压缩文件或目录，如果是压缩文件，我们就用read()方法不断读取，直到返回-1：
+		 */
+		try(ZipInputStream zip = new ZipInputStream(new FileInputStream(""))) {
+			ZipEntry entry = null;
+			while ((entry = zip.getNextEntry()) != null) {
+				String name = entry.getName();
+				if (!entry.isDirectory()) {
+					int n;
+					while ((n = zip.read()) != -1) {
+						
+					}
+				}
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+		/*
+		 * 读取zip包
+		 * 我们来看看ZipInputStream的基本用法。
+		 * 我们要创建一个ZipInputStream，通常是传入一个FileInputStream作为数据源，然后，循环调用getNextEntry()，直到返回null，表示zip流结束。
+		 * 一个ZipEntry表示一个压缩文件或目录，如果是压缩文件，我们就用read()方法不断读取，直到返回-1：
+		 * 下面的代码没有考虑文件的目录结构。如果要实现目录层次结构，new ZipEntry(name)传入的name要用相对路径。
+		 */
+		try(ZipOutputStream zip = new ZipOutputStream(new FileOutputStream(""))){
+			File[] files = new File("").listFiles();
+			for (File file: files) {
+				zip.putNextEntry(new ZipEntry(file.getName()));
+				//zip.write(getFileDataAsBytes(file));
+				zip.closeEntry();
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/com/yale/test/io/imooc/BufferedReaderDemo.java

@@ -12,6 +12,10 @@
 public class BufferedReaderDemo {
 
 	public static void main(String[] args) throws IOException {
+		/*
+		 * 注意到在叠加多个FilterInputStream，我们只需要持有最外层的InputStream，并且，当最外层的InputStream关闭时（在try(resource)块的结束处自动关闭），
+		 * 内层的InputStream的close()方法也会被自动调用，并最终调用到最核心的“基础”InputStream，因此不存在资源泄露。
+		 */
 		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:" + File.separator + "JavaDemo" + File.separator + "info2.txt")));
 		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:" + File.separator + "JavaDemo" + File.separator + "info3.txt")));
 

src/com/yale/test/io/imooc/FileOutputStreamDemo.java

@@ -4,6 +4,19 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 
+/*
+ * 如果数据源不是文本，就只能使用InputStream，如果数据源是文本，使用Reader更方便一些。Writer和OutputStream是类似的。
+ * 同步和异步
+ * 同步IO是指，读写IO时代码必须等待数据返回后才继续执行后续代码，它的优点是代码编写简单，缺点是CPU执行效率低。
+ * 而异步IO是指，读写IO时仅发出请求，然后立刻执行后续代码，它的优点是CPU执行效率高，缺点是代码编写复杂。
+ * Java标准库的包java.io提供了同步IO，而java.nio则是异步IO。上面我们讨论的InputStream、OutputStream、Reader和Writer都是同步IO的抽象类，对应的具体实现类，以文件为例，有FileInputStream、FileOutputStream、FileReader和FileWriter。
+ * 本节我们只讨论Java的同步IO，即输入/输出流的IO模型。
+ * Java的IO标准库提供的InputStream根据来源可以包括：
+    FileInputStream：从文件读取数据，是最终数据源；
+    ServletInputStream：从HTTP请求读取数据，是最终数据源；
+    Socket.getInputStream()：从TCP连接读取数据，是最终数据源；
+    GZIPInputStream
+ */
 public class FileOutputStreamDemo {
 
 	public static void main(String[] args) throws IOException {