For certain code both will equally faster, that can happens, what cannot however is that assembly is slower that Java, if such thing happens that means just that Java found better CPU instruction sequence than you which means then that you have lower skills than a HLL compiler.

In ARM code with Jazelle support the CPU can execute Jave byte codes directly, at full clock speed. There are still many codes that need OS support, but the simple and common codes are native to the processor. You have to rewrite your algo to beat the Java in that case.

But how can it even be equal? Doesn't the Java runtimes have to read the byte code then execute the instructions?

Quote:

But how can it even be equal? Doesn't the Java runtimes have to read the byte code then execute the instructions?

Only once, the JIT is meant for compile the Java bytecodes to native machine code, not as Visual Basic 6.0 and older with its p-code that it is interpreted all the time and never JIT'ed.

PS: Visual Basic 6.0 allows compilation for both, native and p-code.

include 'win32ax.inc'
use_reciprocal = 0 ; Comment this line to use DIV instruction
.data 
    start_time dd 0 
    _output rb 20 
.code 

start: 
            invoke MessageBox,NULL,"Click Ok to start","Speed Test",MB_OK 
            invoke GetTickCount 
            mov [start_time],eax 
            xor ecx, ecx
            mov ebx, 024924925h
            mov edi, 7

            align 16
            place:
            if defined use_reciprocal
                mov eax, ecx
                mul ebx
                mov eax, ecx
                sub eax, edx
                shr eax, 1
                add eax, edx
                shr eax, 2
            else
                xor edx, edx
                mov eax, ecx
                div edi
            end if
                dec ecx
                jnz place

            invoke GetTickCount
            sub eax, [start_time] 
            invoke wsprintf,_output,"%d milliseconds",eax 
            invoke MessageBox,NULL,_output,"Speed Test",MB_OK 
            invoke ExitProcess,0

 .end start    

int _tmain(int argc, _TCHAR* argv[])
{
00401000  sub         esp,8 
       _asm{int 3}
00401003  int         3    
        volatile unsigned int count = 1000000000;
00401004  mov         dword ptr [esp],3B9ACA00h 
       volatile unsigned int nop;
  while (count)
0040100B  mov         eax,dword ptr [esp] 
0040100E  test        eax,eax 
00401010  je          wmain+32h (401032h) 
 {
              nop = count / 7;
00401012  mov         ecx,dword ptr [esp] 
00401015  mov         eax,24924925h 
0040101A  mul         eax,ecx 
0040101C  sub         ecx,edx 
0040101E  shr         ecx,1 
00401020  add         ecx,edx 
00401022  shr         ecx,2 
00401025  mov         dword ptr [esp+4],ecx 
                count--;
00401029  add         dword ptr [esp],0FFFFFFFFh 
0040102D  mov         ecx,dword ptr [esp] 
00401030  jne         wmain+12h (401012h) 
   }
}
00401032  add         esp,8 
00401035  ret     

(but with bigger dividends it works wrong, I not tested from exactly what dividend starts to fails but I tested 100000000 and below and worked)

Code:

include 'win32ax.inc'
use_reciprocal = 0 ; Comment this line to use DIV instruction
.data 
    start_time dd 0 
    _output rb 20 
.code 

start: 
            invoke MessageBox,NULL,"Click Ok to start","Speed Test",MB_OK 
            invoke GetTickCount 
            mov [start_time],eax 
            xor ecx, ecx
            mov ebx, 024924925h
            mov edi, 7

            align 16
            place:
            if defined use_reciprocal
                mov eax, ecx
                mul ebx
                mov eax, ecx
                sub eax, edx
                shr eax, 1
                add eax, edx
                shr eax, 2
            else
                xor edx, edx
                mov eax, ecx
                div edi
            end if
                dec ecx
                jnz place

            invoke GetTickCount
            sub eax, [start_time] 
            invoke wsprintf,_output,"%d milliseconds",eax 
            invoke MessageBox,NULL,_output,"Speed Test",MB_OK 
            invoke ExitProcess,0

 .end start    

On Athlon64 2.0 GHz Venice:
With DIV ~89000 ms
With reciprocal ~10000 ms

I have to confess that I cheated The reciprocal code was generated by Visual C++ 2005 Express by using volatile on all variables.

Code:

int _tmain(int argc, _TCHAR* argv[])
{
00401000  sub         esp,8 
   _asm{int 3}
00401003  int         3    
        volatile unsigned int count = 1000000000;
00401004  mov         dword ptr [esp],3B9ACA00h 
       volatile unsigned int nop;
  while (count)
0040100B  mov         eax,dword ptr [esp] 
0040100E  test        eax,eax 
00401010  je          wmain+32h (401032h) 
 {
              nop = count / 7;
00401012  mov         ecx,dword ptr [esp] 
00401015  mov         eax,24924925h 
0040101A  mul         eax,ecx 
0040101C  sub         ecx,edx 
0040101E  shr         ecx,1 
00401020  add         ecx,edx 
00401022  shr         ecx,2 
00401025  mov         dword ptr [esp+4],ecx 
                count--;
00401029  add         dword ptr [esp],0FFFFFFFFh 
0040102D  mov         ecx,dword ptr [esp] 
00401030  jne         wmain+12h (401012h) 
   }
}
00401032  add         esp,8 
00401035  ret     

I tested the reciprocal against all posible dividends and produces correct result for them all, and if the count max value is the same as in the original code you can remove all the SHR-ADD because it will produce correct result without them (but with bigger dividends it works wrong, I not tested from exactly what dividend starts to fails but I tested 100000000 and below and worked)

;;IN rcx = 32bit num ;;OUT rcx = binary rcp of ecx
MOVQ xmm1, qword[SD_ONE]
CVTDQ2SD xmm0, rcx
DIVSD xmm1, xmm0 ;; Sign(63) Exp(62..52) Mant(51...0)
PSLLQ xmm1, xmm1, 12 ;; Mant(63...12)
MOVQ rcx, xmm1