導讀
二叉樹：是一種優秀的算法。
JDK8新特性：函數式接口與Lambda表達式。
File類：文件目錄或者文件對象。
輸入流與輸出流：底層數據傳輸技術。
字節流與字符流：不同的傳遞媒介，有不同的特性。
文件複製：採用IO技術的底層傳輸實現重新寫出文件。
①、二叉樹
概念分析：用Java實現二叉樹的前序，中序，後序，層序遍歷, S型層序遍歷
算法簡述：
前三個算法在於輸出當前節點的位置，
1、前序： 在遞歸左右兒子之前，輸出當前節點
代碼如下：
void PreOrderPrint(){
System.out.print(value.toString() + " ");
if(left != null)
left.PreOrderPrint();
if(right != null)
right.PreOrderPrint();
}
2、中序：在遞歸左右兒子中間，輸出
代碼如下：
void InOrderPrint(){
if(left != null)
left.InOrderPrint();
System.out.print(value.toString() + " ");
if(right != null)
right.InOrderPrint();
}
3、後序：在遞歸左右兒子之後輸出
代碼如下：
void PostOrderPrint(){
if(left != null)
left.PostOrderPrint();
if(right != null)
right.PostOrderPrint();
System.out.print(value.toString() + " ");
}
4、層序遍歷，這裏的實現方式類似於兩個簸箕（queue1 和 queue2)之間互相倒，知道誰都沒有後繼節點位置，即兩個簸箕都爲空，此處是兩個隊列都爲空——
代碼如下：
void LevelOrderPrint(){
if(this == null)
throw new IllegalArgumentException("null node !");
Queue<Node<E>> queue1 = new LinkedList<Node<E>>();
Queue<Node<E>> queue2 = new LinkedList<Node<E>>();
queue1.add(this);
while(!queue1.isEmpty() || !queue2.isEmpty()){
if(queue2.isEmpty()){
while(!queue1.isEmpty()){
Node<E> currentNode = queue1.poll();
System.out.print(currentNode.value.toString() + " ");
if(currentNode.left != null){
queue2.add(currentNode.left);
}
if(currentNode.right != null){
queue2.add(currentNode.right);
}
}
}
else{
while(!queue2.isEmpty()){
Node<E> currentNode = queue2.poll();
System.out.print(currentNode.value.toString() + " ");
if(currentNode.left != null){
queue1.add(currentNode.left);
}
if(currentNode.right != null){
queue1.add(currentNode.right);
}
}
}
System.out.println();
}
}
5、S型層序遍歷，就是把上面使用的queue換爲stack，注意左右子節點添加順序，就可以了——
代碼如下：
//Print By Level S-style
public void S_LevelOrderPrint(){
Stack<Node<E>> stack1 = new Stack<Node<E>>();
Stack<Node<E>> stack2 = new Stack<Node<E>>();
stack1.add(this);
while(!stack1.isEmpty() || !stack2.isEmpty()){
if(stack1.isEmpty()){
while(!stack2.isEmpty()){
Node<E> currentNode = stack2.pop();
System.out.print(currentNode.value + " ");
if(currentNode.left != null)
stack1.push(currentNode.left);
if(currentNode.right != null)
stack1.push(currentNode.right);
}
}else{
while(!stack1.isEmpty()){
Node<E> currentNode = stack1.pop();
System.out.print(currentNode.value + " ");
if(currentNode.right != null)
stack2.add(currentNode.right);
if(currentNode.left != null)
stack2.add(currentNode.left);
}
}
System.out.println();
}
}
上面的各種分析方式都羅列出來了，下面我們來看一下完整的二叉樹代碼：
package offer;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
class Node<E extends Comparable<E>>{
Node<E> left;
Node<E> right;
E value;
Node(){
left = null;
right = null;
value = null;
}
Node(E value){
this.value = value;
left = null;
right = null;
}
void PreOrderPrint(){
System.out.print(value.toString() + " ");
if(left != null)
left.PreOrderPrint();
if(right != null)
right.PreOrderPrint();
}
void InOrderPrint(){
if(left != null)
left.InOrderPrint();
System.out.print(value.toString() + " ");
if(right != null)
right.InOrderPrint();
}
void PostOrderPrint(){
if(left != null)
left.PostOrderPrint();
if(right != null)
right.PostOrderPrint();
System.out.print(value.toString() + " ");
}
//Print By Level
void LevelOrderPrint(){
if(this == null)
throw new IllegalArgumentException("null node !");
Queue<Node<E>> queue1 = new LinkedList<Node<E>>();
Queue<Node<E>> queue2 = new LinkedList<Node<E>>();
queue1.add(this);
while(!queue1.isEmpty() || !queue2.isEmpty()){
if(queue2.isEmpty()){
while(!queue1.isEmpty()){
Node<E> currentNode = queue1.poll();
System.out.print(currentNode.value.toString() + " ");
if(currentNode.left != null){
queue2.add(currentNode.left);
}
if(currentNode.right != null){
queue2.add(currentNode.right);
}
}
}
else{
while(!queue2.isEmpty()){
Node<E> currentNode = queue2.poll();
System.out.print(currentNode.value.toString() + " ");
if(currentNode.left != null){
queue1.add(currentNode.left);
}
if(currentNode.right != null){
queue1.add(currentNode.right);
}
}
}
System.out.println();
}
}
//Print By Level S-style
public void S_LevelOrderPrint(){
Stack<Node<E>> stack1 = new Stack<Node<E>>();
Stack<Node<E>> stack2 = new Stack<Node<E>>();
stack1.add(this);
while(!stack1.isEmpty() || !stack2.isEmpty()){
if(stack1.isEmpty()){
while(!stack2.isEmpty()){
Node<E> currentNode = stack2.pop();
System.out.print(currentNode.value + " ");
if(currentNode.left != null)
stack1.push(currentNode.left);
if(currentNode.right != null)
stack1.push(currentNode.right);
}
}else{
while(!stack1.isEmpty()){
Node<E> currentNode = stack1.pop();
System.out.print(currentNode.value + " ");
if(currentNode.right != null)
stack2.add(currentNode.right);
if(currentNode.left != null)
stack2.add(currentNode.left);
}
}
System.out.println();
}
}
}
class BinarySearchTree<E extends Comparable<E>>{
private Node<E> root;
public Node<E> getRoot(){
return root;
}
BinarySearchTree(){
root = null;
}
public void InsertNode(E value){
if(root == null){
root = new Node<E>(value);
return;
}
Node<E> currentNode = root;
while(true){
if(value.compareTo(currentNode.value) > 0){
if(currentNode.right == null){
currentNode.right = new Node<E>(value);
break;
}
currentNode = currentNode.right;
}else{
if(currentNode.left == null){
currentNode.left = new Node<E>(value);
break;
}
currentNode = currentNode.left;
}
}
}
}
public class LevelPrintOfBinaryTree<E extends Comparable<E>> {
public static void main(String[] args) {
BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
{
tree.InsertNode(4);
tree.InsertNode(2);
tree.InsertNode(1);
tree.InsertNode(3);
tree.InsertNode(6);
tree.InsertNode(5);
tree.InsertNode(7);
tree.InsertNode(8);
}
System.out.print("PreOrderPrint: ");
tree.getRoot().PreOrderPrint();
System.out.print("\nInOrderPrint: ");
tree.getRoot().InOrderPrint();
System.out.print("\nPostOrderPrint: ");
tree.getRoot().PostOrderPrint();
System.out.println("\nLevelOrderPrint: ");
tree.getRoot().LevelOrderPrint();
System.out.println("\nS_LevelOrderPrint: ");
tree.getRoot().S_LevelOrderPrint();
}
}
JDK8新特性之：函數式接口與Lambda表達式——
這裏來講解一下Java8 新特性中的函數式接口， 以及和Lambda 表達式的關係。看到過很多不少介紹Java8特性的文章，都會介紹到函數式接口和lambda表達式，但是都是分別介紹，沒有將兩者的關係說明清楚，在這裏,把自己的理解整理如下：
詳細分析如下——
一、函數式接口:
函數式接口其實本質上還是一個接口，但是它是一種特殊的接口：SAM類型的接口（Single Abstract Method）。定義了這種類型的接口，使得以其爲參數的方法，可以在調用時，使用一個lambda表達式作爲參數。從另一個方面說，一旦我們調用某方法，可以傳入lambda表達式作爲參數，則這個方法的參數類型，必定是一個函數式的接口，這個類型必定會使用@FunctionalInterface進行修飾。
從SAM原則上講，這個接口中，只能有一個函數需要被實現，但是也可以有如下例外:
1. 默認方法與靜態方法並不影響函數式接口的契約，可以任意使用，即
函數式接口中可以有靜態方法，一個或者多個靜態方法不會影響SAM接口成爲函數式接口，並且靜態方法可以提供方法實現
可以由 default 修飾的默認方法方法，這個關鍵字是Java8中新增的，爲的目的就是使得某一些接口，原則上只有一個方法被實現，但是由於歷史原因，不得不加入一些方法來兼容整個JDK中的API，所以就需要使用default關鍵字來定義這樣的方法
2. 可以有 Object 中覆蓋的方法，也就是 equals，toString，hashcode等方法。
JDK中以前所有的函數式接口都已經使用 @FunctionalInterface 定義，可以通過查看JDK源碼來確認，以下附JDK 8之前已有的函數式接口：
java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener
代碼如下——
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
/** 測試一下 **/
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
【注：方法和構造函數引用在Java8中可以通過 :: 操作符調用】
自行設計的方法中, 如果可以接收 lambda 表達式, 則可以使用 Function 作爲參數, 如下爲一些已經實現的函數式接口:
代碼如下——
// Function<T, R> -T作爲輸入，返回的R作爲輸出
Function<String,String> function = (x) -> {System.out.print(x+": ");return "Function";};
System.out.println(function.apply("hello world"));
//Predicate<T> -T作爲輸入，返回的boolean值作爲輸出
Predicate<String> pre = (x) ->{System.out.print(x);return false;};
System.out.println(": "+pre.test("hello World"));
//Consumer<T> - T作爲輸入，執行某種動作但沒有返回值
Consumer<String> con = (x) -> {System.out.println(x);};
con.accept("hello world");
//Supplier<T> - 沒有任何輸入，返回T
Supplier<String> supp = () -> {return "Supplier";};
System.out.println(supp.get());
//BinaryOperator<T> -兩個T作爲輸入，返回一個T作爲輸出，對於“reduce”操作很有用
BinaryOperator<String> bina = (x,y) ->{System.out.print(x+" "+y);return "BinaryOperator";};
System.out.println(" "+bina.apply("hello ","world"));
二、Lambda表達式（這裏只是簡單提一下）
書寫方法: e -> System.out.println( e )
1. 三部分構成
參數列表
符號 ->
函數體 : 有多個語句,可以用{} 包括, 如果需要返回值且只有一個語句,可以省略 return
2. 訪問控制:
可以訪問類的成員變量和局部變量(非final會自動隱含轉爲final) ——
三、File類核心常用方式
代碼如下：
java中File類的常用所有方法及其應用
創建：
createNewFile()在指定位置創建一個空文件，成功就返回true，如果已存在就不創建，然後返回false。
mkdir() 在指定位置創建一個單級文件夾。
mkdirs() 在指定位置創建一個多級文件夾。
renameTo(File dest)如果目標文件與源文件是在同一個路徑下，那麼renameTo的作用是重命名， 如果目標文件與源文件不是在同一個路徑下，那麼renameTo的作用就是剪切，而且還不能操作文件夾。
刪除：
delete() 刪除文件或者一個空文件夾，不能刪除非空文件夾，馬上刪除文件，返回一個布爾值。
deleteOnExit()jvm退出時刪除文件或者文件夾，用於刪除臨時文件，無返回值。
判斷：
exists() 文件或文件夾是否存在。
isFile() 是否是一個文件，如果不存在，則始終爲false。
isDirectory() 是否是一個目錄，如果不存在，則始終爲false。
isHidden() 是否是一個隱藏的文件或是否是隱藏的目錄。
isAbsolute() 測試此抽象路徑名是否爲絕對路徑名。
獲取：
getName() 獲取文件或文件夾的名稱，不包含上級路徑。
getAbsolutePath()獲取文件的絕對路徑，與文件是否存在沒關係
length() 獲取文件的大小（字節數），如果文件不存在則返回0L，如果是文件夾也返回0L。
getParent() 返回此抽象路徑名父目錄的路徑名字符串；如果此路徑名沒有指定父目錄，則返回null。
lastModified()獲取最後一次被修改的時間。
文件夾相關：
static File[] listRoots()列出所有的根目錄（Window中就是所有系統的盤符）
list() 返回目錄下的文件或者目錄名，包含隱藏文件。對於文件這樣操作會返回null。
listFiles() 返回目錄下的文件或者目錄對象（File類實例），包含隱藏文件。對於文件這樣操作會返回null。
list(FilenameFilter filter)返回指定當前目錄中符合過濾條件的子文件或子目錄。對於文件這樣操作會返回null。
listFiles(FilenameFilter filter)返回指定當前目錄中符合過濾條件的子文件或子目錄。對於文件這樣操作會返回null。
複製代碼
package com.file;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author 王金龍
* @date 創建時間: 2017-2-9 上午11:32:40
* @version 1.0
*/
public class FileMethod {
public static void main(String[] args) throws IOException {
//創建方法
/*
@SuppressWarnings("unused")
File file = new File("F:\\a.txt");
//System.out.println("創建成功了嗎？"+file.createNewFile());
//System.out.println("單級文件夾創建成功了嗎？"+file.mkdir());
//System.out.println("多級文件夾創建成功了嗎？"+file.mkdirs());
//File dest = new File("F:\\電影\\c.txt");
//System.out.println("重命名成功了嗎？"+file.renameTo(dest));
*/
/*
//刪除方法
File file = new File("F:\\電影");
System.out.println("刪除成功了嗎？"+file.delete());
file.deleteOnExit();
*/
//判斷方法
/*
File file = new File("F:\\a.txt");
System.out.println("文件或者文件夾存在嗎？"+file.exists());
System.out.println("是一個文件嗎？"+file.isFile());
System.out.println("是一個文件夾嗎？"+file.isDirectory());
System.out.println("是隱藏文件嗎？"+file.isHidden());
System.out.println("此路徑是絕對路徑名？"+file.isAbsolute());
*/
//獲取方法
/*
File file = new File("f:\\a.txt");
System.out.println("文件或者文件夾得名稱是："+file.getName());
System.out.println("絕對路徑是："+file.getPath());
System.out.println("絕對路徑是："+file.getAbsolutePath());
System.out.println("文件大小是（以字節爲單位）:"+file.length());
System.out.println("父路徑是"+file.getParent());
//使用日期類與日期格式化類進行獲取規定的時間
long lastmodified= file.lastModified();
Date data = new Date(lastmodified);
SimpleDateFormat simpledataformat = new SimpleDateFormat("YY年MM月DD日 HH:mm:ss");
System.out.println("最後一次修改的時間是："+simpledataformat.format(data));
*/
//文件或者文件夾的方法
File[] file = File.listRoots();
System.out.println("所有的盤符是：");
for(File item : file){
System.out.println("\t"+item);
}
File filename =new File("F:\\Java workspace\\Java");
String[] name = filename.list();
System.out.println("指定文件夾下的文件或者文件夾有：");
for(String item : name){
System.out.println("\t"+item);
}
File[] f = filename.listFiles();
System.out.println("獲得該路徑下的文件或文件夾是：");
for(File item : f){
System.out.println("\t"+item.getName());
}
}
}
輸入流與輸出流——
在這裏我推薦一篇博客，寫得非常詳細，希望大家細心研讀，其作者心得很好。
【網址：http://blog.csdn.net/liuxiaogangqq/article/details/25892667/】
文件的複製操作——
/**
* 複製文件
* @param fromFile
* @param toFile
* <br/>
* 2016年12月19日 下午3:31:50
* @throws IOException
*/
public void copyFile(File fromFile,File toFile) throws IOException{
FileInputStream ins = new FileInputStream(fromFile);
FileOutputStream out = new FileOutputStream(toFile);
byte[] b = new byte[1024];
int n=0;
while((n=ins.read(b))!=-1){
out.write(b, 0, n);
}
ins.close();
out.close();
}