导读
二叉树:是一种优秀的算法。
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();
}