Question: MY table is similar the one below. My goal is to get the total points of each person ( WHERE username = 'Bobby' OR username= 'George') and return the result in columns instead of rows. (Note: I have more than two username in my table and each of them contain specific points, in this case I am trying to retrieve the specific total points based on two people specified).

```
id   |   username   |   points
1        Bobby            1
2        George           3
3        Bobby            2
4        Bobby            2
5        George           1

```

Desire Results:

```
column_1(Bobby)  |  column_2 (George)
       5                  4

```

Answer: 
> 
> Can Java finalize an object when it is still in scope?
> 
> 
> 

Yes.

However, I'm being pedantic here. *Scope* is a language concept that determines the validity of names. Whether an object can be garbage collected (and therefore finalized) depends on whether it is *reachable*.

The [answer from ajb](https://stackoverflow.com/a/24376863/1441122) almost had it (+1) by citing a significant passage from the JLS. However I don't think it's directly applicable to the situation. JLS [§12.6.1](http://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.6.1) also says:

> 
> A *reachable* object is any object that can be accessed in any potential continuing computation from any live thread.
> 
> 
> 

Now consider this applied to the following code:

```
class A {
    @Override protected void finalize() {
        System.out.println(this + " was finalized!");
    }

    public static void main(String[] args) {
        A a = new A();
        System.out.println("Created " + a);
        for (int i = 0; i < 1_000_000_000; i++) {
            if (i % 1_000_000 == 0)
                System.gc();
        }
        // System.out.println(a + " was still alive.");
    }
}

```

On JDK 8 GA, this will finalize `a` every single time. If you uncomment the `println` at the end, `a` will never be finalized.

With the `println` commented out, one can see how the reachability rule applies. When the code reaches the loop, there is no possible way that the thread can have any access to `a`. Thus it is unreachable and is therefore subject to finalization and garbage collection.

Note that the name `a` is still *in scope* because one can use `a` anywhere within the enclosing block -- in this case the `main` method body -- from its declaration to the end of the block. The exact scope rules are covered in JLS [§6.3](http://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.3). But really, as you can see, scope has nothing to do with reachability or garbage collection.

To prevent the object from being garbage collected, you can store a reference to it in a static field, or if you don't want to do that, you can keep it reachable by using it later on in the same method after the time-consuming loop. It should be sufficient to call an innocuous method like `toString` on it.
[JLS §12.6.1](http://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.6.1):

> 
> Optimizing transformations of a program can be designed that reduce the number of objects that are reachable to be less than those which would naively be considered reachable. For example, a Java compiler or code generator may choose to set a variable or parameter that will no longer be used to null to cause the storage for such an object to be potentially reclaimable sooner.
> 
> 
> 

So yes, I think it's allowable for a compiler to add hidden code to set `a` to `null`, thus allowing it to be garbage-collected. If this is what's happening, you may not be able to tell from the bytecode (see @user2357112's comment). 

Possible (ugly) workaround: Add `public static boolean alwaysFalse = false;` to the main class or some other classes, and then at the end of `main()`, add `if (alwaysFalse) System.out.println(a);` or something else that references `a`. I don't think an optimizer can ever determine with certainty that `alwaysFalse` is never set (since some class could always use reflection to set it); therefore, it won't be able to tell that `a` is no longer needed. At the least, this kind of "workaround" could be used to determine whether this is indeed the problem.