is it possible to overload a final method

Yes, overloading a final method is perfectly legitimate.

For example:

public final void doStuff(int x) { ... }
public final void doStuff(double x) { ... }

Yes, but be aware that dynamic dispatch might not do what you are expecting! Quick example:

class Base {
    public final void doSomething(Object o) {
        System.out.println("Object");
    }
}

class Derived extends Base {
    public void doSomething(Integer i) {
        System.out.println("Int");
    }
}

public static void main(String[] args) {
    Base b = new Base();
    Base d = new Derived();
    b.doSomething(new Integer(0));
    d.doSomething(new Integer(0));
}

This will print:

Object
Object

Yes, very much possible.

A small program to demonstrate it:

class A{
    final void foo(){ System.out.println("foo ver 1 from class A"); }
    final void foo(int a){ System.out.println("foo ver 2 from class A"); }
    }


class B extends  A{
    final void foo(long l){ System.out.println("foo ver 3 from class B"); }
    // final void foo(){ System.out.println("foo ver 1 from class A"); } NOT ALLOWED
}

public class Test {    
    public static void main(String [] args){
        B obj = new B();

        obj.foo();
        obj.foo(1);
        obj.foo(1L);
    }   
}

Output:

foo ver 1 from class A
foo ver 2 from class A
foo ver 3 from class B

YES, why not? It is as legal as overloading non-final methods.

But you cannot override them (you already know it).

Eg :

public final void func(String x) {/* code */}
public final void func(double x) { /* more code */ }
public final void func(int x) { /* yeah I have still more code */ }

Yes It is possible.

You can examine this kind of things by writing small Java classes.

class TestClass{
   final public  void testMethod(){

   }

   final public  void testMethod(int i){

   }
 }

Yes, You can overload but not override.

yes overloading final method is possible in java.As final methods are restricted not to override the methods.

while overloading argument list must be different type of the overloading method.

yes we can overload the final methods