一个Java小白面试得力集团的收获

- 抽象主题角色：把所有对观察者对象的引用保存在一个集合中，一般用`ArrayList`。每个抽象主题角色都可以有任意数量的观察者。抽象主题可以提供一个接口，可以增加和删除观察者。一般用一个抽象类和接口来实现。
- 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时可以更新自己。
- 具体主题角色： 在具体主题内部状态发生改变的时候，给所有注册过的观察者发出通知。
- 具体观察者角色： 实现抽象观察者中的更新接口，以便使本身的状态与主题的状态相互协调。手写观察者模式

- 定义一个`Subject`类，也就是被观察者。

public class Subject {

    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public abstract class Observer {

    protected Subject subject;

    public abstract void update();
}

 public class BinaryObserver extends Observer {

    public BinaryObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("binary=" + Integer.toBinaryString(subject.getState()));
    }
}

 public class OctalObserver extends Observer {

    public OctalObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("octal:" + Integer.toOctalString(subject.getState()));
    }
}

public class ObserverPatternDemo {

    public static void main(String[] args) {
        Subject subject = new Subject();

        new BinaryObserver(subject);
        new OctalObserver(subject);

        subject.setState(15);

        subject.setState(10);
    }
}

- 观察者和被观察者是抽象耦合的。
- 建立一套触发机制。

- 如果一个被观察者对象有很多的直接和间接的观察者的话， 将所有的观察者都通知到会花费很多时间。
- 如果在观察者和被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，可能会导致系统崩溃。
- 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

public class Person implements Externalizable {

    private String name;
    private int age;

    public Person(String name, int age) {
        System.out.println("有参数的构造器");
        this.name = name;
        this.age = age;
    }

    public Person() {
        System.out.println("无参数的构造器");
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        this.age = in.readInt();
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

public class ExternalizableDemo {

    public static void main(String[] args) throws IOException {
        File fileName = new File("externalizable.txt");
        FileOutputStream fos = new FileOutputStream(fileName);
        FileInputStream fis = new FileInputStream(fileName);
        ObjectOutputStream os = new ObjectOutputStream(fos);
        ObjectInputStream is = new ObjectInputStream(fis);

        try {
            Person person = new Person("cmazxiaoma", 21);
            os.writeObject(person);
            os.writeObject(person);

            Person newPerson = (Person) is.readObject();
            System.out.println(newPerson);
            System.out.println("两个person对象引用是否相等 :" + person == newPerson + "");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            close(is);
            close(os);
            close(fis);
            close(fos);
        }
    }

    public static void close(Closeable closeable) {
        try {
            if (closeable != null) {
                closeable.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class NIODemo {

    public static void main(String[] args) throws IOException {
        // methodOne();
        // methodTwo();
        methodThree();
    }

    public static void methodOne() throws IOException {
        String rFile = "nio_read.txt";
        String wFile = "nio_write.txt";
        FileChannel rFileChannel = new FileInputStream(rFile).getChannel();
        FileChannel wFileChannel = new FileOutputStream(wFile).getChannel();
        ByteBuffer buff = ByteBuffer.allocate(1024);

        while (rFileChannel.read(buff) > 0) {
            buff.flip();
            wFileChannel.write(buff);
            buff.clear();
        }

        close(wFileChannel);
        close(rFileChannel);
    }

    public static void methodTwo() throws IOException {
        String rFile = "nio_read.txt";
        String wFile = "nio_write.txt";
        FileChannel rFileChannel = new FileInputStream(rFile).getChannel();
        FileChannel wFileChannel = new FileOutputStream(wFile).getChannel();

        rFileChannel.transferTo(0, rFileChannel.size(), wFileChannel);

        close(wFileChannel);
        close(rFileChannel);
    }

    public static void methodThree() throws IOException {
        String rFile = "nio_read.txt";
        String wFile = "nio_write.txt";
        RandomAccessFile raf = new RandomAccessFile(rFile, "rw");
        FileChannel randomChannel = raf.getChannel();
        FileChannel wFileChannel = new FileOutputStream(wFile).getChannel();

        // 将Channel中的所有数据映射成ByteChannel
        ByteBuffer buff = randomChannel.map(FileChannel.MapMode.READ_ONLY, 0, raf.length());

        // 把Channel的指针移动到最后
        randomChannel.position(raf.length());
        wFileChannel.write(buff);

        close(wFileChannel);
        close(randomChannel);
    }

    public static void close(Closeable closeable) {
        try {
            if (closeable != null) {
                closeable.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}