iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Vavr refactor 02 07 (#2193) 

* Vavr refactor

* Refactor
This commit is contained in:
Grzegorz Piwowarek 2017-07-02 08:07:32 +02:00 committed by GitHub
parent 6e994240f7
commit ef34fc6576
36 changed files with 356 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java
View File

@ -6,7 +6,7 @@ public class NumbersConsumer implements Runnable {
private final BlockingQueue<Integer> queue;
private final int poisonPill;
public NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) {
NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) {
this.queue = queue;
this.poisonPill = poisonPill;
}

2
core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java
View File

@ -9,7 +9,7 @@ public class NumbersProducer implements Runnable {
private final int poisonPill;
private final int poisonPillPerProducer;
public NumbersProducer(BlockingQueue<Integer> numbersQueue, int poisonPill, int poisonPillPerProducer) {
NumbersProducer(BlockingQueue<Integer> numbersQueue, int poisonPill, int poisonPillPerProducer) {
this.numbersQueue = numbersQueue;
this.poisonPill = poisonPill;
this.poisonPillPerProducer = poisonPillPerProducer;

2
core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java
View File

@ -7,7 +7,7 @@ public class BrokenWorker implements Runnable {
private final List<String> outputScraper;
private final CountDownLatch countDownLatch;
public BrokenWorker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
BrokenWorker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
this.outputScraper = outputScraper;
this.countDownLatch = countDownLatch;
}

2
core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java
View File

@ -10,7 +10,7 @@ public class WaitingWorker implements Runnable {
private final CountDownLatch callingThreadBlocker;
private final CountDownLatch completedThreadCounter;
public WaitingWorker(final List<String> outputScraper, final CountDownLatch readyThreadCounter, final CountDownLatch callingThreadBlocker, CountDownLatch completedThreadCounter) {
WaitingWorker(final List<String> outputScraper, final CountDownLatch readyThreadCounter, final CountDownLatch callingThreadBlocker, CountDownLatch completedThreadCounter) {
this.outputScraper = outputScraper;
this.readyThreadCounter = readyThreadCounter;

2
core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java
View File

@ -7,7 +7,7 @@ public class Worker implements Runnable {
private final List<String> outputScraper;
private final CountDownLatch countDownLatch;
public Worker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
Worker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
this.outputScraper = outputScraper;
this.countDownLatch = countDownLatch;
}

9
core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierDemo.java
View File

@ -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();
}
}

2
core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayObject.java
View File

@ -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;
}

4
core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueConsumer.java
View File

@ -7,9 +7,9 @@ import java.util.concurrent.atomic.AtomicInteger;
public class DelayQueueConsumer implements Runnable {
private BlockingQueue<DelayObject> queue;
private final Integer numberOfElementsToTake;
public final AtomicInteger numberOfConsumedElements = new AtomicInteger();
final AtomicInteger numberOfConsumedElements = new AtomicInteger();
public DelayQueueConsumer(BlockingQueue<DelayObject> queue, Integer numberOfElementsToTake) {
DelayQueueConsumer(BlockingQueue<DelayObject> queue, Integer numberOfElementsToTake) {
this.queue = queue;
this.numberOfElementsToTake = numberOfElementsToTake;
}

6
core-java/src/main/java/com/baeldung/concurrent/delayqueue/DelayQueueProducer.java
View File

@ -9,9 +9,9 @@ public class DelayQueueProducer implements Runnable {
private final Integer numberOfElementsToProduce;
private final Integer delayOfEachProducedMessageMilliseconds;
public DelayQueueProducer(BlockingQueue<DelayObject> queue,
Integer numberOfElementsToProduce,
Integer delayOfEachProducedMessageMilliseconds) {
DelayQueueProducer(BlockingQueue<DelayObject> queue,
Integer numberOfElementsToProduce,
Integer delayOfEachProducedMessageMilliseconds) {
this.queue = queue;
this.numberOfElementsToProduce = numberOfElementsToProduce;
this.delayOfEachProducedMessageMilliseconds = delayOfEachProducedMessageMilliseconds;

3
core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java
View File

@ -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;
}
}
}

2
core-java/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java
View File

@ -7,7 +7,7 @@ public class FactorialSquareCalculator extends RecursiveTask<Integer> {
final private Integer n;
public FactorialSquareCalculator(Integer n) {
FactorialSquareCalculator(Integer n) {
this.n = n;
}

6
core-java/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java
View File

@ -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<Integer> calculate(Integer input) {
Future<Integer> calculate(Integer input) {
return executor.submit(() -> {
Thread.sleep(1000);
return input * input;

114
core-java/src/main/java/com/baeldung/concurrent/locks/ReentrantLockWithCondition.java
View File

@ -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<String> stack = new Stack<>();
int CAPACITY = 5;
private Stack<String> 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();
}
}

114
core-java/src/main/java/com/baeldung/concurrent/locks/SharedObjectWithLock.java
View File

@ -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();
}
}
}

140
core-java/src/main/java/com/baeldung/concurrent/locks/StampedLockDemo.java
View File

@ -12,93 +12,93 @@ import java.util.concurrent.locks.StampedLock;
import static java.lang.Thread.sleep;
public class StampedLockDemo {
Map<String, String> map = new HashMap<>();
Logger logger = LoggerFactory.getLogger(StampedLockDemo.class);
private Map<String, String> 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();
}
}
}

162
core-java/src/main/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLock.java
View File

@ -15,106 +15,106 @@ import static java.lang.Thread.sleep;
public class SynchronizedHashMapWithRWLock {
static Map<String, String> syncHashMap = new HashMap<>();
Logger logger = LoggerFactory.getLogger(SynchronizedHashMapWithRWLock.class);
private static Map<String, String> 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();
}
}
}
}
}

8
core-java/src/main/java/com/baeldung/concurrent/skiplist/Event.java
View File

@ -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;
}
}

18
core-java/src/main/java/com/baeldung/concurrent/skiplist/EventWindowSort.java
View File

@ -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<ZonedDateTime, String> 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<ZonedDateTime, String> getEventsFromLastMinute() {
ConcurrentNavigableMap<ZonedDateTime, String> getEventsFromLastMinute() {
return events.tailMap(ZonedDateTime
.now()
.minusMinutes(1));
.now()
.minusMinutes(1));
}
public ConcurrentNavigableMap<ZonedDateTime, String> getEventsOlderThatOneMinute() {
ConcurrentNavigableMap<ZonedDateTime, String> getEventsOlderThatOneMinute() {
return events.headMap(ZonedDateTime
.now()
.minusMinutes(1));
.now()
.minusMinutes(1));
}
}

6
core-java/src/main/java/com/baeldung/concurrent/sleepwait/WaitSleepExample.java
View File

@ -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");
}
}
}

8
core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedBlocks.java
View File

@ -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;
}
}

12
core-java/src/main/java/com/baeldung/concurrent/synchronize/BaeldungSynchronizedMethods.java
View File

@ -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;
}
}

18
core-java/src/main/java/com/baeldung/datetime/UseLocalDate.java
View File

@ -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;
}

24
core-java/src/main/java/com/baeldung/datetime/UseLocalTime.java
View File

@ -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);
}
}

6
core-java/src/main/java/com/baeldung/datetime/UsePeriod.java
View File

@ -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);
}
}

6
core-java/src/main/java/com/baeldung/datetime/UseToInstant.java
View File

@ -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());
}
}

7
core-java/src/main/java/com/baeldung/datetime/UseZonedDateTime.java
View File

@ -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);
}
}

3
core-java/src/main/java/com/baeldung/dirmonitoring/DirectoryMonitoringExample.java
View File

@ -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"));

15
core-java/src/main/java/com/baeldung/doublecolon/Computer.java
View File

@ -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);
}

6
core-java/src/main/java/com/baeldung/doublecolon/ComputerUtils.java
View File

@ -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<Computer> filter(final List<Computer> 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);
}

2
core-java/src/main/java/com/baeldung/doublecolon/MacbookPro.java
View File

@ -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);
}

2
core-java/src/main/java/com/baeldung/dynamicproxy/TimingDynamicInvocationHandler.java
View File

@ -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()) {

4
core-java/src/main/java/com/baeldung/equalshashcode/entities/Square.java
View File

@ -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);

2
core-java/src/main/java/com/baeldung/filesystem/jndi/LookupFSJNDI.java
View File

@ -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();

2
vavr/src/main/java/com/baeldung/vavr/Person.java
View File

@ -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;

6
vavr/src/main/java/com/baeldung/vavr/PersonValidator.java
View File

@ -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<Seq<String>, Person> validatePerson(String name, int age) {
Validation<Seq<String>, Person> validatePerson(String name, int age) {
return Validation.combine(validateName(name), validateAge(age)).ap(Person::new);
}

6
vavr/src/main/java/com/baeldung/vavr/exception/handling/VavrTry.java
View File

@ -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<Response> getResponse() {
Try<Response> getResponse() {
return Try.of(httpClient::call);
}
}