/** 带头指针的单链表原地逆序(逆序函数为reverse)
* Created by Willow on 1/5/17.
*/
public class List {
  Node head;
  public List(Node head) {
    this.head = head;
  }
  //节点
  static class Node {
    int data;
    Node next;
    public Node() {}
    public Node(int data, Node next) {
      this.data = data;
      this.next = next;
    }
  }
  //逆序
  public void reverse() {
    if (null == head || null == head.next || null == head.next.next)
      return;
    Node pre = null, cur = this.head.next, nex = cur.next;
    while (null != nex) {
      //1. 逆置当前节点指向
      cur.next = pre;
      //2. 前置、当前、后置节点的三个指针向前移动
      pre = cur;
      cur = nex;
      nex = nex.next;
    }
    cur.next = pre;//3. 逆置最后一个节点的指向
    this.head.next = cur;//4. 头指针指向最后一个节点
  }
  //遍历
  public void traverse() {
    if (null == head.next)
      return;
    Node cur = head.next;
    while (null != cur) {
      System.out.println(cur.data);
      cur = cur.next;
    }
    System.out.println("traverse end \n");
  }
  //测试入口
  public static void main(String[] args) {
    Node n7 = new Node(7, null);
    Node n6 = new Node(6, n7);
    Node n5 = new Node(5, n6);
    Node n4 = new Node(4, n5);
    Node n3 = new Node(3, n4);
    Node n2 = new Node(2, n3);
    Node n1 = new Node(1, n2);
    Node head = new Node(0, n1);
    List list = new List(head);
    list.traverse();
    list.reverse();
    list.traverse();
  }
}

public class Node {
  Object Data;
  Node left,right,parent;
}

public class BinTree {
  Node root;
  public boolean judge() {
    int n0 = 0, n = 0, stage = 1;
    if (this.root == null)
      return true;
    Queue<Node> queue = new LinkedList<>();
    queue.offer(this.root);
    while (!queue.isEmpty()) {
      Node node = queue.poll();
      n++;
      //三个必要条件之一
      if (node.left == null && node.right != null)
        return false;
      //三个必要条件之二
      if (stage == 2 && (node.left != null || node.right != null))
        return false;
      stage = (node.left != null && node.right == null) ? 2 : stage;
      if (node.left != null)
        queue.offer(node.left);
      if (node.right != null)
        queue.offer(node.right);
      if (node.left == null && node.right == null) {
        n0++;
        stage=2;
      }
    }
    //三个必要条件之三：完全二叉树满足的公式n0=n/2，其中n0是度为0的节点，n是树总的节点数
    return (n0 == (int) Math.ceil(n / 2.0)) ? true : false;
  }
}

public String doAction(Map context, CGI cgi) {
  CsrfTokenRepository.setToken(context, cgi);
  //...
}

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
  //...
  if (!csrfToken.getToken().equals(actualToken)) {
    response.sendError(403);
    return;
  }
  //...
  filterChain.doFilter(request, response);
}

public class CsrfFilter extends OncePerRequestFilter {
//生产token的货
private final CsrfTokenRepository tokenRepository;
//做放行列表检测的货
private RequestMatcher requireCsrfProtectionMatcher = new CsrfFilter.DefaultRequiresCsrfMatcher();
//做检测结果处理逻辑的货
private AccessDeniedHandler accessDeniedHandler = new AccessDeniedHandlerImpl();
//....

public class HttpSessionCsrfTokenRepository implements CsrfTokenRepository {
    //结合模板引擎生产csrf token
    public static void setToken(HttpServletRequest request, ModelMap context) {
      //尝试拿csrf filter中设置的token
      CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName());
        if (null != csrfToken) {
        context.put("_csrf", csrfToken);
        context.put("_csrf_header", "X-CSRF-TOKEN");
       }
    }
}

public class CsrfFilter implements Filter {
  private final CsrfTokenRepository tokenRepository;
  //...
  public SimpleCsrfFilter() {
    CsrfTokenRepository csrfTokenRepository = new HttpSessionCsrfTokenRepository();
    Assert.notNull(csrfTokenRepository, "csrfTokenRepository cannot be null");
    this.tokenRepository = csrfTokenRepository;
  }
  //...
}

logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));

if(logger.isDebugEnabled()) {
  logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));
}

Object entry = new SomeObject();
logger.debug("The entry is {}.", entry);

logger.debug("The new entry is "+entry+".");
logger.debug("The new entry is {}.", entry);

logger.debug("The new entry is {}. It replaces {}.", entry, oldEntry);

logger.debug("Value {} was inserted between {} and {}.", newVal, below, above);

logger.debug("Set {1,2} differs from {}", "3");

logger.debug("Set {1,2} differs from {{}}", "3");

logger.debug("Set \\{} differs from {}", "3");

logger.debug("File name is C:\\\\{}.", "file.zip");

logger.debug("{}", complexObject);

class A{
    private static A single=null;
    public static A getSingleton(){
        if(null==single){
            single=new A();
        }
        return single;
    }
}

A a = A.getSingleton();

//Product 产品接口
interface Product{}

//具体产品A
class ProductA implements Product{}

//Factory 工厂接口
interface Factory{
    Product create();
}

//class FactoryA implements Factory{
    @Override
    public Product create(){
        return new ProductA();
    }
}

Factory factory = new FactoryA();
Product product = factory.create();

//窗口对象接口
interface Window{}

//某种风格A的窗口
class WindowA implements Window{}

//按钮对象接口
interface Button{}

//某种风格A的按钮
class ButtonA implements Button{}

//工厂接口
interface Factory{
    //创建窗口
    Window createWindow();
    //创建按钮
    Button createButton();
}

//生产某种风格A对象的工厂
class FactoryA implements Factory{
    @Override
    public Window createWindow(){
        return new WindowA();
    }
    @Override
    public Button createButton(){
        return new ButtonA();
    }
}

Factory facory = new FactoryA();
Window window = factory.createWindow();
Button button = factory.createButton();

class A{
    //复制自己的实例
    A clone(){}
}

A a = new A();
A b = a.clone();
//下面b可修改一些属性，成为一个新的对象

/*创建一个个零件类*/

//假设A、B是零件的接口
class Builder{
    A createA();
    B createB();
}

//定义零件组装过程
class Director{
    Builder builder;
    
    Director(Builder builder){
        this.builder = builder;    
    }
    
    void assembly(){
        A a = builder.createA();
        B b = builder.createB();
        //下面就是根据某种方法，将a和b组装起来
    }
}

Builder builder = new Builder();
Director director = new Director(builder);
director.assembly();

//客户想要的接口
interface A{ void function(); }

//已经存在的接口
interface Old{ void func(); }

//设计一个适配器
class Adapter implements A{
    Old o;

    @Override
    function(){
        o.func();
    }
}

A a = new Adapter();
a.function();
//对于客户来说，它并不知道，也没有必要知道这期间是否进行了转接，能用就行

//软件功能
interface Software{ void show(); }
class TextSoftwareimplements Software{
    @Overrride
    void show(){}
}
class ImageSoftware implements Software{
    @Override
    void show(){}
}

//使用群体
interface User{}
class AdultUser implements User{}
class ChildrenUser implements User{}

//平台
interface Platform{}
class PcPlatform implements Platform{
    Software soft;
    User user;
    //下面可以自己组合这些业务元素
}

//结点接口
interface Node{
    void add(Node n);
    void remove(Node n);
}

//叶子结点
class Leaf implements Node(){
    @Override
    public void add(Node n){}
    
    @Override
    public void remove(Node n){}
}

//非叶子结点
class Stem implements Node{
    private List list;
    
    @Override
    public void add(Node n){
        list.add(n);
    }
    
    @Override
    public void remove(Node n){
        list.remove(n);
    }
}

Node root = new Stem();
Node oneStem = new Stem();
Node leaf1 = new Leaf();
Node leaf2 = new Leaf();
Node leaf3 = new Leaf();
oneStem.add(leaf1);
oneStem.add(leaf2);
root.add(oneStem);
root.add(leaf3);

//窗口
interface Window{ void display(); }
//具体的一个窗口
class AWindow inplements Window{
    @Override
    public void display(){}
}
//一个装饰类
class Decorator implements Window{
    // 包含一个窗口
    Window win;
    //区别代理模式：往往被装饰的对象由构造器传入，而代理模式则完全隐藏内部对象的构造过程
    public Decorator(Window win){
        this.win = win;
    }
    
    @Override
    public void display(){
        //先加一个边框
        addBorder();
        //展示本来win里面的内容
        win.display();
    }
    private void addBorder(){}
}

Window a = new Decorator(); //这里不考虑怎么给内部win对象的赋值，这个属于创建型模式需要解决的问题，下同
a.display();

//预处理
interface Prepare{ void doPrepare(); }
//编译
interface Compile{ void doCompile(); }
//链接
interface Link{ void doLink(); }
//清除
interface Remove{ void doRemove(); }

//外观类
class Facade{
    Prepare p;
    Compile c;
    Link l;
    Remove r;
    
    public void build(){
        p.doPrepare();
        c.doCompile();
        l.doLink();
    }
    
    public void remove(){
        r.doRemove();
    }
}

Facade f = new Facade();
//构建软件
f.build();
//清除软件
f.remove();

//字符接口
interface Character{}
//两类字符对象：可以共享的；不可以共享的
class ShareCharacter implements Character{}
class UnshareCharacter implements Character{}

//创建享元对象的工厂
class CharacterFactory{
    Character getChar(char c){
        Character c;
        //根据某些条件判断，是共享一个对象，还是生产一个新的对象
        ...
        return c;
    }
}

Character ch = CharacterFactory.getChar('a');

//需要访问的对象接口
interface Subject{ void operation(); }
//实际访问的类
class RealSubject implements Subject{
    @Override
    public void operation(){}
}
//代理类，提供相同的接口
class Proxy implements Subject{
    Subject real;
    
    @Override
    public void operation(){
        //做一些连接等准备工作
        ...
        //调用真正需要访问的类的功能
        real.operation();
    }
}

Subject obj = new Proxy();
obj.operation();

//操作总接口
interface Handler{
  //转发
  void transfer(Handler next);
  
  //处理消息
  void operation();
}
//具体类
class HandlerA impleements Handler{
  @Override
  public void transfer(Handler next){}
  
  @Override
  public void operation(){
    //先判断是否由自己来处理
    if(isMyDuty){
      doSomething(); 
	}else{
      //如果不是，则转发
      transfer();
	}
  }
}

Handler start = new HandlerA();
start.operation();

// 语言的上下文
class Context{}

// 解析接口
interface Expression { void interpret(Context text); }

// 终结符解释方法
class TerminalExpression implements Expression{
	@Override
	public void interpret(Context text){}
}

// 非终结符解释方法
class NonterminalExpression implements Expression{
	// 非终结符里包含有其他符号
	List<Expression> exp;
	
	@Override
	public void interpret(Context text){}
}

// 迭代接口
interface Iterator{
	Object next();
	boolean hasNext();
}

// 数据元素集合
interface DataSet { Iterator getIterator(); }

// 数据元素具体的实现
class DataSetA implements{
	// 具体里面的数据表示省略了
	// 得到一个迭代器
	@Override
	Iterator getIterator(){
		return new DataSetAIterator(this);
	}
}

// 专门为DataSetA定义的迭代器
class DataSetAIterator implements Iterator{
	DataSetA data;
  
	DataSetAIterator(DataSetA data){
		this.data=data;
	}
	
	@Override
	public Object next(){
		// 按某种方法取得this.data中的下一个元素
	}
	
	public boolean hasNext(){
		// 根据某种方法判断有没有下一个元素
	}
}

DataSet a = new DataSetA();
Iterator ite = a.getIterator();
Object obj = ite.next();

// 中介者接口
interface Mediator{
	void sendTo(String message, String name); 
}

// 联合国是一个中介者
class MediatorUN implements Mediator{
	//联合国需要知道每一个国家
	List<Country> country;
  	public MediatorUn(List<Country> country){
      	this.country = country;
	}	
  
	@Override
	public sendTo(String message, String name){
		//根据name选择一个Country，然后发送消息
	}
}

// 国家抽象类
abstract class Country{
	Mediator med;
  
	// 把消息message发送给名字叫name的国家
	void send(String message, String name);
}

// 中国
class China extends Country{
	@Override
	void send(String message, String name){
		// 把消息和转发对象发给中介者，自己并不需要知道另一
		// 国家的具体情况
		this.med.sentTo(message, name);
	}
}

// 美国
class USA extends Country{
	
	@Override
	void send(String message, String name){
		this.med.sentTo(message, name);
	}
}

// 备忘录，或者是存档
class Memento {
	// 对象的状态，简单的用String表示
	String state;
	
	void setState(String state){
		this.state=state;
	}
	
	String getState(){
		return this.state;
	}
}

// 存档管理者
class MemManage{
	// 创建一个存档对象
	Memento createMemento(){
		return new Memento();
	}
	
	// 保存
	void saveMem(Memento mem){}
	
	// 获取某一个存档
	void getMem(/*参数省略了，取决于实现方法*/){}
}
	
// 游戏程序，可以存档
class Game{
	String state;
	
	// 存档
	void save(Memento mem, String state){
		mem.setState(state);
	}
	
	// 读档
	void load(Memento mem){
		this.state=men.getState();
	}
}

Game game=new Game();
MemManager manager=new MemManager();
//存档
Memento m=manager.createMemento();
game.save(m, “存档1”);
manager.savaMen(m);
// 读档同上

// 观察接口，所以观察者都要实现该接口
interface Observer { void operation(); }

//观察者A
class ObserverA implements Observer{
	@Override
	public void operation(){
		// 收到通知后做相应的事
	}
}
//观察者B
class ObserverB implements Observer{
	@Override
	public void operation(){
		// 收到通知后做相应的事
	}
}

// 被观察者接口
interface Subject {
	// 加入一个观察者
	void add(Observer o);
	
	// 删除一个观察者
	void del(Observer o);
	
	// 通知观察者
	void notify();
}

// 被观察对象C
class SubjectC implements Subject{
	// 比如用一个线性表存储观察者们
	List<Observer> obs;
	
	@Override
	public void add(Observer o){
		obs.add(o);
	}
	
	@Override
	public void del(Observer o){
		obs.remove(o);
	}
	
	@Override
	public void notify(){
		int len=this.obs.length;
		for(int i=0; i<len; i++){
			Observer tmp=this.obs.get(i);
			tmp.operation();
		}
	}
}

// 建立被观察对象
Suject sub=new SubjectC();

// 建立两个观察者
Observer a=new ObserverA();
Observer b=new ObserverB();
// 向被观察对象注册
sub.add(a);
sub.add(b);

// 发生了一些事件，被观察者通知各观察者进行各自相应的动作
sub.notify();

// 定义状态接口
interface State { 
	void operation(Switch s); 
}

// 定义三种状态
class Off implements State{
	@Override
	public void operation(Switch s){
		// 执行关灯的操作
		s.doOff();
		// 改变一下状态
		s.state=new Near();
	}
	
}

class Near implements State{
	@Override
	public void operation(Switch s){
		// 执行近光灯的操作
		s.doNear();
		// 改变一下状态
		s.state=new Far();
	}
}

class Far implements State{
	@Override
	public void operation(Switch s){
		// 执行远光灯的操作
		s.doFar();
		// 改变一下状态
		s.state=new Off();
	}
}

// 开关类
class Switch {
	State st;
	
	Switch(State st){
		this.st=st;
	}

	// 定义按下开关的方法
	void press(){
		st.operation(this);
	}
	
	// 定义三个操作
	void doOff(){}
	void doNear(){}
	void doFar(){}
}

//初始状态为关
Switch swi=new Switch(new Off());
// 按下三次开关
swi.press();
swi.press();
swi.press();

class Switch{
	void press(){
		if(状态关){
			关灯
			改状态为近光灯
		}
		else if(状态近光灯){
			开近光灯
			改状态为远光灯
		}
		else if(状态远光灯){
			开远光灯
			改状态为关
		}
	}
}

Switch swi=new Switch();
// 按下三次开关
swi.press();
swi.press();
swi.press();

// 算法接口
interface Strategy { 
	double getPrice(); 
}

// 正常收费
class Normal implements Strategy{
	@Override
	public double getPrice(){ }
}

// 打折价格
class Discount implements Strategy{
	@Override 
	public double getPrice() { }
}

// 收费程序
class Casher{
	Strategy strategy;
	
	void setStrategy(Strategy strategy){
		this.strategy=strategy;
	}
	
	// 得到商品总价
	double getMoney(int n){
		return n*this.strategy.getPrice();
	}
}

Casher cash=new Casher();
//正常收费
cash.setStrategy(new Noral());
cash.getMoney(2);
// 换成打折收费
cash.setStrategy(new Discount());
cash.getMoney();

// 抽象类，没定下来的操作作为抽象方法
abstract DoFish{
	void operation(){
		// 放油
		putOil();
		
		// 放鱼
		putFish();
		
		// 放水
		putWater();
		
		// 放调料
		putFlavour();
	}	
	
	abstract void putOil();
	void putFish(){
		// ...
	}
	abstract void putWater();
	
	abstract void putFlavour();
}

// 一种具体的做法
class OneDoFish extends DoFish(){
	@Override
	void putOil(){}
	
	@Override
	void putWater(){}
	
	@Override
	void putFlavour(){}
}

DoFish o=new OneDoFish();
o.operation();