皇天
皇天

04-行为型模式

1. 模板方法模式*

模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤

abstract class MySort {
    // 模板方法：
    // 提供了排序算法，但按什么顺序排没有实现
    public final void sort() {
        if (hook()) {
            orderBy();
        } else {
            System.out.println("默认排序规则");
        }
    }

    public abstract void orderBy();

    // 钩子方法：默认为不做任何事情，子类可以视情况去选择是否重写
    public boolean hook() {
        return true;
    }
}

class AscSort extends MySort {
    @Override
    public void orderBy() {
        System.out.println("Asc");
    }
}

class DescSort extends MySort {
    @Override
    public void orderBy() {
        System.out.println("Desc");
    }
}

class DefaultSort extends MySort {
    @Override
    public void orderBy() {
    }

    @Override
    public boolean hook() {
        return false;
    }
}

public class TemplateMethodClient {
    public static void main(String[] args) {
        MySort ascSort = new AscSort();
        MySort descSort = new DescSort();
        MySort defaultSort = new DefaultSort();
        ascSort.sort();
        descSort.sort();
        defaultSort.sort();
    }
}

2. 命令模式

命令模式：将一个请求封装为一个对象，让发出命令的责任和执行命令的责任分割开，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作

命令模式结构：

  1. Receiver：命令接收者，真正执行命令的对象
  2. Command：执行命令的接口，声明执行命令的方法
  3. ConcreteCommand：实现命令接口的命令对象，是“虚”的实现；通常会持有命令接收者，并调用命令接收者的功能来完成命令要执行的操作
  4. Invoker：调用命令对象去执行命令，通常会持有命令对象；这是使用命令对象的入口
  5. Client：创建具体的命令对象，并且设置命令对象的接收者
// 命令接收者：真正执行命令的对象
class Tv {
    public void turnOn() {
        System.out.println("电视机开机");
    }

    public void turnOff() {
        System.out.println("电视机关机");
    }
}

// 执行命令的接口
interface Command {
    void execute();

    void undo();
}

// 开机命令
class OnCommand implements Command {
    Tv tv;

    public OnCommand(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.turnOn();
    }

    @Override
    public void undo() {
        tv.turnOff();
    }
}

// 关机命令
class OffCommand implements Command {
    Tv tv;

    public OffCommand(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.turnOff();
    }

    @Override
    public void undo() {
        tv.turnOn();
    }
}

// 空命令：可以用来初始化Invoker中的每个命令
class EmptyCommand implements Command {
    @Override
    public void execute() {
    }

    @Override
    public void undo() {
    }
}

// 遥控器
class Invoker {
    Command onCommand = new EmptyCommand();
    Command offCommand = new EmptyCommand();

    public Invoker(Command onCommand, Command offCommand) {
        this.onCommand = onCommand;
        this.offCommand = offCommand;
    }

    public void turnOn() {
        onCommand.execute();
    }

    public void turnOff() {
        offCommand.execute();
    }
}

public class CommandClient {
    public static void main(String[] args) {
        Tv tv = new Tv();
        Invoker invoker = new Invoker(new OnCommand(tv), new OffCommand(tv));
        invoker.turnOn();
        invoker.turnOff();
    }
}

3. 访问者模式

访问者模式：把数据结构和作用于结构上的操作解耦合，使得可以在不改变各元素的类的前提下定义作用于这些元素的新操作

访问者模式适用于数据结构相对稳定、算法又易变化的系统，因为访问者模式使得算法操作增加变得容易

结构对象是使用访问者模式必备条件，而且这个结构对象必须存在遍历自身各个对象的方法。这便类似于Java语言当中的collection概念了

访问者模式涉及的角色：

  1. Visitor：抽象访问者角色，为该对象结构中的每一个具体元素角色声明一个访问操作接口
  2. ConcreteVisitor：具体访问者角色，实现Visitor声明的接口
  3. Element：定义一个接受访问的操作(accept())，它以一个访问者(Visitor)作为参数
  4. ConcreteElement：具体元素，实现了抽象元素(Element)所定义的接受操作接口
  5. ObjectStructure：结构对象角色，这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素

据《大话设计模式》中说，访问者模式算是最复杂也是最难以理解的一种模式了！

import java.util.ArrayList;
import java.util.List;

// 抽象访问者角色
interface Visitor {
    void visitElementA(ConcreteElementA elementA);

    void visitElementB(ConcreteElementB elementB);
}

/**
 * 具体访问者角色：1
 * 不同的具体访问者，访问元素的方式可能不同
 */
class ConcreteVisitor1 implements Visitor {
    @Override
    public void visitElementA(ConcreteElementA elementA) {
        System.out.println("以方式1来访问元素A");
    }

    @Override
    public void visitElementB(ConcreteElementB elementB) {
        System.out.println("以方式1来访问元素B");
    }
}

// 具体访问者角色：2
class ConcreteVisitor2 implements Visitor {
    @Override
    public void visitElementA(ConcreteElementA elementA) {
        System.out.println("以方式2来访问元素A");
    }

    @Override
    public void visitElementB(ConcreteElementB elementB) {
        System.out.println("以方式2来访问元素B");
    }
}

// 定义一个接受访问的操作
interface Element {
    void accept(Visitor visitor);
}

/**
 * 具体元素：A
 * 使用了双分派：
 * 第一次分派：在客户端调用时将具体状态作为参数传递到ConcreteElementA中
 * 第二次分派：将ConcreteElementA对象本身作为参数传递到visitElementA中
 */
class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitElementA(this);
    }
}

// 具体元素：B
class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitElementB(this);
    }
}

// 结构对象角色
class ObjectStructure {
    List elementList = new ArrayList<>();

    public void attach(Element element) {
        elementList.add(element);
    }

    public void detach(Element element) {
        elementList.remove(element);
    }

    public void display(Visitor visitor) {
        for (Element element : elementList) {
            element.accept(visitor);
        }
    }
}

public class VisitorClient {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.attach(new ConcreteElementA());
        objectStructure.attach(new ConcreteElementB());
        objectStructure.attach(new ConcreteElementA());
        objectStructure.display(new ConcreteVisitor1());
        System.out.println("----------------------");
        objectStructure.display(new ConcreteVisitor2());
    }
}

4. 迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示

迭代器模式涉及的角色：

  1. Iterator(迭代器)：定义访问和遍历元素的接口
  2. ConcreteIterator(具体迭代器)：实现迭代器接口；对该聚合遍历时跟踪当前位置
  3. Aggregate(聚合)：定义创建相应迭代器对象的接口
  4. ConcreteAggregate(具体聚合)：实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

// 迭代器接口使用java现成的java.util.Iterator接口
// 具体迭代器
class ListIterator implements Iterator {
    List list;
    // 要返回的下一个元素的索引
    int cursor = 0;
    // 返回的最后一个元素的索引
    int lastRet = -1;

    public ListIterator(List list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return cursor < list.size();
    }

    @Override
    public E next() {
        if (cursor >= list.size())
            throw new NoSuchElementException();
        lastRet = cursor;
        cursor++;
        return list.get(lastRet);
    }

    @Override
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        list.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
    }
}

// 聚合
interface MyCollection {
    Iterator getIterator();

    void addString(String s);
}

// 具体聚合
class MyList implements MyCollection {
    List list = new ArrayList<>();

    @Override
    public ListIterator getIterator() {
        return new ListIterator<>(list);
    }

    @Override
    public void addString(String s) {
        list.add(s);
    }
}

public class IteratorClient {
    public static void main(String[] args) {
        MyList myList = new MyList();
        myList.addString("1");
        myList.addString("2");
        myList.addString("3");
        ListIterator listIterator = myList.getIterator();
        // 1 3
        while (listIterator.hasNext()) {
            String next = listIterator.next();
            if (next.equals("2"))
                listIterator.remove();
            else
                System.out.print(next + " ");
        }
    }
}

5. 观察者模式*

观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知

观察者模式涉及的角色：

  1. 抽象观察者(Observer)：为所有的具体观察者定义一个接口，在得到主题通知时更新自己
  2. 具体观察者(Concrete Observer)：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调
  3. 抽象主题(Subject)：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象
  4. 具体主题(Concrete Subject)：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知

java.util.Observable类就使用了观察者模式

发布订阅机制就类似于观察者模式

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

// 需要更新的数据
@Data
@NoArgsConstructor
@AllArgsConstructor
class UpdatedData {
    String username;
    String password;
}

// 抽象观察者
interface Observer {
    void update(UpdatedData updatedData);
}

// 具体观察者：可以有多个
class ConcreteObserver implements Observer {
    UpdatedData updatedData = new UpdatedData();

    @Override
    public void update(UpdatedData updatedData) {
        this.updatedData = updatedData;
        System.out.println(this.toString() + "已更新：" + this.updatedData);
    }
}

// 抽象主题
interface Subject {
    void subscribe(Observer observer);

    void unsubscribe(Observer observer);

    void publish(UpdatedData updatedData);
}

// 具体主题：一般有1个
class ConcreteSubject implements Subject {
    List observerList = new ArrayList<>();

    @Override
    public void subscribe(Observer observer) {
        System.out.println(observer + "订阅");
        observerList.add(observer);
    }

    @Override
    public void unsubscribe(Observer observer) {
        System.out.println(observer + "退订");
        if (observerList.contains(observer))
            observerList.remove(observer);
    }

    @Override
    public void publish(UpdatedData updatedData) {
        System.out.println("发布");
        for (Observer observer : observerList) {
            observer.update(updatedData);
        }
    }
}

public class ObserverClient {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observer = new ConcreteObserver();
        subject.subscribe(observer);
        subject.publish(new UpdatedData("root", "123456"));
        subject.unsubscribe(observer);
    }
}

6. 中介者模式

中介者模式(调停者模式)：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互

中介者模式涉及的角色：

  1. 同事(Colleague)：每一个同事都知道它的中介者对象，在需要与其他同事通信的时候，与它的中介者通信
  2. 具体同事(ConcreteColleague)：实现同事接口
  3. 中介者(Mediator)：中介者定义一个接口用于与各同事(Colleague)对象通信
  4. 具体中介者(ConcreteMediator)：具体中介者通过协调各同事对象实现协作行为，了解并维护它的各个同事
import java.util.ArrayList;
import java.util.List;

// 同事
abstract class Colleague {
    Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    abstract void receive();

    abstract void send();
}

// 具体同事：1
class ConcreteColleague1 extends Colleague {
    @Override
    void receive() {
        System.out.println("具体同事1收到请求");
    }

    @Override
    void send() {
        System.out.println("具体同事1发出请求");
        // 请中介者转发
        mediator.relay(this);
    }
}

// 具体同事：2
class ConcreteColleague2 extends Colleague {
    @Override
    void receive() {
        System.out.println("具体同事2收到请求");
    }

    @Override
    void send() {
        System.out.println("具体同事2发出请求");
        // 请中介者转发
        mediator.relay(this);
    }
}

// 中介者
interface Mediator {
    void register(Colleague colleague);

    void relay(Colleague colleague);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    List colleagueList = new ArrayList<>();

    @Override
    public void register(Colleague colleague) {
        if (!colleagueList.contains(colleague)) {
            colleagueList.add(colleague);
            colleague.setMediator(this);
        }
    }

    @Override
    public void relay(Colleague colleague) {
        // 给除了colleague的所有Colleague转发
        for (Colleague coll : colleagueList) {
            if (!coll.equals(colleague)) {
                coll.receive();
            }
        }
    }
}

public class MediatorClient {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Colleague colleague1 = new ConcreteColleague1();
        Colleague colleague2 = new ConcreteColleague2();
        mediator.register(colleague1);
        mediator.register(colleague2);
        colleague1.send();
        System.out.println("---------------------");
        colleague2.send();
    }
}

7. 备忘录模式

备忘录模式又叫做快照模式或Token模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态

备忘录模式涉及的角色：

  1. Originator(发起人)：负责创建一个备忘录Memento，用以记录当前时刻自身的内部状态，并可使用备忘录恢复内部状态。Originator可以根据需要决定Memento存储自己的哪些内部状态。
  2. Memento(备忘录)：负责存储Originator对象的内部状态，并可以防止Originator以外的其他对象访问备忘录。备忘录有两个接口：Caretaker只能看到备忘录的窄接口，他只能将备忘录传递给其他对象。Originator却可看到备忘录的宽接口，允许它访问返回到先前状态所需要的所有数据。
  3. Caretaker(管理者)：负责备忘录Memento，不能对Memento的内容进行访问或者操作。
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

// 发起人
@Data
class Originator {
    String state;

    public void setStateFromMemento(Memento memento) {
        state = memento.getState();
    }

    public Memento createMementoToSaveState() {
        return new Memento(state);
    }
}

// 备忘录
class Memento {
    String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

// 管理者
class Caretaker {
    List mementoList = new ArrayList<>();

    void add(Memento memento) {
        mementoList.add(memento);
    }

    Memento get(int index) {
        return mementoList.get(index);
    }
}

public class MementoClient {
    public static void main(String[] args) {
        Caretaker caretaker = new Caretaker();
        Originator originator = new Originator();
        originator.state = "状态0";
        caretaker.add(originator.createMementoToSaveState());
        originator.state = "状态1";
        caretaker.add(originator.createMementoToSaveState());
        // 当前状态：Originator(state=状态1)
        System.out.println("当前状态：" + originator);
        originator.setStateFromMemento(caretaker.get(0));
        // 恢复后，当前状态：Originator(state=状态0)
        System.out.println("恢复后，当前状态：" + originator);
    }
}

8. 解释器模式

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

解释器模式涉及的角色：

  1. 上下文(Context)：包含解释器之外的一些全局信息
  2. 抽象表达式(AbstractExpression)：声明一个抽象的解释操作，这个接口为抽象语法树中所有的结点所共享。
  3. 终结符表达式(TerminalExpression)：实现与文法中的终结符相关联的解释操作
  4. 非终结符表达式(NonterminalExpression)：为文法中的非终结符实现解释操作；解释一般要递归地调用解释操作(Interpret)
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

/**
 * 抽象表达式
 * Map context充当上下文
 */
interface AbstractExpression {
    // Map中的key为变量名，value为变量值
    int interpret(Map context);
}

// 终结符表达式
class TerminalExpression implements AbstractExpression {
    String key;

    public TerminalExpression(String key) {
        this.key = key;
    }

    // 根据变量名，然后对应的值
    @Override
    public int interpret(Map context) {
        return context.get(this.key);
    }
}

/**
 * 非终结符表达式：
 * 每个运算符只和其左右两边的数字有关，
 * 但左右两边的数字也可能是一个解析结果，
 * 而且无论哪个解析结果，都是AbstractExpression类型
 */
abstract class NonterminalExpression implements AbstractExpression {
    AbstractExpression left;
    AbstractExpression right;

    public NonterminalExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }
}

// 加运算符
class AddOperator extends NonterminalExpression {
    public AddOperator(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    @Override
    public int interpret(Map context) {
        return super.left.interpret(context) + super.right.interpret(context);
    }
}

// 减运算符
class SubOperator extends NonterminalExpression {
    public SubOperator(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    @Override
    public int interpret(Map context) {
        return super.left.interpret(context) - super.right.interpret(context);
    }
}

public class InterpreterClient {
    public static void main(String[] args) {
        System.out.println("定义变量：");
        Map context = new HashMap<>();
        context.put("a", 10);
        context.put("b", 5);
        context.put("c", 6);
        context.entrySet().forEach(entry -> System.out.println(entry.getKey() + " = " + entry.getValue()));
        System.out.println("计算表达式：");
        String expr = "a + b - c";
        System.out.println(expr + " = " + calc(expr).interpret(context));
    }

    // 计算的规则
    public static AbstractExpression calc(String expr) {
        LinkedList stack = new LinkedList<>();
        AbstractExpression left, right;
        for (int i = 0; i < expr.length(); i++) {
            switch (expr.charAt(i)) {
                case '+':
                    left = stack.pop();
                    right = new TerminalExpression(expr.charAt(++i) + "");
                    stack.push(new AddOperator(left, right));
                    break;
                case '-':
                    left = stack.pop();
                    right = new TerminalExpression(expr.charAt(++i) + "");
                    stack.push(new SubOperator(left, right));
                    break;
                case ' ':
                    break;
                default:
                    stack.push(new TerminalExpression(expr.charAt(i) + ""));
                    break;
            }
        }
        return stack.pop();
    }
}

9. 状态模式

状态模式：允许一个对象在其内部状态改变时改变它的行为

状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化

状态模式涉及的角色：

  1. 环境(Context)：定义客户感兴趣的接口，维护一个ConcreteState子类的实例，这个实例定义当前状态
  2. 状态(State)：定义一个接口以封装与Context的一个特定状态相关的行为
  3. 具体状态子类(ConcreteState)：每一子类实现一个与Context的一个状态相关的行为

使用状态模式前，可以先画出状态转换图来分析各个状态间的关系

// 环境
class Context {
    State state;

    public Context(State state) {
        this.state = state;
    }

    void request() {
        state.handle(this);
    }
}

// 状态
interface State {
    void handle(Context context);
}

// 具体状态子类：A
class ConcreteStateA implements State {
    @Override
    public void handle(Context context) {
        context.state = new ConcreteStateB();
        System.out.println("已从状态A切换到状态B");
    }
}

// 具体状态子类：B
class ConcreteStateB implements State {
    @Override
    public void handle(Context context) {
        context.state = new ConcreteStateA();
        System.out.println("已从状态B切换到状态A");
    }
}

public class StateClient {
    public static void main(String[] args) {
        // 初始化状态为A
        Context context = new Context(new ConcreteStateA());
        context.request();
        context.request();
        context.request();
    }
}

10. 策略模式

策略模式：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换；策略模式使得算法可独立于使用它的客户而变化

策略模式涉及的角色：

  1. 策略(Strategy)：定义所有支持的算法的公共接口；Context使用这个接口来调用某ConcreteStrategy
  2. 具体策略(ConcreteStrategy)：实现Strategy接口的某个算法
  3. 上下文(Context)：维护一个对Strategy对象的引用

java.util.Arrays就使用了策略模式：对自定义对象排序时，根据不同的排序策略来进行排序

// 策略
interface Strategy {
    void AlgorithmInterface();
}

// 具体策略A
class ConcreteStrategyA implements Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("正在使用策略A");
    }
}

// 具体策略B
class ConcreteStrategyB implements Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("正在使用策略B");
    }
}

// 上下文
class Context {
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void contextInterface() {
        this.strategy.AlgorithmInterface();
    }
}

public class StrategyClient {
    public static void main(String[] args) {
        // 默认使用策略A
        Context context = new Context(new ConcreteStrategyA());
        context.contextInterface();
        context.setStrategy(new ConcreteStrategyB());
        context.contextInterface();
    }
}

11. 责任链模式*

责任链模式：由每一个对象对其下家的引用而连接起来形成一条链，请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任

责任链模式涉及的角色：

  1. 抽象处理者角色(Handler)：定义一个处理请求的接口，可以定义出一个方法以设定和返回对下家的引用
  2. 具体处理者角色(ConcreteHandler)：接到请求后，如果可处理该请求，就处理之；否则将该请求转发给它的后继者
// 抽象处理者角色
abstract class Handler {
    protected int maxPriority;
    protected Handler successor;

    public Handler setSuccessor(Handler successor) {
        this.successor = successor;
        return this;
    }

    public final void request(int priority) {
        if (priority <= this.maxPriority) {
            handleRequest();
        } else if (successor != null) {
            successor.request(priority);
        } else {
            System.out.println("无法处理");
        }
    }

    abstract void handleRequest();
}

// 具体处理者角色：1
class ConcreteHandler1 extends Handler {
    public ConcreteHandler1(int maxPriority) {
        this.maxPriority = maxPriority;
    }

    @Override
    void handleRequest() {
        System.out.println("第一层处理");
    }
}

// 具体处理者角色：2
class ConcreteHandler2 extends Handler {
    public ConcreteHandler2(int maxPriority) {
        this.maxPriority = maxPriority;
    }

    @Override
    void handleRequest() {
        System.out.println("第二层处理");
    }
}

public class ChainOfResponsibilityClient {
    public static void main(String[] args) {
        // 所有请求，都从第一个Handler开始处理
        Handler handler = new ConcreteHandler1(10).setSuccessor(
                new ConcreteHandler2(100).setSuccessor(
                        null));
        handler.request(5);
        System.out.println("---------");
        handler.request(50);
        System.out.println("---------");
        handler.request(500);
    }
}

你可能感兴趣的:(04-行为型模式)

  • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
  • 23种设计模式详解 WineMonk #设计模式设计模式
    23种设计模式详解文章目录23种设计模式详解1设计模式概述1.1创建型模式（CreationalPatterns）2.2结构型模式（StructuralPatterns）3.3行为型模式（BehavioralPatterns）2设计模式详解2.1简单工厂模式（SimpleFactoryPattern）2.1.1定义2.1.2结构2.1.3示例代码2.1.4特点2.1.5适用场景2.1.6工厂方法模
  • Java设计模式之单例模式/饿汉式/懒汉式/DCL双重检测锁模式/静态内部类实现单例模式/使用反射破坏单例模式/枚举类实现单例模式 ZaynFox #JavaSE
    一、概念设计模式：是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。共有23种设计模式：创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共11种：策
  • java设计模式---中介者模式 奔跑的扫地僧 Java设计模式java
    首先我们了解下设计模式的总览：GoF提出的设计模式总共有23种，根据目的准则分类分为三大类：创建型模式，共五种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式
  • 设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者 JunSIr_# 面向对象设计模式责任链命令观察者备忘录
    设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者文章目录设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者责任链模式（ChainofResponsibilityPattern）命令模式（CommandPattern）迭代器模式（IteratorPattern）备忘录模式（MementoPattern）观察者模式（Obse
  • 软考-常见的23种设计模式整理 ppliu600 软件架构数据仓库数据库数据挖掘
    参考：23种设计模式总结设计模式可以将复用别人的解决方案。一、设计模式的分类创建型模式，共5种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、组合模式、代理模式、享元模式、外观模式、桥接模式、装饰器模式、行为型模式，共11种：观察者模式、策略模式、模板方法模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
  • Python之最常用的16种设计模式 ModelBulider Python基础（千锋篇）python设计模式javascript
    文章目录一、设计模式与面向对象介绍1.1设计模式1.2复习：面向对象1.3接口二、面向对象设计SOLID原则三、设计模式分类四、创造型模式4.1简单工厂模式4.2工厂方法模式4.3抽象工厂模式4.4建造者模式4.5单例模式4.6创建型模式小结五、结构型模式5.1适配器模式5.2桥模式5.3组合模式5.4外观模式5.5代理模式六、行为型模式6.1责任链模式6.2观察者模式6.3策略模式6.4模板方法
  • Java 创建型设计模式详解 li.wz JavaSE设计模式java设计模式
    Java创建型设计模式详解在软件开发中，设计模式是解决特定问题的通用解决方案。设计模式并不依赖于编程语言，但它们在Java等面向对象的语言中非常有用。设计模式可以分为三类：创建型模式、结构型模式和行为型模式。本文将深入探讨六种常见的创建型设计模式：简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。1.简单工厂模式（SimpleFactoryPattern）概念简单工厂模式并
  • 【备战软考（嵌入式系统设计师）】04-嵌入式软件架构 折途想要敲代码 备战软考架构嵌入式硬件mcu单片机
    嵌入式操作系统嵌入式系统有以下特点：要求编码体积小，能够在有限的存储空间内运行。面向应用，可以进行裁剪和移植。用于特定领域，可以支持多任务。可靠性高，及时响应，无需人工干预独立运行。实时性高，且要求固态存储。要求在系统投入前就具有确定性和可预测性。一般考在选择题。机内自检BIT（Built-InTest，机内自检），可以完成对故障的检测和定位。包括下面四种：上电BIT：在系统上电的时候对所有硬件资
  • 浙大陈越数据结构04-树4 是否同一棵二叉搜索树 ethnanli c++算法
    本方法使用慕课上何老师讲的方法，使用C++实现#include#includeusingnamespacestd;structTreeNode;typedefTreeNode*treePointer;structTreeNode{intval;treePointerleft;treePointerright;intflag;TreeNode(intnum):val(num),left(nullpt
  • 04-树4 是否同一棵二叉搜索树(浙大数据结构PTA习题） Learner_HJ 数据结构算法c++c语言
    04-树4是否同一棵二叉搜索树分数25作者陈越单位浙江大学给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2,1,3}和{2,3,1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。输入格式:输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)和
  • 浙大数据结构：04-树4 是否同一棵二叉搜索树 _Power_Y 数据结构浙大数据结构c++算法
    这道题依然使用了map（不知道为什么很爱用map，哈哈），缩短了一些代码量简单先说一下思路，建立一棵标准的树，然后依次建立待测试的树，拿它与标准的树每一个结点去对比，不一样则为No.1、条件准备map还是老样子，键存值，数对存左右结点#include#includeusingnamespacestd;map>ma,mb;这里n,l输入并判断是否结束，具体实现放在solve里intmain(){io
  • 设计模式-行为型模式-迭代器模式 LB_bei 设计模式迭代器模式
    1.迭代器模式的定义迭代器模式提供一种对容器对象中的各个元素进行访问的方法，而不需要暴露该对象的内部细节；在软件系统中，容器对象有两个职责：一是存储数据，二是遍历数据；从依赖性上看，前者是基本职责，而后者是可以变化的，又是可以分离的，因此可以将遍历数据的行为从容器中抽取出来，封装到迭代器对象中，由迭代器来提供遍历数据的行为，这将简化聚合对象的设计，更加符合单一职责原则；对于迭代器模式，设计时很少用
  • c#--实现23种常见的设计模式动态汇总 @Crazy Snail C#新手村c#设计模式开发语言
    设计模式通常分为三个主要类别：创建型模式结构型模式行为型模式。这些模式是用于解决常见的对象导向设计问题的最佳实践。以下是23种常见的设计模式并且提供c#代码案例：创建型模式：1.单例模式（Singleton）public sealed class Singleton{    //创建一个只读的静态Singleton实例    private static readonly Singleton in
  • 【卷起来】VUE3.0教程-04-表单输入绑定 听潮阁 VUE3.xhtml5csscss3vue.jslayuiscss
    Hello，各位老铁，今天我们继续给大家讲解VUE3.0教程，本期我们讲述一下VUE中的表单输入绑定，在实际开发过程中，表单的输入是我们常见的功能，那么我们接下来看看，VUE是如何处理的。=========各位看官，在开始学习之前，请帮我点个关注和赞吧==========表单输入绑定概述在前端处理表单时，我们常常需要将表单输入框的内容同步给JavaScript中相应的变量。手动连接值绑定和更改事件
  • 设计模式-行为型模式-策略模式 LB_bei 设计模式设计模式策略模式
    1.策略模式的定义定义一系列算法，将每个算法封装起来，并使他们可以相互替换，使得算法可以随着使用他的客户端变化而变化；当实现某一个功能存在多种算法或策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来实现该功能；1.1策略模式的优缺点优点由于策略类都实现同一个接口，他们之间可以自由切换；易于扩展，增加一个新的策略只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合开闭原则；避免使
  • 设计模式-行为型模式-职责链模式 LB_bei 设计模式设计模式
    1.职责链模式的定义避免讲一个请求的发送者与接收者耦合在一起，让多个对象都有机会处理请求，将接受请求的对象连接成一条链，并且沿着这条链传递请求，直到有一个对象能处理他为止；1.1职责链模式的优缺点优点降低了对象之间的耦合度增强了系统的可扩展性，可以根据需要增加新的请求处理类，满足开闭原则；增强了给对象指派职责的灵活性，当工作流程发生变化时，可以动态的改变链内的成员或者修改他们的次序，也可以动态的新
  • 设计模式之观察者模式 200不是二百 观察者模式
    观察者模式观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。当对象间存在一对多关系时，则使用观察者模式（ObserverPattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。创建了对象间的一种一对多的依赖关系，当一个对象状态改变时，所有依赖于它的对象都会得到通知并自动更新。主要解决
  • 面向对象23种设计模式通俗理解 孟吶李唦 设计模式
    终点即是起点,自强不息!设计模式的理解设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。模式：在某些场景下，针对某类问题的某种通用的解决方案。场景：项目所在的环境问题：约束条件，项目目标等解决方案：通用、可复用的设计，解决约束达到目标。设计模式的三个分类创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。结构型模式：把类或对象结合在一起形成一个更大的结构。行为型模式：
  • 设计模式 15 解释器模式 WineMonk #设计模式设计模式解释器模式
    设计模式15创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式15解释器模式（InterpreterPattern）1定义
  • 设计模式 18 备忘录模式 WineMonk #设计模式设计模式备忘录模式
    设计模式18创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式18备忘录模式（MementoPattern）1定义2结构3
  • java 23种设计模式 Lambert_lin0 java设计模式开发语言
    作者备注：该文未全部完成，正在编辑完善中文字结构：第1章为类型第2章为概念第3章为概念和优缺点第4章为详细或demo第1章Java语言中常用的设计模式有23种，它们被分为三大类：1、创建型模式（CreationalPatterns）2、结构型模式（StructuralPatterns）3、行为型模式（BehavioralPatterns）第2章创建型模式（CreationalPatterns）:1
  • 【重走编程路】设计模式概述（八） -- 策略模式、模板方法模式 咖啡+=方糖 重走编程路设计模式策略模式模板方法模式
    文章目录前言13.策略模式（Strategy）定义解决方案应用场景优缺点14.模板方法模式（TemplateMethod）问题解决方案应用场景优缺点前言行为型模式关注对象之间的交互以及如何分配职责，提供了一种定义对象之间的行为和职责的最佳方式。本章介绍创建型模式中的策略模式和模板方法模式。13.策略模式（Strategy）定义策略模式定义了一系列算法，并将每一种算法封装起来，使它们可以相互替换。策
  • 设计模式-备忘录模式（Memento） BrightChen666 设计模式设计模式备忘录模式
    1.概念备忘录模式（MementoPattern）是一种行为型设计模式，它允许在不破坏对象封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样，以后就可以将该对象恢复到原先保存的状态。该模式属于行为型模式，主要目的是提供一种可以恢复对象状态的机制。2.原理结构图图发起人（Originator）角色定义：记录当前时刻的内部状态，并可以恢复到一个先前状态（即它之前保存至备忘录的状态
  • Java23种设计模式-行为型模式之备忘录模式 秃头佛爷 设计模式笔记设计模式备忘录模式
    备忘录模式（MementoPattern）:用于捕获和存储一个对象的内部状态，以便在以后可以将对象恢复到这个状态。备忘录模式通常用于实现撤销功能或者保存对象的历史状态。主要角色：发起人（Originator）：负责创建一个备忘录对象，用于记录当前的内部状态，并可以使用备忘录对象来恢复内部状态。备忘录（Memento）：用于存储发起人的内部状态，可以包含多个状态属性。管理者（Caretaker）：负
  • 行为模式6.备忘录模式------文本的撤销和保存 臣妾写不来啊 23种设计模式备忘录模式
    行为型模式模板方法模式（TemplateMethodPattern）命令模式（CommandPattern）迭代器模式（IteratorPattern）观察者模式（ObserverPattern）中介者模式（MediatorPattern）备忘录模式（MementoPattern）解释器模式（InterpreterPattern）状态模式（StatePattern）策略模式（StrategyPat
  • Java的设计模式 贾斯汀玛尔斯 Javajava设计模式开发语言
    设计模式分类在Java中，设计模式是一套被反复使用的、被多数人知晓的、经过分类编目的、代码设计经验的总结。它们是软件开发过程中为了提升代码的可维护性、可扩展性和可重用性而采用的解决方案。Java设计模式主要分为三大类：创建型模式（CreationalPatterns）结构型模式（StructuralPatterns）行为型模式（BehavioralPatterns）下面详细介绍每一类模式及其子模式
  • 设计模式 11 享元模式 WineMonk #设计模式设计模式享元模式
    设计模式11创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式11享元模式（FlyweightPattern）1定义2结构
  • 设计模式之行为型模式 川谷_ 设计模式设计模式
    一、概述1、行为型模式关注系统中对象之间的交互，研究系统在运行时对象之间的相互通信与协作，进一步明确对象的职责2、行为型模式：不仅仅关注类和对象本身，还重点关注它们之间的相互作用和职责划分3、类行为型模式：使用继承关心在几个类之间分配行为，主要通过多态等方式来分配父类与子类的职责4、对象行为模式：使用对象的关联关系来分配行为，主要通过对象关联等方式分配两个或多个类的职责二、行为型模式分类职责链模式
  • 【设计模式】命令模式（Command Pattren） 櫆溟 命令模式设计模式java
    命令模式(CommandPattren)属于行为型模式，它又被称做动作(Action)模式或事务(Transaction)模式。命令模式将请求者发送的请求封装为命令对象，这个命令对象将携带请求者的相关信息被传递到接收者，以此来达到请求者和接收者的解耦操作，让对象之间的调用更加灵活。在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理
  • java杨辉三角 3213213333332132 java基础
    package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
  • 《大话重构》之大布局的辛酸历史 白糖_ 重构
    《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。   背景         公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
  • 电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频ed2k
    本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
  • Javascript中函数的toString()方法 周凡杨 JavaScriptjstoStringfunctionobject
    简述     The toString() method returns a string representing the source code of the function.     简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 句法     function.
  • struts处理自定义异常 g21121 struts
    很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
  • Linux中find常见用法示例 510888780 linux
    Linux中find常见用法示例 ·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; find命令的参数；
  • SpringMVC的各种参数绑定方式 Harry642 springMVC绑定表单
    1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
  • Java 获取Oracle ROWID aijuans javaoracle
    A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
  • java获取方法的参数名 antlove javajdkparametermethodreflect
    reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
  • JAVA正则表达式匹配 查找 替换 提取操作 百合不是茶 java正则表达式替换提取查找
    正则表达式的查找;主要是用到String类中的split();       String str;      str.split();方法中传入按照什么规则截取,返回一个String数组   常见的截取规则: str.split("\\.")按照.来截取 str.
  • Java中equals()与hashCode()方法详解 bijian1013 javasetequals()hashCode()
    一.equals()方法详解     equals()方法在object类中定义如下：  public boolean equals(Object obj) { return (this == obj); }    很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
  • 精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle数据库plsql
    --工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
  • 【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
     Nginx作为静态文件HTTP服务器 在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片 在主配置文件中添加http指令   http { server { listen 80; server_name
  • kafka获得最新partition offset blackproof kafkapartitionoffset最新
    kafka获得partition下标，需要用到kafka的simpleconsumer   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
  • centos 7安装docker两种方式 ronin47
          第一种是采用yum 方式              yum install -y docker           
  • java-60-在O(1)时间删除链表结点 bylijinnan java
    public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
  • nginx利用proxy_cache来缓存文件 cfyme cache
    user  zhangy users; worker_processes 10; error_log  /var/vlogs/nginx_error.log  crit; pid        /var/vlogs/nginx.pid; #Specifies the value for ma
  • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
        假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做：     string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))"     定义一个0整数c,然后用这个整数c去
  • 如何集成支付宝官方文档 dai_lm android
    官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成 调试的时候估计会真的扣款，请注意
  • 应该在什么时候使用Hadoop datamachine hadoop
    原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
  • 在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
    在GridView中使用关联模型进行搜索和排序 首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
  • 使用NSString 的格式化大全 dcj3sjt126com Objective-C
    格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
  • 使用activeX插件对象object滚动有重影 蕃薯耀 activeX插件滚动有重影
      使用activeX插件对象object滚动有重影   <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
  • SpringMVC4零配置 hanqunfeng springmvc4
    基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。     项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
  • 《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
    问题引入 上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
  • AngularJS浅析 kvhur JavaScript
    概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
  • 架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
    1.前言.    jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
  • 如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
      本文链接:  http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求 首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 说一下，
  • C语言算法之水仙花数 qiufeihu c算法
    /** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
  • JSP指令 wyzuomumu jsp
    jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他