diff --git a/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java b/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java index 13fe0c3126..7b261b2b8e 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java +++ b/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java @@ -6,7 +6,7 @@ public class NumbersConsumer implements Runnable { private final BlockingQueue queue; private final int poisonPill; - public NumbersConsumer(BlockingQueue queue, int poisonPill) { + NumbersConsumer(BlockingQueue queue, int poisonPill) { this.queue = queue; this.poisonPill = poisonPill; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java b/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java index b262097c63..9dcd0a3e47 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java +++ b/core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java @@ -9,7 +9,7 @@ public class NumbersProducer implements Runnable { private final int poisonPill; private final int poisonPillPerProducer; - public NumbersProducer(BlockingQueue numbersQueue, int poisonPill, int poisonPillPerProducer) { + NumbersProducer(BlockingQueue numbersQueue, int poisonPill, int poisonPillPerProducer) { this.numbersQueue = numbersQueue; this.poisonPill = poisonPill; this.poisonPillPerProducer = poisonPillPerProducer; diff --git a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java index 90cd01b69f..d48f317fe7 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java +++ b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java @@ -7,7 +7,7 @@ public class BrokenWorker implements Runnable { private final List outputScraper; private final CountDownLatch countDownLatch; - public BrokenWorker(final List outputScraper, final CountDownLatch countDownLatch) { + BrokenWorker(final List outputScraper, final CountDownLatch countDownLatch) { this.outputScraper = outputScraper; this.countDownLatch = countDownLatch; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java index 66be2030e2..4aee5cf89a 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java +++ b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java @@ -10,7 +10,7 @@ public class WaitingWorker implements Runnable { private final CountDownLatch callingThreadBlocker; private final CountDownLatch completedThreadCounter; - public WaitingWorker(final List outputScraper, final CountDownLatch readyThreadCounter, final CountDownLatch callingThreadBlocker, CountDownLatch completedThreadCounter) { + WaitingWorker(final List outputScraper, final CountDownLatch readyThreadCounter, final CountDownLatch callingThreadBlocker, CountDownLatch completedThreadCounter) { this.outputScraper = outputScraper; this.readyThreadCounter = readyThreadCounter; diff --git a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java index e712fc18d6..389e25719b 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java +++ b/core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java @@ -7,7 +7,7 @@ public class Worker implements Runnable { private final List outputScraper; private final CountDownLatch countDownLatch; - public Worker(final List outputScraper, final CountDownLatch countDownLatch) { + Worker(final List outputScraper, final CountDownLatch countDownLatch) { this.outputScraper = outputScraper; this.countDownLatch = countDownLatch; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierDemo.java b/core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierDemo.java index 69b6d46599..977dae4fdb 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierDemo.java +++ b/core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierDemo.java @@ -7,9 +7,6 @@ import java.util.Random; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; -/** - * Created by cv on 24/6/17. - */ public class CyclicBarrierDemo { private CyclicBarrier cyclicBarrier; @@ -19,7 +16,7 @@ public class CyclicBarrierDemo { private int NUM_WORKERS; - public void runSimulation(int numWorkers, int numberOfPartialResults) { + private void runSimulation(int numWorkers, int numberOfPartialResults) { NUM_PARTIAL_RESULTS = numberOfPartialResults; NUM_WORKERS = numWorkers; @@ -49,9 +46,7 @@ public class CyclicBarrierDemo { try { System.out.println(thisThreadName + " waiting for others to reach barrier."); cyclicBarrier.await(); - } catch (InterruptedException e) { - e.printStackTrace(); - } catch (BrokenBarrierException e) { + } catch (InterruptedException | BrokenBarrierException e) { e.printStackTrace(); } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayObject.java b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayObject.java index aa4ca58d6a..5f72758e71 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayObject.java +++ b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayObject.java @@ -9,7 +9,7 @@ public class DelayObject implements Delayed { private String data; private long startTime; - public DelayObject(String data, long delayInMilliseconds) { + DelayObject(String data, long delayInMilliseconds) { this.data = data; this.startTime = System.currentTimeMillis() + delayInMilliseconds; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueConsumer.java b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueConsumer.java index 8a969bf7aa..d1c1eae9f2 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueConsumer.java +++ b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueConsumer.java @@ -7,9 +7,9 @@ import java.util.concurrent.atomic.AtomicInteger; public class DelayQueueConsumer implements Runnable { private BlockingQueue queue; private final Integer numberOfElementsToTake; - public final AtomicInteger numberOfConsumedElements = new AtomicInteger(); + final AtomicInteger numberOfConsumedElements = new AtomicInteger(); - public DelayQueueConsumer(BlockingQueue queue, Integer numberOfElementsToTake) { + DelayQueueConsumer(BlockingQueue queue, Integer numberOfElementsToTake) { this.queue = queue; this.numberOfElementsToTake = numberOfElementsToTake; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueProducer.java b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueProducer.java index 617f19b9ac..f24f4bc385 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueProducer.java +++ b/core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueProducer.java @@ -9,9 +9,9 @@ public class DelayQueueProducer implements Runnable { private final Integer numberOfElementsToProduce; private final Integer delayOfEachProducedMessageMilliseconds; - public DelayQueueProducer(BlockingQueue queue, - Integer numberOfElementsToProduce, - Integer delayOfEachProducedMessageMilliseconds) { + DelayQueueProducer(BlockingQueue queue, + Integer numberOfElementsToProduce, + Integer delayOfEachProducedMessageMilliseconds) { this.queue = queue; this.numberOfElementsToProduce = numberOfElementsToProduce; this.delayOfEachProducedMessageMilliseconds = delayOfEachProducedMessageMilliseconds; diff --git a/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java index 3f1eacd276..c5672706ad 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java +++ b/core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java @@ -5,7 +5,7 @@ public class Philosopher implements Runnable { private final Object leftFork; private final Object rightFork; - public Philosopher(Object left, Object right) { + Philosopher(Object left, Object right) { this.leftFork = left; this.rightFork = right; } @@ -30,7 +30,6 @@ public class Philosopher implements Runnable { } } catch (InterruptedException e) { Thread.currentThread().interrupt(); - return; } } } \ No newline at end of file diff --git a/core-java/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java b/core-java/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java index 471072b333..35bb2aa497 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java +++ b/core-java/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java @@ -7,7 +7,7 @@ public class FactorialSquareCalculator extends RecursiveTask { final private Integer n; - public FactorialSquareCalculator(Integer n) { + FactorialSquareCalculator(Integer n) { this.n = n; } diff --git a/core-java/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java b/core-java/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java index bcd559dd3b..3329fa599b 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java +++ b/core-java/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java @@ -3,15 +3,15 @@ package com.baeldung.concurrent.future; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; -public class SquareCalculator { +class SquareCalculator { private final ExecutorService executor; - public SquareCalculator(ExecutorService executor) { + SquareCalculator(ExecutorService executor) { this.executor = executor; } - public Future calculate(Integer input) { + Future calculate(Integer input) { return executor.submit(() -> { Thread.sleep(1000); return input * input; diff --git a/core-java/src/main/java/com/baeldung/concurrent/locks/ReentrantLockWithCondition.java b/core-java/src/main/java/com/baeldung/concurrent/locks/ReentrantLockWithCondition.java index 4f061d2efd..f01c675fd2 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/locks/ReentrantLockWithCondition.java +++ b/core-java/src/main/java/com/baeldung/concurrent/locks/ReentrantLockWithCondition.java @@ -13,71 +13,71 @@ import static java.lang.Thread.sleep; public class ReentrantLockWithCondition { - static Logger logger = LoggerFactory.getLogger(ReentrantLockWithCondition.class); + private static Logger LOG = LoggerFactory.getLogger(ReentrantLockWithCondition.class); - Stack stack = new Stack<>(); - int CAPACITY = 5; + private Stack stack = new Stack<>(); + private static final int CAPACITY = 5; - ReentrantLock lock = new ReentrantLock(); - Condition stackEmptyCondition = lock.newCondition(); - Condition stackFullCondition = lock.newCondition(); + private ReentrantLock lock = new ReentrantLock(); + private Condition stackEmptyCondition = lock.newCondition(); + private Condition stackFullCondition = lock.newCondition(); - public void pushToStack(String item) throws InterruptedException { - try { - lock.lock(); - if (stack.size() == CAPACITY) { - logger.info(Thread.currentThread().getName() + " wait on stack full"); - stackFullCondition.await(); - } - logger.info("Pushing the item " + item); - stack.push(item); - stackEmptyCondition.signalAll(); - } finally { - lock.unlock(); - } + private void pushToStack(String item) throws InterruptedException { + try { + lock.lock(); + if (stack.size() == CAPACITY) { + LOG.info(Thread.currentThread().getName() + " wait on stack full"); + stackFullCondition.await(); + } + LOG.info("Pushing the item " + item); + stack.push(item); + stackEmptyCondition.signalAll(); + } finally { + lock.unlock(); + } - } + } - public String popFromStack() throws InterruptedException { - try { - lock.lock(); - if (stack.size() == 0) { - logger.info(Thread.currentThread().getName() + " wait on stack empty"); - stackEmptyCondition.await(); - } - return stack.pop(); - } finally { - stackFullCondition.signalAll(); - lock.unlock(); - } - } + private String popFromStack() throws InterruptedException { + try { + lock.lock(); + if (stack.size() == 0) { + LOG.info(Thread.currentThread().getName() + " wait on stack empty"); + stackEmptyCondition.await(); + } + return stack.pop(); + } finally { + stackFullCondition.signalAll(); + lock.unlock(); + } + } - public static void main(String[] args) { - final int threadCount = 2; - ReentrantLockWithCondition object = new ReentrantLockWithCondition(); - final ExecutorService service = Executors.newFixedThreadPool(threadCount); - service.execute(() -> { - for (int i = 0; i < 10; i++) { - try { - object.pushToStack("Item " + i); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } + public static void main(String[] args) { + final int threadCount = 2; + ReentrantLockWithCondition object = new ReentrantLockWithCondition(); + final ExecutorService service = Executors.newFixedThreadPool(threadCount); + service.execute(() -> { + for (int i = 0; i < 10; i++) { + try { + object.pushToStack("Item " + i); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } - }); + }); - service.execute(() -> { - for (int i = 0; i < 10; i++) { - try { - logger.info("Item popped " + object.popFromStack()); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } + service.execute(() -> { + for (int i = 0; i < 10; i++) { + try { + LOG.info("Item popped " + object.popFromStack()); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } - }); + }); - service.shutdown(); - } + service.shutdown(); + } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/locks/SharedObjectWithLock.java b/core-java/src/main/java/com/baeldung/concurrent/locks/SharedObjectWithLock.java index b6a4615638..14ae47b2f3 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/locks/SharedObjectWithLock.java +++ b/core-java/src/main/java/com/baeldung/concurrent/locks/SharedObjectWithLock.java @@ -12,81 +12,77 @@ import static java.lang.Thread.sleep; public class SharedObjectWithLock { - Logger logger = LoggerFactory.getLogger(SharedObjectWithLock.class); + private static final Logger LOG = LoggerFactory.getLogger(SharedObjectWithLock.class); - ReentrantLock lock = new ReentrantLock(true); + private ReentrantLock lock = new ReentrantLock(true); - int counter = 0; + private int counter = 0; - public void perform() { + void perform() { - lock.lock(); - logger.info("Thread - " + Thread.currentThread().getName() + " acquired the lock"); - try { - logger.info("Thread - " + Thread.currentThread().getName() + " processing"); - counter++; - } catch (Exception exception) { - logger.error(" Interrupted Exception ", exception); - } finally { - lock.unlock(); - logger.info("Thread - " + Thread.currentThread().getName() + " released the lock"); - } - } + lock.lock(); + LOG.info("Thread - " + Thread.currentThread().getName() + " acquired the lock"); + try { + LOG.info("Thread - " + Thread.currentThread().getName() + " processing"); + counter++; + } catch (Exception exception) { + LOG.error(" Interrupted Exception ", exception); + } finally { + lock.unlock(); + LOG.info("Thread - " + Thread.currentThread().getName() + " released the lock"); + } + } - public void performTryLock() { + private void performTryLock() { - logger.info("Thread - " + Thread.currentThread().getName() + " attempting to acquire the lock"); - try { - boolean isLockAcquired = lock.tryLock(2, TimeUnit.SECONDS); - if (isLockAcquired) { - try { - logger.info("Thread - " + Thread.currentThread().getName() + " acquired the lock"); + LOG.info("Thread - " + Thread.currentThread().getName() + " attempting to acquire the lock"); + try { + boolean isLockAcquired = lock.tryLock(2, TimeUnit.SECONDS); + if (isLockAcquired) { + try { + LOG.info("Thread - " + Thread.currentThread().getName() + " acquired the lock"); - logger.info("Thread - " + Thread.currentThread().getName() + " processing"); - sleep(1000); - } finally { - lock.unlock(); - logger.info("Thread - " + Thread.currentThread().getName() + " released the lock"); + LOG.info("Thread - " + Thread.currentThread().getName() + " processing"); + sleep(1000); + } finally { + lock.unlock(); + LOG.info("Thread - " + Thread.currentThread().getName() + " released the lock"); - } - } - } catch (InterruptedException exception) { - logger.error(" Interrupted Exception ", exception); - } - logger.info("Thread - " + Thread.currentThread().getName() + " could not acquire the lock"); - } + } + } + } catch (InterruptedException exception) { + LOG.error(" Interrupted Exception ", exception); + } + LOG.info("Thread - " + Thread.currentThread().getName() + " could not acquire the lock"); + } - public ReentrantLock getLock() { - return lock; - } + public ReentrantLock getLock() { + return lock; + } - boolean isLocked() { - return lock.isLocked(); - } + boolean isLocked() { + return lock.isLocked(); + } - boolean hasQueuedThreads() { - return lock.hasQueuedThreads(); - } + boolean hasQueuedThreads() { + return lock.hasQueuedThreads(); + } - int getCounter() { - return counter; - } + int getCounter() { + return counter; + } - public static void main(String[] args) { + public static void main(String[] args) { - final int threadCount = 2; - final ExecutorService service = Executors.newFixedThreadPool(threadCount); - final SharedObjectWithLock object = new SharedObjectWithLock(); + final int threadCount = 2; + final ExecutorService service = Executors.newFixedThreadPool(threadCount); + final SharedObjectWithLock object = new SharedObjectWithLock(); - service.execute(() -> { - object.perform(); - }); - service.execute(() -> { - object.performTryLock(); - }); + service.execute(object::perform); + service.execute(object::performTryLock); - service.shutdown(); + service.shutdown(); - } + } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/locks/StampedLockDemo.java b/core-java/src/main/java/com/baeldung/concurrent/locks/StampedLockDemo.java index 0b0dbc72cb..638bb56b2f 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/locks/StampedLockDemo.java +++ b/core-java/src/main/java/com/baeldung/concurrent/locks/StampedLockDemo.java @@ -12,93 +12,93 @@ import java.util.concurrent.locks.StampedLock; import static java.lang.Thread.sleep; public class StampedLockDemo { - Map map = new HashMap<>(); - Logger logger = LoggerFactory.getLogger(StampedLockDemo.class); + private Map map = new HashMap<>(); + private Logger logger = LoggerFactory.getLogger(StampedLockDemo.class); - private final StampedLock lock = new StampedLock(); + private final StampedLock lock = new StampedLock(); - public void put(String key, String value) throws InterruptedException { - long stamp = lock.writeLock(); + public void put(String key, String value) throws InterruptedException { + long stamp = lock.writeLock(); - try { - logger.info(Thread.currentThread().getName() + " acquired the write lock with stamp " + stamp); - map.put(key, value); - } finally { - lock.unlockWrite(stamp); - logger.info(Thread.currentThread().getName() + " unlocked the write lock with stamp " + stamp); - } - } + try { + logger.info(Thread.currentThread().getName() + " acquired the write lock with stamp " + stamp); + map.put(key, value); + } finally { + lock.unlockWrite(stamp); + logger.info(Thread.currentThread().getName() + " unlocked the write lock with stamp " + stamp); + } + } - public String get(String key) throws InterruptedException { - long stamp = lock.readLock(); - logger.info(Thread.currentThread().getName() + " acquired the read lock with stamp " + stamp); - try { - sleep(5000); - return map.get(key); + public String get(String key) throws InterruptedException { + long stamp = lock.readLock(); + logger.info(Thread.currentThread().getName() + " acquired the read lock with stamp " + stamp); + try { + sleep(5000); + return map.get(key); - } finally { - lock.unlockRead(stamp); - logger.info(Thread.currentThread().getName() + " unlocked the read lock with stamp " + stamp); + } finally { + lock.unlockRead(stamp); + logger.info(Thread.currentThread().getName() + " unlocked the read lock with stamp " + stamp); - } + } - } + } - public String readWithOptimisticLock(String key) throws InterruptedException { - long stamp = lock.tryOptimisticRead(); - String value = map.get(key); + private String readWithOptimisticLock(String key) throws InterruptedException { + long stamp = lock.tryOptimisticRead(); + String value = map.get(key); - if (!lock.validate(stamp)) { - stamp = lock.readLock(); - try { - sleep(5000); - return map.get(key); + if (!lock.validate(stamp)) { + stamp = lock.readLock(); + try { + sleep(5000); + return map.get(key); - } finally { - lock.unlock(stamp); - logger.info(Thread.currentThread().getName() + " unlocked the read lock with stamp " + stamp); + } finally { + lock.unlock(stamp); + logger.info(Thread.currentThread().getName() + " unlocked the read lock with stamp " + stamp); - } - } - return value; - } + } + } + return value; + } - public static void main(String[] args) { - final int threadCount = 4; - final ExecutorService service = Executors.newFixedThreadPool(threadCount); - StampedLockDemo object = new StampedLockDemo(); + public static void main(String[] args) { + final int threadCount = 4; + final ExecutorService service = Executors.newFixedThreadPool(threadCount); + StampedLockDemo object = new StampedLockDemo(); - Runnable writeTask = () -> { + Runnable writeTask = () -> { - try { - object.put("key1", "value1"); - } catch (InterruptedException e) { - e.printStackTrace(); - } - }; - Runnable readTask = () -> { + try { + object.put("key1", "value1"); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }; + Runnable readTask = () -> { - try { - object.get("key1"); - } catch (InterruptedException e) { - e.printStackTrace(); - } - }; - Runnable readOptimisticTask = () -> { + try { + object.get("key1"); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }; + Runnable readOptimisticTask = () -> { - try { - object.readWithOptimisticLock("key1"); - } catch (InterruptedException e) { - e.printStackTrace(); - } - }; - service.submit(writeTask); - service.submit(writeTask); - service.submit(readTask); - service.submit(readOptimisticTask); + try { + object.readWithOptimisticLock("key1"); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }; + service.submit(writeTask); + service.submit(writeTask); + service.submit(readTask); + service.submit(readOptimisticTask); - service.shutdown(); + service.shutdown(); - } + } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLock.java b/core-java/src/main/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLock.java index 83b8b34fe9..eeb7aa4b13 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLock.java +++ b/core-java/src/main/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLock.java @@ -15,106 +15,106 @@ import static java.lang.Thread.sleep; public class SynchronizedHashMapWithRWLock { - static Map syncHashMap = new HashMap<>(); - Logger logger = LoggerFactory.getLogger(SynchronizedHashMapWithRWLock.class); + private static Map syncHashMap = new HashMap<>(); + private Logger logger = LoggerFactory.getLogger(SynchronizedHashMapWithRWLock.class); - private final ReadWriteLock lock = new ReentrantReadWriteLock(); - private final Lock readLock = lock.readLock(); - private final Lock writeLock = lock.writeLock(); + private final ReadWriteLock lock = new ReentrantReadWriteLock(); + private final Lock readLock = lock.readLock(); + private final Lock writeLock = lock.writeLock(); - public void put(String key, String value) throws InterruptedException { + public void put(String key, String value) throws InterruptedException { - try { - writeLock.lock(); - logger.info(Thread.currentThread().getName() + " writing"); - syncHashMap.put(key, value); - sleep(1000); - } finally { - writeLock.unlock(); - } + try { + writeLock.lock(); + logger.info(Thread.currentThread().getName() + " writing"); + syncHashMap.put(key, value); + sleep(1000); + } finally { + writeLock.unlock(); + } - } + } - public String get(String key) { - try { - readLock.lock(); - logger.info(Thread.currentThread().getName() + " reading"); - return syncHashMap.get(key); - } finally { - readLock.unlock(); - } - } + public String get(String key) { + try { + readLock.lock(); + logger.info(Thread.currentThread().getName() + " reading"); + return syncHashMap.get(key); + } finally { + readLock.unlock(); + } + } - public String remove(String key) { - try { - writeLock.lock(); - return syncHashMap.remove(key); - } finally { - writeLock.unlock(); - } - } + public String remove(String key) { + try { + writeLock.lock(); + return syncHashMap.remove(key); + } finally { + writeLock.unlock(); + } + } - public boolean containsKey(String key) { - try { - readLock.lock(); - return syncHashMap.containsKey(key); - } finally { - readLock.unlock(); - } - } + public boolean containsKey(String key) { + try { + readLock.lock(); + return syncHashMap.containsKey(key); + } finally { + readLock.unlock(); + } + } - boolean isReadLockAvailable() { - return readLock.tryLock(); - } + boolean isReadLockAvailable() { + return readLock.tryLock(); + } - public static void main(String[] args) throws InterruptedException { + public static void main(String[] args) throws InterruptedException { - final int threadCount = 3; - final ExecutorService service = Executors.newFixedThreadPool(threadCount); - SynchronizedHashMapWithRWLock object = new SynchronizedHashMapWithRWLock(); + final int threadCount = 3; + final ExecutorService service = Executors.newFixedThreadPool(threadCount); + SynchronizedHashMapWithRWLock object = new SynchronizedHashMapWithRWLock(); - service.execute(new Thread(new Writer(object), "Writer")); - service.execute(new Thread(new Reader(object), "Reader1")); - service.execute(new Thread(new Reader(object), "Reader2")); + service.execute(new Thread(new Writer(object), "Writer")); + service.execute(new Thread(new Reader(object), "Reader1")); + service.execute(new Thread(new Reader(object), "Reader2")); - service.shutdown(); - } + service.shutdown(); + } - private static class Reader implements Runnable { + private static class Reader implements Runnable { - SynchronizedHashMapWithRWLock object; + SynchronizedHashMapWithRWLock object; - public Reader(SynchronizedHashMapWithRWLock object) { - this.object = object; - } + Reader(SynchronizedHashMapWithRWLock object) { + this.object = object; + } - @Override - public void run() { - for (int i = 0; i < 10; i++) { - object.get("key" + i); - } - } - } + @Override + public void run() { + for (int i = 0; i < 10; i++) { + object.get("key" + i); + } + } + } - private static class Writer implements Runnable { + private static class Writer implements Runnable { - SynchronizedHashMapWithRWLock object; + SynchronizedHashMapWithRWLock object; - public Writer(SynchronizedHashMapWithRWLock object) { - this.object = object; - } + public Writer(SynchronizedHashMapWithRWLock object) { + this.object = object; + } - @Override - public void run() { - for (int i = 0; i < 10; i++) { - try { - object.put("key" + i, "value" + i); - sleep(1000); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - } - } + @Override + public void run() { + for (int i = 0; i < 10; i++) { + try { + object.put("key" + i, "value" + i); + sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/skiplist/Event.java b/core-java/src/main/java/com/baeldung/concurrent/skiplist/Event.java index ce1f57bb93..d5ff5f7842 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/skiplist/Event.java +++ b/core-java/src/main/java/com/baeldung/concurrent/skiplist/Event.java @@ -2,20 +2,20 @@ package com.baeldung.concurrent.skiplist; import java.time.ZonedDateTime; -public class Event { +class Event { private final ZonedDateTime eventTime; private final String content; - public Event(ZonedDateTime eventTime, String content) { + Event(ZonedDateTime eventTime, String content) { this.eventTime = eventTime; this.content = content; } - public ZonedDateTime getEventTime() { + ZonedDateTime getEventTime() { return eventTime; } - public String getContent() { + String getContent() { return content; } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/skiplist/EventWindowSort.java b/core-java/src/main/java/com/baeldung/concurrent/skiplist/EventWindowSort.java index 3aca6b0147..2e501ed368 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/skiplist/EventWindowSort.java +++ b/core-java/src/main/java/com/baeldung/concurrent/skiplist/EventWindowSort.java @@ -5,24 +5,24 @@ import java.util.Comparator; import java.util.concurrent.ConcurrentNavigableMap; import java.util.concurrent.ConcurrentSkipListMap; -public class EventWindowSort { +class EventWindowSort { private final ConcurrentSkipListMap events - = new ConcurrentSkipListMap<>(Comparator.comparingLong(value -> value.toInstant().toEpochMilli())); + = new ConcurrentSkipListMap<>(Comparator.comparingLong(value -> value.toInstant().toEpochMilli())); - public void acceptEvent(Event event) { + void acceptEvent(Event event) { events.put(event.getEventTime(), event.getContent()); } - public ConcurrentNavigableMap getEventsFromLastMinute() { + ConcurrentNavigableMap getEventsFromLastMinute() { return events.tailMap(ZonedDateTime - .now() - .minusMinutes(1)); + .now() + .minusMinutes(1)); } - public ConcurrentNavigableMap getEventsOlderThatOneMinute() { + ConcurrentNavigableMap getEventsOlderThatOneMinute() { return events.headMap(ZonedDateTime - .now() - .minusMinutes(1)); + .now() + .minusMinutes(1)); } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/sleepwait/WaitSleepExample.java b/core-java/src/main/java/com/baeldung/concurrent/sleepwait/WaitSleepExample.java index 0311d9b0b2..90bc4dceed 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/sleepwait/WaitSleepExample.java +++ b/core-java/src/main/java/com/baeldung/concurrent/sleepwait/WaitSleepExample.java @@ -13,10 +13,10 @@ public class WaitSleepExample { private static final Object LOCK = new Object(); public static void main(String... args) throws InterruptedException { - sleepWaitInSyncronizedBlocks(); + sleepWaitInSynchronizedBlocks(); } - private static void sleepWaitInSyncronizedBlocks() throws InterruptedException { + private static void sleepWaitInSynchronizedBlocks() throws InterruptedException { Thread.sleep(1000); // called on the thread LOG.debug("Thread '" + Thread.currentThread().getName() + "' is woken after sleeping for 1 second"); @@ -25,5 +25,5 @@ public class WaitSleepExample { LOG.debug("Object '" + LOCK + "' is woken after waiting for 1 second"); } } - + } diff --git a/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java b/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java index d66cd0d796..332a6d9263 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java +++ b/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java @@ -5,13 +5,13 @@ public class BaeldungSynchronizedBlocks { private int count = 0; private static int staticCount = 0; - public void performSynchronisedTask() { + void performSynchronisedTask() { synchronized (this) { setCount(getCount() + 1); } } - public static void performStaticSyncTask() { + static void performStaticSyncTask() { synchronized (BaeldungSynchronizedBlocks.class) { setStaticCount(getStaticCount() + 1); } @@ -25,11 +25,11 @@ public class BaeldungSynchronizedBlocks { this.count = count; } - public static int getStaticCount() { + static int getStaticCount() { return staticCount; } - public static void setStaticCount(int staticCount) { + private static void setStaticCount(int staticCount) { BaeldungSynchronizedBlocks.staticCount = staticCount; } } diff --git a/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java b/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java index 1295140b7c..179c6fb9ef 100644 --- a/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java +++ b/core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java @@ -5,17 +5,17 @@ public class BaeldungSynchronizedMethods { private int sum = 0; private int syncSum = 0; - public static int staticSum = 0; + static int staticSum = 0; - public void calculate() { + void calculate() { setSum(getSum() + 1); } - public synchronized void synchronisedCalculate() { + synchronized void synchronisedCalculate() { setSyncSum(getSyncSum() + 1); } - public static synchronized void syncStaticCalculate() { + static synchronized void syncStaticCalculate() { staticSum = staticSum + 1; } @@ -27,11 +27,11 @@ public class BaeldungSynchronizedMethods { this.sum = sum; } - public int getSyncSum() { + int getSyncSum() { return syncSum; } - public void setSyncSum(int syncSum) { + private void setSyncSum(int syncSum) { this.syncSum = syncSum; } } diff --git a/core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java b/core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java index 82f5745b3c..0d727cf0b5 100644 --- a/core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java +++ b/core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java @@ -6,40 +6,40 @@ import java.time.LocalDateTime; import java.time.temporal.ChronoUnit; import java.time.temporal.TemporalAdjusters; -public class UseLocalDate { +class UseLocalDate { - public LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth) { + LocalDate getLocalDateUsingFactoryOfMethod(int year, int month, int dayOfMonth) { return LocalDate.of(year, month, dayOfMonth); } - public LocalDate getLocalDateUsingParseMethod(String representation) { + LocalDate getLocalDateUsingParseMethod(String representation) { return LocalDate.parse(representation); } - public LocalDate getLocalDateFromClock() { + LocalDate getLocalDateFromClock() { LocalDate localDate = LocalDate.now(); return localDate; } - public LocalDate getNextDay(LocalDate localDate) { + LocalDate getNextDay(LocalDate localDate) { return localDate.plusDays(1); } - public LocalDate getPreviousDay(LocalDate localDate) { + LocalDate getPreviousDay(LocalDate localDate) { return localDate.minus(1, ChronoUnit.DAYS); } - public DayOfWeek getDayOfWeek(LocalDate localDate) { + DayOfWeek getDayOfWeek(LocalDate localDate) { DayOfWeek day = localDate.getDayOfWeek(); return day; } - public LocalDate getFirstDayOfMonth() { + LocalDate getFirstDayOfMonth() { LocalDate firstDayOfMonth = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth()); return firstDayOfMonth; } - public LocalDateTime getStartOfDay(LocalDate localDate) { + LocalDateTime getStartOfDay(LocalDate localDate) { LocalDateTime startofDay = localDate.atStartOfDay(); return startofDay; } diff --git a/core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java b/core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java index 9bd8f9706c..8d166c413f 100644 --- a/core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java +++ b/core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java @@ -5,31 +5,27 @@ import java.time.temporal.ChronoUnit; public class UseLocalTime { - public LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds) { - LocalTime localTime = LocalTime.of(hour, min, seconds); - return localTime; + LocalTime getLocalTimeUsingFactoryOfMethod(int hour, int min, int seconds) { + return LocalTime.of(hour, min, seconds); } - public LocalTime getLocalTimeUsingParseMethod(String timeRepresentation) { - LocalTime localTime = LocalTime.parse(timeRepresentation); - return localTime; + LocalTime getLocalTimeUsingParseMethod(String timeRepresentation) { + return LocalTime.parse(timeRepresentation); } - public LocalTime getLocalTimeFromClock() { - LocalTime localTime = LocalTime.now(); - return localTime; + private LocalTime getLocalTimeFromClock() { + return LocalTime.now(); } - public LocalTime addAnHour(LocalTime localTime) { - LocalTime newTime = localTime.plus(1, ChronoUnit.HOURS); - return newTime; + LocalTime addAnHour(LocalTime localTime) { + return localTime.plus(1, ChronoUnit.HOURS); } - public int getHourFromLocalTime(LocalTime localTime) { + int getHourFromLocalTime(LocalTime localTime) { return localTime.getHour(); } - public LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute) { + LocalTime getLocalTimeWithMinuteSetToValue(LocalTime localTime, int minute) { return localTime.withMinute(minute); } } diff --git a/core-java/src/main/java/com/baeldung/datetime/UsePeriod.java b/core-java/src/main/java/com/baeldung/datetime/UsePeriod.java index 5a42ef83b4..10bc6caec3 100644 --- a/core-java/src/main/java/com/baeldung/datetime/UsePeriod.java +++ b/core-java/src/main/java/com/baeldung/datetime/UsePeriod.java @@ -3,13 +3,13 @@ package com.baeldung.datetime; import java.time.LocalDate; import java.time.Period; -public class UsePeriod { +class UsePeriod { - public LocalDate modifyDates(LocalDate localDate, Period period) { + LocalDate modifyDates(LocalDate localDate, Period period) { return localDate.plus(period); } - public Period getDifferenceBetweenDates(LocalDate localDate1, LocalDate localDate2) { + Period getDifferenceBetweenDates(LocalDate localDate1, LocalDate localDate2) { return Period.between(localDate1, localDate2); } } diff --git a/core-java/src/main/java/com/baeldung/datetime/UseToInstant.java b/core-java/src/main/java/com/baeldung/datetime/UseToInstant.java index 94154ce5c0..1fa413bbf2 100644 --- a/core-java/src/main/java/com/baeldung/datetime/UseToInstant.java +++ b/core-java/src/main/java/com/baeldung/datetime/UseToInstant.java @@ -8,12 +8,10 @@ import java.util.Date; public class UseToInstant { public LocalDateTime convertDateToLocalDate(Date date) { - LocalDateTime localDateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()); - return localDateTime; + return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()); } public LocalDateTime convertDateToLocalDate(Calendar calendar) { - LocalDateTime localDateTime = LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault()); - return localDateTime; + return LocalDateTime.ofInstant(calendar.toInstant(), ZoneId.systemDefault()); } } diff --git a/core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java b/core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java index 2d1b17484b..f5e1af0a06 100644 --- a/core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java +++ b/core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java @@ -4,10 +4,9 @@ import java.time.LocalDateTime; import java.time.ZoneId; import java.time.ZonedDateTime; -public class UseZonedDateTime { +class UseZonedDateTime { - public ZonedDateTime getZonedDateTime(LocalDateTime localDateTime, ZoneId zoneId) { - ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId); - return zonedDateTime; + ZonedDateTime getZonedDateTime(LocalDateTime localDateTime, ZoneId zoneId) { + return ZonedDateTime.of(localDateTime, zoneId); } } diff --git a/core-java/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java b/core-java/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java index f9028bd159..bdc732947f 100644 --- a/core-java/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java +++ b/core-java/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java @@ -13,8 +13,7 @@ public class DirectoryMonitoringExample { private static final Logger LOG = LoggerFactory.getLogger(DirectoryMonitoringExample.class); - - public static final int POLL_INTERVAL = 500; + private static final int POLL_INTERVAL = 500; public static void main(String[] args) throws Exception { FileAlterationObserver observer = new FileAlterationObserver(System.getProperty("user.home")); diff --git a/core-java/src/main/java/com/baeldung/doublecolon/Computer.java b/core-java/src/main/java/com/baeldung/doublecolon/Computer.java index b5d2e70abd..dc0b064013 100644 --- a/core-java/src/main/java/com/baeldung/doublecolon/Computer.java +++ b/core-java/src/main/java/com/baeldung/doublecolon/Computer.java @@ -6,12 +6,12 @@ public class Computer { private String color; private Integer healty; - public Computer(final int age, final String color) { + Computer(final int age, final String color) { this.age = age; this.color = color; } - public Computer(final Integer age, final String color, final Integer healty) { + Computer(final Integer age, final String color, final Integer healty) { this.age = age; this.color = color; this.healty = healty; @@ -28,7 +28,7 @@ public class Computer { this.age = age; } - public String getColor() { + String getColor() { return color; } @@ -36,11 +36,11 @@ public class Computer { this.color = color; } - public Integer getHealty() { + Integer getHealty() { return healty; } - public void setHealty(final Integer healty) { + void setHealty(final Integer healty) { this.healty = healty; } @@ -72,10 +72,7 @@ public class Computer { final Computer computer = (Computer) o; - if (age != null ? !age.equals(computer.age) : computer.age != null) { - return false; - } - return color != null ? color.equals(computer.color) : computer.color == null; + return (age != null ? age.equals(computer.age) : computer.age == null) && (color != null ? color.equals(computer.color) : computer.color == null); } diff --git a/core-java/src/main/java/com/baeldung/doublecolon/ComputerUtils.java b/core-java/src/main/java/com/baeldung/doublecolon/ComputerUtils.java index d181dfcdf7..317808d893 100644 --- a/core-java/src/main/java/com/baeldung/doublecolon/ComputerUtils.java +++ b/core-java/src/main/java/com/baeldung/doublecolon/ComputerUtils.java @@ -7,8 +7,8 @@ import java.util.List; public class ComputerUtils { - public static final ComputerPredicate after2010Predicate = (c) -> (c.getAge() > 2010); - public static final ComputerPredicate blackPredicate = (c) -> "black".equals(c.getColor()); + static final ComputerPredicate after2010Predicate = (c) -> (c.getAge() > 2010); + static final ComputerPredicate blackPredicate = (c) -> "black".equals(c.getColor()); public static List filter(final List inventory, final ComputerPredicate p) { @@ -18,7 +18,7 @@ public class ComputerUtils { return result; } - public static void repair(final Computer computer) { + static void repair(final Computer computer) { if (computer.getHealty() < 50) { computer.setHealty(100); } diff --git a/core-java/src/main/java/com/baeldung/doublecolon/MacbookPro.java b/core-java/src/main/java/com/baeldung/doublecolon/MacbookPro.java index f5c31e9653..79c8d9e383 100644 --- a/core-java/src/main/java/com/baeldung/doublecolon/MacbookPro.java +++ b/core-java/src/main/java/com/baeldung/doublecolon/MacbookPro.java @@ -13,7 +13,7 @@ public class MacbookPro extends Computer { super(age, color); } - public MacbookPro(Integer age, String color, Integer healty) { + MacbookPro(Integer age, String color, Integer healty) { super(age, color, healty); } diff --git a/core-java/src/main/java/com/baeldung/dynamicproxy/TimingDynamicInvocationHandler.java b/core-java/src/main/java/com/baeldung/dynamicproxy/TimingDynamicInvocationHandler.java index 942efc50cc..c35b69d075 100644 --- a/core-java/src/main/java/com/baeldung/dynamicproxy/TimingDynamicInvocationHandler.java +++ b/core-java/src/main/java/com/baeldung/dynamicproxy/TimingDynamicInvocationHandler.java @@ -15,7 +15,7 @@ public class TimingDynamicInvocationHandler implements InvocationHandler { private Object target; - public TimingDynamicInvocationHandler(Object target) { + TimingDynamicInvocationHandler(Object target) { this.target = target; for(Method method: target.getClass().getDeclaredMethods()) { diff --git a/core-java/src/main/java/com/baeldung/equalshashcode/entities/Square.java b/core-java/src/main/java/com/baeldung/equalshashcode/entities/Square.java index b9125c3e2f..66de220057 100644 --- a/core-java/src/main/java/com/baeldung/equalshashcode/entities/Square.java +++ b/core-java/src/main/java/com/baeldung/equalshashcode/entities/Square.java @@ -1,10 +1,10 @@ package com.baeldung.equalshashcode.entities; -import java.awt.Color; +import java.awt.*; public class Square extends Rectangle { - Color color; + private Color color; public Square(double width, Color color) { super(width, width); diff --git a/core-java/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java b/core-java/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java index d8d35d5363..4afce56e39 100644 --- a/core-java/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java +++ b/core-java/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java @@ -8,7 +8,7 @@ import javax.naming.InitialContext; import javax.naming.NamingException; public class LookupFSJNDI { - InitialContext ctx = null; + private InitialContext ctx = null; public LookupFSJNDI() throws NamingException { super(); diff --git a/vavr/src/main/java/com/baeldung/vavr/Person.java b/vavr/src/main/java/com/baeldung/vavr/Person.java index 0c6c427c73..bd497c0b77 100644 --- a/vavr/src/main/java/com/baeldung/vavr/Person.java +++ b/vavr/src/main/java/com/baeldung/vavr/Person.java @@ -4,7 +4,7 @@ public class Person { private String name; private int age; - public Person(String name, int age) { + Person(String name, int age) { super(); this.name = name; this.age = age; diff --git a/vavr/src/main/java/com/baeldung/vavr/PersonValidator.java b/vavr/src/main/java/com/baeldung/vavr/PersonValidator.java index efaa74c710..f53bdad7ec 100644 --- a/vavr/src/main/java/com/baeldung/vavr/PersonValidator.java +++ b/vavr/src/main/java/com/baeldung/vavr/PersonValidator.java @@ -4,10 +4,10 @@ import io.vavr.collection.Seq; import io.vavr.control.Validation; class PersonValidator { - String NAME_ERR = "Invalid characters in name: "; - String AGE_ERR = "Age must be at least 0"; + private static final String NAME_ERR = "Invalid characters in name: "; + private static final String AGE_ERR = "Age must be at least 0"; - public Validation, Person> validatePerson(String name, int age) { + Validation, Person> validatePerson(String name, int age) { return Validation.combine(validateName(name), validateAge(age)).ap(Person::new); } diff --git a/vavr/src/main/java/com/baeldung/vavr/exception/handling/VavrTry.java b/vavr/src/main/java/com/baeldung/vavr/exception/handling/VavrTry.java index 3a9399c4f0..af10a91c33 100644 --- a/vavr/src/main/java/com/baeldung/vavr/exception/handling/VavrTry.java +++ b/vavr/src/main/java/com/baeldung/vavr/exception/handling/VavrTry.java @@ -5,14 +5,14 @@ import com.baeldung.vavr.exception.handling.client.HttpClient; import com.baeldung.vavr.exception.handling.client.Response; import io.vavr.control.Try; -public class VavrTry { +class VavrTry { private final HttpClient httpClient; - public VavrTry(HttpClient httpClient) { + VavrTry(HttpClient httpClient) { this.httpClient = httpClient; } - public Try getResponse() { + Try getResponse() { return Try.of(httpClient::call); } }