Arithmetic expression performance

Question

Hi,
Is there any difference in arithmetic expression evaluation performance between one big expression and several smaller that save their partial results in variables?
For example: Which solution will work faster:
1)
int i;
for(i=1000000; i>=0; i--)
  x=i*a+b*c; //a, b, c - some variables
}2) int i,p1, p2;
for(i=1000000; i>=0; i--)
//a, b, c - some variables
p1 = i*a;
p2 = b*c;
x[i] = p1+p2;

Answer 1

I some cases I can replace a division with a multiplication.
Instead of:
for(int i=0; i<1000; i++)
  tab=tab[i]/5;
}I can use:int scale = (1<<16)/5;
for(int i=0; i<1000; i++)
tab[i]=(tab[i] * scale)>>16;
}The second solution gives the same result and avoids division by replacing it with multiplication and very fast bit shift operation.
I can see that my problem is wider that I  thought. Processor manuals are quite precise, but I'm programming in java, not in assebler. So most important issue for me is the way the JVM implementation will execute each bytecode operation. I think that various JVM for various platforms may execute instructions differently. So I'm looking for general tips which operations should be avoided when performance is the key issue.
I'm writing image processing aplication for mobile devices, so any milisecond counts for me.
I found some java performance tips on the inernet, but, frankly, I don't trust them. For example: It is recommended to avoid 2-dimensional tables and implement them as 1D table. So instead of:int[][] tab = new int[100][100];
tab[x][y] = c;one should use:int[] tab = new int[10000];
tab[y*100+x]=c;It seems reasonable, but the second solution needs multiplication. In the first solution compiler can generate code that store pointers to "second dimension tables" in "first dimension" (table with references to tables). Pointers (references, i mean) have size of 2^n. Integers in second dimension are also of size 2^n. So theoretically compiler may produce byte code that will need no multiplication but only very fast bit-shift operations.
My question is - how does the compiler cope with 2d arrays.