java - 在构建容器时，为什么使用 Java 泛型比使用对象类更好？（Java 泛型和数据结构）

问题描述

所以我一直在审查我的数据结构，并遇到了一个关于 Java 泛型和Object类的有趣想法。我已经以两种不同的方式实现和运行“通用包” （注意如下：IObjectBag.java、ObjectBag.java、IGenericBag.java 和 GenericBag.java）并使用了它们（注意：在 main.java 和输出下方） . 我已经根据堆栈溢出规则删除了一些不必要的代码，但如果你想要完整的实现，请告诉我。

此外，除了查看此处ArrayList课程的源代码之外，我还在许多网站、书籍和课程中研究过该主题，我知道我的选择比我的更好，但不足以在学习期间以实用的方式解释它面试。而且我很困惑，我在其实现中使用了比我更多的转换操作（请参阅和）。GenericBagObjectBagGenericBagObjectBagRemovePrintBag

那么，除了语法糖，为什么我的GenericBag更好呢？请以我的课程为例。
我没有注意到运行时/开销/空间/时间是否有任何重要差异？
你会如何回答这个问题或期望它在面试中得到回答？

奖励问题：如果您愿意，请在评论Main和GenericBag评论中回答奖励问题（我想我可以自己回答，只是想听听您的意见）。

IObjectBag界面：

public interface IObjectBag {
    void add(Object item);
    Object remove(Object item) throws NoSuchElementException;
    boolean isEmpty();
    int find(Object item);
    Object get(int index);
    int numItems();
}

ObjectBag班级：

public class ObjectBag implements IObjectBag {
    private Object [] items; // the java class attribute that will hold out "ints"
    private int numItems;
    
    public static void printBag(IObjectBag bag) {
        for(int i = 0; i < bag.numItems(); i++) {
            System.out.println(bag.get(i));
        }
    }
    
    public ObjectBag(int size) {
        this.items = new Object[size]; // fills array with null values
        this.numItems = 0;
    }
    
    public void add(Object item){
        // adds item to end of bag
    }
    
    public Object remove(Object item) {
        int index = this.find(item);

        if(index == -1) throw new NoSuchElementException("oops nothing found");
        
        Object out = this.items[index];
        
        this.items[index] = null;
        this.numItems -= 1;
        
        if(index + 1 != this.items.length && this.items[index + 1] != null) {  
            for(int i = index; i < this.items.length; i++) {
                if(i + 1 != this.items.length) this.items[i] = this.items[i + 1];
            }
            
            this.items[this.items.length - 1] = null;
        }
        
        return out;
    }
    
    public int find(Object item) {
        // return index given item or -1 
    }
    
    public Object get(int index) {
        // returns item given index
    }
    
}

IGenericBag班级：

public interface IGenericBag <T> {
    void add(T item);
    T remove(T item) throws NoSuchElementException;
    boolean isEmpty();
    int find(T item);
    T get(int index);
}

GenericBag班级：

public class GenericBag<T> implements IGenericBag<T> {
    // private T[] items; can't use this b/c see comment in constructor
    private Object[] items;
    private int numItems;
    
    public static void printBag(GenericBag bag) {
        for(int i = 0; i < bag.numItems(); i++) {
            System.out.println(bag.get(i));
        }
    }
    
    public GenericBag(int size) {
        // this.items = new T[size]; Bonus: throws generic array creation error (why?)
        this.items = new Object[size];
        this.numItems = 0;
    }
    
    public void add(T item){
        this.items[this.numItems] = item;
        this.numItems += 1;
    }
    
    public T remove(T item) {
        int index = this.find(item);

        if(index == -1) throw new NoSuchElementException("oops nothing found");
        
        T out = (T) this.items[index];
        
        this.items[index] = null;
        this.numItems -= 1;
        
        if(index + 1 != this.items.length && this.items[index + 1] != null) {  
            for(int i = index; i < this.items.length; i++) {
                if(i + 1 != this.items.length) this.items[i] = this.items[i + 1];
            }
            
            this.items[this.items.length - 1] = null;
        }
        
        return out;
    }
    
    public int find(Object item) {
        // given object return index or throw exception
    }
    
    public T get(int index) {
        return (T) this.items[index];
    }
    
}

Main班级：

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Hello StackOverFlow!");
        Object int1 = new Integer(1);
        Object int2 = new Integer(2);
        Object int3 = new Integer(3);
        
        
        /* using my object bag ************************************************/
        System.out.println("using my object bag");
        IObjectBag myObjectBag = new ObjectBag(3);
                
        myObjectBag.add(int1);
        myObjectBag.add(int2);
        myObjectBag.add(int3);
        myObjectBag.remove(int2);
        
        ObjectBag.printBag(myObjectBag);
        
        /* using my generic bag ***********************************************/
        System.out.println("using generic bag");
        
        
        // Bonus Question: using object like above causes error at add method (why?)
        Integer int4 = new Integer(4); 
        Integer int5 = new Integer(5);
        Integer int6 = new Integer(6);
        
        GenericBag<Integer> myGenericBag = new GenericBag<Integer>(3); 
        //Bonus Question: using Interface decllaration like above causes error in print bag (why?) 
        
        myGenericBag.add(int4);
        myGenericBag.add(int5);
        myGenericBag.add(int6);
        myGenericBag.remove(int4);
        
        GenericBag.printBag(myGenericBag);
    }
    
}

输出：

Hello StackOverFlow!
using my object bag
1
3
using generic bag
5
6

标签： javagenericscontainerstype-safetycollect

java - 在构建容器时，为什么使用 Java 泛型比使用对象类更好？（Java 泛型和数据结构）

问题描述

解决方案

推荐阅读