zoukankan      html  css  js  c++  java
  • Java集合类(Java Collections classes)

     Java集合结构图

     

    Example1:

    Problem: Want a simple banking system. Can look up accounts by name or number, deposit or withdraw, print.

    问题:设计一个简单的银行系统。可以看到每一个账号里面的名称、编号、存款或取款,并打印之。

    方案:

    class Account {
        Account (String name, String number, int init) {
            this.name = name; this.number = number;
            this.balance = init;
        }
        /** 账号拥有者名字 */
        final String name;
        /** 账号编号 */
        final String number;
        /** 当前余额 */
        int balance;
        /** 按照一定格式打印 */
        void print (PrintWriter str) { ... }
    }
    class Bank {
        SortedMap<String,Account> accounts = new TreeMap<String,Account> ();
        SortedMap<String,Account> names = new TreeMap<String,Account> ();
        void openAccount (String name, int initBalance) {
            Account acc = new Account (name, chooseNumber (), initBalance);
            accounts.put (acc.number, acc);
            names.put (name, acc);
        }
        void deposit (String number, int amount) {
            Account acc = accounts.get (number);
            if (acc == null) ERROR(...);
            acc.balance += amount;
        }
        // 取款也相同
        /** 按照账号编号打印 */
        void printByAccount (PrintStream str) {
            for (Account account : accounts.values ())
                account.print (str);
        }
        /** 按照账号拥有者打印 */
        void printByName (PrintStream str) {
            for (Account account : names.values ())
               account.print (str);
        }
    }

    A Design Question: What would be an appropriate representation for keeping a record of all transactions (deposits and withdrawals) against each account?

    一个设计问题:怎样的形式适合存储每个账号的交易(存款或者提款)数据?

    Example2

    抽象类应用例子。

    Problem: Want to create a reversed view of an existing List (same elements in reverse order).

    问题:如何创建一个反序列表。

    public class ReverseList<Item> extends AbstractList<Item> {
        private final List<Item> L;
        public ReverseList (List<Item> L) { this.L = L; }
        public int size () { return L.size (); }
        public Item get (int k) { return L.get (L.size ()-k-1); }
        public void add (int k, Item x)
            { L.add (L.size ()-k, x); }
        public Item set (int k, Item x)
            { return L.set (L.size ()-k-1, x); }
        public Item remove (int k)
            { return L.remove (L.size () - k - 1); }
    }

    ArrayList

    – Advantages: compact, fast random access (indexing).
    – Disadvantages: insertion, deletion can be slow

    — 好处:

    1. 紧凑的空间利用,比其包含的所有元素所占空间总量要小
    2. 随机获取元素快(Θ(1)),常数时间完成操作

    — 坏处:

      在最坏情况下,改变序列的操作非常缓慢(Θ(N))

    • 考虑A.read(x),也就是A.add(A.size(), x),即在序列最后添加元素。对于一个总容量为K的ArrayList,如果当存储元素达到总容量时,总容量扩大1,则有成本:

        

    于是最差情况下有:

        

    有点没写清楚,应该是Θ(M0 + (M0 + 1) + ... +  (M0 + N))

    • 换一种方法,如果到达总容量时,容量扩一倍,则有成本:

        

    我们利用势能分析法(potential method),构造一个势能公式,势能必然与添加元素个数i,容量Si,原容量S0有关,满足:

        ai + b (Si - S0)

    必须满足,势能起点为0,势能必然大于0。所以可以构造出:

       

    因为2i > Si ,所以满足大于等于0。

    当i < Si 时,有:

    当i = Si 时,有:

    可见分摊成本是常数。

    单链表(Singly Linked Lists)

    简单实现:

    class Entry {
        Entry (Object head, Entry next) {
            this.head = head; this.next = next;
        }
        Object head;
        Entry next;
    }

    Changing the structure of a linked list (its set of containers) involves what is colloquially known as “pointer swinging.” 

    改变其数据结构,要使用被俗称为“摇曳的指针”(正如你所见到的,这是我胡起的)的手段。

    “哨兵”(Sentinels)技术:

    通常我们用这种方式添加链表:

    L = L.next; 
    L = new Entry ("aardvark", L); 

    但这样子头部的时候有所差别,所以我们添加一个“哨兵”节点来解决头部的差异性:

    然后我们这要返回除掉哨兵节点的链表就可以了。

    单链表好处:

    • 简单创建,操作方便

    单链表坏处:

    1. 被迫只能从头部迭代到当前位置,没有较快的方法到当前位置
    2. 要删除当前位置的元素,我们需要前一个元素的指针,但单链表没这东东

    于是我们添加一个向前的指针来解决这个问题。

    特殊列表

    堆栈(Stack):先进的后出,从头部进从头部出。

    队列(Queue):先进的先出,从头部进从尾部出。

    双端列表(Deque):那边进出都可以。

    相关资料

    Data Structures (Into Java) . Paul N. Hilfinger

    Potential method . Wiki

    数据结构(算法艺术) . 刘汝佳

  • 相关阅读:
    IO 单个文件的多线程拷贝
    day30 进程 同步 异步 阻塞 非阻塞 并发 并行 创建进程 守护进程 僵尸进程与孤儿进程 互斥锁
    day31 进程间通讯,线程
    d29天 上传电影练习 UDP使用 ScketServer模块
    d28 scoket套接字 struct模块
    d27网络编程
    d24 反射,元类
    d23 多态,oop中常用的内置函数 类中常用内置函数
    d22 封装 property装饰器 接口 抽象类 鸭子类型
    d21天 继承
  • 原文地址:https://www.cnblogs.com/justany/p/2760838.html
Copyright © 2011-2022 走看看