chapter.java.io.xml

<?xml version="1.0" encoding="UTF-8"?>
<chapter id="index"><?dbhtml dir="io" ?>
	<title>IO</title>
	<section id="File">
		<title>取出文件名中的扩展名</title>
		<programlisting>
		<![CDATA[
	File file = new File("HelloWorld.jpeg");
	String fileName = file.getName();
	String suffix = fileName.substring(fileName.lastIndexOf(".") + 1);
	System.out.println(suffix);
		
		]]>
		</programlisting>
		<section id="getAbsolutePath()">
			<title>getAbsolutePath() 获取绝对路径</title>
			<programlisting>
			<![CDATA[
	File configFile = new File(System.getProperty("user.dir") + configPath);
	System.out.printf("configFile : %s\n", configFile.getAbsolutePath());			
			]]>
			</programlisting>
		</section>
		<section id="File.mkdir()">
			<title>创建目录 mkdir()</title>
			<programlisting>
			<![CDATA[
//判断cache目录是否存在的代码，如果不存在则创建cache目录
String path="/tmp/cache";
File dirname = new File(path);

//目录不存在  
if (!dirname.isDirectory()) 
{ 
     dirname.mkdir(); //创建目录
} 			
			]]>
			</programlisting>
		</section>
		<section>
			<title>文件删除</title>
			<programlisting>
			<![CDATA[
    public static boolean delete(String pathname) {
        boolean status = false;
        File file = new File(pathname);
        if (file.isFile() && file.exists()) {
            status = file.delete();
        }
        return status;
    }			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
    public static void deleteOnExit(String pathname) {
        File file = new File(pathname);
        file.deleteOnExit();
    }
			]]>
			</programlisting>
			<para>演示</para>
			<programlisting>
			<![CDATA[
public class Test {
    public static void main(String[] args) throws IOException {
        File dir = new File("d:\\test");
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File("d:\\test\\a.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
        new FileInputStream(file);

        boolean delete = file.delete();
        System.out.println(delete ? "删除成功！" : "删除失败！");
    }
}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>获取路径中目录和文件名</title>
			<programlisting>
			<![CDATA[
import java.io.File;

public class GetDirectory {
    public static void main(String[] args) {
        String path = "development/2026-03-01/5e021a21153a48828a2a19283b03ebaa/家庭用车选择丰田双擎的优势(甘特图).svg";
        
        File file = new File(path);
        // 获取文件所在的目录
        String directory = file.getParent();
        
        System.out.println("目录路径：" + directory);
    }
}    
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
import java.io.File;

public class FileNameExtractor {
    public static void main(String[] args) {
        String path = "development/2026-03-01/5e021a21153a48828a2a19283b03ebaa/家庭用车选择丰田双擎的优势(甘特图).svg";
        
        File file = new File(path);
        String fileName = file.getName(); // 直接获取文件名
        
        System.out.println("提取到的文件名：" + fileName);
    }
}
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
public class FileNameExtractor {
    public static void main(String[] args) {
        String path = "development/2026-03-01/5e021a21153a48828a2a19283b03ebaa/家庭用车选择丰田双擎的优势(甘特图).svg";
        
        // 按 / 分割，取最后一段就是文件名
        String fileName = path.split("/")[path.split("/").length - 1];
        
        System.out.println("提取到的文件名：" + fileName);
    }
}			
			]]>
			</programlisting>
		</section>
		<section id="File.createTempFile">
			<title>临时文件</title>
			<programlisting>
		<![CDATA[
package cn.netkiller.file;

import java.io.File;
import java.io.IOException;

public class CreateTempFileExample
{
    public static void main(String[] args)
    {	
    
    	try{
    		
    	   //create a temp file
    	   File temp = File.createTempFile("temp-file-name", ".tmp"); 
    		
    	   System.out.println("Temp file : " + temp.getAbsolutePath());
    		
    	}catch(IOException e){
    		
    	   e.printStackTrace();
    		
    	}
    	
    }
}
		]]>
			</programlisting>
			<para>Temp file :
				C:\Users\neo\AppData\Local\Temp\temp-file-name623426.tmp
			</para>
			<para>指定目录创建临时文件，运行之后将会在 /tmp/convert 目录中创建文件</para>
			<programlisting>
		<![CDATA[
	@SneakyThrows
    public InputStream convertInputStreamAmrToPcm(InputStream inputStreamAmr) {
//        UUID uuid = UUID.randomUUID();
//        String filename = uuid.toString();
        String filename = "convert-";

        File source = File.createTempFile(filename, ".amr", new File("/tmp/convert"));
        File target = File.createTempFile(filename, ".pcm", new File("/tmp/convert"));

        if (!target.getParentFile().isDirectory()) {
            boolean directory = target.getParentFile().mkdirs();
        }

        log.info("Source: {}, Target: {}", source.getAbsolutePath(), target.getAbsolutePath());
        source.deleteOnExit();
        target.deleteOnExit();
        inputStreamAmr.transferTo(new FileOutputStream(source));
        boolean status = audioFormatConversion(source, target);
        log.info("Amr To Pcm: {}", status);
        if (!status) {
            return null;
        }
        InputStream inputStream = new FileInputStream(target);

        return inputStream;
    }		
		]]>
			</programlisting>
		</section>
	</section>

	<section id="java.io.FileWriter">
		<title>FileWriter 文本写入文件</title>
		<programlisting>
		<![CDATA[
import java.io.*;

public class Main {

    public static void main(String[] args) {

        try {
            String str = "SomeMoreTextIsHere";
            File newTextFile = new File("thetextfile.txt");

            FileWriter fw = new FileWriter(newTextFile);
            fw.write(str);
            fw.close();

        } catch (IOException iox) {
            //do stuff with exception
            iox.printStackTrace();
        }
    }
}		
		]]>

		</programlisting>
	</section>
	<section id="java.nio.file">
		<title>Files</title>
		<section>
			<title>删除文件</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

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

public class FileDirectory {
    public static void main(String[] args) throws IOException {
        //如果文件不存在，抛出NoSuchFileException
        //如果文件夹里面包含文件，抛出DirectoryNotEmptyException
        Path path = Paths.get("D:\\data\test");
        Files.delete(path);   //返回值void
        
    }
}
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
    //如果文件不存在，返回false，表示删除失败(文件不存在)
	//如果文件夹里面包含文件，抛出DirectoryNotEmptyException
    private static void deleteIfExists() throws IOException {
        Path path = Paths.get("D:\data\test1");
        boolean result = Files.deleteIfExists(path);
        System.out.println(result);
    }

    private static void deleteDirectoryStream(Path path) {
        try {
            Files.delete(path);
            System.out.printf("删除文件成功：%s%n",path.toString());
        } catch (IOException e) {
            System.err.printf("无法删除的路径 %s%n%s", path, e);
        }
    }
    
    // 递归删除目录，使用Files.walk遍历文件夹，然后返回 Stream<Path>，接着递归调用删除目录方法
    private static void testDeleteFileDir6() throws IOException {
        createMoreFiles();
        Path path = Paths.get("D:\data\");

        try (Stream<Path> walk = Files.walk(path)) {
            walk.sorted(Comparator.reverseOrder())
                    .forEach(DeleteFileDir::deleteDirectoryStream);
        }

    }
			]]>
			</programlisting>
			<para>walkFileTree与FileVisitor配合使用，walkFileTree方法遍历整个文件目录树，使用FileVisitor处理遍历结果（文件或文件夹）
			</para>
			<programlisting>
			<![CDATA[
	// FileVisitor的postVisitDirectory方法，注意方法中的“post”表示“后去做……”的意思，所以用来文件都处理完成之后再去处理文件夹，所以使用这个方法删除文件夹就可以有效避免文件夹内容不为空的异常，因为在去删除文件夹之前，该文件夹里面的文件已经被删除了。
    private static void walkFileTree() throws IOException {
        Path path = Paths.get("D:\\data");

        Files.walkFileTree(path,
                new SimpleFileVisitor<Path>() {
                    // 先去遍历删除文件
                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                        Files.delete(file);
                        System.out.printf("删除文件 : %s%n", file);
                        return FileVisitResult.CONTINUE;
                    }

                    // 再去遍历删除目录
                    @Override
                    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                        Files.delete(dir);
                        System.out.printf("删除文件夹: %s%n", dir);
                        return FileVisitResult.CONTINUE;
                    }

                }
        );

    }			
			]]>
			</programlisting>
		</section>
		<section>
			<title>创建目录和文件</title>
			<programlisting>
			<![CDATA[
    private  void createMoreFiles() throws IOException {
        Files.createDirectories(Paths.get("D:\data\test1\test2\test3\test4\test5\"));
        Files.write(Paths.get("D:\data\test1\test2\test2.log"), "hello".getBytes());
        Files.write(Paths.get("D:\data\test1\test2\test3\test3.log"), "hello".getBytes());
    }			
			]]>
			</programlisting>
		</section>
	</section>
	<section id="BufferedWriter">
		<title>BufferedWriter</title>
		<programlisting>
		<![CDATA[
 	File file = new File( fileName );

    // if file doesnt exists, then create it 
    if ( ! file.exists( ) )
    {
        file.createNewFile( );
    }

    FileWriter fw = new FileWriter( file.getAbsoluteFile( ) );
    BufferedWriter bw = new BufferedWriter( fw );
    bw.write( text );
    bw.close( );		
		]]>
		</programlisting>
	</section>


	<section id="PrintWriter">
		<title>PrintWriter</title>
		<programlisting>
		<![CDATA[
package cn.netkiller.io;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class PrintWriterTest {

	public PrintWriterTest() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		PrintWriter output = new PrintWriter("temp.txt");
		output.print("Welcome to Java!");
		output.close();
	}

}
		]]>
		</programlisting>
	</section>

	<section id="FileOutputStream">
		<title>FileOutputStream</title>
		<programlisting>
		<![CDATA[
byte[] data = ...

FileOutputStream fos = new FileOutputStream(filePath)
fos.write(data, 0, data.length);
fos.flush();
fos.close();		
		]]>
		</programlisting>
		<section id="FileOutputStream.try">
			<title>FileOutputStream + try 用法</title>
			<programlisting>
			<![CDATA[
	try (FileOutputStream fileOutputStream = new FileOutputStream(filePath)) {
		...
		fileOutputStream.write(audioBuffer);
		...
	} catch (Exception e) {
	    throw new RuntimeException(e);
	}			
			]]>
			</programlisting>
		</section>
		<section id="OutputStreamWriter">
			<title>OutputStreamWriter</title>
			<programlisting>
		<![CDATA[
		File file = new File("/tmp" + File.separator + "netkiller.txt");
		OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file), "utf-8");
		outputStreamWriter.write("Netkiller Java 手札");
		outputStreamWriter.close();		
		]]>
			</programlisting>
		</section>
	</section>
	<section id="FileInputStream">
		<title>FileInputStream</title>
		<programlisting>
		<![CDATA[
File inputFile = new File(filePath);
byte[] data = new byte[inputFile.length()];
FileInputStream fis = new FileInputStream(inputFile);
fis.read(data, 0, data.length);
fis.close();		
		]]>
		</programlisting>
		<section id="InputStreamReader">
			<title>InputStreamReader</title>
			<programlisting>
		<![CDATA[
InputStreamReader stream = new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream(filename));		
		]]>
			</programlisting>
		</section>
		<section id="inputStream.transferTo()">
			<title>inputStream.transferTo()</title>
			<screen>
		<![CDATA[

var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("hello.txt");
var tmp = File.createTempFile("tmp", "txt");
try (var outputStream = new FileOutputStream(tmp)) {
    inputStream.transferTo(outputStream);
}
		]]>
			</screen>
		</section>
	</section>
	<section id="java.util.Scanner">
		<title>Scanner</title>
		<programlisting>
		<![CDATA[
Scanner input = new Scanner(new File("temp.txt"));
System.out.print(input.nextLine());		
		]]>
		</programlisting>
		<programlisting>
		<![CDATA[
package cn.netkiller.io;

import java.io.File;
import java.io.FileNotFoundException;
//import java.io.PrintWriter;
import java.util.Scanner;

public class PrintWriterTest {

	private static Scanner input;

	public PrintWriterTest() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		// PrintWriter output = new PrintWriter("temp.txt");
		// output.print("Welcome to Java!");
		// output.close();

		input = new Scanner(new File("temp.txt"));
		System.out.print(input.nextLine());
	}

}
		]]>
		</programlisting>
		<programlisting>
		<![CDATA[
@Test
void testReadFile1() throws IOException {

   String fileName = "D:\\test\\netkiller\\neo.txt";

   try (Scanner sc = new Scanner(new FileReader(fileName))) {
      while (sc.hasNextLine()) {  //按行读取字符串
         String line = sc.nextLine();
         System.out.println(line);
      }
   }

   try (Scanner sc = new Scanner(new FileReader(fileName))) {
      sc.useDelimiter("\\|");  //分隔符
      while (sc.hasNext()) {   //按分隔符读取字符串
         String str = sc.next();
         System.out.println(str);
      }
   }

   //sc.hasNextInt() 、hasNextFloat() 、基础数据类型等等等等。
   fileName = "D:\\netkiller\\test\\neo.txt";
   try (Scanner sc = new Scanner(new FileReader(fileName))) {
      sc.useDelimiter("\\|");  //分隔符
      while (sc.hasNextInt()) {   //按分隔符读取Int
          int intValue = sc.nextInt();
         System.out.println(intValue);
      }
   }
}		
		]]>
		</programlisting>
	</section>
	<section id="Files">
		<title>Files</title>
		<section>
			<title>Files.lines</title>
			<programlisting>	
			<![CDATA[
@Test
void testReadFile2() throws IOException {
   String fileName = "D:\\test\\netkiller\\neo.txt";

   // 读取文件内容到Stream流中，按行读取
   Stream<String> lines = Files.lines(Paths.get(fileName));

   // 随机行顺序进行数据处理
   lines.forEach(line -> {
      System.out.println(line);
   });
}		
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
// 按文件行顺序进行处理
lines.forEachOrdered(System.out::println);

// 利用CPU多和的能力，进行数据的并行处理parallel()，适合比较大的文件。
lines.parallel().forEachOrdered(System.out::println);			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.readAllLines</title>
			<programlisting>
			<![CDATA[
@Test
void testReadFile3() throws IOException {
   String fileName = "D:\\test\\netkiller\\neo.txt";

   // 转换成List<String>, 要注意java.lang.OutOfMemoryError: Java heap space
   List<String> lines = Files.readAllLines(Paths.get(fileName),
               StandardCharsets.UTF_8);
   lines.forEach(System.out::println);

}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.readAllBytes</title>
			<programlisting>
			<![CDATA[
@Test
void testReadFile5() throws IOException {
   String fileName = "D:\\test\\netkiller\\neo.txt";

   //如果是JDK11用上面的方法，如果不是用这个方法也很容易
   byte[] bytes = Files.readAllBytes(Paths.get(fileName));

   String content = new String(bytes, StandardCharsets.UTF_8);
   System.out.println(content);
}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.newBufferedReader</title>
			<programlisting>
			<![CDATA[
@Test
void testReadFile6() throws IOException {
   String fileName = "D:\\test\\netkiller\\neo.txt";

   // 带缓冲的流读取，默认缓冲区8k
   try (BufferedReader br = new BufferedReader(new FileReader(fileName))){
      String line;
      while ((line = br.readLine()) != null) {
         System.out.println(line);
      }
   }

   //java 8中这样写也可以
   try (BufferedReader br = Files.newBufferedReader(Paths.get(fileName))){
      String line;
      while ((line = br.readLine()) != null) {
         System.out.println(line);
      }
   }

}			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.delete</title>
			<programlisting>
			<![CDATA[
Files.delete(file.toPath());			
			]]>
			</programlisting>
			<para>boolean delete = file.delete(); 传统delete返回false/true没有返回失败原因，而Files则会给出“文件占用/文件不存在/删除目录非空”等原因，同时会抛出异常</para>
			<programlisting>
			<![CDATA[
public class Test {
    public static void main(String[] args) throws IOException {
        File dir = new File("d:\\test");
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File("d:\\test\\a.txt");
        if (!file.exists()) {
            file.createNewFile();
        }
        new FileInputStream(file);

        boolean delete = file.delete();
        System.out.println(delete ? "删除成功！" : "删除失败！");     
    }
}
			]]>
			</programlisting>
		</section>
	</section>
	<section id="file.binary">
		<title>二进制文件</title>
		<section id="binary.int">
			<title>理解二进制文件</title>
			<para>我们运行下面一段程序，向文件 netkiller.bin 中写入一个整形数值 1 ，然后观察文件变化</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(1);
		out.close();		
			]]>
			</programlisting>
			<para>打开终端，使用 xxd 命令查看二进制文件</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.bin 
00000000: 00000000 00000000 00000000 00000001                    ....			
			]]>
			</screen>
			<para>可以看到一串二进制 00000000 00000000 00000000
				00000001，运行下面程序可以讲二进制转换为十进制，注意替换掉空格。
			</para>
			<programlisting>
			<![CDATA[
		int n = Integer.valueOf("00000000 00000000 00000000 00000001".replaceAll(" ", ""), 2);
		System.out.println(n);			
			]]>
			</programlisting>
			<para>运行结果是 1 ，为什前面那么多 0 呢？请运行下面一段程序</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(Integer.MAX_VALUE);
		out.close();
			]]>
			</programlisting>
			<para>现在观察结果</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.bin
00000000: 01111111 11111111 11111111 11111111                    ....			
			]]>
			</screen>
			<programlisting>
			<![CDATA[
		int n = Integer.valueOf("01111111 11111111 11111111 11111111".replaceAll(" ", ""), 2);
		System.out.println(n);			
			]]>
			</programlisting>
			<para>输出结果是 2147483647, 这是 int 得最大值，2147483647 + 1 会怎么样呢？</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(Integer.MAX_VALUE + 1);
		out.close();

		System.out.println(Integer.MAX_VALUE + 1);			
			]]>
			</programlisting>
			<para>输出结果是 -2147483648，正确应该是 2147483648
				这就是整形溢出。整形变量得二进制表示方法是4个字节长度32位 00000000 00000000 00000000 00000000 到
				01111111 11111111 11111111 11111111 ， 其中第一位0表示正数1表示负数。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.bin
00000000: 10000000 00000000 00000000 00000000                    ....			
			]]>
			</screen>
			<para>整形溢出演示，超出整形范围怎么办？ 使用 Long 型。</para>
			<screen>
			<![CDATA[
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MAX_VALUE + 1);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MIN_VALUE - 1);

输出结果如下：

2147483647
-2147483648
-2147483648
2147483647			
			]]>
			</screen>
			<para>负数演示</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(-1);
		out.writeInt(Integer.MAX_VALUE + 1);
		out.close();			
			]]>
			</programlisting>
			<para>-1 得结果是 11111111 11111111 11111111 11111111 </para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.bin
00000000: 11111111 11111111 11111111 11111111                    ....			
			]]>
			</screen>
			<para>现在我们存储两个整形数值</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(1);
		out.writeInt(-1);
		out.close();			
			]]>
			</programlisting>
			<para>很清楚的看到里面有两个数值，1 和 -1 </para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 4 -b netkiller.bin
00000000: 00000000 00000000 00000000 00000001  ....
00000004: 11111111 11111111 11111111 11111111  ....			
			]]>
			</screen>
			<para>读取二进制文件中的 int 数据</para>
			<programlisting>
			<![CDATA[
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			int i = in.readInt();
			System.out.println(i);
		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
		</section>
		<section id="binary.byte">
			<title>byte 类型</title>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeByte(1);
		out.close();
			]]>
			</programlisting>
			<para>byte 只占用一个字节8位</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 4 -b netkiller.bin
00000000: 00000001   			
			]]>
			</screen>
			<para>如果写入 -1 结果是，由此得出 第一位 0 是正数，1 是负数，可以得出他的取值范围 -128 ~
				127。超出范围也会溢出。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 4 -b netkiller.bin
00000000: 11111111   			
			]]>
			</screen>
			<para>常常写入最小值与最大值</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeByte(Byte.MIN_VALUE);
		out.writeByte(Byte.MAX_VALUE);
		out.close();			
			]]>
			</programlisting>
			<para>运行结果</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 1 -b netkiller.bin
00000000: 10000000  .
00000001: 01111111  .			
			]]>
			</screen>
			<para>写入一个字符</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeBytes("a");
		out.close();			
			]]>
			</programlisting>
			<para>写入结果</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 1 -b netkiller.bin
00000000: 01100001  a			
			]]>
			</screen>
			<para>从 ASCII 表中查出 01100001 十进制 97 十六进制 61 对应字母 a</para>
			<para>写入一段字符串</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeBytes("http://www.netkiller.cn");
		out.close();			
			]]>
			</programlisting>
			<para>运行结果</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin
00000000: 01101000 01110100 01110100 01110000 00111010 00101111 00101111 01110111  http://w
00000008: 01110111 01110111 00101110 01101110 01100101 01110100 01101011 01101001  ww.netki
00000010: 01101100 01101100 01100101 01110010 00101110 01100011 01101110           ller.cn			
			]]>
			</screen>
			<para>读取二进制文件中的 byte 字符串，readAllBytes() 可以一次读取所有 byte 到 byte[] 中。
			</para>
			<programlisting>
			<![CDATA[
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			System.out.println(new String(in.readAllBytes()));
		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
			<para>readByte() 逐字节读取</para>
			<programlisting>
			<![CDATA[
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			char c = ' ';
			while (true) {
				try {
					c = (char) in.readByte();
					System.out.print(c);

				} catch (EOFException e) {
					System.out.println();
					break;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
			<para>现在我们已经掌握了 byte 的操作方法，现在我们来做一个例子，读取 int 数据，int 是由 4
				个字节组成一组。所以我们每次取 4个字节。
			</para>
			<programlisting>
			<![CDATA[
		// 这个例子中，我们写入三个数值到 netkiller.bin 文件，分别是 1024，-128，2147483647
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(1024);
		out.writeInt(-128);
		out.writeInt(Integer.MAX_VALUE);
		out.close();
			]]>
			</programlisting>
			<para>二进制文件如下</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 4 -b netkiller.bin
00000000: 00000000 00000000 00000100 00000000  ....
00000004: 11111111 11111111 11111111 10000000  ....
00000008: 01111111 11111111 11111111 11111111  ....			
			]]>
			</screen>
			<para>从二进制文件读出 int 数据。</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		FileInputStream stream = new FileInputStream(filename);

		byte[] buffer = new byte[4];

		while (stream.read(buffer) != -1) {
			ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
			System.out.println(byteBuffer.getInt());
		}			
			]]>
			</programlisting>
			<para>运行结果</para>
			<screen>
			<![CDATA[
1024
-128
2147483647			
			]]>
			</screen>
		</section>
		<section id="binary.boolean">
			<title>boolean 布尔型</title>
			<para>我们想文件写入两个布尔类型，一个是 true, 另一个是 false</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeBoolean(true);
		out.writeBoolean(false);
		out.close();			
			]]>
			</programlisting>
			<para>运行结果可以看出 boolean 使用了一个字节，最后一位 1 表示true, 0 表示
				false。所以对于二进制文件最小单位就是 byte 字节，虽然boolean型只需要一个 1 bit
				位，但是存储的最小单位是字节，所以前面需要补7个零 0000000。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 1 -b netkiller.bin
00000000: 00000001  .
00000001: 00000000  .			
			]]>
			</screen>
			<para>使用 ls 命令可以看这个文件占用了 2B（两个字节）</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % ll netkiller.bin 
-rw-r--r--  1 neo  staff     2B Oct 18 13:47 netkiller.bin			
			]]>
			</screen>
			<para>读取二进制文件中的 boolean 数据</para>
			<programlisting>
			<![CDATA[
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			boolean bool = in.readBoolean();
			System.out.println(bool);
		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
		</section>
		<section id="binary.long">
			<title>Long 型</title>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeLong(1);
		out.close();			
			]]>
			</programlisting>
			<para>有了上面 int 型数据的经验，下面一看你就会明白。long 型采用 8 个字节保存数据，是 int
				的一倍。取值范围这里就不多说了，也会存在溢出现象。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin
00000000: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001  ........			
			]]>
			</screen>
			<para>取值范围</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeLong(Long.MIN_VALUE);
		out.writeLong(Long.MAX_VALUE);
		out.close();			
			]]>
			</programlisting>
			<para>输出文件</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin
00000000: 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000  ........
00000008: 01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111  ........			
			]]>
			</screen>
			<para>读取二进制文件中的 long 数据</para>
			<programlisting>
			<![CDATA[
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
		
			long l = in.readLong();
			System.out.println(l);

		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
		</section>
		<section id="binary.char">
			<title>char 类型</title>
			<para>有符号 signed char 类型的范围为 -128~127</para>
			<para>无符号 unsigned char 的范围为0~ 255</para>
			<para>char 与 byte 操作类似，我们首先去 ASCII 表查找字符 A 对应 65，我们将 65
				写入二进制文件。然后读取该字符，输出结果是 A。
			</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeChar(65);
		out.close();
		
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {

			char c = in.readChar();
			System.out.println(c);

		} catch (EOFException e) {
			e.printStackTrace();
		}
			]]>
			</programlisting>
			<para>从二进制文件中我们可以看到 char 类型占用2个字节16位</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 2 -b netkiller.bin
00000000: 00000000 01000001  .A			
			]]>
			</screen>
			<para>使用 writeChars()写入字符串到二进制文件</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeChars("http://www.netkiller.cn");
		out.close();
		
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));

		char c = ' ';
		while (true) {
			try {
				c = in.readChar();
				System.out.print(c);

			} catch (EOFException e) {
				System.out.println();
				break;
			}
		}

			]]>
			</programlisting>
			<para>二进制文件如下，你会发现第一个字节没有用到，很多 00000000 所以如果存储英文 byte 更适合，char 是双倍
				byte 开销。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin 
00000000: 00000000 01101000 00000000 01110100 00000000 01110100 00000000 01110000  .h.t.t.p
00000008: 00000000 00111010 00000000 00101111 00000000 00101111 00000000 01110111  .:././.w
00000010: 00000000 01110111 00000000 01110111 00000000 00101110 00000000 01101110  .w.w...n
00000018: 00000000 01100101 00000000 01110100 00000000 01101011 00000000 01101001  .e.t.k.i
00000020: 00000000 01101100 00000000 01101100 00000000 01100101 00000000 01110010  .l.l.e.r
00000028: 00000000 00101110 00000000 01100011 00000000 01101110                    ...c.n			
			]]>
			</screen>
			<para>存储汉字</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		String s = "陈";
		char name = s.charAt(s.length() - 1);
		out.writeChar(name);
		out.close();
		
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));

		char c = ' ';
		while (true) {
			try {
				c = in.readChar();
				System.out.print(c);

			} catch (EOFException e) {
				System.out.println();
				break;
			}
		}

			]]>
			</programlisting>
			<para>二进制文件如下，使用两个字节表示一个汉字</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 2 -b netkiller.bin
00000000: 10010110 01001000  .H			
			]]>
			</screen>
			<para>转成 Hex 十六进制，得到 96 48 两个数字。</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % hexdump  netkiller.bin 
0000000 96 48                                          
0000002			
			]]>
			</screen>
			<para>现在去搜索引擎搜索“汉字内码”，然后查询“陈”这个汉字，可以看到 Unicode编码16进制就是 96 48</para>
			<para>尝试写入汉字字符串</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeChars("陈景峰");
		out.close();

		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			char c = ' ';
			while (true) {
				try {
					c = in.readChar();
					System.out.print(c);

				} catch (EOFException e) {
					System.out.println();
					break;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
			]]>
			</programlisting>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.bin 
00000000: 10010110 01001000 01100110 01101111 01011100 11110000  .Hfo\.			
			]]>
			</screen>
		</section>
		<section id="binary.utf">
			<title>UTF 字符串</title>
			<para>这次我们使用新的文件名 netkiller.txt</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.txt";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
	
		out.writeUTF("峰");

		out.close();

		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			System.out.println(in.readUTF());
		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
			<para>查看二进制文件，一个汉字怎么这么多字节？</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -b netkiller.txt    
00000000: 00000000 00000011 11100101 10110011 10110000           .....
			]]>
			</screen>
			<para>转成 16 禁止看看。</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % hexdump netkiller.txt
0000000 00 03 e5 b3 b0                                 
0000005					
			]]>
			</screen>
			<para>我们在网上查询 “峰” 字的汉字内码，可以看到UTF-8 内码是 E5 B3 B0。这是因为UTF8使用三个字节存储汉字。
				00000000 00000011 可能是 UTF 标志位，具体我也不太清楚，总之不是 BOM 信息。
			</para>
			<para>我们现在写入一个字符串试试</para>
			<programlisting>
			<![CDATA[
		out.writeUTF("陈景峰");			
			]]>
			</programlisting>
			<para>xxd -s 2 -c 3 表示跳过两个字节，三列显示</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -s 2 -c 3 -b netkiller.txt
00000002: 11101001 10011001 10001000  ...
00000005: 11100110 10011001 10101111  ...
00000008: 11100101 10110011 10110000  ...
			]]>
			</screen>
			<para>UTF字符是可以直接使用文本工具查看的。</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % cat netkiller.txt 
	陈景峰			
			]]>
			</screen>
		</section>
		<section id="binary.short">
			<title>Short 类型</title>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));

		out.writeShort(1);

		out.flush();
		out.close();			
			]]>
			</programlisting>
			<para>输出结果，Short 使用两个字节16位表示。</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 2 -b netkiller.bin
00000000: 00000000 00000001  ..			
			]]>
			</screen>
			<para>Short 分为有符号和无符号类型</para>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));

		out.writeShort(1);
		out.writeShort(1);
		out.writeShort(-1);
		out.writeShort(-1);

		out.flush();
		out.close();


		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
		try {
			System.out.println(in.readShort());
			System.out.println(in.readUnsignedShort());
			System.out.println(in.readShort());
			System.out.println(in.readUnsignedShort());
		} catch (EOFException e) {
			e.printStackTrace();
		}			
			]]>
			</programlisting>
			<para>运行结果</para>
			<screen>
			<![CDATA[
1
1
-1
65535
			]]>
			</screen>
			<para>有符号的取值范围</para>
			<screen>
			<![CDATA[
最小值：Short.MIN_VALUE=-32768 （-2的15此方）
最大值：Short.MAX_VALUE=32767 （2的15次方-1）			
			]]>
			</screen>
			<para>无符号的取值范围是 0 ~ 65535</para>
		</section>
		<section id="binary.float">
			<title>float 单精度浮点类型</title>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));

		out.writeFloat(0);
		out.writeFloat(1.0f);
		out.writeFloat(1.1f);
		out.flush();
		out.close();

		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));

		float c = 0;
		while (true) {
			try {
				c = in.readFloat();
				System.out.println(c);

			} catch (EOFException e) {
				System.out.println();
				break;
			}
		}			
			]]>
			</programlisting>
			<para>float 使用 4 字节 32 为表示浮点类型，float
				不同于前面数据类型，无法直接读取浮点数，需要经过计算才能得出，有点复杂。
			</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 4 -b netkiller.bin
00000000: 00000000 00000000 00000000 00000000  ....
00000004: 00111111 10000000 00000000 00000000  ?...
00000008: 00111111 10001100 11001100 11001101  ?...			
			]]>
			</screen>
			<para>浮点型示意图</para>
			<screen>
			<![CDATA[
 /------------- 32 bit ----------------\
 | 1 |     8  |           23            |
 |--------------------------------------|
 31 30        22                        0
  ^       ^               ^
符号位   指数位     	    尾数部分         32位

首先float二进制是从后向前读。与上面所有类型相反。
符号位(Sign) : 0代表正，1代表为负
指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
尾数部分（Mantissa）：尾数部分


将一个内存存储的float二进制格式转化为十进制的步骤： 
（1）将第22位到第0位的二进制数写出来，在最左边补一位“1”，得到二十四位有效数字。将小数点点在最左边那个“1”的右边。 
（2）取出第29到第23位所表示的值n。当30位是“0”时将n各位求反。当30位是“1”时将n增1。 
（3）将小数点左移n位（当30位是“0”时）或右移n位（当30位是“1”时），得到一个二进制表示的实数。 
（4）将这个二进制实数化为十进制，并根据第31位是“0”还是“1”加上正号或负号即可。


1.0f = 00111111 10000000 00000000 00000000

Sign 31 位是 0 表示正数
Exponent 23~30 位 0111111 1
Mantissa 0~22 位 0000000 00000000 00000000

得到

| 0 | 0111111 1 | 0000000 00000000 00000000 |

具体细节请参考 IEEE R32.24
			]]>
			</screen>
		</section>
		<section id="binary.double">
			<title>double 数据类型</title>
			<programlisting>
			<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeDouble(12.5d);
		out.flush();
		out.close();

		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));

		double d = 0d;
		while (true) {
			try {
				d = in.readDouble();
				System.out.println(d);

			} catch (EOFException e) {
				System.out.println();
				break;
			}
		}			
			]]>
			</programlisting>
			<para>二进制文件</para>
			<screen>
			<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin
00000000: 01000000 00101001 00000000 00000000 00000000 00000000 00000000 00000000  @)......			
			]]>
			</screen>
			<screen>
			<![CDATA[
 /------------------------- 64 bit ------------------------------\
 | 1 |    11    |           52                                    |
 |----------------------------------------------------------------|
 63 62          51                                                0
  ^         ^                  ^
符号位     指数位       	    尾数部分                              64位

首先float二进制是从后向前读。与上面所有类型相反。
符号位(Sign) : 0代表正，1代表为负
指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
尾数部分（Mantissa）：尾数部分
			
详细参加考 IEEE R64.53
			]]>
			</screen>
		</section>
		<section id="binary.exmaple">
			<title>二进制文件操作演示</title>
			<section>
				<title>所有类型演示一遍</title>

				<programlisting>
				<![CDATA[
		String filename = "netkiller.bin";
		DataOutputStream out = new DataOutputStream(new FileOutputStream(filename));
		out.writeInt(1024);
		out.writeShort(255);
		out.writeLong(100000000000L);
		out.writeFloat(3.14f);
		out.writeDouble(3.141592653579d);
		out.writeBoolean(true);
		out.writeChar(165);
		out.writeChars("陈景峰");
		out.writeUTF("Netkiller Java 手札 - http://www.netkiller.cn");
		out.writeChars("这是最后一行\r\n");
		out.flush();
		out.close();

		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));

		System.out.println(in.readInt());
		System.out.println(in.readUnsignedShort());
		System.out.println(in.readLong());
		System.out.println(in.readFloat());
		System.out.println(in.readDouble());
		System.out.println(in.readBoolean());
		System.out.println(in.readChar());

		int i = 0;
		String name = "";
		while (i < 3) {
			try {
				char c = in.readChar();
				name += c;
			} catch (EOFException e) {
				break;
			}
			i++;
		}

		System.out.println(name);
		System.out.println(in.readUTF());
		System.out.println(in.readUTF());		
				]]>
				</programlisting>
				<para>需要注意的一点是 out.writeChars("陈景峰");
					写入char字符串，在读取的时候你需要知道字符串的长度。然后循环取出char数据。
				</para>
				<para>二进制文件内容</para>
				<screen>
				<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % xxd -c 8 -b netkiller.bin
00000000: 00000000 00000000 00000100 00000000 00000000 11111111 00000000 00000000  ........
00000008: 00000000 00010111 01001000 01110110 11101000 00000000 01000000 01001000  ..Hv..@H
00000010: 11110101 11000011 01000000 00001001 00100001 11111011 01010100 01000011  ..@.!.TC
00000018: 11001110 00101000 00000001 00000000 10100101 10010110 01001000 01100110  .(....Hf
00000020: 01101111 01011100 11110000 00000000 00101111 01001110 01100101 01110100  o\../Net
00000028: 01101011 01101001 01101100 01101100 01100101 01110010 00100000 01001010  killer J
00000030: 01100001 01110110 01100001 00100000 11100110 10001001 10001011 11100110  ava ....
00000038: 10011100 10101101 00100000 00101101 00100000 01101000 01110100 01110100  .. - htt
00000040: 01110000 00111010 00101111 00101111 01110111 01110111 01110111 00101110  p://www.
00000048: 01101110 01100101 01110100 01101011 01101001 01101100 01101100 01100101  netkille
00000050: 01110010 00101110 01100011 01101110 10001111 11011001 01100110 00101111  r.cn..f/
00000058: 01100111 00000000 01010100 00001110 01001110 00000000 10001000 01001100  g.T.N..L
00000060: 00000000 00001101 00000000 00001010                                      ....			
				]]>
				</screen>
				<para>16 进制编辑器更好阅读一些</para>
				<screen>
				<![CDATA[
neo@MacBook-Pro ~/workspace/netkiller % hexdump -C netkiller.bin 
00000000  00 00 04 00 00 ff 00 00  00 17 48 76 e8 00 40 48  |..........Hv..@H|
00000010  f5 c3 40 09 21 fb 54 43  ce 28 01 00 a5 96 48 66  |..@.!.TC.(....Hf|
00000020  6f 5c f0 00 2f 4e 65 74  6b 69 6c 6c 65 72 20 4a  |o\../Netkiller J|
00000030  61 76 61 20 e6 89 8b e6  9c ad 20 2d 20 68 74 74  |ava ...... - htt|
00000040  70 3a 2f 2f 77 77 77 2e  6e 65 74 6b 69 6c 6c 65  |p://www.netkille|
00000050  72 2e 63 6e 8f d9 66 2f  67 00 54 0e 4e 00 88 4c  |r.cn..f/g.T.N..L|
00000060  00 0d 00 0a                                       |....|
00000064			
				]]>
				</screen>
			</section>
			<section>
				<title>检查文件是否是 png 文件</title>
				<programlisting>
				<![CDATA[
package cn.netkiller.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

public class PngFile {

	private static InputStream inputStream;

	public PngFile() {
	}

	public static void main(String[] args) throws FileNotFoundException {

		int[] pngSignature = { 137, 80, 78, 71, 13, 10, 26, 10 };

		try {
			inputStream = new FileInputStream("/Users/neo/Downloads/NBRC.png");

			byte[] headerBytes = new byte[8];
			inputStream.read(headerBytes);

			// for (byte b : headerBytes) {
			// System.out.println(b);
			// }

			int[] pngHeader = new int[8];

			for (int i = 0; i < headerBytes.length; i++) {
				pngHeader[i] = (int) headerBytes[i] & 0xff;
			}

			if (Arrays.equals(pngHeader, pngSignature)) {
				System.out.println("This is a PNG file! ");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

}				
				]]>
				</programlisting>
			</section>
		</section>
	</section>
	<section id="java.io.path">
		<title>路径操作汇总</title>
		<section id="resources.path">
			<title>获得 Resource 下文件路径</title>
			<programlisting>
		<![CDATA[
String path = Main.class.getClassLoader().getResource("netkiller-config.yaml").getPath();
String path = Main.class.getClassLoader().getResource("netkiller-config.yaml").getPath();
		]]>
			</programlisting>
		</section>
		<section>
			<title>URI/相对/拒绝/路径/文件</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.io.File;

public class Test {


    public Test() {
    }
    
    public static void main(String[] args) throws Exception {
        String path = "src/java/resources";
        File file = new File(path);
        System.out.println("toURI: " + file.toURI());
        System.out.println("toURL: " + file.toURI().toURL());

        System.out.println("getParent: " + file.getParent());
        System.out.println("getParentFile: " + file.getParentFile());

        System.out.println("getAbsolutePath: " + file.getAbsolutePath());
        System.out.println("getAbsoluteFile: " + file.getAbsoluteFile());

        System.out.println("getCanonicalPath: " + file.getCanonicalPath());
        System.out.println("getCanonicalFile: " + file.getCanonicalFile());

        System.out.println("getPath: " + file.getPath());
        System.out.println("getName: " + file.getName());

        System.out.println("getFreeSpace: " + file.getFreeSpace());
        System.out.println("getTotalSpace: " + file.getTotalSpace());
        System.out.println("getUsableSpace: " + file.getUsableSpace());
    }

}
			]]>
			</programlisting>
			<para>输出结果</para>
			<screen>
			<![CDATA[
toURI: file:/Users/neo/workspace/watch/src/java/resources
toURL: file:/Users/neo/workspace/watch/src/java/resources
getParent: src/java
getParentFile: src/java
getAbsolutePath: /Users/neo/workspace/watch/src/java/resources
getAbsoluteFile: /Users/neo/workspace/watch/src/java/resources
getCanonicalPath: /Users/neo/workspace/watch/src/java/resources
getCanonicalFile: /Users/neo/workspace/watch/src/java/resources
getPath: src/java/resources
getName: resources
getFreeSpace: 0
getTotalSpace: 0
getUsableSpace: 0			
			]]>
			</screen>
		</section>
		<section>
			<title>URL 操作汇总</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.io.InputStream;
import java.net.URL;

public class Test {
    public Test() {
    }

    public static void main(String[] args) throws Exception {

        URL url = new URL("https://neo:password@www.netkiller.cn/linux/index.html?id=1&cid=2#openssh");

        System.out.println("getProtocol: " + url.getProtocol());
        System.out.println("getUserInfo: " + url.getUserInfo());
        System.out.println("getHost: " + url.getHost());
        System.out.println("getDefaultPort: " + url.getDefaultPort());
        System.out.println("getFile: " + url.getFile());

        System.out.println("getPath: " + url.getPath());
        System.out.println("getQuery: " + url.getQuery());
        System.out.println("getRef: " + url.getRef());

        System.out.println("getAuthority: " + url.getAuthority());
        System.out.println("toExternalForm: " + url.toExternalForm());
        System.out.println("toURI: " + url.toURI());

        InputStream inputStream = (InputStream) url.getContent();
        System.out.println("getContent: " + new String(inputStream.readAllBytes()));

    }

}
			]]>
			</programlisting>
			<para>结果输出</para>
			<screen>
			<![CDATA[
getProtocol: https
getUserInfo: neo:password
getHost: www.netkiller.cn
getDefaultPort: 443
getFile: /linux/index.html?id=1&cid=2
getPath: /linux/index.html
getQuery: id=1&cid=2
getRef: openssh
getAuthority: neo:password@www.netkiller.cn
toExternalForm: https://neo:password@www.netkiller.cn/linux/index.html?id=1&cid=2#openssh
toURI: https://neo:password@www.netkiller.cn/linux/index.html?id=1&cid=2#openssh
getContent: <?xml version="1.0" encoding="UTF-8" standalone="no"?>			
			]]>
			</screen>
		</section>
		<section>
			<title>nio 路径库</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

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

public class Test {
    public Test() {
    }

    public static void main(String[] args) throws Exception {

        Path resourceDirectory = Paths.get("src", "main", "resources");
        System.out.println("toURL: " + resourceDirectory.toUri().toURL());
        System.out.println("getParent: " + resourceDirectory.getParent());
        System.out.println("getFileName: " + resourceDirectory.getFileName());

        System.out.println("-".repeat(20));

        Path directory = Paths.get("src/java/resources");
        System.out.println("toURL: " + directory.toUri().toURL());
        System.out.println("getFileName: " + directory.getFileName());
        System.out.println("getParent: " + directory.getParent());
        System.out.println("getNameCount: " + directory.getNameCount());
        System.out.println("getName: " + directory.getName(2));
        System.out.println("getRoot: " + directory.getRoot());
        System.out.println("getFileSystem: " + directory.getFileSystem().getSeparator());
        System.out.println("toFile: " + directory.toFile());

        System.out.println("-".repeat(20));

        Path path = Path.of("src/java/resources", "netkiller.png");
        System.out.println("getParent: " + path.getParent());
    }

}			
			]]>
			</programlisting>
			<para>输出结果</para>
			<screen>
			<![CDATA[
toURL: file:/Users/neo/workspace/watch/src/main/resources/
getParent: src/main
getFileName: resources
--------------------
toURL: file:/Users/neo/workspace/watch/src/java/resources
getFileName: resources
getParent: src/java
getNameCount: 3
getName: resources
getRoot: null
getFileSystem: /
toFile: src/java/resources
--------------------
getParent: src/java/resources			
			]]>
			</screen>
			<para>FileSystems 例子</para>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.nio.file.FileSystems;

public class Test {
    public Test() {
    }

    public static void main(String[] args) throws Exception {

        String baseUrl = FileSystems
                .getDefault()
                .getPath("src", "main", "resources")
                .toUri()
                .toURL()
                .toString();

        System.out.println("url: " + baseUrl);
    }

}			
			]]>
			</programlisting>
		</section>
	</section>
	<section>
		<title>遍历目录和文件</title>
		<section>
			<title>listFiles()</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.path;

import lombok.Data;

import java.io.File;
import java.io.IOException;

@Data
public class FileDirectory {
    public static void main(String[] args) throws IOException {
//        String path = "D:\\TMP";/     //要遍历的路径 windows
        String path = "/etc";        	//要遍历的路径 linux/mac
        File file = new File(path);     //获取其file对象
        listFiles(file);
    }

    private static void listFiles(File file) {
        File[] files = file.listFiles();
        if (files == null) return;
        for (File f : files) {
            if (f.isDirectory())    //若是目录，则递归打印该目录下的文件
                listFiles(f);
            if (f.isFile())         //若是文件，直接打印
                System.out.println(f);
        }
    }
}			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
    public static Set<String> listFilesStream(String dir) {
        return Stream.of(Objects.requireNonNull(new File(dir).listFiles()))
                .filter(file -> file.isFile())
                .map(File::toString)
                .collect(Collectors.toSet());
    }
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.newDirectoryStream</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashSet;
import java.util.Set;

public class FileDirectory {
    public static void main(String[] args) throws IOException {
        String path = "/etc";        //要遍历的路径
        listDirectoryStream(path).forEach(file -> {
            System.out.println(file);
        });
    }


    public static Set<String> listDirectoryStream(String dir) throws IOException {
        Set<String> fileSet = new HashSet<>();
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir))) {
            for (Path path : stream) {
                if (!Files.isDirectory(path)) {
                    fileSet.add(path.toString());
                }
            }
        }
        return fileSet;
    }
}			
			]]>
			</programlisting>
			<para>递归遍历目录</para>
			<programlisting>
			<![CDATA[
    public static Set<String> listDirectoryStream(String dir) {
        Set<String> fileSet = new HashSet<>();
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir))) {
            for (Path path : stream) {
                if (!Files.isDirectory(path)) {
                    fileSet.add(path.toString());
                } else {
                    listDirectoryStream(path.toString()).forEach(file -> {
                        fileSet.add(file);
                    });
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return fileSet;
    }			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.list</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FileDirectory {
    public static void main(String[] args) throws IOException {

        String path = "/etc";        //要遍历的路径
        filesList(path).forEach(file -> {
            System.out.println(file);
        });
    }

    public static Set<String> filesList(String dir) throws IOException {
        try (Stream<Path> stream = Files.list(Paths.get(dir))) {
            return stream
                    .filter(file -> !Files.isDirectory(file))
//                    .map(Path::getFileName)
                    .map(Path::toString)
                    .collect(Collectors.toSet());
        }
    }
}
			
			]]>
			</programlisting>
		</section>
		<section>
			<title>Files.walk 递归遍历目录</title>
			<programlisting>
			<![CDATA[
package cn.netkiller.test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FileDirectory {
    public static void main(String[] args) throws IOException {

        String path = "/tmp/test";        //要遍历的路径
        filesWalk(path).forEach(file -> {
            System.out.println(file);
        });
    }

    public static Set<String> filesWalk(String dir) {
        try (Stream<Path> stream = Files.walk(Paths.get(dir))) {
//            stream.toList().forEach(path -> {
//                System.out.println(path.toString());
//            });
//            return stream.sorted().map(Path::toString).collect(Collectors.toSet());
            return stream.sorted().filter(file -> !Files.isDirectory(file))
//                    .map(Path::getFileName)
                    .map(Path::toString)
                    .collect(Collectors.toSet());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new HashSet<>();
    }
}
			]]>
			</programlisting>
			<para>指定目录深度 5 层</para>
			<programlisting>
			<![CDATA[
Stream<Path> stream = Files.walk(Paths.get(dir), 5)			
			]]>
			</programlisting>
			<programlisting>
			<![CDATA[
    public Set<String> listFilesWalk(String dir, int depth) throws IOException {
        try (Stream<Path> stream = Files.walk(Paths.get(dir), depth)) {
            return stream
                    .filter(file -> !Files.isDirectory(file))
                    .map(Path::getFileName)
                    .map(Path::toString)
                    .collect(Collectors.toSet());
        }
    }			
			]]>
			</programlisting>
		</section>
		<section>
			<title>SimpleFileVisitor</title>
			<programlisting>
			<![CDATA[
    public Set<String> listFilesWalkAndVisitor(String dir) throws IOException {
        Set<String> fileList = new HashSet<>();
        Files.walkFileTree(Paths.get(dir), new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                if (!Files.isDirectory(file)) {
                    fileList.add(file.getFileName().toString());
                }
                return FileVisitResult.CONTINUE;
            }
        });
        return fileList;
    }			
			]]>
			</programlisting>
		</section>
	</section>
</chapter>