Java实现双向链表的实现 简单的工厂代理模式

6人阅读 评论(0) 收藏 举报
分类:

设计思想:

这里写图片描述

package ListTest;

//定义链表接口 定义链表行为的地方
interface Link {
    void add(Object obj);
    boolean remove(int index);
    boolean contains(Object obj);
    int indexOf(Object obj);
    boolean set(int index, Object obj);
    Object get(int index);
    int length();
    void clear();
    Object[] toArray();
    void printLink();
}

//工厂模式
class Factory{
    private Factory() {}
    public static Link getLinkInstance() {
        return new LinkImpl();
    }
}

//实现接口
class LinkImpl implements Link {
    private class Node {
        Object data;
        Node prev;
        Node next;
        public Node(Node prev, Object obj, Node next) {
            this.data = obj;
            this.prev = prev;
            this.next = next;
        }
    }
    private Node first;
    private Node last;
    int size;
    public void add(Object obj) {
        if(first == null) {
            Node newNode = new Node(null, obj, null);
            this.first = this.last = newNode;
            newNode.prev = newNode.next = null;
            ++this.size;
        } else{
            Node newNode = new Node(last, obj, null);
            this.last.next = newNode;
            this.last = newNode;
            ++this.size;
        }
    }
    public boolean remove(int index) {
        if(!this.isEmptyIndex(index)) {
            return false;
        }
        Node rm = (Node)this.get(index);
        if(rm == this.first) {
            if(this.first == this.last) {
                this.first = this.last = null;
                this.size--;
            } else {
                this.first = rm.next;
                this.first.prev = null;
                this.size--;
            }
        } else if (rm == this.last) {
            this.last = rm.prev;
            this.last.next = null;
            this.size--;
        } else {
            rm.prev.next = rm.next;
            rm.next.prev = rm.prev;
            this.size--;
        }
        return true;
    }

    public boolean contains(Object obj) {
        for(Node tmp = this.first; tmp != null; tmp = tmp.next) {
            if(obj.equals(tmp.data)) {
                return true;
            }
        }
        return false;
    }
    public int indexOf(Object obj) {
        int index = 0;
        for(Node tmp = this.first; tmp != null; tmp = tmp.next) {
            ++index;
            if(obj.equals(tmp.data)) {
                return index;
            }
        }
        return -1;
    }
    public boolean set(int index, Object obj) {
        if(!this.isEmptyIndex(index)) {
            return false;
        }
        Node tmp = (Node)this.get(index);
        tmp.data = obj;
        return true;
    }
    public Object get(int index) {
        if(!this.isEmptyIndex(index)) {
            return false;
        }
        Node tmp = this.first;
        while(index-- != 0) {
            tmp = tmp.next;
        }
        return tmp;
    }
    public int length() {
        return this.size;
    }
    public void clear() {
        for(Node tmp = this.first; tmp != null;) {
            Node next = tmp.next;
            tmp.next = tmp.prev = null;
            tmp = next;
        }
    }
    public Object[] toArray() {
        Object[] obj = new Object[this.size];
        int j = 0;
        for(Node i = this.first; i != null; i = i.next) {
            obj[j++] = i.data;
        }
        System.out.println("转换为数组时数组的长度:" + obj.length);
        return obj;
    }
    public void printLink() {
        for(Object data : this.toArray()) {
            System.out.println(data);
        }
    }
    public boolean isEmptyIndex(int index) {
        return index >= 0 && index <= this.size;
    }
}

//主函数,测试链表
public class ListTest {
    public static void main(String[] args) {
        Link link = Factory.getLinkInstance();
        link.add("车头");
        link.add("一号车厢");
        link.add("二号车厢");
        link.add("三号车厢");
        link.printLink();
        System.out.println("link 的长度" + link.length());
        link.remove(3);
        link.printLink();
        System.out.println("link 的长度" + link.length()); 
    }

在eclipse 4.7.2 下运行结果
这里写图片描述

查看评论

单例模式,工厂模式,代理模式汇总

1.单例模式: 饿汉式 (可用) public class Demo{ private static Demo demo = new Demo(); private Demo()...
  • rusbme
  • rusbme
  • 2016-05-03 16:17:18
  • 3896

Java 的工厂方法及代理模式

Java 的工厂方法及代理模式
  • Air_hjj
  • Air_hjj
  • 2017-05-22 15:37:24
  • 634

代理模式,简单(静态)工厂模式,单例模式,模板方法模式个人理解

简言:java中总共有23种设计模式,每个模式的出现都是为了解决某一方面的问题,所以这23种设计模式有他们各自适用的地方(废话有点多),而设计模式的产生主要是为了降低类与类之间的耦合度。下面我们就简单...
  • u013825231
  • u013825231
  • 2016-07-21 19:53:31
  • 1018

设计模式篇-工厂模式与代理模式的混用(Factory+proxy pattern )

设计模式篇-工厂模式与代理模式的混用(Factory+proxy pattern )本篇博客将介绍一个 工厂模式+ 代理模式 一起混合使用的 demo 此demo的需求 是一个弹弹球工厂, 产品 ...
  • qq_14995933
  • qq_14995933
  • 2016-03-12 22:42:46
  • 1345

设计模式——单例模式、工厂模式、代理模式、观察者模式、装饰器模式

设计模式是一种解决方案,用于解决在软件设计中普遍存在的问题,是前辈们对之前软件设计中反复出现的问题的一个总结。 至于我们为什么要学习设计模式,我觉得轮子哥总结的很好 我们学设计模式,是为了学习如...
  • learrrrrrrrn
  • learrrrrrrrn
  • 2017-03-26 16:55:17
  • 1951

简单代理模式 JAVA

在阎宏博士的《JAVA与模式》一书中开头是这样描述代理(Proxy)模式的:   代理模式是对象的结构模式。代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。 代理模式的结...
  • chenpeng19910926
  • chenpeng19910926
  • 2016-05-20 10:14:36
  • 509

小型Java Web项目之DAO操作标准、DAO接口真实实现类、DAO代理实现类、DAO工厂

DAO模式的好处是数据访问和业务逻辑分离,便于数据维护,业务逻辑不需要了解访问细节。 DAO的组成: 1.DatabaseConnection:负责打开和关闭数据库; 2.VO:包含属性以及其g...
  • DiligentOrange
  • DiligentOrange
  • 2017-05-02 21:59:48
  • 404

线程池与工厂模式、代理模式的结合使用

为了提高代码的效率,我们经常会使用到线程池,那在实际项目工作中,如何将线程池与工厂模式和代理模式结合使用,使我们的代码更高效,更具有面象对象的思想,以及维护和拓展性更高呢? 接下来,我将结合下列代码...
  • GitHub_boy
  • GitHub_boy
  • 2016-04-03 01:27:28
  • 1572

学习笔记----设计模式之动态代理+工厂模式的混合使用简单demo

最近项目有个需求,要用到动态代理调用远程接口,然后就学习了一下该设计模式并记录下来。...
  • li_yan_fei
  • li_yan_fei
  • 2017-04-07 16:07:30
  • 706

Java双向链表实现

public class DoublyLinkList { private class Data{ private Object obj; private Data left = null;...
  • a19881029
  • a19881029
  • 2014-04-03 22:42:08
  • 8413
    个人资料
    等级:
    访问量: 1463
    积分: 195
    排名: 103万+
    文章分类