• Pleasing to the eye
• Preserves knowledge
• Must preserve non-obvious knownledge
• Reading text is easier than interpreting code
• Use the right place for the doc: class vs. method vs. inline

/**
 * Resizable-array implementation of the {@code List} interface.  Implements
 * all optional list operations, and permits all elements, including
 * {@code null}.  In addition to implementing the {@code List} interface,
 * this class provides methods to manipulate the size of the array that is
 * used internally to store the list.  (This class is roughly equivalent to
 * {@code Vector}, except that it is unsynchronized.)
 *
 * <p>The {@code size}, {@code isEmpty}, {@code get}, {@code set},
 * {@code iterator}, and {@code listIterator} operations run in constant
 * time.  The {@code add} operation runs in <i>amortized constant time</i>,
 * that is, adding n elements requires O(n) time.  All of the other operations
 * run in linear time (roughly speaking).  The constant factor is low compared
 * to that for the {@code LinkedList} implementation.
 *
 * <p>Each {@code ArrayList} instance has a <i>capacity</i>. The capacity is
 * the size of the array used to store the elements in the list.  It is always
 * at least as large as the list size.  As elements are added to an ArrayList,
 * its capacity grows automatically.  The details of the growth policy are not
 * specified beyond the fact that adding an element has constant amortized
 * time cost.
 *
 * <p><strong>Note that this implementation is not synchronized.</strong>
 * If multiple threads access an {@code ArrayList} instance concurrently,
 * and at least one of the threads modifies the list structurally, it
 * <i>must</i> be synchronized externally...
 *
 * The iterators returned by this class's {@link #iterator() iterator} and
 * {@link #listIterator(int) listIterator} methods are <em>fail-fast</em>...
 * Thus, in the face of concurrent modification, the iterator fails quickly and
 * cleanly, rather than risking arbitrary, non-deterministic behavior
 * at an undetermined time in the future.
 *
 * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
 * as it is, generally speaking, impossible to make any hard guarantees in the
 * presence of unsynchronized concurrent modification.
        

/**
 * This class implements a vector of bits that grows as needed. Each
 * component of the bit set has a {@code boolean} value. The
 * bits of a {@code BitSet} are indexed by nonnegative integers.
 * Individual indexed bits can be examined, set, or cleared. One
 * {@code BitSet} may be used to modify the contents of another
 * {@code BitSet} through logical AND, logical inclusive OR, and
 * logical exclusive OR operations.
 *
 * <p>By default, all bits in the set initially have the value
 * {@code false}.
 *
 * <p>Every bit set has a current size, which is the number of bits
 * of space currently in use by the bit set. Note that the size is
 * related to the implementation of a bit set, so it may change with
 * implementation. The length of a bit set relates to logical length
 * of a bit set and is defined independently of implementation.
 *
 * <p>Unless otherwise noted, passing a null parameter to any of the
 * methods in a {@code BitSet} will result in a
 * {@code NullPointerException}.
 *
 * <p>A {@code BitSet} is not safe for multithreaded use without
 * external synchronization.
 *
 * @author  Arthur van Hoff
 * @author  Michael McCloskey
 * @author  Martin Buchholz
 * @since   1.0
 */
    

/**
 * Returns a new bit set containing all the bits in the given byte
 * buffer between its position and limit.
 *
 * <p>More precisely,
 * <br>{@code BitSet.valueOf(bb).get(n) == ((bb.get(bb.position()+n/8) & (1<<(n%8))) != 0)}
 * <br>for all {@code n < 8 * bb.remaining()}.
 *
 * <p>The byte buffer is not modified by this method, and no
 * reference to the buffer is retained by the bit set.
 *
 * @param bb a byte buffer containing a little-endian representation
 *        of a sequence of bits between its position and limit, to be
 *        used as the initial bits of the new bit set
 * @return a {@code BitSet} containing all the bits in the buffer in the
 *         specified range
 * @since 1.7
 */
public static BitSet valueOf(ByteBuffer bb) {
    bb = bb.slice().order(ByteOrder.LITTLE_ENDIAN);
    int n;
    for (n = bb.remaining(); n > 0 && bb.get(n - 1) == 0; n--)
        ;
    long[] words = new long[(n + 7) / 8];
    bb.limit(n);
    int i = 0;
    while (bb.remaining() >= 8)
        words[i++] = bb.getLong();
    for (int remaining = bb.remaining(), j = 0; j < remaining; j++)
        words[i] |= (bb.get() & 0xffL) << (8 * j);
    return new BitSet(words);
}

public static int getLevenshteinDistance(CharSequence s, CharSequence t, final int threshold) {
   if (s == null || t == null) {
       throw new IllegalArgumentException("Strings must not be null");
   }
   if (threshold < 0) {
       throw new IllegalArgumentException("Threshold must not be negative");
   }

   // Huge explaination of the algorithm was here (removed by me)

   int n = s.length(); // length of s
   int m = t.length(); // length of t

   // if one string is empty, the edit distance is necessarily the length of the other
   if (n == 0) {
       return m <= threshold ? m : -1;
   }
   if (m == 0) {
       return n <= threshold ? n : -1;
   }
   if (Math.abs(n - m) > threshold) {
       // no need to calculate the distance if the length difference is greater than the threshold
       return -1;
   }

   if (n > m) {
       // swap the two strings to consume less memory
       final CharSequence tmp = s;
       s = t;
       t = tmp;
       n = m;
       m = t.length();
   }

   int[] p = new int[n + 1]; // 'previous' cost array, horizontally
   int[] d = new int[n + 1]; // cost array, horizontally
   int[] tmp; // placeholder to assist in swapping p and d

   // fill in starting table values
   final int boundary = Math.min(n, threshold) + 1;
   for (int i = 0; i < boundary; i++) {
       p[i] = i;
   }
   // these fills ensure that the value above the rightmost entry of our
   // stripe will be ignored in following loop iterations
   Arrays.fill(p, boundary, p.length, Integer.MAX_VALUE);
   Arrays.fill(d, Integer.MAX_VALUE);

   // iterates through t
   for (int j = 1; j <= m; j++) {
       final char jOfT = t.charAt(j - 1); // jth character of t
       d[0] = j;

       // compute stripe indices, constrain to array size
       final int min = Math.max(1, j - threshold);
       final int max = j > Integer.MAX_VALUE - threshold ? n : Math.min(n, j + threshold);

       // the stripe may lead off of the table if s and t are of different sizes
       if (min > max) {
           return -1;
       }

       // ignore entry left of leftmost
       if (min > 1) {
           d[min - 1] = Integer.MAX_VALUE;
       }

       // iterates through [min, max] in s
       for (int i = min; i <= max; i++) {
           if (s.charAt(i - 1) == jOfT) {
               // diagonally left and up
               d[i] = p[i - 1];
           } else {
               // 1 + minimum of cell to the left, to the top, diagonally left and up
               d[i] = 1 + Math.min(Math.min(d[i - 1], p[i]), p[i - 1]);
           }
       }

       // copy current distance counts to 'previous row' distance counts
       tmp = p;
       p = d;
       d = tmp;
   }

   // if p[n] is greater than the threshold, there's no guarantee on it being the correct
   // distance
   if (p[n] <= threshold) {
       return p[n];
   }
   return -1;
}

for (n = lb.remaining(); n > 0 && lb.get(n - 1) == 0; n--)
    ;

do {
    if (e.hash == hash &&
        ((k = e.key) == key || (key != null && key.equals(k))))
        return e;
} while ((e = e.next) != null);

for (int binCount = 0; ; ++binCount) {
    if ((e = p.next) == null) {
        p.next = newNode(hash, key, value, null);
        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            treeifyBin(tab, hash);
        break;
    }
}

public void clear() {
    while (wordsInUse > 0)
        words[--wordsInUse] = 0;
}

while (true) {
    if (word != 0)
        return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros(word);
    if (++u == wordsInUse)
        return wordsInUse * BITS_PER_WORD;
    word = ~words[u];
}

int i = 0;
found: {
     if (o == null) {
         for (; i < size; i++)
             if (es[i] == null)
                 break found;
     } else {
         for (; i < size; i++)
             if (o.equals(es[i]))
                 break found;
     }
     return false;
}

public class LRUBloomHashMap<K, V>
{
    // static should be mostly final
    public static final int LAYERCOUNT = 3;

    public final int capacity;
    public final int slotSize;
}

public static int hashCodeWithLimit(final CharSequence s,
                                    final char limitingChar)
{
    int hash = 0;

    final int length = s.length();
    for (int i = 0; i < length; i++)
    {
        final char c = s.charAt(i);

        if (c != limitingChar)
        {
            final int h1 = hash << 5;
            final int h2 = c - hash;
            hash = h1 + h2;
        }
        else
        {
            break;
        }

    }

    return hash;
}

private static long getInitValue()
{
    long initValue = System.currentTimeMillis();

    // modify the init value for each user thread
    // when in a load test
    if (Session.getCurrent().isLoadTest())
    {
        final String userId = Thread.currentThread().getName();

        // String.hashCode() is not good enough -> #2890
        // final long hashCode = userId.hashCode();

        // use CRC32 instead, but square the result to extend
        // the range to 64 bits
        long hashCode = Hashing.crc32()
                            .hashUnencodedChars(userId)
                            .padToLong();
        hashCode = hashCode * hashCode;

        initValue += hashCode;
    }

    return initValue;
}

/**
 * Returns the next pseudorandom, Gaussian ("normally") distributed
 * {@code double} value with mean {@code 0.0} and standard
 * deviation {@code 1.0} from this random number generator's sequence.
 ...
 * This uses the <i>polar method</i> of G. E. P. Box, M. E. Muller, and
 * G. Marsaglia, as described by Donald E. Knuth in <i>The Art of
 * Computer Programming</i>, Volume 2: <i>Seminumerical Algorithms</i>,
 * section 3.4.1, subsection C, algorithm P. Note that it generates two
 * independent values at the cost of only one call to {@code StrictMath.log}
 * and one call to {@code StrictMath.sqrt}.
 *
 * @return the next pseudorandom, Gaussian ("normally") distributed
 *         {@code double} value with mean {@code 0.0} and
 *         standard deviation {@code 1.0} from this random number
 *         generator's sequence
 */
public synchronized double nextGaussian() {
    // See Knuth, ACP, Section 3.4.1 Algorithm C.
    if (haveNextNextGaussian) {
        haveNextNextGaussian = false;
        return nextNextGaussian;
    } else {
        ...
    }
}
        

/**
 * Sums up all parsable values. Returns 0 for null data and data without
 * fields. In case of parsing problems or null fields, this fields is just
 * skipped. The performance is O(n) and there is no extra memory allocated.
 *
 * @param data an array of Data, can be null or empty
 * @return the sum of all valid entries, assumes 0 otherwise
 */
public static long sum(final Data[] data) {
    if (data == null) {
        return 0;
    }

    long sum = 0;

    for (Data d : data) {
        try {
            // parseInt also handles null
            sum += Integer.parseInt(d.value);
        }
        catch (NumberFormatException e) {
            // we don't care and just skip this entry
        }
    }

    return sum;
}

• Your consumers should shape your code quality
• Embrace refactoring
• Embrace rewriting
• Don't overthink design, keep it simple
• Your code teaches!
• It is ok to hack a prototype or tool without comments