Use lambdas, method references and Comparator APIs.

Author: greenrobot-team

tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java

@@ -82,29 +82,23 @@ public void testMaxReaders() throws InterruptedException {
         builder = createBoxStoreBuilder(false);
         store = builder.maxReaders(1).build();
         final Exception[] exHolder = {null};
-        final Thread thread = new Thread(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    getTestEntityBox().count();
-                } catch (Exception e) {
-                    exHolder[0] = e;
-                }
-                getTestEntityBox().closeThreadResources();
+        final Thread thread = new Thread(() -> {
+            try {
+                getTestEntityBox().count();
+            } catch (Exception e) {
+                exHolder[0] = e;
             }
+            getTestEntityBox().closeThreadResources();
         });
 
         getTestEntityBox().count();
-        store.runInReadTx(new Runnable() {
-            @Override
-            public void run() {
-                getTestEntityBox().count();
-                thread.start();
-                try {
-                    thread.join(5000);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
+        store.runInReadTx(() -> {
+            getTestEntityBox().count();
+            thread.start();
+            try {
+                thread.join(5000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
             }
         });
 

tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java

@@ -194,12 +194,9 @@ public void testCallInReadTxWithRetry_callback() {
         final int[] countHolderCallback = {0};
 
         BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir)
-                .failedReadTxAttemptCallback(new TxCallback() {
-                    @Override
-                    public void txFinished(@Nullable Object result, @Nullable Throwable error) {
-                        assertNotNull(error);
-                        countHolderCallback[0]++;
-                    }
+                .failedReadTxAttemptCallback((result, error) -> {
+                    assertNotNull(error);
+                    countHolderCallback[0]++;
                 });
         store = builder.build();
         String value = store.callInReadTxWithRetry(createTestCallable(countHolder), 5, 0, true);
@@ -209,15 +206,12 @@ public void txFinished(@Nullable Object result, @Nullable Throwable error) {
     }
 
     private Callable<String> createTestCallable(final int[] countHolder) {
-        return new Callable<String>() {
-            @Override
-            public String call() throws Exception {
-                int count = ++countHolder[0];
-                if (count < 5) {
-                    throw new DbException("Count: " + count);
-                }
-                return "42";
+        return () -> {
+            int count = ++countHolder[0];
+            if (count < 5) {
+                throw new DbException("Count: " + count);
             }
+            return "42";
         };
     }
 

tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java

@@ -193,14 +193,11 @@ public void testPanicModeRemoveAllObjects() {
     @Test
     public void testRunInTx() {
         final long[] counts = {0, 0};
-        store.runInTx(new Runnable() {
-            @Override
-            public void run() {
-                box.put(new TestEntity());
-                counts[0] = box.count();
-                box.put(new TestEntity());
-                counts[1] = box.count();
-            }
+        store.runInTx(() -> {
+            box.put(new TestEntity());
+            counts[0] = box.count();
+            box.put(new TestEntity());
+            counts[1] = box.count();
         });
         assertEquals(1, counts[0]);
         assertEquals(2, counts[1]);

tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java

@@ -221,15 +221,12 @@ public void testWriteTxBlocksOtherWriteTx() throws InterruptedException {
         long duration = System.currentTimeMillis() - time; // Usually 0 on desktop
         final CountDownLatch latchBeforeBeginTx = new CountDownLatch(1);
         final CountDownLatch latchAfterBeginTx = new CountDownLatch(1);
-        new Thread() {
-            @Override
-            public void run() {
-                latchBeforeBeginTx.countDown();
-                Transaction tx2 = store.beginTx();
-                latchAfterBeginTx.countDown();
-                tx2.close();
-            }
-        }.start();
+        new Thread(() -> {
+            latchBeforeBeginTx.countDown();
+            Transaction tx2 = store.beginTx();
+            latchAfterBeginTx.countDown();
+            tx2.close();
+        }).start();
         assertTrue(latchBeforeBeginTx.await(1, TimeUnit.SECONDS));
         long waitTime = 100 + duration * 10;
         assertFalse(latchAfterBeginTx.await(waitTime, TimeUnit.MILLISECONDS));

tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java

@@ -48,22 +48,16 @@ protected BoxStore createBoxStore() {
 
     final List<Class> classesWithChanges = new ArrayList<>();
 
-    DataObserver objectClassObserver = new DataObserver<Class>() {
-        @Override
-        public void onData(Class objectClass) {
-            classesWithChanges.add(objectClass);
-            observerLatch.countDown();
-        }
+    DataObserver objectClassObserver = (DataObserver<Class>) objectClass -> {
+        classesWithChanges.add(objectClass);
+        observerLatch.countDown();
     };
 
-    Runnable txRunnable = new Runnable() {
-        @Override
-        public void run() {
-            putTestEntities(3);
-            Box<TestEntityMinimal> boxMini = store.boxFor(TestEntityMinimal.class);
-            boxMini.put(new TestEntityMinimal(), new TestEntityMinimal());
-            assertEquals(0, classesWithChanges.size());
-        }
+    Runnable txRunnable = () -> {
+        putTestEntities(3);
+        Box<TestEntityMinimal> boxMini = store.boxFor(TestEntityMinimal.class);
+        boxMini.put(new TestEntityMinimal(), new TestEntityMinimal());
+        assertEquals(0, classesWithChanges.size());
     };
 
     @Before
@@ -83,12 +77,9 @@ public void testTwoObjectClassesChanged_catchAllObserverWeak() {
 
     public void testTwoObjectClassesChanged_catchAllObserver(boolean weak) {
         DataSubscription subscription = subscribe(weak, null);
-        store.runInTx(new Runnable() {
-            @Override
-            public void run() {
-                // Dummy TX, still will be committed
-                getTestEntityBox().count();
-            }
+        store.runInTx(() -> {
+            // Dummy TX, still will be committed
+            getTestEntityBox().count();
         });
         assertEquals(0, classesWithChanges.size());
 
@@ -172,31 +163,21 @@ private void testTransform(TestScheduler scheduler) throws InterruptedException
         final Thread testThread = Thread.currentThread();
 
         SubscriptionBuilder<Long> subscriptionBuilder = store.subscribe().onlyChanges().
-                transform(new DataTransformer<Class, Long>() {
-            @Override
-            @SuppressWarnings("NullableProblems")
-            public Long transform(Class source) throws Exception {
-                assertNotSame(testThread, Thread.currentThread());
-                return store.boxFor(source).count();
-            }
-        });
+                transform(source -> {
+                    assertNotSame(testThread, Thread.currentThread());
+                    return store.boxFor(source).count();
+                });
         if (scheduler != null) {
             subscriptionBuilder.on(scheduler);
         }
-        DataSubscription subscription = subscriptionBuilder.observer(new DataObserver<Long>() {
-            @Override
-            public void onData(Long data) {
-                objectCounts.add(data);
-                latch.countDown();
-            }
+        DataSubscription subscription = subscriptionBuilder.observer(data -> {
+            objectCounts.add(data);
+            latch.countDown();
         });
 
-        store.runInTx(new Runnable() {
-            @Override
-            public void run() {
-                // Dummy TX, still will be committed, should not add anything to objectCounts
-                getTestEntityBox().count();
-            }
+        store.runInTx(() -> {
+            // Dummy TX, still will be committed, should not add anything to objectCounts
+            getTestEntityBox().count();
         });
 
         store.runInTx(txRunnable);
@@ -262,24 +243,14 @@ public void testTransformError(Scheduler scheduler) throws InterruptedException
         final CountDownLatch latch = new CountDownLatch(2);
         final Thread testThread = Thread.currentThread();
 
-        DataSubscription subscription = store.subscribe().onlyChanges().transform(new DataTransformer<Class, Long>() {
-            @Override
-            @SuppressWarnings("NullableProblems")
-            public Long transform(Class source) throws Exception {
-                throw new Exception("Boo");
-            }
-        }).onError(new ErrorObserver() {
-            @Override
-            public void onError(Throwable th) {
-                assertNotSame(testThread, Thread.currentThread());
-                errors.add(th);
-                latch.countDown();
-            }
-        }).on(scheduler).observer(new DataObserver<Long>() {
-            @Override
-            public void onData(Long data) {
-                throw new RuntimeException("Should not reach this");
-            }
+        DataSubscription subscription = store.subscribe().onlyChanges().transform((DataTransformer<Class, Long>) source -> {
+            throw new Exception("Boo");
+        }).onError(throwable -> {
+            assertNotSame(testThread, Thread.currentThread());
+            errors.add(throwable);
+            latch.countDown();
+        }).on(scheduler).observer(data -> {
+            throw new RuntimeException("Should not reach this");
         });
 
         store.runInTx(txRunnable);
@@ -312,18 +283,12 @@ public void testObserverError(Scheduler scheduler) throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(2);
         final Thread testThread = Thread.currentThread();
 
-        DataSubscription subscription = store.subscribe().onlyChanges().onError(new ErrorObserver() {
-            @Override
-            public void onError(Throwable th) {
-                assertNotSame(testThread, Thread.currentThread());
-                errors.add(th);
-                latch.countDown();
-            }
-        }).on(scheduler).observer(new DataObserver<Class>() {
-            @Override
-            public void onData(Class data) {
-                throw new RuntimeException("Boo");
-            }
+        DataSubscription subscription = store.subscribe().onlyChanges().onError(th -> {
+            assertNotSame(testThread, Thread.currentThread());
+            errors.add(th);
+            latch.countDown();
+        }).on(scheduler).observer(data -> {
+            throw new RuntimeException("Boo");
         });
 
         store.runInTx(txRunnable);
@@ -430,13 +395,9 @@ public void testSingle(boolean weak, boolean wrapped) {
     @Test
     public void testSingleCancelSubscription() throws InterruptedException {
         DataSubscription subscription = store.subscribe().single()
-                .transform(new DataTransformer<Class, Class>() {
-                    @Override
-                    @SuppressWarnings("NullableProblems")
-                    public Class transform(Class source) throws Exception {
-                        Thread.sleep(20);
-                        return source;
-                    }
+                .transform(source -> {
+                    Thread.sleep(20);
+                    return source;
                 }).observer(objectClassObserver);
         subscription.cancel();
         Thread.sleep(40);