Java 字典集合中的LinkedList

我对整个“数据结构”是个新手

我正在尝试使用LinkedList（来自Java集合）实现字典。 我截取了过去某个人的一个例子

[Entry.java]

public class Entry<K, V> {

    K key;
    V value;

    public Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K key() {
        return key;
    }

    public V value() {
        return value;
    }
}

公共类条目{
K键；
V值；
公共输入（K键，V值）{
this.key=key；
这个值=值；
}
公钥{
返回键；
}
公共价值{
返回值；
}
}

[Dictionary.java]

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Dictionary<K, V> {

    private List<Entry<K, V>> set;

    public Dictionary() {
        this.set = new LinkedList<Entry<K, V>>();
    }

    public Entry<K, V> find(K key) {
        // for all entries in set...
        //   check if key mathches
        //     - if it does than return it

        // else
        return null;
    }


    /**
     * insert(k, o): inserts and returns the entry (k, o)
     */
    public Entry<K, V> insert(K key, V value) {
        // obvious
        return null;
    }

    public int size() {
        return set.size();
    }

    public boolean isEmpty() {
        return size() == 0;
    }
}

import java.util.Iterator；
导入java.util.LinkedList；
导入java.util.List；
公共类词典{
私有列表集；
公共词典（）{
this.set=新建LinkedList（）；
}
公共条目查找（K键）{
//对于集合中的所有条目。。。
//检查键是否正确
//-如果有，则退回
//否则
返回null；
}
/**
*插入（k，o）：插入并返回条目（k，o）
*/
公共输入插入（K键，V值）{
//明显的
返回null；
}
公共整数大小（）{
返回set.size（）；
}
公共布尔值为空（）{
返回大小（）==0；
}
}

你能给我举个例子，说明如何使用LinkedList的Java集合中的“插入”和“查找”函数吗？ 我需要一个单独的索引吗？除了K和V

---

非常感谢。地图界面正是您需要的。根据Javadocs：

Dictionary类是任何类的抽象父类，例如 哈希表，它将键映射到值。每个键和每个值都是一个 对象在任何一个Dictionary对象中，每个键都与at关联 最重要的是一个值。给定一个字典和一个键，关联的元素 可以查到。任何非null对象都可以用作键和 价值一般来说，实现应该使用equals方法 来决定两个键是否相同

注意：这个类是 过时的。新的实现应该实现映射接口， 而不是扩展此类。

正如Javadocs所述，hashmap包含一个键值对，下面是如何实现此类的：

    package hashmap;
import java.util.*;

public class HashMap<K,V> implements Map<K,V> {
    private final int TABLESIZE = 101;
    private LinkedList<Node<K, V>>[] list;

    @SuppressWarnings("unchecked")
    public HashMap() {
        // Creates a hash table with a table size of TABLESIZE  
        list = new LinkedList[TABLESIZE];
    }

    // Returns the Hasindex of a key
    private int getHashIndex(Object key) {
        String hashCode = key.toString();
        int i = Integer.parseInt(hashCode.substring(hashCode.length() - 4));
        return i % TABLESIZE;
    }

包hashmap；
导入java.util.*；
公共类HashMap实现映射{
私有final int TABLESIZE=101；
私有链接列表[]列表；
@抑制警告（“未选中”）
公共HashMap（）{
//创建表大小为TABLESIZE的哈希表
列表=新的LinkedList[表大小]；
}
//返回键的索引
私有int getHashIndex（对象键）{
字符串hashCode=key.toString（）；
int i=Integer.parseInt（hashCode.substring（hashCode.length（）-4））；
返回i%表大小；
}

//get方法，该方法首先查找bucket，然后迭代每个bucket public V get（对象键）{ 试一试{

            LinkedList<Node<K,V>> bucket = list[getHashIndex(key)]; 
            Iterator<Node<K,V>> itr = bucket.iterator();
            while (itr.hasNext()) {
                Node<K,V> node = itr.next();
                if (node.getKey().equals(key)) {
                    return node.getValue();
                }
            }
        }
        // if there is no bucket return null

        catch (NullPointerException e) {
            return null;
        }

        return null;
    }

       //add method
    public V put(K key, V value) {  
        // Hvis der ikke er en spand i forvejen tilføjes en ny
        if (list[getHashIndex(key)] == null) {
            list[getHashIndex(key)] = new LinkedList<Node<K,V>>();
        }

        LinkedList<Node<K,V>> bucket = list[getHashIndex(key)]; 
        Iterator<Node<K,V>> itr = bucket.iterator();
        V prevouis = null;
        while (itr.hasNext()) {
            Node<K,V> node = itr.next();
            if (node.getKey().equals(key)) {
                prevouis = node.getValue();
                bucket.remove(node);
                break;
            }
        }
        bucket.addLast(new Node<K,V>(key, value));


        return prevouis;
    }

    // remove method
    public V remove(Object key) {
        // Itererer igennem spanden for at finde og slette den korrekte nøgle       
        LinkedList<Node<K,V>> bucket = list[getHashIndex(key)]; 
        Iterator<Node<K,V>> itr = bucket.iterator();
        V value = null;
        while (itr.hasNext()) {
            Node<K,V> node = itr.next();
            if (node.getKey().equals(key)) {
                value = node.getValue();
                bucket.remove(node);
                break;
            }
        }


        if (bucket.isEmpty()) {
            list[getHashIndex(key)] = null;
        }


        return value;
    }

    @Override
    public void clear() {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean containsKey(Object key) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean containsValue(Object value) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public Set<K> keySet() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        // TODO Auto-generated method stub

    }

    @Override
    public int size() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public Collection<V> values() {
        // TODO Auto-generated method stub
        return null;
    }


    public void printHashTable() {
        System.out.println("HashTable:");
        int nodeCount = 0;
        for (int i = 0; i < list.length; i++) {
            LinkedList<Node<K,V>> bucket = list[i];
            if (bucket != null) {
                nodeCount += bucket.size();
                System.out.println("Index " + i + ": " + bucket);
            }
        }
        System.out.println("Total nodes: " + nodeCount + "\n");
    }
}

LinkedList bucket=list[getHashIndex（key）]；
迭代器itr=bucket.Iterator（）；
while（itr.hasNext（））{
Node=itr.next（）；
if（node.getKey（）.equals（key））{
返回node.getValue（）；
}
}
}
//如果没有bucket返回null
捕获（NullPointerException e）{
返回null；
}
返回null；
}
//添加方法
公共V put（K键，V值）{
//我在纽约的天气如何
if（列表[getHashIndex（键）]==null）{
list[getHashIndex（key）]=新建LinkedList（）；
}
LinkedList bucket=list[getHashIndex（key）]；
迭代器itr=bucket.Iterator（）；
V prevouis=null；
while（itr.hasNext（））{
Node=itr.next（）；
if（node.getKey（）.equals（key））{
prevouis=node.getValue（）；
铲斗。移除（节点）；
打破
}
}
bucket.addLast（新节点（键、值））；
返回prevouis；
}
//删除方法
公共V删除（对象密钥）{
//在科雷克特诺格尔的芬德·奥格·斯莱特酒店
LinkedList bucket=list[getHashIndex（key）]；
迭代器itr=bucket.Iterator（）；
V值=空；
while（itr.hasNext（））{
Node=itr.next（）；
if（node.getKey（）.equals（key））{
value=node.getValue（）；
铲斗。移除（节点）；
打破
}
}
if（bucket.isEmpty（））{
列表[getHashIndex（键）]=null；
}
返回值；
}
@凌驾
公共空间清除（）{
//TODO自动生成的方法存根
}
@凌驾
公共布尔containsKey（对象键）{
//TODO自动生成的方法存根
返回false；
}
@凌驾
公共布尔包含值（对象值）{
//TODO自动生成的方法存根
返回false；
}
@凌驾
公共集入口集（）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
公共布尔值为空（）{
//TODO自动生成的方法存根
返回false；
}
@凌驾
公共集密钥集（）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
public void putAll（map）我想让你查找
HashMap
，而不是显示你想要什么。对不起，我在docs.oracle.com上查找了HashMap。但不确定这与我的有什么关系。谢谢。你知道，在某些语言中，HashMap被称为字典。这应该足够了。