Low Level Class Methods in Java

 

1. Bitwise and integer operations

Integer & Long

(Also in Long with long versions)

  • bitCount(int x) — popcount (Hamming weight)

  • numberOfLeadingZeros(int x)

  • numberOfTrailingZeros(int x)

  • highestOneBit(int x) — isolate MSB

  • lowestOneBit(int x) — isolate LSB

  • rotateLeft(int x, int n)

  • rotateRight(int x, int n)

  • reverse(int x) — bit reversal

  • reverseBytes(int x) — byte swap

  • compareUnsigned(int x, int y)

  • divideUnsigned(int dividend, int divisor)

  • remainderUnsigned(int dividend, int divisor)

  • toUnsignedLong(int x)

  • Const: BYTES, SIZE

2. Unsigned helpers

  • Byte.toUnsignedInt(byte b)

  • Short.toUnsignedInt(short s)

  • Integer.toUnsignedLong(int i)

  • Integer.compareUnsigned(...), Integer.divideUnsigned(...), Integer.remainderUnsigned(...)

  • Same for Long (compareUnsigned, divideUnsigned, remainderUnsigned)

3. IEEE-754 float/double bit manipulation

Float

  • floatToIntBits(float f) — normalizes NaN

  • floatToRawIntBits(float f) — preserves NaN payload

  • intBitsToFloat(int bits)

  • isFinite(float f)

  • isNaN(float f)

  • isInfinite(float f)

  • compare(float f1, float f2) — total order (with NaN handling)

  • sum(...), max(...), min(...) — exact for +0.0 / -0.0

Double

  • doubleToLongBits(double d)

  • doubleToRawLongBits(double d)

  • longBitsToDouble(long bits)

  • Same isFinite, isNaN, isInfinite, compare, sum, max, min

4. IEEE-754 Math helpers

Math / StrictMath:

  • nextUp, nextDown

  • ulp

  • scalb — fast x * 2^n

  • getExponent

  • copySign

  • fma — fused multiply-add

  • floorDiv, floorMod — correct signed division/mod

  • multiplyExact (int/long) — detect overflow

  • addExact, subtractExact, negateExact, incrementExact, decrementExact

  • multiplyHigh(long x, long y) — high 64 bits of 128-bit multiply (intrinsic on some CPUs)

  • floorDiv, floorMod (correct for negatives)

  • hypot, expm1, log1p — high precision variants

  • Math.clamp(...) — no built-in until Java 23 (but easy to implement)

5. Bulk memory & array ops

  • System.arraycopy(src, srcPos, dst, dstPos, length) — often intrinsic

  • Arrays.fill(array, value) — bulk fill

  • Arrays.mismatch(array1, array2) — first differing index (vectorized in some JDKs)

  • Arrays.equals(...) — often intrinsic for primitives

  • Arrays.hashCode(...) — optimized for primitives

6. Byte order, endian conversion

  • ByteOrder.nativeOrder()

  • ByteBuffer.order(ByteOrder)

  • Integer.reverseBytes(int), Long.reverseBytes(long), Short.reverseBytes(short)

7. Bit sets and big integers

BitSet

  • Logical ops: and, or, xor, andNot

  • Queries: nextSetBit, nextClearBit, previousSetBit, previousClearBit

  • Bulk: flip(from, to), set(from, to, value), clear(from, to)

BigInteger

  • setBit, clearBit, flipBit

  • testBit

  • bitCount, bitLength

  • Arbitrary shiftLeft/shiftRight

  • modInverse, modPow — useful in number theory

8. Concurrency / atomics / fences

java.util.concurrent.atomic

  • AtomicInteger, AtomicLong, AtomicReference, etc.:

    • getAndAdd, getAndSet, compareAndSet, weakCompareAndSet

  • AtomicIntegerArray, AtomicLongArray

  • AtomicIntegerFieldUpdater, AtomicLongFieldUpdater

VarHandle (Java 9+)

  • Fine-grained memory ordering:

    • getOpaque, setOpaque

    • getAcquire, setRelease

    • compareAndSet, compareAndExchange

    • getAndAdd, getAndBitwiseOr, etc.

  • Works for arrays, fields, and off-heap buffers

Thread

  • onSpinWait() — hint to CPU in spin loops (Java 9+)

9. Checksums and CRC

  • java.util.zip.CRC32 — hardware-accelerated on some CPUs

  • java.util.zip.Adler32 — simpler checksum

  • java.util.zip.Checksum — common interface

10. Misc numeric / low-level odds & ends

  • Short.reverseBytes(short)

  • Character.getNumericValue(char) — safe digit parsing

  • Character.digit(char, radix)

  • Locale.ROOT — avoids locale issues in numeric parsing

  • String.format(Locale.ROOT, ...) — deterministic formatting

11. Memory-mapped & off-heap access

  • FileChannel.map(MapMode.READ_WRITE, position, size) — MappedByteBuffer

  • ByteBuffer.allocateDirect(size)

  • .asFloatBuffer(), .asIntBuffer(), .asLongBuffer() — typed views

  • MappedByteBuffer.force() — flush changes to disk

  • Java 19+: MemorySegment / MemoryLayout / VarHandle (Project Panama) for C-like struct access

12. Rare / underused intrinsics

These are mapped to CPU instructions on HotSpot when possible:

  • Math.multiplyHigh(long, long) — high 64 bits of a 128-bit multiply

  • Integer.bitCount, Long.bitCount — POPCNT

  • Integer.numberOfLeadingZeros, Long.numberOfLeadingZeros — CLZ

  • Integer.numberOfTrailingZeros, Long.numberOfTrailingZeros — CTZ

  • Integer.reverse, Long.reverse — bit reversal

  • System.arraycopy — memmove

  • Math.fma — FMA3/FMA4

  • Thread.onSpinWait — PAUSE instruction on x86

13. Constant values

  • Integer.BYTES, Integer.SIZE — number of bytes/bits in type

  • Same for Byte, Short, Long, Float, Double

  • Float.MIN_NORMAL — smallest normalized float

  • Float.MIN_VALUE — smallest positive subnormal

  • Float.MAX_EXPONENT, MIN_EXPONENT

  • Double.MIN_NORMAL, Double.MIN_VALUE, etc.

Comments

Post a Comment

Popular posts from this blog

Neon Bulb Oscillators

Image
Neon Tube Oscillators  Fig. 1 High voltage to headphones, don't do this in modern times. Very high impedance headphones are implied. A neon bulb is useful in many ways in an amateur station, but there are undoubtedly many amateurs who are not aware of the fact that the device can be made to oscillate at either audio or radio frequencies. Fig. 1 shows how a single bulb may be hooked up as an audio frequency oscillator. The L-C circuit is formed by the headphones and a condenser, and by varying the capacity the circuit can be made to oscillate at frequencies from a few cycles per second up to the highest audio frequencies.  The variable resistor in series with the bulb and battery controls the strength of oscillation, and also controls the frequency to some extent. A 1 nf variable condenser will be sufficient to cover most of the audio range.  Fig. 2 The circuit in Fig. 2 may be used when an RF oscillator is to be modulated at audio frequencies. The transformer may be an or...
Read more

23 Circuits you can Build in an Hour - Free Book

Image
Unleash your inner electronics wizard with 23 captivating circuits you can build in a jiffy! Tired of staring at daunting circuit diagrams that seem to go on forever? Craving hands-on experience that will ignite your passion for electronics? Look no further than this electrifying collection of 23 circuits you can build in an hour or less! From the delightfully simple to the mind-bendingly clever, these circuits are guaranteed to spark your curiosity and inspire further experimentation. Whether you're a seasoned pro or a budding hobbyist, you'll find something to tantalize your taste buds in this smorgasbord of electronic delights. Get the book now, it's free. The Lost SuperFoods (sponsored) Crash GPT course (sponsored) From Zero To Off-Grid Hero (sponsored)
Read more

Q Multiplier Circuits

Image
Q Multipliers Q multipliers were commonly used in amateur radio circuits in the past, especially in shortwave receivers. They were used to improve the selectivity and sensitivity of the receivers, making it possible to receive weaker signals and to distinguish between signals that were close together in frequency. Here are some specific examples of amateur radio circuits from the past that used Q multipliers: The Heathkit AR-3 receiver, which was a popular shortwave receiver in the 1950s, had a built-in Q multiplier. The Drake 2B receiver, which was another popular shortwave receiver in the 1950s and 1960s, had a separate Q multiplier unit that could be added to the receiver. The Collins KWS-1 transmitter, which was a popular amateur radio transmitter in the 1960s and 1970s, used a Q multiplier to generate the SSB signal. From Zero To Off-Grid Hero (sponsored) Operation By cancelling out the resistance and other losses in an LC (aka LCR) circuit its Q (voltage magnification at resonant...
Read more