Fix a bunch of FindBugs and IntelliJ inspections

Author: JoshRosen

unsafe/src/main/java/org/apache/spark/unsafe/array/LongArray.java

@@ -29,7 +29,8 @@
  */
 public final class LongArray {
 
-  private static final int WIDTH = 8;
+  // This is a long so that we perform long multiplications when computing offsets.
+  private static final long WIDTH = 8;
 
   private final MemoryBlock memory;
   private final Object baseObj;

unsafe/src/main/java/org/apache/spark/unsafe/map/BytesToBytesMap.java

@@ -176,9 +176,13 @@ public BytesToBytesMap(
   }
 
   @Override
-  public void finalize() {
-    // In case the programmer forgot to call `free()`, try to perform that cleanup now:
-    free();
+  protected void finalize() throws Throwable {
+    try {
+      // In case the programmer forgot to call `free()`, try to perform that cleanup now:
+      free();
+    } finally {
+      super.finalize();
+    }
   }
 
   /**

unsafe/src/main/java/org/apache/spark/unsafe/memory/MemoryAllocator.java

@@ -23,11 +23,11 @@ public interface MemoryAllocator {
    * Allocates a contiguous block of memory. Note that the allocated memory is not guaranteed
    * to be zeroed out (call `zero()` on the result if this is necessary).
    */
-  public MemoryBlock allocate(long size) throws OutOfMemoryError;
+  MemoryBlock allocate(long size) throws OutOfMemoryError;
 
-  public void free(MemoryBlock memory);
+  void free(MemoryBlock memory);
 
-  public static final MemoryAllocator UNSAFE = new UnsafeMemoryAllocator();
+  MemoryAllocator UNSAFE = new UnsafeMemoryAllocator();
 
-  public static final MemoryAllocator HEAP = new HeapMemoryAllocator();
+  MemoryAllocator HEAP = new HeapMemoryAllocator();
 }

unsafe/src/main/java/org/apache/spark/unsafe/memory/MemoryBlock.java

@@ -26,7 +26,7 @@
  */
 public class MemoryBlock extends MemoryLocation {
 
-  final long length;
+  private final long length;
 
   MemoryBlock(@Nullable Object obj, long offset, long length) {
     super(obj, offset);

unsafe/src/main/java/org/apache/spark/unsafe/memory/MemoryLocation.java

@@ -26,9 +26,9 @@
 public class MemoryLocation {
 
   @Nullable
-  protected Object obj;
+  Object obj;
 
-  protected long offset;
+  long offset;
 
   public MemoryLocation(@Nullable Object obj, long offset) {
     this.obj = obj;
@@ -44,10 +44,6 @@ public void setObjAndOffset(Object newObj, long newOffset) {
     this.offset = newOffset;
   }
 
-  public void setOffset(long newOffset) {
-    this.offset = newOffset;
-  }
-
   public final Object getBaseObject() {
     return obj;
   }

unsafe/src/main/java/org/apache/spark/unsafe/string/UTF8StringMethods.java

@@ -107,7 +107,7 @@ public static int getLengthInCodePoints(Object baseObject, long baseOffset, int
   }
 
   public static String toJavaString(Object baseObject, long baseOffset, int lengthInBytes) {
-    final byte[] bytes = new byte[(int) lengthInBytes];
+    final byte[] bytes = new byte[lengthInBytes];
     PlatformDependent.UNSAFE.copyMemory(
       baseObject,
       baseOffset,
@@ -129,8 +129,11 @@ public static String toJavaString(Object baseObject, long baseOffset, int length
    *
    * @return the number of bytes written, including the space for tracking the string's length.
    */
-  public static int createFromJavaString(Object baseObject, long baseOffset, String str) {
-    final byte[] strBytes = str.getBytes();
+  public static int createFromJavaString(
+      Object baseObject,
+      long baseOffset,
+      String str) throws UnsupportedEncodingException {
+    final byte[] strBytes = str.getBytes("utf-8");
     final int strLengthInBytes = strBytes.length;
     PlatformDependent.copyMemory(
       strBytes,
@@ -159,7 +162,7 @@ public static int numOfBytes(byte b) {
    * number of tailing bytes in a UTF8 sequence for a code point
    * see http://en.wikipedia.org/wiki/UTF-8, 192-256 of Byte 1
    */
-  private static int[] bytesOfCodePointInUTF8 = new int[] {
+  private static final int[] bytesOfCodePointInUTF8 = new int[] {
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

unsafe/src/test/java/org/apache/spark/unsafe/array/TestLongArray.java

@@ -24,7 +24,7 @@
 
 public class TestLongArray {
 
-  private LongArray createTestData() {
+  private static LongArray createTestData() {
     byte[] bytes = new byte[16];
     LongArray arr = new LongArray(MemoryBlock.fromByteArray(bytes));
     arr.set(0, 1L);

unsafe/src/test/java/org/apache/spark/unsafe/bitset/TestBitSet.java

@@ -25,7 +25,7 @@
 
 public class TestBitSet {
 
-  private BitSet createBitSet(int capacity) {
+  private static BitSet createBitSet(int capacity) {
     assert capacity % 64 == 0;
     return new BitSet(MemoryBlock.fromLongArray(new long[capacity / 64]).zero());
   }

unsafe/src/test/java/org/apache/spark/unsafe/hash/TestMurmur3_x86_32.java

@@ -30,7 +30,7 @@
  */
 public class TestMurmur3_x86_32 {
 
-  private static Murmur3_x86_32 hasher = new Murmur3_x86_32(0);
+  private static final Murmur3_x86_32 hasher = new Murmur3_x86_32(0);
 
   @Test
   public void testKnownIntegerInputs() {

unsafe/src/test/java/org/apache/spark/unsafe/map/AbstractTestBytesToBytesMap.java

@@ -17,28 +17,28 @@
 
 package org.apache.spark.unsafe.map;
 
+import java.lang.Exception;
+import java.nio.ByteBuffer;
+import java.util.*;
+
+import org.junit.Assert;
+import org.junit.Test;
+
 import org.apache.spark.unsafe.array.ByteArrayMethods;
 import org.apache.spark.unsafe.PlatformDependent;
 import org.apache.spark.unsafe.memory.MemoryAllocator;
 import org.apache.spark.unsafe.memory.MemoryLocation;
 import static org.apache.spark.unsafe.PlatformDependent.BYTE_ARRAY_OFFSET;
-import org.junit.Assert;
-import org.junit.Test;
-
-import java.lang.Exception;
-import java.lang.IllegalStateException;
-import java.nio.ByteBuffer;
-import java.util.*;
 
 public abstract class AbstractTestBytesToBytesMap {
 
-  protected final Random rand = new Random(42);
+  private final Random rand = new Random(42);
 
-  protected final MemoryAllocator allocator = getMemoryAllocator();
+  private final MemoryAllocator allocator = getMemoryAllocator();
 
   protected abstract MemoryAllocator getMemoryAllocator();
 
-  protected byte[] getByteArray(MemoryLocation loc, int size) {
+  private static byte[] getByteArray(MemoryLocation loc, int size) {
     final byte[] arr = new byte[size];
     PlatformDependent.UNSAFE.copyMemory(
       loc.getBaseObject(),
@@ -50,7 +50,7 @@ protected byte[] getByteArray(MemoryLocation loc, int size) {
     return arr;
   }
 
-  protected byte[] getRandomByteArray(int numWords) {
+  private byte[] getRandomByteArray(int numWords) {
     Assert.assertTrue(numWords > 0);
     final int lengthInBytes = numWords * 8;
     final byte[] bytes = new byte[lengthInBytes];
@@ -62,7 +62,7 @@ protected byte[] getRandomByteArray(int numWords) {
    * Fast equality checking for byte arrays, since these comparisons are a bottleneck
    * in our stress tests.
    */
-  protected boolean arrayEquals(
+  private static boolean arrayEquals(
       byte[] expected,
       MemoryLocation actualAddr,
       long actualLengthBytes) {