How to find the number of references created for a given object ??

Question

How to find the number of references created for a given object in a big application environment.
That means, if i give any object name (of my application) as input, then how can i find the[b] number of references created for that particular object ??

Answer 1

Please do not post the same question multiple times.
As for your original question, there is no direct way to do it.
Especially not the way you phrased it,
since objects don't have "names".
Applications also don't have "names".
They have classes and instances.
Also, there are 2 related issues, and I'm not sure which one is the one you asked.
#1. Finding the number of references to the same object.
Eg.
Map<String,String> a = new HashMap<String,String>();
Map<String,String> b = new HashMap<String,String>();
Map<String,String> c = a;In this case, there are only 2 objects.
The first object has (at least) 2 references pointing to it.
The second object has (at least) 1 reference pointing to it.
(There may be more, if the HashMap library keeps
references to these things, or if the HashMap object has
some internal cyclic references...)
If you're asking this, then it can't be done.
It's an active research topic in universities
and software research labs, called "alias analysis".
Type it in google, and you'll see people are working hard
and having little success so far.
#2. Finding the number of instances created from a class.
In this case, what you have to do is to add a counter to
the constructor of the class. Every time an object is constructed,
you increment the counter. Like this:
   class MyClass
       public static int counter = 0;
       public MyClass( )  { counter++; }
    // Then later in your program, you can do this:
    MyClass a = new MyClass();
    MyClass b = new MyClass();
    System.out.println(MyClass.counter); // It should show 2Note: you won't be able to do this to every class in the system.
For every class you care about, you have to modify its constructor.
Also: when an object is deleted, you won't always know it
(and thus you won't always be able to decrement the counter).
Finalizers cannot always work (read Joshua Bloch's
"Effective Java" book if you don't believe me), but basically
(1) finalizers will not always be called, and
(2) finalizers can sometimes cause objects to not be deleted,
and thus the JVM will run out of memory and crash