是否值得在方法中使用按位运算符？

Question

I am very new to Java (and programming in general, my previous experience is with ActionScript 2.0 and some simple JavaScript), and I am working my way slowly and methodically through Java: A Beginner's Guide by Herbert Schildt. It is an incredible book.

For one thing, I finally understand more-or-less what bitwise operators (which I first encountered in ActionScript 2.0) do, and that they are more efficient than other methods for certain sums.

My question is, is it more efficient to use a method that uses, say, a shift right, to perform all your divisions/2 (or divisions/even) for you in a large program with many calculations (in this case, a sprawling RPG), or is it more efficient to simply use standard mathematical operations because the compiler will optimise it all for you?

Or, am I asking the wrong question entirely?

Answer 1

You are asking the wrong question entirely. The question you should be asking is "should I keep my code simple and readable, or use tricks that I believe will improve its performance, even though I haven't measured its performance." The answer should be obvious.

Bitwise operators have their place, especially when you're dealing with binary file formats that need to pack a lot of data into small space. And it's absolutely critical to know how to mask out the high bits of a byte so that you don't accidentally sign-extend (print out these two variables to see what I mean):

byte b = (byte)0xDC;
int  i = b & 0xFF;

But don't go looking for places to use these operators, especially to replace such simple tasks as dividing by 2.

Answer 2

Optimizations like this should only be done if you have a real NEED to do it. If you simply think the code will run faster, it may not be worth it.

Often times the compiler may be smarter than you think, and do the optimizations for you, other times there may be caveats that only get you deeper in trouble. In top of that (and probably the biggest reason against doing this), is that if it makes your code hard to read/understand for future developers (or yourself), you may only be adding more anti-optimizations in the future trying to work around the original code.

Answer 3

Usually the compiler does a lot of optimizations. Also you need to investigate what your bottleneck really is before you go optimizing it. Optimizing things that are not the bottleneck just leads to more of your threads hitting the real bottleneck faster. Look up constraint theory.

Answer 4

For learning purpose you can skip optimizing your code that way. It requires some experience otherwise you may face problems debugging your code (I mainly mean "what the heck is this thing doing?" syndrome) Compilers nowadays are smart enough to optimize the output code and deal with known patterns the right way. Unless you are going to really need to save each millisecond or cpu cycle, focus on keeping your code clean.

Answer 5

The latter. Which is to say, write your code in the most clear way possible first, which will most likely entail standard mathematical operations. Let the compiler take care of the rest.

Java, because it runs on a VM, has other interesting built-in optimization features: for example, as your program runs, the VM can see which branches of code are being executed most frequently and make those branches more efficient.

Once you write your program, then use a profiling tool to measure which specific methods are slow. Once you know that, then you will know what kind of code to optimize. For example, you might find that reading a configuration from a file is the slowest thing you do, and you can look for ways to make that faster. My hunch is that you're not likely to find any performance benefit at all by using things like bitwise operators rather than normal arithmetic.

Best of luck!

Answer 6

For one thing, I finally understand more-or-less what bitwise operators (which I first encountered in ActionScript 2.0) do, and that they are more efficient than other methods for certain sums.

No this is wrong here. Bitwise operations has more applications that doing a division or multiplication that you ask about.
You can efficiently use bitmasks as flags, to pack values, to emulate access rights in compact manner, in crytography etc etc.
See this thread. You should search for more applications than just read a chapter that says about how a shift is similar and (perhaps) faster than a division (not necessarily as the compiler would convert to shift anyway)