Q:

Prove that A == B, B==C, A != C

Can there be objects or primitive types where the transitive law can not hold true; for example
A == B, B == C but A != B 
I am not talking about equals() method. I am interested in == operative
Can we prove this ? 

A:

Here you go. A==B and B==C cause the Floats to get promoted to float, so == returns true. However, A==C is reference equality, which is false.
    Float A = new Float(1.0f);
    float B = 1.0f;
    Float C = new Float(1.0f);
    System.out.println(A==B);
    System.out.println(B==C);
    System.out.println(A==C);

Float isn't special here, it could just as easily be Integer or Boolean.
Here's the relevant sections from the language specification:

15.21.1. Numerical Equality Operators == and !=
If the operands of an equality operator are both of numeric type, or
  one is of numeric type and the other is convertible (§5.1.8) to
  numeric type, binary numeric promotion is performed on the operands
  (§5.6.2).

and

15.21.3. Reference Equality Operators == and !=
If the operands of an equality operator are both of either reference
  type or the null type, then the operation is object equality.

Here's a second counter-example, this time using the fact that comparing a long and float is done using float comparison.
        long a = 99999999999999L;
        float b = 99999999999999.0f;
        long c = 99999999999998L;
        System.out.println(a==b);
        System.out.println(b==c);
        System.out.println(a==c);

Thirdly, I believe it's also possible in theory for non-transitivity to exist even if A, B and C are the same type.
If A and C are double-extended-exponent values (that have the same value B as the nearest double to them), then when A==B and B==C are calculated, the language implementation may choose to round A and C to their nearest double value (which is B). It may equally choose not to round when A==C is performed. The comparisons would have to be done in a context that's not marked as FP-strict
Essentially "5.1.13. Value Set Conversion" gives Java a limited implementation-defined set of behaviors for non-FP-strict float/double calculations, and this can be leveraged (at least in theory) to find a counter-example to equality transitivity.

