Map是条目的集合，其中每个条目都是一个键值对。所以你的 Vetor_map 类应该实现 java.util.Map –确实如此–但我认为您还应该创建一个实现接口的类 Map.Entry .
在下面的代码中，我添加了一个内部类 VectorMapEntry 实现 Map.Entry 因此，阶级 VectorMap –实现接口 Map –包含一组 VectorMapEntry 示例。从这里开始，实现两个接口的方法就很简单了，即 Map 以及 Map.Entry .
请注意以下代码。
我把名字改成 Vetor_map 至 VectorMap .
我添加了一些方法 toString() 以及 main() 上课 VectorMap 仅用于测试目的。我还添加了方法 toString() 到班级 Key 以及 Student 也用于测试目的。
您没有为类提供代码 Key 以及 Student 所以我为这两个类添加了 backbone 定义。请注意，每个类- Key 以及 Student –每个实现方法必须相等。我只添加了方法hashcode，因为方法的javadoc equals() 建议这样做。 VectorMap 不能包含null Key 但它可以包含null Student 作为给定值 Key .
每个 Key 在 VectorMap 是独一无二的。调用方法时 put() 用一个 Key 已经存在于 VectorMap ，则替换现有值。

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class VectorMap implements Map<Key, Student> {

    private static class VectorMapEntry implements Map.Entry<Key, Student> {
        private Key key;
        private Student student;

        public VectorMapEntry(Key k, Student s) {
            key = k;
            student = s;
        }

        public Key getKey() {
            return key;
        }

        public Student getStudent() {
            return student;
        }

        public void setStudent(Student s) {
            student = s;
        }

        @Override
        public Student getValue() {
            return student;
        }

        @Override
        public Student setValue(Student value) {
            student = value;
            return value;
        }
    }

    private int nElements;
    private VectorMapEntry[] entries;

    public VectorMap(int initialSize) {
        if (initialSize <= 0) {
            throw new IllegalArgumentException("Initial size must be positive.");
        }
        entries = new VectorMapEntry[initialSize];
    }

    @Override
    public int size() {
        return nElements;
    }

    @Override
    public boolean isEmpty() {
        return nElements == 0;
    }

    @Override
    public boolean containsKey(Object key) {
        boolean found = false;
        for (VectorMapEntry entry : entries) {
            if (entry == null) {
                break;
            }
            found = entry.getKey().equals(key);
            if (found) {
                break;
            }
        }
        return found;
    }

    @Override
    public boolean containsValue(Object value) {
        boolean found = false;
        for (VectorMapEntry entry : entries) {
            if (entry == null) {
                break;
            }
            found = entry.getStudent().equals(value);
            if (found) {
                break;
            }
        }
        return found;
    }

    @Override
    public Student get(Object key) {
        for (VectorMapEntry entry : entries) {
            if (entry == null) {
                break;
            }
            if (entry.getKey().equals(key)) {
                return entry.getStudent();
            }
        }
        return null;
    }

    @Override
    public Student put(Key key, Student value) {
        if (key == null) {
            throw new IllegalArgumentException("Null key.");
        }
        boolean found = false;
        for (VectorMapEntry entry : entries) {
            if (entry == null) {
                break;
            }
            if (entry.getKey().equals(key)) {
                entry.setStudent(value);
                found = true;
                break;
            }
        }
        if (!found) {
            if (nElements == entries.length) {
                throw new RuntimeException("Map is full.");
            }
            entries[nElements] = new VectorMapEntry(key, value);
            nElements++;
        }
        return value;
    }

    @Override
    public Student remove(Object key) {
        int index = 0;
        Student s = null;
        for (VectorMapEntry entry : entries) {
            if (entry == null) {
                break;
            }
            if (entry.getKey().equals(key)) {
                s = entry.getStudent();
                break;
            }
            index++;
        }
        if (index < nElements) {
            for (int i = index; i < nElements - 1; i++) {
                entries[i] = entries[i + 1];
            }
            nElements--;
        }
        return s;
    }

    @Override
    public void putAll(Map<? extends Key, ? extends Student> m) {
        if (m != null) {
            m.entrySet()
             .stream()
             .forEach(ent -> put(ent.getKey(), ent.getValue()));
        }
    }

    @Override
    public void clear() {
        for (int i = 0; i < nElements; i++) {
            entries[i] = null;
        }
        nElements = 0;
    }

    @Override
    public Set<Key> keySet() {
        Set<Key> keySet = new HashSet<>();
        for (int i = 0; i < nElements; i++) {
            keySet.add(entries[i].getKey());
        }
        return keySet;
    }

    @Override
    public Collection<Student> values() {
        Collection<Student> vals = new ArrayList<>(nElements);
        for (int i = 0; i < nElements; i++) {
            vals.add(entries[i].getStudent());
        }
        return vals;
    }

    @Override
    public Set<Map.Entry<Key, Student>> entrySet() {
        Set<Map.Entry<Key, Student>> entSet = new HashSet<>();
        for (int i = 0; i < nElements; i++) {
            entSet.add(entries[i]);
        }
        return entSet;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        boolean first = true;
        for (int i = 0; i < nElements; i++) {
            if (first) {
                first = false;
            }
            else {
                sb.append(", ");
            }
            sb.append(entries[i].getKey());
            sb.append('=');
            sb.append(entries[i].getValue());
        }
        sb.append(']');
        return sb.toString();
    }

    public static void main(String[] args) {
        Key ch = new Key();
        Student es = new Student();
        VectorMap vm = new VectorMap(10);
        System.out.println("Key: " + ch + ", Estudant: "+ es);
        vm.put(ch, es);
        System.out.println(vm);
    }
}

class Key {
    public boolean equals(Object obj) {
        return false;
    }

    public int hashCode() {
        return -1;
    }

    public String toString() {
        return "Key";
    }
}

class Student {
    public boolean equals(Object obj) {
        return false;
    }

    public int hashCode() {
        return -1;
    }

    public String toString() {
        return "Student";
    }
}

还请注意，可以更改上述代码，以便 VectorMap 可以（理论上）包含无限多个键值对。这可以通过简单地扩大 entries 当数组被完全填满时。