Question

class Node<E> {
     private E data;
     private Node<E> next;
     Node(E data, Node<E> next) {
         this.data = data;
         this.next = next;
     }
     // .. getter-setters
}

为了计算Node类的对象数量，我们可以在类中添加一个静态属性，并在创建新对象时增加它。

如何保留为EACH类型创建的Node实例数？（例如，6个节点实例的类型为Integer，4个节点的类型为Float等）。

一种天真的方法可以是为每种类型添加静态变量（例如IntCount，FloatCount），并根据传递给构造函数的数据实例来增加它。

class Node<E> {
    private E data;
    private Node<E> next;
    private static int GlobalCount;
    private static int IntCount, FloatCount;

    static {
        GlobalCount = IntCount = FloatCount = 0;
    }

    Node(E data, Node<E> next) {
        this.data = data;
        this.next = next;
        GlobalCount++;

        if(data instanceof Integer) 
            IntCount++;
        else if (data instanceof Float) 
            FloatCount++;
    }
}

目前，这将仅跟踪Integer和Float的计数。如果要跟踪的类型的数量增加，则上述修改将不是一个好的解决方案。

我想知道是否有更好的方法来实现这一目标。

Answer 1

您可以关注HashMap

static HashMap<Class, Integer> refCount = new HashMap<Class, Integer>();

Node(E data, Node<E> next) 
{
    this.data = data;
    this.next = next;
    GlobalCount++;

    Class type = data.getClass();

    Integer countObj = refCount.get(type);
    int count = 1;
    if(countObj != null)
    {
        count = countObj.intValue();
        count++;
    }
    refCount.put(type, count); 
}

Answer 2

不要让计数器'静止'。

我的数据结构类......

public class LinkedList<T> {

private GenericNode<T> head;
private int size;    //Don't make this 'static'

public LinkedList(){
    this.head = null;
    size = 0;
}

public int size(){
    return size;
}

我的申请类......

private static LinkedList<Flight> scheduledFlights;
private static LinkedList<Passenger> outboundPassengers;

public static void main(String[] args) {

    scheduledFlights = new LinkedList<Flight>();
    outboundPassengers = new LinkedList<Passenger>();



    scheduledFlights.add(new Flight("EI123", "Aer Lingus", "CDG"));
    scheduledFlights.add(new Flight("EI223", "Aer Lingus", "STN"));

    outboundPassengers.add(new Passenger("John", "LHR", "London"));
    outboundPassengers.add(new Passenger("Paul", "LHR", "London"));
    outboundPassengers.add(new Passenger("George", "LHR", "London"));
    outboundPassengers.add(new Passenger("Ringo", "LHR", "London"));

    System.out.println(scheduledFlights.size());
    System.out.println(outboundPassengers.size());

控制台输出......

2
4

显示计数器特定于LinkedList的实例。

为什么......我很欣赏普通对象类中的计数器，你会使用静态计数器。 “静态”计数器通常会在对象的所有实例中引用，因此所有增量或减量都会影响同一个计数器。

当您实例化任何类型的泛型类时，“静态”变量与GenericsClass的实例绑定，而不是GenericsClass<anytype>。所以在我的例子中，static int size在LinkedList的所有实例中都是常见的int变量，无论它是LinkedList<Flight>还是LinkedList<Passenger>。

因此，在使用基于Generics的数据结构时，使用常规实例变量作为计数器是正确的。

希望这有帮助。

约翰

计算每种类型单独创建的对象

2 个答案: