Merge branch 'master' into BAEL-3596_Asynchronous_Method_Calls_in_Java
This commit is contained in:
commit
d8e31976f7
|
@ -39,7 +39,6 @@ target/
|
|||
spring-openid/src/main/resources/application.properties
|
||||
.recommenders/
|
||||
/spring-hibernate4/nbproject/
|
||||
spring-security-openid/src/main/resources/application.properties
|
||||
|
||||
spring-all/*.log
|
||||
|
||||
|
|
|
@ -1,3 +1,4 @@
|
|||
**UPDATE**: The price of "Learn Spring Security OAuth" will permanently change on the 11th of December, along with the upcoming OAuth2 material: http://bit.ly/github-lss
|
||||
|
||||
The Courses
|
||||
==============================
|
||||
|
|
|
@ -15,5 +15,4 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
|
|||
- [Creating a Triangle with for Loops in Java](https://www.baeldung.com/java-print-triangle)
|
||||
- [Efficient Word Frequency Calculator in Java](https://www.baeldung.com/java-word-frequency)
|
||||
- [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
|
||||
- [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
|
||||
- More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)
|
||||
|
|
|
@ -10,4 +10,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
|
|||
- [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
|
||||
- [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
|
||||
- [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
|
||||
- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
|
||||
- [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
|
||||
- More articles: [[<-- prev]](/../algorithms-miscellaneous-4)
|
||||
|
|
|
@ -34,6 +34,11 @@
|
|||
<artifactId>tradukisto</artifactId>
|
||||
<version>${tradukisto.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.google.guava</groupId>
|
||||
<artifactId>guava</artifactId>
|
||||
<version>28.1-jre</version>
|
||||
</dependency>
|
||||
|
||||
<dependency>
|
||||
<groupId>org.assertj</groupId>
|
||||
|
|
|
@ -0,0 +1,20 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import lombok.Getter;
|
||||
|
||||
public class Follower {
|
||||
|
||||
@Getter String username;
|
||||
@Getter long count;
|
||||
|
||||
public Follower(String username, long count) {
|
||||
super();
|
||||
this.username = username;
|
||||
this.count = count;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "User: " + username + ", Followers: " + count + "\n\r" ;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,44 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class FollowersPath {
|
||||
|
||||
private List<Follower> accounts;
|
||||
private long count;
|
||||
|
||||
public FollowersPath() {
|
||||
super();
|
||||
this.accounts = new ArrayList<>();
|
||||
}
|
||||
|
||||
public List<Follower> getAccounts() {
|
||||
return accounts;
|
||||
}
|
||||
public long getCount() {
|
||||
return count;
|
||||
}
|
||||
|
||||
public void addFollower(String username, long count) {
|
||||
accounts.add(new Follower(username, count));
|
||||
}
|
||||
|
||||
public void addCount(long count) {
|
||||
this.count += count;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
String details = "";
|
||||
for(Follower a : accounts) {
|
||||
details+=a.toString() + ", ";
|
||||
}
|
||||
|
||||
return "Total: " + count + ", \n\r" +
|
||||
" Details: { " + "\n\r" +
|
||||
details + "\n\r" +
|
||||
" }";
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,43 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GreedyAlgorithm {
|
||||
|
||||
int currentLevel = 0;
|
||||
final int maxLevel = 3;
|
||||
SocialConnector sc;
|
||||
FollowersPath fp;
|
||||
|
||||
public GreedyAlgorithm(SocialConnector sc) {
|
||||
super();
|
||||
this.sc = sc;
|
||||
this.fp = new FollowersPath();
|
||||
}
|
||||
|
||||
public long findMostFollowersPath(String account) {
|
||||
long max = 0;
|
||||
SocialUser toFollow = null;
|
||||
|
||||
List<SocialUser> followers = sc.getFollowers(account);
|
||||
for (SocialUser el : followers) {
|
||||
long followersCount = el.getFollowersCount();
|
||||
if (followersCount > max) {
|
||||
toFollow = el;
|
||||
max = followersCount;
|
||||
}
|
||||
}
|
||||
|
||||
if (currentLevel < maxLevel - 1) {
|
||||
currentLevel++;
|
||||
max += findMostFollowersPath(toFollow.getUsername());
|
||||
return max;
|
||||
} else {
|
||||
return max;
|
||||
}
|
||||
}
|
||||
|
||||
public FollowersPath getFollowers() {
|
||||
return fp;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,43 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class NonGreedyAlgorithm {
|
||||
|
||||
int currentLevel = 0;
|
||||
final int maxLevel = 3;
|
||||
SocialConnector tc;
|
||||
|
||||
public NonGreedyAlgorithm(SocialConnector tc, int level) {
|
||||
super();
|
||||
this.tc = tc;
|
||||
this.currentLevel = level;
|
||||
}
|
||||
|
||||
public long findMostFollowersPath(String account) {
|
||||
List<SocialUser> followers = tc.getFollowers(account);
|
||||
long total = currentLevel > 0 ? followers.size() : 0;
|
||||
|
||||
if (currentLevel < maxLevel ) {
|
||||
currentLevel++;
|
||||
|
||||
long[] count = new long[followers.size()];
|
||||
int i = 0;
|
||||
for (SocialUser el : followers) {
|
||||
NonGreedyAlgorithm sub = new NonGreedyAlgorithm(tc, currentLevel);
|
||||
count[i] = sub.findMostFollowersPath(el.getUsername());
|
||||
i++;
|
||||
}
|
||||
|
||||
long max = 0;
|
||||
for (; i > 0; i--) {
|
||||
if (count[i-1] > max )
|
||||
max = count[i-1];
|
||||
}
|
||||
|
||||
return total + max;
|
||||
}
|
||||
|
||||
return total;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,36 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
public class SocialConnector {
|
||||
private boolean isCounterEnabled = true;
|
||||
private int counter = 4;
|
||||
@Getter @Setter List<SocialUser> users;
|
||||
|
||||
public SocialConnector() {
|
||||
users = new ArrayList<>();
|
||||
}
|
||||
|
||||
public boolean switchCounter() {
|
||||
this.isCounterEnabled = !this.isCounterEnabled;
|
||||
return this.isCounterEnabled;
|
||||
}
|
||||
|
||||
public List<SocialUser> getFollowers(String account) {
|
||||
if (counter < 0)
|
||||
throw new IllegalStateException ("API limit reached");
|
||||
else {
|
||||
if(this.isCounterEnabled) counter--;
|
||||
for(SocialUser user : users) {
|
||||
if (user.getUsername().equals(account)) {
|
||||
return user.getFollowers();
|
||||
}
|
||||
}
|
||||
}
|
||||
return new ArrayList<>();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,38 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import lombok.Getter;
|
||||
|
||||
public class SocialUser {
|
||||
|
||||
@Getter private String username;
|
||||
@Getter private List<SocialUser> followers;
|
||||
|
||||
public SocialUser(String username) {
|
||||
super();
|
||||
this.username = username;
|
||||
this.followers = new ArrayList<>();
|
||||
}
|
||||
|
||||
public SocialUser(String username, List<SocialUser> followers) {
|
||||
super();
|
||||
this.username = username;
|
||||
this.followers = followers;
|
||||
}
|
||||
|
||||
public long getFollowersCount() {
|
||||
return followers.size();
|
||||
}
|
||||
|
||||
public void addFollowers(List<SocialUser> followers) {
|
||||
this.followers.addAll(followers);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
return ((SocialUser) obj).getUsername().equals(username);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,42 @@
|
|||
package com.baeldung.algorithms.integerstreammedian;
|
||||
|
||||
import java.util.PriorityQueue;
|
||||
import java.util.Queue;
|
||||
|
||||
import static java.util.Comparator.reverseOrder;
|
||||
|
||||
public class MedianOfIntegerStream {
|
||||
|
||||
private Queue<Integer> minHeap, maxHeap;
|
||||
|
||||
MedianOfIntegerStream() {
|
||||
minHeap = new PriorityQueue<>();
|
||||
maxHeap = new PriorityQueue<>(reverseOrder());
|
||||
}
|
||||
|
||||
void add(int num) {
|
||||
if (!minHeap.isEmpty() && num < minHeap.peek()) {
|
||||
maxHeap.offer(num);
|
||||
if (maxHeap.size() > minHeap.size() + 1) {
|
||||
minHeap.offer(maxHeap.poll());
|
||||
}
|
||||
} else {
|
||||
minHeap.offer(num);
|
||||
if (minHeap.size() > maxHeap.size() + 1) {
|
||||
maxHeap.offer(minHeap.poll());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
double getMedian() {
|
||||
int median;
|
||||
if (minHeap.size() < maxHeap.size()) {
|
||||
median = maxHeap.peek();
|
||||
} else if (minHeap.size() > maxHeap.size()) {
|
||||
median = minHeap.peek();
|
||||
} else {
|
||||
median = (minHeap.peek() + maxHeap.peek()) / 2;
|
||||
}
|
||||
return median;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,36 @@
|
|||
package com.baeldung.algorithms.integerstreammedian;
|
||||
|
||||
import java.util.PriorityQueue;
|
||||
import java.util.Queue;
|
||||
|
||||
import static java.util.Comparator.reverseOrder;
|
||||
|
||||
public class MedianOfIntegerStream2 {
|
||||
|
||||
private Queue<Integer> minHeap, maxHeap;
|
||||
|
||||
MedianOfIntegerStream2() {
|
||||
minHeap = new PriorityQueue<>();
|
||||
maxHeap = new PriorityQueue<>(reverseOrder());
|
||||
}
|
||||
|
||||
void add(int num) {
|
||||
if (minHeap.size() == maxHeap.size()) {
|
||||
maxHeap.offer(num);
|
||||
minHeap.offer(maxHeap.poll());
|
||||
} else {
|
||||
minHeap.offer(num);
|
||||
maxHeap.offer(minHeap.poll());
|
||||
}
|
||||
}
|
||||
|
||||
double getMedian() {
|
||||
int median;
|
||||
if (minHeap.size() > maxHeap.size()) {
|
||||
median = minHeap.peek();
|
||||
} else {
|
||||
median = (minHeap.peek() + maxHeap.peek()) / 2;
|
||||
}
|
||||
return median;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,72 @@
|
|||
package com.baeldung.algorithms.kruskal;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class CycleDetector {
|
||||
|
||||
List<DisjointSetInfo> nodes;
|
||||
|
||||
public CycleDetector(int totalNodes) {
|
||||
initDisjointSets(totalNodes);
|
||||
}
|
||||
|
||||
public boolean detectCycle(Integer u, Integer v) {
|
||||
Integer rootU = pathCompressionFind(u);
|
||||
Integer rootV = pathCompressionFind(v);
|
||||
if (rootU.equals(rootV)) {
|
||||
return true;
|
||||
}
|
||||
unionByRank(rootU, rootV);
|
||||
return false;
|
||||
}
|
||||
|
||||
private void initDisjointSets(int totalNodes) {
|
||||
nodes = new ArrayList<>(totalNodes);
|
||||
for (int i = 0; i < totalNodes; i++) {
|
||||
nodes.add(new DisjointSetInfo(i));
|
||||
}
|
||||
}
|
||||
|
||||
private Integer find(Integer node) {
|
||||
Integer parent = nodes.get(node).getParentNode();
|
||||
if (parent.equals(node)) {
|
||||
return node;
|
||||
} else {
|
||||
return find(parent);
|
||||
}
|
||||
}
|
||||
|
||||
private Integer pathCompressionFind(Integer node) {
|
||||
DisjointSetInfo setInfo = nodes.get(node);
|
||||
Integer parent = setInfo.getParentNode();
|
||||
if (parent.equals(node)) {
|
||||
return node;
|
||||
} else {
|
||||
Integer parentNode = find(parent);
|
||||
setInfo.setParentNode(parentNode);
|
||||
return parentNode;
|
||||
}
|
||||
}
|
||||
|
||||
private void union(Integer rootU, Integer rootV) {
|
||||
DisjointSetInfo setInfoU = nodes.get(rootU);
|
||||
setInfoU.setParentNode(rootV);
|
||||
}
|
||||
|
||||
private void unionByRank(int rootU, int rootV) {
|
||||
DisjointSetInfo setInfoU = nodes.get(rootU);
|
||||
DisjointSetInfo setInfoV = nodes.get(rootV);
|
||||
int rankU = setInfoU.getRank();
|
||||
int rankV = setInfoV.getRank();
|
||||
if (rankU < rankV) {
|
||||
setInfoU.setParentNode(rootV);
|
||||
} else {
|
||||
setInfoV.setParentNode(rootU);
|
||||
if (rankU == rankV) {
|
||||
setInfoU.setRank(rankU + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,28 @@
|
|||
package com.baeldung.algorithms.kruskal;
|
||||
|
||||
public class DisjointSetInfo {
|
||||
|
||||
private Integer parentNode;
|
||||
private int rank;
|
||||
|
||||
DisjointSetInfo(Integer nodeNumber) {
|
||||
setParentNode(nodeNumber);
|
||||
setRank(1);
|
||||
}
|
||||
|
||||
public Integer getParentNode() {
|
||||
return parentNode;
|
||||
}
|
||||
|
||||
public void setParentNode(Integer parentNode) {
|
||||
this.parentNode = parentNode;
|
||||
}
|
||||
|
||||
public int getRank() {
|
||||
return rank;
|
||||
}
|
||||
|
||||
public void setRank(int rank) {
|
||||
this.rank = rank;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,53 @@
|
|||
package com.baeldung.algorithms.kruskal;
|
||||
|
||||
import com.google.common.graph.EndpointPair;
|
||||
import com.google.common.graph.MutableValueGraph;
|
||||
import com.google.common.graph.ValueGraph;
|
||||
import com.google.common.graph.ValueGraphBuilder;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
public class Kruskal {
|
||||
|
||||
public ValueGraph<Integer, Double> minSpanningTree(ValueGraph<Integer, Double> graph) {
|
||||
|
||||
return spanningTree(graph, true);
|
||||
}
|
||||
|
||||
public ValueGraph<Integer, Double> maxSpanningTree(ValueGraph<Integer, Double> graph) {
|
||||
return spanningTree(graph, false);
|
||||
}
|
||||
|
||||
private ValueGraph<Integer, Double> spanningTree(ValueGraph<Integer, Double> graph, boolean minSpanningTree) {
|
||||
Set<EndpointPair<Integer>> edges = graph.edges();
|
||||
List<EndpointPair<Integer>> edgeList = new ArrayList<>(edges);
|
||||
|
||||
if (minSpanningTree) {
|
||||
edgeList.sort(Comparator.comparing(e -> graph.edgeValue(e).get()));
|
||||
} else {
|
||||
edgeList.sort(Collections.reverseOrder(Comparator.comparing(e -> graph.edgeValue(e).get())));
|
||||
}
|
||||
|
||||
int totalNodes = graph.nodes().size();
|
||||
CycleDetector cycleDetector = new CycleDetector(totalNodes);
|
||||
int edgeCount = 0;
|
||||
|
||||
MutableValueGraph<Integer, Double> spanningTree = ValueGraphBuilder.undirected().build();
|
||||
for (EndpointPair<Integer> edge : edgeList) {
|
||||
if (cycleDetector.detectCycle(edge.nodeU(), edge.nodeV())) {
|
||||
continue;
|
||||
}
|
||||
spanningTree.putEdgeValue(edge.nodeU(), edge.nodeV(), graph.edgeValue(edge).get());
|
||||
edgeCount++;
|
||||
if (edgeCount == totalNodes - 1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return spanningTree;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,58 @@
|
|||
package com.baeldung.algorithms.greedy;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class GreedyAlgorithmUnitTest {
|
||||
|
||||
private SocialConnector prepareNetwork() {
|
||||
SocialConnector sc = new SocialConnector();
|
||||
SocialUser root = new SocialUser("root");
|
||||
SocialUser child1 = new SocialUser("child1");
|
||||
SocialUser child2 = new SocialUser("child2");
|
||||
SocialUser child3 = new SocialUser("child3");
|
||||
SocialUser child21 = new SocialUser("child21");
|
||||
SocialUser child211 = new SocialUser("child211");
|
||||
SocialUser child2111 = new SocialUser("child2111");
|
||||
SocialUser child31 = new SocialUser("child31");
|
||||
SocialUser child311 = new SocialUser("child311");
|
||||
SocialUser child3111 = new SocialUser("child3111");
|
||||
child211.addFollowers(Arrays.asList(new SocialUser[]{child2111}));
|
||||
child311.addFollowers(Arrays.asList(new SocialUser[]{child3111}));
|
||||
child21.addFollowers(Arrays.asList(new SocialUser[]{child211}));
|
||||
child31.addFollowers(Arrays.asList(new SocialUser[]{child311,
|
||||
new SocialUser("child312"), new SocialUser("child313"), new SocialUser("child314")}));
|
||||
child1.addFollowers(Arrays.asList(new SocialUser[]{new SocialUser("child11"), new SocialUser("child12")}));
|
||||
child2.addFollowers(Arrays.asList(new SocialUser[]{child21, new SocialUser("child22"), new SocialUser("child23")}));
|
||||
child3.addFollowers(Arrays.asList(new SocialUser[]{child31}));
|
||||
root.addFollowers(Arrays.asList(new SocialUser[]{child1, child2, child3}));
|
||||
sc.setUsers(Arrays.asList(new SocialUser[]{root, child1, child2, child3, child21, child31, child311, child211}));
|
||||
return sc;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void greedyAlgorithmTest() {
|
||||
GreedyAlgorithm ga = new GreedyAlgorithm(prepareNetwork());
|
||||
assertEquals(ga.findMostFollowersPath("root"), 5);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nongreedyAlgorithmTest() {
|
||||
NonGreedyAlgorithm nga = new NonGreedyAlgorithm(prepareNetwork(), 0);
|
||||
Assertions.assertThrows(IllegalStateException.class, () -> {
|
||||
nga.findMostFollowersPath("root");
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nongreedyAlgorithmUnboundedTest() {
|
||||
SocialConnector sc = prepareNetwork();
|
||||
sc.switchCounter();
|
||||
NonGreedyAlgorithm nga = new NonGreedyAlgorithm(sc, 0);
|
||||
assertEquals(nga.findMostFollowersPath("root"), 6);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,41 @@
|
|||
package com.baeldung.algorithms.integerstreammedian;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class MedianOfIntegerStreamUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach1() {
|
||||
MedianOfIntegerStream mis = new MedianOfIntegerStream();
|
||||
for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
|
||||
mis.add(e.getKey());
|
||||
assertEquals(e.getValue(), (Double) mis.getMedian());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach2() {
|
||||
MedianOfIntegerStream2 mis = new MedianOfIntegerStream2();
|
||||
for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
|
||||
mis.add(e.getKey());
|
||||
assertEquals(e.getValue(), (Double) mis.getMedian());
|
||||
}
|
||||
}
|
||||
|
||||
private Map<Integer, Double> testcaseFixture() {
|
||||
return new LinkedHashMap<Integer, Double>() {{
|
||||
put(1, 1d);
|
||||
put(7, 4d);
|
||||
put(5, 5d);
|
||||
put(8, 6d);
|
||||
put(3, 5d);
|
||||
put(9, 6d);
|
||||
put(4, 5d);
|
||||
}};
|
||||
}
|
||||
}
|
|
@ -0,0 +1,67 @@
|
|||
package com.baeldung.algorithms.kruskal;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import com.google.common.graph.MutableValueGraph;
|
||||
import com.google.common.graph.ValueGraph;
|
||||
import com.google.common.graph.ValueGraphBuilder;
|
||||
import com.baeldung.algorithms.kruskal.Kruskal;
|
||||
|
||||
public class KruskalUnitTest {
|
||||
|
||||
private MutableValueGraph<Integer, Double> graph;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
graph = ValueGraphBuilder.undirected().build();
|
||||
graph.putEdgeValue(0, 1, 8.0);
|
||||
graph.putEdgeValue(0, 2, 5.0);
|
||||
graph.putEdgeValue(1, 2, 9.0);
|
||||
graph.putEdgeValue(1, 3, 11.0);
|
||||
graph.putEdgeValue(2, 3, 15.0);
|
||||
graph.putEdgeValue(2, 4, 10.0);
|
||||
graph.putEdgeValue(3, 4, 7.0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenGraph_whenMinimumSpanningTree_thenOutputCorrectResult() {
|
||||
final Kruskal kruskal = new Kruskal();
|
||||
ValueGraph<Integer, Double> spanningTree = kruskal.minSpanningTree(graph);
|
||||
|
||||
assertTrue(spanningTree.hasEdgeConnecting(0, 1));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(0, 2));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(2, 4));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(3, 4));
|
||||
assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
|
||||
assertEquals(graph.edgeValue(0, 2), spanningTree.edgeValue(0, 2));
|
||||
assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
|
||||
assertEquals(graph.edgeValue(3, 4), spanningTree.edgeValue(3, 4));
|
||||
|
||||
assertFalse(spanningTree.hasEdgeConnecting(1, 2));
|
||||
assertFalse(spanningTree.hasEdgeConnecting(1, 3));
|
||||
assertFalse(spanningTree.hasEdgeConnecting(2, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenGraph_whenMaximumSpanningTree_thenOutputCorrectResult() {
|
||||
final Kruskal kruskal = new Kruskal();
|
||||
ValueGraph<Integer, Double> spanningTree = kruskal.maxSpanningTree(graph);
|
||||
|
||||
assertTrue(spanningTree.hasEdgeConnecting(0, 1));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(1, 3));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(2, 3));
|
||||
assertTrue(spanningTree.hasEdgeConnecting(2, 4));
|
||||
assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
|
||||
assertEquals(graph.edgeValue(1, 3), spanningTree.edgeValue(1, 3));
|
||||
assertEquals(graph.edgeValue(2, 3), spanningTree.edgeValue(2, 3));
|
||||
assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
|
||||
|
||||
assertFalse(spanningTree.hasEdgeConnecting(0, 2));
|
||||
assertFalse(spanningTree.hasEdgeConnecting(1, 2));
|
||||
assertFalse(spanningTree.hasEdgeConnecting(3, 4));
|
||||
}
|
||||
}
|
|
@ -9,3 +9,4 @@ This module contains articles about searching algorithms.
|
|||
- [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
|
||||
- [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
|
||||
- [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
|
||||
- [Range Search Algorithm in Java](https://www.baeldung.com/java-range-search)
|
||||
|
|
|
@ -0,0 +1,24 @@
|
|||
package com.baeldung.algorithms.quadtree;
|
||||
|
||||
public class Point {
|
||||
private float x;
|
||||
private float y;
|
||||
|
||||
public Point(float x, float y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
|
||||
public float getX() {
|
||||
return x;
|
||||
}
|
||||
|
||||
public float getY() {
|
||||
return y;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "[" + x + " , " + y + "]";
|
||||
}
|
||||
}
|
|
@ -0,0 +1,109 @@
|
|||
package com.baeldung.algorithms.quadtree;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class QuadTree {
|
||||
private static final int MAX_POINTS = 3;
|
||||
private Region area;
|
||||
private List<Point> points = new ArrayList<>();
|
||||
private List<QuadTree> quadTrees = new ArrayList<>();
|
||||
private StringBuilder searchTraversePath;
|
||||
|
||||
public QuadTree(Region area) {
|
||||
this.area = area;
|
||||
}
|
||||
|
||||
public boolean addPoint(Point point) {
|
||||
if (this.area.containsPoint(point)) {
|
||||
if (this.points.size() < MAX_POINTS) {
|
||||
this.points.add(point);
|
||||
return true;
|
||||
} else {
|
||||
if (this.quadTrees.size() == 0) {
|
||||
createQuadrants();
|
||||
}
|
||||
return addPointToOneQuadrant(point);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean addPointToOneQuadrant(Point point) {
|
||||
boolean isPointAdded;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
isPointAdded = this.quadTrees.get(i)
|
||||
.addPoint(point);
|
||||
if (isPointAdded)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private void createQuadrants() {
|
||||
Region region;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
region = this.area.getQuadrant(i);
|
||||
quadTrees.add(new QuadTree(region));
|
||||
}
|
||||
}
|
||||
|
||||
public List<Point> search(Region searchRegion, List<Point> matches, String depthIndicator) {
|
||||
searchTraversePath = new StringBuilder();
|
||||
if (matches == null) {
|
||||
matches = new ArrayList<Point>();
|
||||
searchTraversePath.append(depthIndicator)
|
||||
.append("Search Boundary =")
|
||||
.append(searchRegion)
|
||||
.append("\n");
|
||||
}
|
||||
if (!this.area.doesOverlap(searchRegion)) {
|
||||
return matches;
|
||||
} else {
|
||||
for (Point point : points) {
|
||||
if (searchRegion.containsPoint(point)) {
|
||||
searchTraversePath.append(depthIndicator)
|
||||
.append("Found match " + point)
|
||||
.append("\n");
|
||||
matches.add(point);
|
||||
}
|
||||
}
|
||||
if (this.quadTrees.size() > 0) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
searchTraversePath.append(depthIndicator)
|
||||
.append("Q")
|
||||
.append(i)
|
||||
.append("-->")
|
||||
.append(quadTrees.get(i).area)
|
||||
.append("\n");
|
||||
quadTrees.get(i)
|
||||
.search(searchRegion, matches, depthIndicator + "\t");
|
||||
this.searchTraversePath.append(quadTrees.get(i)
|
||||
.printSearchTraversePath());
|
||||
}
|
||||
}
|
||||
}
|
||||
return matches;
|
||||
}
|
||||
|
||||
public String printTree(String depthIndicator) {
|
||||
String str = "";
|
||||
if (depthIndicator == "") {
|
||||
str += "Root-->" + area.toString() + "\n";
|
||||
}
|
||||
|
||||
for (Point point : points) {
|
||||
str += depthIndicator + point.toString() + "\n";
|
||||
}
|
||||
for (int i = 0; i < quadTrees.size(); i++) {
|
||||
str += depthIndicator + "Q" + String.valueOf(i) + "-->" + quadTrees.get(i).area.toString() + "\n";
|
||||
str += quadTrees.get(i)
|
||||
.printTree(depthIndicator + "\t");
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
public String printSearchTraversePath() {
|
||||
return searchTraversePath.toString();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,85 @@
|
|||
package com.baeldung.algorithms.quadtree;
|
||||
|
||||
public class Region {
|
||||
private float x1;
|
||||
private float y1;
|
||||
private float x2;
|
||||
private float y2;
|
||||
|
||||
public Region(float x1, float y1, float x2, float y2) {
|
||||
if (x1 >= x2 || y1 >= y2)
|
||||
throw new IllegalArgumentException("(x1,y1) should be lesser than (x2,y2)");
|
||||
this.x1 = x1;
|
||||
this.y1 = y1;
|
||||
this.x2 = x2;
|
||||
this.y2 = y2;
|
||||
}
|
||||
|
||||
public Region getQuadrant(int quadrantIndex) {
|
||||
float quadrantWidth = (this.x2 - this.x1) / 2;
|
||||
float quadrantHeight = (this.y2 - this.y1) / 2;
|
||||
|
||||
// 0=SW, 1=NW, 2=NE, 3=SE
|
||||
switch (quadrantIndex) {
|
||||
case 0:
|
||||
return new Region(x1, y1, x1 + quadrantWidth, y1 + quadrantHeight);
|
||||
case 1:
|
||||
return new Region(x1, y1 + quadrantHeight, x1 + quadrantWidth, y2);
|
||||
case 2:
|
||||
return new Region(x1 + quadrantWidth, y1 + quadrantHeight, x2, y2);
|
||||
case 3:
|
||||
return new Region(x1 + quadrantWidth, y1, x2, y1 + quadrantHeight);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean containsPoint(Point point) {
|
||||
// Consider left and top side to be inclusive for points on border
|
||||
return point.getX() >= this.x1
|
||||
&& point.getX() < this.x2
|
||||
&& point.getY() >= this.y1
|
||||
&& point.getY() < this.y2;
|
||||
}
|
||||
|
||||
public boolean doesOverlap(Region testRegion) {
|
||||
// Is test region completely to left of my region?
|
||||
if (testRegion.getX2() < this.getX1()) {
|
||||
return false;
|
||||
}
|
||||
// Is test region completely to right of my region?
|
||||
if (testRegion.getX1() > this.getX2()) {
|
||||
return false;
|
||||
}
|
||||
// Is test region completely above my region?
|
||||
if (testRegion.getY1() > this.getY2()) {
|
||||
return false;
|
||||
}
|
||||
// Is test region completely below my region?
|
||||
if (testRegion.getY2() < this.getY1()) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "[Region (x1=" + x1 + ", y1=" + y1 + "), (x2=" + x2 + ", y2=" + y2 + ")]";
|
||||
}
|
||||
|
||||
public float getX1() {
|
||||
return x1;
|
||||
}
|
||||
|
||||
public float getY1() {
|
||||
return y1;
|
||||
}
|
||||
|
||||
public float getX2() {
|
||||
return x2;
|
||||
}
|
||||
|
||||
public float getY2() {
|
||||
return y2;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,60 @@
|
|||
package com.baeldung.algorithms.quadtree;
|
||||
|
||||
import org.junit.Assert;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class QuadTreeSearchUnitTest {
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(QuadTreeSearchUnitTest.class);
|
||||
|
||||
private static QuadTree quadTree;
|
||||
|
||||
@BeforeClass
|
||||
public static void setUp() {
|
||||
Region area = new Region(0, 0, 400, 400);
|
||||
quadTree = new QuadTree(area);
|
||||
|
||||
float[][] points = new float[][] { { 21, 25 }, { 55, 53 }, { 70, 318 }, { 98, 302 },
|
||||
{ 49, 229 }, { 135, 229 }, { 224, 292 }, { 206, 321 }, { 197, 258 }, { 245, 238 } };
|
||||
|
||||
for (int i = 0; i < points.length; i++) {
|
||||
Point point = new Point(points[i][0], points[i][1]);
|
||||
quadTree.addPoint(point);
|
||||
}
|
||||
LOGGER.info("\n" + quadTree.printTree(""));
|
||||
LOGGER.info("==============================================");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenQuadTree_whenSearchingForRange_thenReturn1MatchingItem() {
|
||||
Region searchArea = new Region(200, 200, 250, 250);
|
||||
List<Point> result = quadTree.search(searchArea, null, "");
|
||||
LOGGER.info(result.toString());
|
||||
LOGGER.info(quadTree.printSearchTraversePath());
|
||||
|
||||
Assert.assertEquals(1, result.size());
|
||||
Assert.assertArrayEquals(new float[] { 245, 238 },
|
||||
new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenQuadTree_whenSearchingForRange_thenReturn2MatchingItems() {
|
||||
Region searchArea = new Region(0, 0, 100, 100);
|
||||
List<Point> result = quadTree.search(searchArea, null, "");
|
||||
LOGGER.info(result.toString());
|
||||
LOGGER.info(quadTree.printSearchTraversePath());
|
||||
|
||||
Assert.assertEquals(2, result.size());
|
||||
Assert.assertArrayEquals(new float[] { 21, 25 },
|
||||
new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
|
||||
Assert.assertArrayEquals(new float[] { 55, 53 },
|
||||
new float[]{result.get(1).getX(), result.get(1).getY() }, 0);
|
||||
|
||||
}
|
||||
}
|
|
@ -16,7 +16,7 @@
|
|||
</context-param>
|
||||
<context-param>
|
||||
<param-name>contextConfigLocation</param-name>
|
||||
<param-value>org.baeldung.config</param-value>
|
||||
<param-value>com.baeldung.config</param-value>
|
||||
</context-param>
|
||||
|
||||
<listener>
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.java;
|
||||
package com.baeldung.java;
|
||||
|
||||
import java.io.BufferedOutputStream;
|
||||
import java.io.File;
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.java;
|
||||
package com.baeldung.java;
|
||||
|
||||
import java.io.BufferedOutputStream;
|
||||
import java.io.BufferedReader;
|
|
@ -3,7 +3,7 @@
|
|||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>org.baeldung.examples.olingo2</groupId>
|
||||
<groupId>com.baeldung.examples.olingo2</groupId>
|
||||
<artifactId>olingo2</artifactId>
|
||||
<name>olingo2</name>
|
||||
<description>Sample Olingo 2 Project</description>
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.examples.olingo2;
|
||||
package com.baeldung.examples.olingo2;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
@ -9,10 +9,8 @@ import javax.persistence.EntityManagerFactory;
|
|||
import javax.persistence.EntityTransaction;
|
||||
import javax.persistence.FlushModeType;
|
||||
import javax.persistence.LockModeType;
|
||||
import javax.persistence.Persistence;
|
||||
import javax.persistence.Query;
|
||||
import javax.persistence.StoredProcedureQuery;
|
||||
import javax.persistence.SynchronizationType;
|
||||
import javax.persistence.TypedQuery;
|
||||
import javax.persistence.criteria.CriteriaBuilder;
|
||||
import javax.persistence.criteria.CriteriaDelete;
|
||||
|
@ -25,11 +23,8 @@ import org.apache.olingo.odata2.api.processor.ODataContext;
|
|||
import org.apache.olingo.odata2.jpa.processor.api.ODataJPAContext;
|
||||
import org.apache.olingo.odata2.jpa.processor.api.ODataJPAServiceFactory;
|
||||
import org.apache.olingo.odata2.jpa.processor.api.exception.ODataJPARuntimeException;
|
||||
import org.baeldung.examples.olingo2.JerseyConfig.EntityManagerFilter;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.springframework.orm.jpa.EntityManagerFactoryUtils;
|
||||
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
/**
|
||||
|
@ -58,7 +53,7 @@ public class CarsODataJPAServiceFactory extends ODataJPAServiceFactory {
|
|||
ODataJPAContext ctx = getODataJPAContext();
|
||||
ODataContext octx = ctx.getODataContext();
|
||||
HttpServletRequest request = (HttpServletRequest)octx.getParameter(ODataContext.HTTP_SERVLET_REQUEST_OBJECT);
|
||||
EntityManager em = (EntityManager)request.getAttribute(EntityManagerFilter.EM_REQUEST_ATTRIBUTE);
|
||||
EntityManager em = (EntityManager)request.getAttribute(JerseyConfig.EntityManagerFilter.EM_REQUEST_ATTRIBUTE);
|
||||
|
||||
// Here we're passing the EM that was created by the EntityManagerFilter (see JerseyConfig)
|
||||
ctx.setEntityManager(new EntityManagerWrapper(em));
|
|
@ -1,11 +1,10 @@
|
|||
package org.baeldung.examples.olingo2;
|
||||
package com.baeldung.examples.olingo2;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import javax.persistence.EntityManager;
|
||||
import javax.persistence.EntityManagerFactory;
|
||||
import javax.persistence.EntityTransaction;
|
||||
import javax.servlet.ServletContext;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.ws.rs.ApplicationPath;
|
||||
import javax.ws.rs.Path;
|
|
@ -1,8 +1,7 @@
|
|||
package org.baeldung.examples.olingo2;
|
||||
package com.baeldung.examples.olingo2;
|
||||
|
||||
import org.springframework.boot.SpringApplication;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
import org.springframework.boot.builder.SpringApplicationBuilder;
|
||||
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
|
||||
|
||||
@SpringBootApplication
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.examples.olingo2.domain;
|
||||
package com.baeldung.examples.olingo2.domain;
|
||||
|
||||
import java.util.List;
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.examples.olingo2.domain;
|
||||
package com.baeldung.examples.olingo2.domain;
|
||||
|
||||
import javax.persistence.Entity;
|
||||
import javax.persistence.FetchType;
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.examples.olingo2;
|
||||
package com.baeldung.examples.olingo2;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
|
@ -0,0 +1,5 @@
|
|||
## Apache RocketMQ
|
||||
|
||||
This module contains articles about Apache RocketMQ
|
||||
|
||||
### Relevant Articles:
|
|
@ -0,0 +1,27 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<artifactId>apache-rocketmq</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
<name>apache-rocketmq</name>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung</groupId>
|
||||
<artifactId>parent-modules</artifactId>
|
||||
<version>1.0.0-SNAPSHOT</version>
|
||||
</parent>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.apache.rocketmq</groupId>
|
||||
<artifactId>rocketmq-spring-boot-starter</artifactId>
|
||||
<version>2.0.4</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<properties>
|
||||
<geode.core>1.6.0</geode.core>
|
||||
</properties>
|
||||
</project>
|
|
@ -0,0 +1,34 @@
|
|||
package com.baeldung.rocketmq.consumer;
|
||||
|
||||
import com.baeldung.rocketmq.event.CartItemEvent;
|
||||
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
|
||||
import org.apache.rocketmq.spring.core.RocketMQListener;
|
||||
import org.springframework.boot.SpringApplication;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
@SpringBootApplication
|
||||
public class CartEventConsumer {
|
||||
|
||||
public static void main(String[] args) {
|
||||
SpringApplication.run(CartEventConsumer.class, args);
|
||||
}
|
||||
|
||||
@Service
|
||||
@RocketMQMessageListener(topic = "cart-item-add-topic", consumerGroup = "cart-consumer_cart-item-add-topic")
|
||||
public class CardItemAddConsumer implements RocketMQListener<CartItemEvent> {
|
||||
public void onMessage(CartItemEvent addItemEvent) {
|
||||
System.out.println("Adding item: " + addItemEvent);
|
||||
// logic
|
||||
}
|
||||
}
|
||||
|
||||
@Service
|
||||
@RocketMQMessageListener(topic = "cart-item-removed-topic", consumerGroup = "cart-consumer_cart-item-removed-topic")
|
||||
public class CardItemRemoveConsumer implements RocketMQListener<CartItemEvent> {
|
||||
public void onMessage(CartItemEvent removeItemEvent) {
|
||||
System.out.println("Removing item: " + removeItemEvent);
|
||||
// logic
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,32 @@
|
|||
package com.baeldung.rocketmq.event;
|
||||
|
||||
public class CartItemEvent {
|
||||
private String itemId;
|
||||
private int quantity;
|
||||
|
||||
public CartItemEvent(String itemId, int quantity) {
|
||||
this.itemId = itemId;
|
||||
this.quantity = quantity;
|
||||
}
|
||||
|
||||
public String getItemId() {
|
||||
return itemId;
|
||||
}
|
||||
|
||||
public void setItemId(String itemId) {
|
||||
this.itemId = itemId;
|
||||
}
|
||||
|
||||
public int getQuantity() {
|
||||
return quantity;
|
||||
}
|
||||
|
||||
public void setQuantity(int quantity) {
|
||||
this.quantity = quantity;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "CartItemEvent{" + "itemId='" + itemId + '\'' + ", quantity=" + quantity + '}';
|
||||
}
|
||||
}
|
|
@ -0,0 +1,26 @@
|
|||
package com.baeldung.rocketmq.producer;
|
||||
|
||||
|
||||
import com.baeldung.rocketmq.event.CartItemEvent;
|
||||
import org.apache.rocketmq.spring.core.RocketMQTemplate;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.boot.CommandLineRunner;
|
||||
import org.springframework.boot.SpringApplication;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
|
||||
@SpringBootApplication
|
||||
public class CartEventProducer implements CommandLineRunner {
|
||||
|
||||
@Autowired
|
||||
private RocketMQTemplate rocketMQTemplate;
|
||||
|
||||
public static void main(String[] args) {
|
||||
SpringApplication.run(CartEventProducer.class, args);
|
||||
}
|
||||
|
||||
public void run(String... args) throws Exception {
|
||||
rocketMQTemplate.convertAndSend("cart-item-add-topic", new CartItemEvent("bike", 1));
|
||||
rocketMQTemplate.convertAndSend("cart-item-add-topic", new CartItemEvent("computer", 2));
|
||||
rocketMQTemplate.convertAndSend("cart-item-removed-topic", new CartItemEvent("bike", 1));
|
||||
}
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
package com.baeldung.rocketmq.transaction;
|
||||
|
||||
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
|
||||
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
|
||||
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
|
||||
import org.springframework.messaging.Message;
|
||||
|
||||
@RocketMQTransactionListener(txProducerGroup = "test-transaction")
|
||||
class TransactionListenerImpl implements RocketMQLocalTransactionListener {
|
||||
@Override
|
||||
public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
|
||||
// ... local transaction process, return ROLLBACK, COMMIT or UNKNOWN
|
||||
return RocketMQLocalTransactionState.UNKNOWN;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
|
||||
// ... check transaction status and return ROLLBACK, COMMIT or UNKNOWN
|
||||
return RocketMQLocalTransactionState.COMMIT;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,9 @@
|
|||
rocketmq.name-server=127.0.0.1:9876
|
||||
rocketmq.producer.group=my-group
|
||||
rocketmq.producer.send-message-timeout=300000
|
||||
rocketmq.producer.compress-message-body-threshold=4096
|
||||
rocketmq.producer.max-message-size=4194304
|
||||
rocketmq.producer.retry-times-when-send-async-failed=0
|
||||
rocketmq.producer.retry-next-server=true
|
||||
rocketmq.producer.retry-times-when-send-failed=2
|
||||
|
|
@ -2,10 +2,13 @@ package com.baeldung.metaprogramming.extension
|
|||
|
||||
import com.baeldung.metaprogramming.Employee
|
||||
|
||||
import java.time.LocalDate
|
||||
import java.time.Year
|
||||
|
||||
class BasicExtensions {
|
||||
|
||||
static int getYearOfBirth(Employee self) {
|
||||
return (new Date().getYear() + 1900) - self.age;
|
||||
return Year.now().value - self.age
|
||||
}
|
||||
|
||||
static String capitalize(String self) {
|
||||
|
|
|
@ -1,6 +1,9 @@
|
|||
package com.baeldung.metaprogramming
|
||||
|
||||
import groovy.time.TimeCategory
|
||||
|
||||
import java.time.LocalDate
|
||||
import java.time.Period
|
||||
import java.time.Year
|
||||
|
||||
class MetaprogrammingUnitTest extends GroovyTestCase {
|
||||
|
||||
|
@ -51,14 +54,16 @@ class MetaprogrammingUnitTest extends GroovyTestCase {
|
|||
|
||||
void testJavaMetaClass() {
|
||||
String.metaClass.capitalize = { String str ->
|
||||
str.substring(0, 1).toUpperCase() + str.substring(1);
|
||||
str.substring(0, 1).toUpperCase() + str.substring(1)
|
||||
}
|
||||
assert "norman".capitalize() == "Norman"
|
||||
}
|
||||
|
||||
void testEmployeeExtension() {
|
||||
Employee emp = new Employee(age: 28)
|
||||
assert emp.getYearOfBirth() == 1991
|
||||
def age = 28
|
||||
def expectedYearOfBirth = Year.now() - age
|
||||
Employee emp = new Employee(age: age)
|
||||
assert emp.getYearOfBirth() == expectedYearOfBirth.value
|
||||
}
|
||||
|
||||
void testJavaClassesExtensions() {
|
||||
|
@ -115,4 +120,4 @@ class MetaprogrammingUnitTest extends GroovyTestCase {
|
|||
Employee employee = new Employee(1, "Norman", "Lewis", 28)
|
||||
employee.logEmp()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,2 +0,0 @@
|
|||
### Relevant Articles:
|
||||
- [Java 9 java.lang.Module API](https://www.baeldung.com/java-lambda-effectively-final-local-variables)
|
|
@ -12,3 +12,4 @@ This module contains articles about Java 11 core features
|
|||
- [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)
|
||||
- [Guide to jlink](https://www.baeldung.com/jlink)
|
||||
- [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
|
||||
- [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)
|
||||
|
|
|
@ -0,0 +1,29 @@
|
|||
package com.baeldung.patternreuse;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class PatternJava11UnitTest {
|
||||
|
||||
@Test
|
||||
public void givenPreCompiledPattern_whenCallAsMatchPredicate_thenReturnMatchPredicateToMatchesPattern() {
|
||||
List<String> namesToValidate = Arrays.asList("Fabio Silva", "Fabio Luis Silva");
|
||||
Pattern firstLastNamePreCompiledPattern = Pattern.compile("[a-zA-Z]{3,} [a-zA-Z]{3,}");
|
||||
|
||||
Predicate<String> patternAsMatchPredicate = firstLastNamePreCompiledPattern.asMatchPredicate();
|
||||
List<String> validatedNames = namesToValidate.stream()
|
||||
.filter(patternAsMatchPredicate)
|
||||
.collect(Collectors.toList());
|
||||
|
||||
assertTrue(validatedNames.contains("Fabio Silva"));
|
||||
assertFalse(validatedNames.contains("Fabio Luis Silva"));
|
||||
}
|
||||
}
|
|
@ -0,0 +1,52 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>com.baeldung</groupId>
|
||||
<artifactId>core-java-14</artifactId>
|
||||
<version>1.0.0-SNAPSHOT</version>
|
||||
<name>core-java-14</name>
|
||||
<packaging>jar</packaging>
|
||||
<url>http://maven.apache.org</url>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung</groupId>
|
||||
<artifactId>parent-modules</artifactId>
|
||||
<version>1.0.0-SNAPSHOT</version>
|
||||
<relativePath>../../</relativePath>
|
||||
</parent>
|
||||
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>${maven-compiler-plugin.version}</version>
|
||||
<configuration>
|
||||
<source>${maven.compiler.source.version}</source>
|
||||
<target>${maven.compiler.target.version}</target>
|
||||
<compilerArgs>
|
||||
<compilerArg>
|
||||
--enable-preview
|
||||
</compilerArg>
|
||||
</compilerArgs>
|
||||
</configuration>
|
||||
</plugin>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-surefire-plugin</artifactId>
|
||||
<version>3.0.0-M3</version>
|
||||
<configuration>
|
||||
<argLine>--enable-preview</argLine>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
<properties>
|
||||
<maven.compiler.source.version>14</maven.compiler.source.version>
|
||||
<maven.compiler.target.version>14</maven.compiler.target.version>
|
||||
</properties>
|
||||
|
||||
</project>
|
|
@ -0,0 +1,50 @@
|
|||
package com.baeldung.serial;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.io.ObjectStreamException;
|
||||
import java.io.ObjectStreamField;
|
||||
import java.io.Serial;
|
||||
import java.io.Serializable;
|
||||
|
||||
/**
|
||||
* Class showcasing the usage of the Java 14 @Serial annotation.
|
||||
*
|
||||
* @author Donato Rimenti
|
||||
*/
|
||||
public class MySerialClass implements Serializable {
|
||||
|
||||
@Serial
|
||||
private static final ObjectStreamField[] serialPersistentFields = null;
|
||||
|
||||
@Serial
|
||||
private static final long serialVersionUID = 1;
|
||||
|
||||
@Serial
|
||||
private void writeObject(ObjectOutputStream stream) throws IOException {
|
||||
// ...
|
||||
}
|
||||
|
||||
@Serial
|
||||
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
|
||||
// ...
|
||||
}
|
||||
|
||||
@Serial
|
||||
private void readObjectNoData() throws ObjectStreamException {
|
||||
// ...
|
||||
}
|
||||
|
||||
@Serial
|
||||
private Object writeReplace() throws ObjectStreamException {
|
||||
// ...
|
||||
return null;
|
||||
}
|
||||
|
||||
@Serial
|
||||
private Object readResolve() throws ObjectStreamException {
|
||||
// ...
|
||||
return null;
|
||||
}
|
||||
}
|
|
@ -19,6 +19,16 @@
|
|||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-lang3</artifactId>
|
||||
<version>${commons-lang3.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.openjdk.jmh</groupId>
|
||||
<artifactId>jmh-core</artifactId>
|
||||
<version>${jmh.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.openjdk.jmh</groupId>
|
||||
<artifactId>jmh-generator-annprocess</artifactId>
|
||||
<version>${jmh.version}</version>
|
||||
</dependency>
|
||||
<!-- test scoped -->
|
||||
<dependency>
|
||||
|
@ -37,9 +47,34 @@
|
|||
<filtering>true</filtering>
|
||||
</resource>
|
||||
</resources>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-shade-plugin</artifactId>
|
||||
<version>3.2.0</version>
|
||||
<executions>
|
||||
<execution>
|
||||
<phase>package</phase>
|
||||
<goals>
|
||||
<goal>shade</goal>
|
||||
</goals>
|
||||
<configuration>
|
||||
<finalName>benchmarks</finalName>
|
||||
<transformers>
|
||||
<transformer
|
||||
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
|
||||
<mainClass>org.openjdk.jmh.Main</mainClass>
|
||||
</transformer>
|
||||
</transformers>
|
||||
</configuration>
|
||||
</execution>
|
||||
</executions>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
<properties>
|
||||
<jmh.version>1.19</jmh.version>
|
||||
<!-- util -->
|
||||
<commons-lang3.version>3.9</commons-lang3.version>
|
||||
<!-- testing -->
|
||||
|
|
|
@ -0,0 +1,72 @@
|
|||
package com.baeldung.arraysort;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import org.openjdk.jmh.annotations.Benchmark;
|
||||
import org.openjdk.jmh.annotations.BenchmarkMode;
|
||||
import org.openjdk.jmh.annotations.Fork;
|
||||
import org.openjdk.jmh.annotations.Level;
|
||||
import org.openjdk.jmh.annotations.Measurement;
|
||||
import org.openjdk.jmh.annotations.Mode;
|
||||
import org.openjdk.jmh.annotations.OutputTimeUnit;
|
||||
import org.openjdk.jmh.annotations.Param;
|
||||
import org.openjdk.jmh.annotations.Scope;
|
||||
import org.openjdk.jmh.annotations.Setup;
|
||||
import org.openjdk.jmh.annotations.State;
|
||||
import org.openjdk.jmh.annotations.Warmup;
|
||||
import org.openjdk.jmh.infra.Blackhole;
|
||||
|
||||
@BenchmarkMode(Mode.AverageTime)
|
||||
@Warmup(iterations = 5)
|
||||
@Measurement(iterations = 10)
|
||||
@Fork(2)
|
||||
@OutputTimeUnit(TimeUnit.MILLISECONDS)
|
||||
public class ArraySortingBenchmark {
|
||||
|
||||
@State(Scope.Benchmark)
|
||||
public static class ArrayContainer {
|
||||
|
||||
@Param({ "1000", "10000", "100000", "1000000" })
|
||||
int arraySize;
|
||||
|
||||
// initial unsorted array
|
||||
int[] unsortedArray;
|
||||
|
||||
//cloned array to sort
|
||||
int[] arrayToSort;
|
||||
|
||||
@Setup(Level.Trial)
|
||||
public void createUnSortedArray() {
|
||||
unsortedArray = new int[arraySize];
|
||||
for (int i = 0; i < arraySize; i++) {
|
||||
unsortedArray[i] = new Random().nextInt(1000);
|
||||
}
|
||||
}
|
||||
|
||||
@Setup(Level.Invocation)
|
||||
public void createUnSortedArrayCopy() {
|
||||
arrayToSort = unsortedArray.clone();
|
||||
}
|
||||
|
||||
int[] getArrayToSort() {
|
||||
return arrayToSort;
|
||||
}
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void benchmark_arrays_parallel_sort(ArrayContainer d, Blackhole b) {
|
||||
int[] arr = d.getArrayToSort();
|
||||
Arrays.parallelSort(arr);
|
||||
b.consume(arr);
|
||||
}
|
||||
|
||||
@Benchmark
|
||||
public void benchmark_arrays_sort(ArrayContainer d, Blackhole b) {
|
||||
int[] arr = d.getArrayToSort();
|
||||
Arrays.sort(arr);
|
||||
b.consume(arr);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,185 @@
|
|||
package com.baeldung.arraysort;
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertNotSame;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Random;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.FixMethodOrder;
|
||||
import org.junit.Test;
|
||||
import org.junit.runners.MethodSorters;
|
||||
|
||||
/**
|
||||
* Time taken by JUnit test cases can be seen in JUnit Runner
|
||||
* @author rchaudhary23
|
||||
*
|
||||
*/
|
||||
|
||||
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
|
||||
public class SortComparisonUnitTest {
|
||||
|
||||
private int[] sizeOfArrays = { 1000, 10000, 100000, 1000000 };
|
||||
|
||||
private int[] _1000_elements_array;
|
||||
private int[] _10000_elements_array;
|
||||
private int[] _100000_elements_array;
|
||||
private int[] _1000000_elements_array;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
_1000_elements_array = new int[sizeOfArrays[0]];
|
||||
_10000_elements_array = new int[sizeOfArrays[1]];
|
||||
_100000_elements_array = new int[sizeOfArrays[2]];
|
||||
_1000000_elements_array = new int[sizeOfArrays[3]];
|
||||
|
||||
Random random = new Random();
|
||||
for (int i = 0; i < sizeOfArrays[0]; i++) {
|
||||
_1000_elements_array[i] = random.nextInt(sizeOfArrays[0]) + random.nextInt(sizeOfArrays[0]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < sizeOfArrays[1]; i++) {
|
||||
_10000_elements_array[i] = random.nextInt(sizeOfArrays[1]) + random.nextInt(sizeOfArrays[1]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < sizeOfArrays[2]; i++) {
|
||||
_100000_elements_array[i] = random.nextInt(sizeOfArrays[2]) + random.nextInt(sizeOfArrays[2]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < sizeOfArrays[3]; i++) {
|
||||
_1000000_elements_array[i] = random.nextInt(sizeOfArrays[3]) + random.nextInt(sizeOfArrays[3]);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
|
||||
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
|
||||
int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
|
||||
|
||||
Arrays.sort(array);
|
||||
|
||||
assertArrayEquals(expected, array);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenUsingArraysSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
|
||||
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
|
||||
int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
|
||||
|
||||
Arrays.sort(array, 2, 8);
|
||||
|
||||
assertArrayEquals(expected, array);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
|
||||
int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
|
||||
|
||||
Arrays.parallelSort(array);
|
||||
|
||||
assertArrayEquals(expected, array);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenUsingArraysParallelSortMethodWithRange_thenSortRangeOfArrayInAscendingOrder() {
|
||||
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
|
||||
int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
|
||||
|
||||
Arrays.parallelSort(array, 2, 8);
|
||||
|
||||
assertArrayEquals(expected, array);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf1000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] sequentialDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
|
||||
Arrays.sort(sequentialDataSet);
|
||||
|
||||
assertNotNull(sequentialDataSet);
|
||||
assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), sequentialDataSet);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf1000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] parallelDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
|
||||
Arrays.parallelSort(parallelDataSet);
|
||||
|
||||
assertNotNull(parallelDataSet);
|
||||
assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), parallelDataSet);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf10000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] sequentialDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
|
||||
Arrays.sort(sequentialDataSet);
|
||||
|
||||
assertNotNull(sequentialDataSet);
|
||||
assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), sequentialDataSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf10000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] parallelDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
|
||||
Arrays.parallelSort(parallelDataSet);
|
||||
|
||||
assertNotNull(parallelDataSet);
|
||||
assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), parallelDataSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf100000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] sequentialDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
|
||||
Arrays.sort(sequentialDataSet);
|
||||
|
||||
assertNotNull(sequentialDataSet);
|
||||
assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), sequentialDataSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf100000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] parallelDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
|
||||
Arrays.parallelSort(parallelDataSet);
|
||||
|
||||
assertNotNull(parallelDataSet);
|
||||
assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), parallelDataSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf1000000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] sequentialDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
|
||||
Arrays.sort(sequentialDataSet);
|
||||
|
||||
assertNotNull(sequentialDataSet);
|
||||
assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), sequentialDataSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIntegerArrayOf1000000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
|
||||
int[] parallelDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
|
||||
Arrays.parallelSort(parallelDataSet);
|
||||
|
||||
assertNotNull(parallelDataSet);
|
||||
assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), parallelDataSet);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
sizeOfArrays = null;
|
||||
_1000_elements_array = null;
|
||||
_10000_elements_array = null;
|
||||
_100000_elements_array = null;
|
||||
_1000000_elements_array = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -24,11 +24,21 @@ public class DuplicatesCounter {
|
|||
return resultMap;
|
||||
}
|
||||
|
||||
public static <T> Map<T, Long> countByClassicalLoopWithMapCompute(List<T> inputList) {
|
||||
public static <T> Map<T, Long> countByForEachLoopWithGetOrDefault(List<T> inputList) {
|
||||
Map<T, Long> resultMap = new HashMap<>();
|
||||
for (T element : inputList) {
|
||||
resultMap.compute(element, (k, v) -> v == null ? 1 : v + 1);
|
||||
}
|
||||
inputList.forEach(e -> resultMap.put(e, resultMap.getOrDefault(e, 0L) + 1L));
|
||||
return resultMap;
|
||||
}
|
||||
|
||||
public static <T> Map<T, Long> countByForEachLoopWithMapCompute(List<T> inputList) {
|
||||
Map<T, Long> resultMap = new HashMap<>();
|
||||
inputList.forEach(e -> resultMap.compute(e, (k, v) -> v == null ? 1L : v + 1L));
|
||||
return resultMap;
|
||||
}
|
||||
|
||||
public static <T> Map<T, Long> countByForEachLoopWithMapMerge(List<T> inputList) {
|
||||
Map<T, Long> resultMap = new HashMap<>();
|
||||
inputList.forEach(e -> resultMap.merge(e, 1L, Long::sum));
|
||||
return resultMap;
|
||||
}
|
||||
|
||||
|
|
|
@ -11,7 +11,6 @@ import static org.assertj.core.data.MapEntry.entry;
|
|||
|
||||
class DuplicatesCounterUnitTest {
|
||||
|
||||
|
||||
private static List<String> INPUT_LIST = Lists.list(
|
||||
"expect1",
|
||||
"expect2", "expect2",
|
||||
|
@ -24,10 +23,21 @@ class DuplicatesCounterUnitTest {
|
|||
verifyResult(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenInput_whenCountByForEachLoopWithGetOrDefault_thenGetResultMap() {
|
||||
Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithGetOrDefault(INPUT_LIST);
|
||||
verifyResult(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenInput_whenCountByClassicalLoopWithMapCompute_thenGetResultMap() {
|
||||
Map<String, Long> result = DuplicatesCounter.countByClassicalLoopWithMapCompute(INPUT_LIST);
|
||||
void givenInput_whenCountByForEachLoopWithMapCompute_thenGetResultMap() {
|
||||
Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithMapCompute(INPUT_LIST);
|
||||
verifyResult(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenInput_whenCountByForEachLoopWithMapMerge_thenGetResultMap() {
|
||||
Map<String, Long> result = DuplicatesCounter.countByForEachLoopWithMapMerge(INPUT_LIST);
|
||||
verifyResult(result);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,8 +1,10 @@
|
|||
package com.baeldung.date.comparison;
|
||||
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.time.Instant;
|
||||
import java.time.LocalDate;
|
||||
import java.time.ZoneId;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.TimeZone;
|
||||
|
@ -23,6 +25,14 @@ public class DateComparisonUtils {
|
|||
return localDate1.isEqual(localDate2);
|
||||
}
|
||||
|
||||
public static boolean isSameDayUsingInstant(Date date1, Date date2) {
|
||||
Instant instant1 = date1.toInstant()
|
||||
.truncatedTo(ChronoUnit.DAYS);
|
||||
Instant instant2 = date2.toInstant()
|
||||
.truncatedTo(ChronoUnit.DAYS);
|
||||
return instant1.equals(instant2);
|
||||
}
|
||||
|
||||
public static boolean isSameDayUsingSimpleDateFormat(Date date1, Date date2) {
|
||||
SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
|
||||
return fmt.format(date1)
|
||||
|
|
|
@ -1,13 +1,13 @@
|
|||
package com.baeldung.date.comparison;
|
||||
|
||||
import org.junit.Test;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.ZoneId;
|
||||
import java.util.Date;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import org.junit.Test;
|
||||
|
||||
public class DateComparisonUtilsUnitTest {
|
||||
|
||||
|
@ -23,6 +23,7 @@ public class DateComparisonUtilsUnitTest {
|
|||
@Test
|
||||
public void givenDatesWithDifferentTime_whenIsSameDay_thenReturnsTrue() {
|
||||
assertTrue(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day1Evening));
|
||||
assertTrue(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day1Evening));
|
||||
assertTrue(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day1Evening));
|
||||
assertTrue(DateComparisonUtils.isSameDayUsingCalendar(day1Morning, day1Evening));
|
||||
assertTrue(DateComparisonUtils.isSameDayUsingApacheCommons(day1Morning, day1Evening));
|
||||
|
@ -35,6 +36,9 @@ public class DateComparisonUtilsUnitTest {
|
|||
assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Morning, day2Morning));
|
||||
assertFalse(DateComparisonUtils.isSameDayUsingLocalDate(day1Evening, day2Morning));
|
||||
|
||||
assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Morning, day2Morning));
|
||||
assertFalse(DateComparisonUtils.isSameDayUsingInstant(day1Evening, day2Morning));
|
||||
|
||||
assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Morning, day2Morning));
|
||||
assertFalse(DateComparisonUtils.isSameDayUsingSimpleDateFormat(day1Evening, day2Morning));
|
||||
|
||||
|
|
|
@ -9,12 +9,6 @@ import static org.junit.Assert.assertEquals;
|
|||
|
||||
public class DateUtilsUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenTimeMillis_thenDateIsReturned() {
|
||||
Date now = DateUtils.getNow();
|
||||
assertEquals(DateUtils.getDate(now.getTime()), now);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenDateAndPattern_thenDateIsCorrectlyReturned() throws ParseException {
|
||||
long milliseconds = new Date(2020 - 1900, 0, 1).getTime();
|
||||
|
|
|
@ -9,11 +9,6 @@ import org.junit.Test;
|
|||
|
||||
public class DateUtilsUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenCurrentDate_thenTodayIsReturned() {
|
||||
assertEquals(DateUtils.getNow().toLocalDate(), LocalDate.now());
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void givenDateAsString_whenPatternIsNotRespected_thenExceptionIsThrown() {
|
||||
DateUtils.getDate("2020 01 01");
|
||||
|
|
|
@ -1,22 +1,13 @@
|
|||
package com.baeldung.datetime.sql;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import com.baeldung.datetime.sql.TimestampUtils;
|
||||
|
||||
import java.text.ParseException;
|
||||
import java.util.Date;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class TimestampUtilsUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenCurrentTimestamp_thenNowIsReturned() {
|
||||
assertEquals(TimestampUtils.getNow()
|
||||
.getTime(), new Date().getTime());
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void givenTimestampAsString_whenPatternIsNotRespected_thenExceptionIsThrown() {
|
||||
TimestampUtils.getTimestamp("2020/01/01 10:11-12");
|
||||
|
|
|
@ -1,9 +1,8 @@
|
|||
package com.baeldung.timezone;
|
||||
package com.baeldung.jvmtimezone;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.TimeZone;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
@ -13,9 +12,7 @@ public class ModifyDefaultTimezoneUnitTest {
|
|||
@Test
|
||||
public void givenDefaultTimezoneSet_thenDateTimezoneIsCorrect() {
|
||||
TimeZone.setDefault(TimeZone.getTimeZone("Portugal"));
|
||||
Date date = new Date();
|
||||
Calendar calendar = Calendar.getInstance();
|
||||
calendar.setTime(date);
|
||||
assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("Portugal"));
|
||||
}
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package com.baeldung.timezone;
|
||||
package com.baeldung.jvmtimezone;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
|
@ -14,7 +14,7 @@ public class ModifyTimezonePropertyUnitTest {
|
|||
|
||||
@Before
|
||||
public void setup() {
|
||||
System.setProperty("user.timezone", "IST");
|
||||
System.setProperty("user.timezone", "Asia/Kolkata");
|
||||
TimeZone.setDefault(null);
|
||||
}
|
||||
|
||||
|
@ -25,10 +25,8 @@ public class ModifyTimezonePropertyUnitTest {
|
|||
|
||||
@Test
|
||||
public void givenTimezonePropertySet_thenDateTimezoneIsCorrect() {
|
||||
Date date = new Date();
|
||||
Calendar calendar = Calendar.getInstance();
|
||||
calendar.setTime(date);
|
||||
assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("IST"));
|
||||
assertEquals(calendar.getTimeZone(), TimeZone.getTimeZone("Asia/Kolkata"));
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,38 @@
|
|||
package com.baeldung.exceptions;
|
||||
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
public class CatchingThrowable {
|
||||
|
||||
class CapacityException extends Exception {
|
||||
CapacityException(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
class StorageAPI {
|
||||
|
||||
public void addIDsToStorage(int capacity, Set<String> storage) throws CapacityException {
|
||||
if (capacity < 1) {
|
||||
throw new CapacityException("Capacity of less than 1 is not allowed");
|
||||
}
|
||||
int count = 0;
|
||||
while (count < capacity) {
|
||||
storage.add(UUID.randomUUID().toString());
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// other methods go here ...
|
||||
}
|
||||
|
||||
public void add(StorageAPI api, int capacity, Set<String> storage) {
|
||||
try {
|
||||
api.addIDsToStorage(capacity, storage);
|
||||
} catch (Throwable throwable) {
|
||||
// do something here
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,14 @@
|
|||
package com.baeldung.finallykeyword;
|
||||
|
||||
public class FinallyExample {
|
||||
|
||||
public void printCount(String count) {
|
||||
try {
|
||||
System.out.println("The count is " + Integer.parseInt(count));
|
||||
} catch (NumberFormatException e) {
|
||||
System.out.println("No count");
|
||||
} finally {
|
||||
System.out.println("In finally");
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,53 @@
|
|||
package com.baeldung.finallykeyword;
|
||||
|
||||
public class FinallyExecutedCases {
|
||||
|
||||
public void noExceptionFinally() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public void unhandledException() throws Exception {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
throw new Exception();
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public void handledException() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
throw new Exception();
|
||||
} catch (Exception e) {
|
||||
System.out.println("Inside catch");
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public String returnFromTry() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
return "from try";
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public String returnFromCatch() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
throw new Exception();
|
||||
} catch (Exception e) {
|
||||
System.out.println("Inside catch");
|
||||
return "from catch";
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,54 @@
|
|||
package com.baeldung.finallykeyword;
|
||||
|
||||
public class FinallyNotExecutedCases {
|
||||
|
||||
public void callingSystemExit() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
System.exit(1);
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public void callingRuntimeHalt() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
Runtime.getRuntime()
|
||||
.halt(1);
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public void infiniteLoop() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
while (true) {
|
||||
}
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
}
|
||||
}
|
||||
|
||||
public void daemonThread() throws InterruptedException {
|
||||
Runnable runnable = () -> {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
} finally {
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
System.out.println("Inside finally");
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
};
|
||||
Thread regular = new Thread(runnable);
|
||||
Thread daemon = new Thread(runnable);
|
||||
daemon.setDaemon(true);
|
||||
regular.start();
|
||||
Thread.sleep(300);
|
||||
daemon.start();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,33 @@
|
|||
package com.baeldung.finallykeyword;
|
||||
|
||||
public class PitfallsWhenUsingFinally {
|
||||
|
||||
public String disregardsUnCaughtException() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
throw new RuntimeException();
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
return "from finally";
|
||||
}
|
||||
}
|
||||
|
||||
public String ignoringOtherReturns() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
return "from try";
|
||||
} finally {
|
||||
System.out.println("Inside finally");
|
||||
return "from finally";
|
||||
}
|
||||
}
|
||||
|
||||
public String throwsException() {
|
||||
try {
|
||||
System.out.println("Inside try");
|
||||
return "from try";
|
||||
} finally {
|
||||
throw new RuntimeException();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,49 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
public class Coordinates {
|
||||
|
||||
private double longitude;
|
||||
private double latitude;
|
||||
private String placeName;
|
||||
|
||||
public Coordinates() {}
|
||||
|
||||
public Coordinates(double longitude, double latitude, String placeName) {
|
||||
this.longitude = longitude;
|
||||
this.latitude = latitude;
|
||||
this.placeName = placeName;
|
||||
}
|
||||
|
||||
public double calculateDistance(Coordinates c) {
|
||||
|
||||
double s1 = Math.abs(this.longitude - c.longitude);
|
||||
double s2 = Math.abs(this.latitude - c.latitude);
|
||||
|
||||
return Math.hypot(s1, s2);
|
||||
}
|
||||
|
||||
public double getLongitude() {
|
||||
return longitude;
|
||||
}
|
||||
|
||||
public void setLongitude(double longitude) {
|
||||
this.longitude = longitude;
|
||||
}
|
||||
|
||||
public double getLatitude() {
|
||||
return latitude;
|
||||
}
|
||||
|
||||
public void setLatitude(double latitude) {
|
||||
this.latitude = latitude;
|
||||
}
|
||||
|
||||
public String getPlaceName() {
|
||||
return placeName;
|
||||
}
|
||||
|
||||
public void setPlaceName(String placeName) {
|
||||
this.placeName = placeName;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,27 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
class MultipleReturnValuesUsingArrays {
|
||||
|
||||
|
||||
static double[] getCoordinatesDoubleArray() {
|
||||
|
||||
double[] coordinates = new double[2];
|
||||
|
||||
coordinates[0] = 10;
|
||||
coordinates[1] = 12.5;
|
||||
|
||||
return coordinates;
|
||||
}
|
||||
|
||||
|
||||
static Number[] getCoordinatesNumberArray() {
|
||||
|
||||
Number[] coordinates = new Number[2];
|
||||
|
||||
coordinates[0] = 10; //Integer
|
||||
coordinates[1] = 12.5; //Double
|
||||
|
||||
return coordinates;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,30 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
class MultipleReturnValuesUsingCollections {
|
||||
|
||||
static List<Number> getCoordinatesList() {
|
||||
|
||||
List<Number> coordinates = new ArrayList<>();
|
||||
|
||||
coordinates.add(10);
|
||||
coordinates.add(12.5);
|
||||
|
||||
return coordinates;
|
||||
}
|
||||
|
||||
static Map<String, Number> getCoordinatesMap() {
|
||||
|
||||
Map<String, Number> coordinates = new HashMap<>();
|
||||
|
||||
coordinates.put("longitude", 10);
|
||||
coordinates.put("latitude", 12.5);
|
||||
|
||||
return coordinates;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,14 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
class MultipleReturnValuesUsingContainer {
|
||||
|
||||
static Coordinates getCoordinates() {
|
||||
|
||||
double longitude = 10;
|
||||
double latitude = 12.5;
|
||||
String placeName = "home";
|
||||
|
||||
return new Coordinates(longitude, latitude, placeName);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,17 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
class MultipleReturnValuesUsingTuples {
|
||||
|
||||
static Tuple2<Coordinates, Double> getMostDistantPoint(List<Coordinates> coordinatesList,
|
||||
Coordinates target) {
|
||||
|
||||
return coordinatesList.stream()
|
||||
.map(coor -> new Tuple2<>(coor, coor.calculateDistance(target)))
|
||||
.max((d1, d2) -> Double.compare(d1.getSecond(), d2.getSecond()))
|
||||
.get();
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,31 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
public class Tuple2 <K, V> {
|
||||
|
||||
private K first;
|
||||
private V second;
|
||||
|
||||
public Tuple2() {}
|
||||
|
||||
public Tuple2(K first, V second) {
|
||||
this.first = first;
|
||||
this.second = second;
|
||||
}
|
||||
|
||||
public K getFirst() {
|
||||
return first;
|
||||
}
|
||||
|
||||
public V getSecond() {
|
||||
return second;
|
||||
}
|
||||
|
||||
public void setFirst(K first) {
|
||||
this.first = first;
|
||||
}
|
||||
|
||||
public void setSecond(V second) {
|
||||
this.second = second;
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,27 @@
|
|||
package com.baeldung.finallykeyword;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class PitfallsWhenUsingFinallyUnitTest {
|
||||
|
||||
PitfallsWhenUsingFinally instance = new PitfallsWhenUsingFinally();
|
||||
|
||||
@Test
|
||||
public void testIgnoresException() {
|
||||
String result = instance.disregardsUnCaughtException();
|
||||
assertEquals("from finally", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIgnoresOtherReturns() {
|
||||
String result = instance.ignoringOtherReturns();
|
||||
assertEquals("from finally", result);
|
||||
}
|
||||
|
||||
@Test(expected = RuntimeException.class)
|
||||
public void testThrowsException() {
|
||||
instance.throwsException();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,25 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class MultipleReturnValuesUsingArraysUnitTest {
|
||||
|
||||
@Test
|
||||
void whenUsingArrayOfDoubles_thenMultipleDoubleFieldsAreReturned() {
|
||||
|
||||
double[] coordinates = MultipleReturnValuesUsingArrays.getCoordinatesDoubleArray();
|
||||
assertEquals(10, coordinates[0]);
|
||||
assertEquals(12.5, coordinates[1]);
|
||||
}
|
||||
|
||||
@Test
|
||||
void whenUsingArrayOfNumbers_thenMultipleNumberFieldsAreReturned() {
|
||||
|
||||
Number[] coordinates = MultipleReturnValuesUsingArrays.getCoordinatesNumberArray();
|
||||
assertEquals(10, coordinates[0]);
|
||||
assertEquals(12.5, coordinates[1]);
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,25 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class MultipleReturnValuesUsingCollectionsUnitTest {
|
||||
|
||||
@Test
|
||||
void whenUsingList_thenMultipleFieldsAreReturned() {
|
||||
|
||||
List<Number> coordinates = MultipleReturnValuesUsingCollections.getCoordinatesList();
|
||||
assertEquals(Integer.valueOf(10), coordinates.get(0));
|
||||
assertEquals(Double.valueOf(12.5), coordinates.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
void whenUsingMap_thenMultipleFieldsAreReturned() {
|
||||
|
||||
Map<String, Number> coordinates = MultipleReturnValuesUsingCollections.getCoordinatesMap();
|
||||
assertEquals(Integer.valueOf(10), coordinates.get("longitude"));
|
||||
assertEquals(Double.valueOf(12.5), coordinates.get("latitude"));
|
||||
}
|
||||
}
|
|
@ -0,0 +1,17 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class MultipleReturnValuesUsingContainerUnitTest {
|
||||
|
||||
@Test
|
||||
void whenUsingContainerClass_thenMultipleFieldsAreReturned() {
|
||||
|
||||
Coordinates coordinates = MultipleReturnValuesUsingContainer.getCoordinates();
|
||||
|
||||
assertEquals(10, coordinates.getLongitude());
|
||||
assertEquals(12.5, coordinates.getLatitude());
|
||||
assertEquals("home", coordinates.getPlaceName());
|
||||
}
|
||||
}
|
|
@ -0,0 +1,31 @@
|
|||
package com.baeldung.methodmultiplereturnvalues;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class MultipleReturnValuesUsingTuplesUnitTest {
|
||||
|
||||
@Test
|
||||
void whenUsingTuple_thenMultipleFieldsAreReturned() {
|
||||
|
||||
List<Coordinates> coordinatesList = new ArrayList<>();
|
||||
coordinatesList.add(new Coordinates(1, 1, "home"));
|
||||
coordinatesList.add(new Coordinates(2, 2, "school"));
|
||||
coordinatesList.add(new Coordinates(3, 3, "hotel"));
|
||||
|
||||
Coordinates target = new Coordinates(5, 5, "gym");
|
||||
|
||||
Tuple2<Coordinates, Double> mostDistantPoint = MultipleReturnValuesUsingTuples.getMostDistantPoint(coordinatesList, target);
|
||||
|
||||
assertEquals(1, mostDistantPoint.getFirst().getLongitude());
|
||||
assertEquals(1, mostDistantPoint.getFirst().getLatitude());
|
||||
assertEquals("home", mostDistantPoint.getFirst().getPlaceName());
|
||||
assertEquals(5.66, BigDecimal.valueOf(mostDistantPoint.getSecond()).setScale(2, RoundingMode.HALF_UP).doubleValue());
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -7,3 +7,5 @@
|
|||
- [Java 8 Unsigned Arithmetic Support](https://www.baeldung.com/java-unsigned-arithmetic)
|
||||
- [How to Separate Double into Integer and Decimal Parts](https://www.baeldung.com/java-separate-double-into-integer-decimal-parts)
|
||||
- [The strictfp Keyword in Java](https://www.baeldung.com/java-strictfp)
|
||||
- [Basic Calculator in Java](https://www.baeldung.com/java-basic-calculator)
|
||||
- [Overflow and Underflow in Java](https://www.baeldung.com/java-overflow-underflow)
|
||||
|
|
|
@ -0,0 +1,320 @@
|
|||
package com.baeldung.powerset;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.AbstractSet;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Set;
|
||||
|
||||
public class PowerSetUtility<T> {
|
||||
|
||||
private Map<T, Integer> map = new HashMap<>();
|
||||
private List<T> reverseMap = new ArrayList<>();
|
||||
|
||||
//Lazy Load PowerSet class
|
||||
private static class PowerSet<E> extends AbstractSet<Set<E>> {
|
||||
private Map<E, Integer> map = new HashMap<>();
|
||||
private List<E> reverseMap = new ArrayList<>();
|
||||
private Set<E> set;
|
||||
|
||||
public PowerSet(Set<E> set) {
|
||||
this.set = set;
|
||||
initializeMap();
|
||||
}
|
||||
|
||||
abstract class ListIterator<K> implements Iterator<K> {
|
||||
|
||||
protected int position = 0;
|
||||
private int size;
|
||||
|
||||
public ListIterator(int size) {
|
||||
this.size = size;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return position < size;
|
||||
}
|
||||
}
|
||||
|
||||
static class Subset<E> extends AbstractSet<E> {
|
||||
private Map<E, Integer> map;
|
||||
private List<E> reverseMap;
|
||||
private int mask;
|
||||
|
||||
public Subset(Map<E, Integer> map, List<E> reverseMap, int mask) {
|
||||
this.map = map;
|
||||
this.reverseMap = reverseMap;
|
||||
this.mask = mask;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterator<E> iterator() {
|
||||
return new Iterator<E>() {
|
||||
int remainingSetBits = mask;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return remainingSetBits != 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public E next() {
|
||||
int index = Integer.numberOfTrailingZeros(remainingSetBits);
|
||||
if (index == 32) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
remainingSetBits &= ~(1 << index);
|
||||
return reverseMap.get(index);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return Integer.bitCount(mask);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(@Nullable Object o) {
|
||||
Integer index = map.get(o);
|
||||
return index != null && (mask & (1 << index)) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterator<Set<E>> iterator() {
|
||||
return new ListIterator<Set<E>>(this.size()) {
|
||||
@Override
|
||||
public Set<E> next() {
|
||||
return new Subset<>(map, reverseMap, position++);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return (1 << this.set.size());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(@Nullable Object obj) {
|
||||
if (obj instanceof Set) {
|
||||
Set<?> set = (Set<?>) obj;
|
||||
return reverseMap.containsAll(set);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(@Nullable Object obj) {
|
||||
if (obj instanceof PowerSet) {
|
||||
PowerSet<?> that = (PowerSet<?>) obj;
|
||||
return set.equals(that.set);//Set equals check to have the same element regardless of the order of the items
|
||||
}
|
||||
return super.equals(obj);
|
||||
}
|
||||
|
||||
|
||||
private void initializeMap() {
|
||||
int mapId = 0;
|
||||
for (E c : this.set) {
|
||||
map.put(c, mapId++);
|
||||
reverseMap.add(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Set<Set<T>> lazyLoadPowerSet(Set<T> set) {
|
||||
return new PowerSet<>(set);
|
||||
}
|
||||
|
||||
public Set<Set<T>> recursivePowerSet(Set<T> set) {
|
||||
if (set.isEmpty()) {
|
||||
Set<Set<T>> ret = new HashSet<>();
|
||||
ret.add(set);
|
||||
return ret;
|
||||
}
|
||||
|
||||
T element = set.iterator().next();
|
||||
Set<T> subSetWithoutElement = getSubSetWithoutElement(set, element);
|
||||
Set<Set<T>> powerSetSubSetWithoutElement = recursivePowerSet(subSetWithoutElement);
|
||||
|
||||
Set<Set<T>> powerSetSubSetWithElement = addElementToAll(powerSetSubSetWithoutElement, element);
|
||||
|
||||
Set<Set<T>> powerSet = new HashSet<>();
|
||||
powerSet.addAll(powerSetSubSetWithoutElement);
|
||||
powerSet.addAll(powerSetSubSetWithElement);
|
||||
return powerSet;
|
||||
}
|
||||
|
||||
public Set<Set<T>> recursivePowerSetIndexRepresentation(Collection<T> set) {
|
||||
initializeMap(set);
|
||||
Set<Set<Integer>> powerSetIndices = recursivePowerSetIndexRepresentation(0, set.size());
|
||||
return unMapIndex(powerSetIndices);
|
||||
}
|
||||
|
||||
private List<List<Boolean>> iterativePowerSetByLoopOverNumbersWithReverseLexicographicalOrder(int n) {
|
||||
List<List<Boolean>> powerSet = new ArrayList<>();
|
||||
for (int i = 0; i < (1 << n); i++) {
|
||||
List<Boolean> subset = new ArrayList<>(n);
|
||||
for (int j = 0; j < n; j++)
|
||||
subset.add(((1 << j) & i) > 0);
|
||||
powerSet.add(subset);
|
||||
}
|
||||
return powerSet;
|
||||
}
|
||||
|
||||
private List<List<Boolean>> iterativePowerSetByLoopOverNumbersWithGrayCodeOrder(int n) {
|
||||
List<List<Boolean>> powerSet = new ArrayList<>();
|
||||
for (int i = 0; i < (1 << n); i++) {
|
||||
List<Boolean> subset = new ArrayList<>(n);
|
||||
for (int j = 0; j < n; j++) {
|
||||
int grayEquivalent = i ^ (i >> 1);
|
||||
subset.add(((1 << j) & grayEquivalent) > 0);
|
||||
}
|
||||
powerSet.add(subset);
|
||||
}
|
||||
return powerSet;
|
||||
}
|
||||
|
||||
public Set<Set<T>> recursivePowerSetBinaryRepresentation(Collection<T> set) {
|
||||
initializeMap(set);
|
||||
Set<List<Boolean>> powerSetBoolean = recursivePowerSetBinaryRepresentation(0, set.size());
|
||||
return unMapBinary(powerSetBoolean);
|
||||
}
|
||||
|
||||
public List<List<T>> iterativePowerSetByLoopOverNumbers(Set<T> set) {
|
||||
initializeMap(set);
|
||||
List<List<Boolean>> sets = iterativePowerSetByLoopOverNumbersWithReverseLexicographicalOrder(set.size());
|
||||
return unMapListBinary(sets);
|
||||
}
|
||||
|
||||
public List<List<T>> iterativePowerSetByLoopOverNumbersMinimalChange(Set<T> set) {
|
||||
initializeMap(set);
|
||||
List<List<Boolean>> sets = iterativePowerSetByLoopOverNumbersWithGrayCodeOrder(set.size());
|
||||
return unMapListBinary(sets);
|
||||
}
|
||||
|
||||
public static int getRankInLexicographicalOrder(List<Boolean> subset) {
|
||||
int rank = 0;
|
||||
for (int i = 0; i < subset.size(); i++)
|
||||
if (subset.get(i))
|
||||
rank += (1 << (subset.size() - i - 1));
|
||||
return rank;
|
||||
}
|
||||
|
||||
public static List<Boolean> getSubsetForRankInLexicographicalOrder(int rank, int sizeOfSet) {
|
||||
Boolean[] subset = new Boolean[sizeOfSet];
|
||||
for(int j = 0; j < sizeOfSet; j++) {
|
||||
subset[sizeOfSet - j - 1] = ((rank & (1 << j)) > 0);
|
||||
}
|
||||
return Arrays.asList(subset);
|
||||
}
|
||||
|
||||
private Set<Set<Integer>> recursivePowerSetIndexRepresentation(int idx, int n) {
|
||||
if (idx == n) {
|
||||
Set<Set<Integer>> empty = new HashSet<>();
|
||||
empty.add(new HashSet<>());
|
||||
return empty;
|
||||
}
|
||||
Set<Set<Integer>> powerSetSubset = recursivePowerSetIndexRepresentation(idx + 1, n);
|
||||
Set<Set<Integer>> powerSet = new HashSet<>(powerSetSubset);
|
||||
for (Set<Integer> s : powerSetSubset) {
|
||||
HashSet<Integer> subSetIdxInclusive = new HashSet<>(s);
|
||||
subSetIdxInclusive.add(idx);
|
||||
powerSet.add(subSetIdxInclusive);
|
||||
}
|
||||
return powerSet;
|
||||
}
|
||||
|
||||
private Set<List<Boolean>> recursivePowerSetBinaryRepresentation(int idx, int n) {
|
||||
if (idx == n) {
|
||||
Set<List<Boolean>> powerSetOfEmptySet = new HashSet<>();
|
||||
powerSetOfEmptySet.add(Arrays.asList(new Boolean[n]));
|
||||
return powerSetOfEmptySet;
|
||||
}
|
||||
Set<List<Boolean>> powerSetSubset = recursivePowerSetBinaryRepresentation(idx + 1, n);
|
||||
Set<List<Boolean>> powerSet = new HashSet<>();
|
||||
for (List<Boolean> s : powerSetSubset) {
|
||||
List<Boolean> subSetIdxExclusive = new ArrayList<>(s);
|
||||
subSetIdxExclusive.set(idx, false);
|
||||
powerSet.add(subSetIdxExclusive);
|
||||
List<Boolean> subSetIdxInclusive = new ArrayList<>(s);
|
||||
subSetIdxInclusive.set(idx, true);
|
||||
powerSet.add(subSetIdxInclusive);
|
||||
}
|
||||
return powerSet;
|
||||
}
|
||||
|
||||
private void initializeMap(Collection<T> collection) {
|
||||
int mapId = 0;
|
||||
for (T c : collection) {
|
||||
map.put(c, mapId++);
|
||||
reverseMap.add(c);
|
||||
}
|
||||
}
|
||||
|
||||
private Set<Set<T>> unMapIndex(Set<Set<Integer>> sets) {
|
||||
Set<Set<T>> ret = new HashSet<>();
|
||||
for (Set<Integer> s : sets) {
|
||||
HashSet<T> subset = new HashSet<>();
|
||||
for (Integer i : s)
|
||||
subset.add(reverseMap.get(i));
|
||||
ret.add(subset);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private Set<Set<T>> unMapBinary(Collection<List<Boolean>> sets) {
|
||||
Set<Set<T>> ret = new HashSet<>();
|
||||
for (List<Boolean> s : sets) {
|
||||
HashSet<T> subset = new HashSet<>();
|
||||
for (int i = 0; i < s.size(); i++)
|
||||
if (s.get(i))
|
||||
subset.add(reverseMap.get(i));
|
||||
ret.add(subset);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private List<List<T>> unMapListBinary(Collection<List<Boolean>> sets) {
|
||||
List<List<T>> ret = new ArrayList<>();
|
||||
for (List<Boolean> s : sets) {
|
||||
List<T> subset = new ArrayList<>();
|
||||
for (int i = 0; i < s.size(); i++)
|
||||
if (s.get(i))
|
||||
subset.add(reverseMap.get(i));
|
||||
ret.add(subset);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private Set<Set<T>> addElementToAll(Set<Set<T>> powerSetSubSetWithoutElement, T element) {
|
||||
Set<Set<T>> powerSetSubSetWithElement = new HashSet<>();
|
||||
for (Set<T> subsetWithoutElement : powerSetSubSetWithoutElement) {
|
||||
Set<T> subsetWithElement = new HashSet<>(subsetWithoutElement);
|
||||
subsetWithElement.add(element);
|
||||
powerSetSubSetWithElement.add(subsetWithElement);
|
||||
}
|
||||
return powerSetSubSetWithElement;
|
||||
}
|
||||
|
||||
private Set<T> getSubSetWithoutElement(Set<T> set, T element) {
|
||||
Set<T> subsetWithoutElement = new HashSet<>();
|
||||
for (T s : set) {
|
||||
if (!s.equals(element))
|
||||
subsetWithoutElement.add(s);
|
||||
}
|
||||
return subsetWithoutElement;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,225 @@
|
|||
package com.baeldung.powerset;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import com.google.common.collect.Sets;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.hamcrest.Matchers;
|
||||
import org.hamcrest.collection.IsCollectionWithSize;
|
||||
import org.junit.Test;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
import java.util.Set;
|
||||
|
||||
public class PowerSetUtilityUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenGuavaLibraryGeneratePowerSet_ThenItContainsAllSubsets() {
|
||||
ImmutableSet<String> set = ImmutableSet.of("APPLE", "ORANGE", "MANGO");
|
||||
Set<Set<String>> powerSet = Sets.powerSet(set);
|
||||
Assertions.assertEquals((1 << set.size()), powerSet.size());
|
||||
MatcherAssert.assertThat(powerSet, Matchers.containsInAnyOrder(
|
||||
ImmutableSet.of(),
|
||||
ImmutableSet.of("APPLE"),
|
||||
ImmutableSet.of("ORANGE"),
|
||||
ImmutableSet.of("APPLE", "ORANGE"),
|
||||
ImmutableSet.of("MANGO"),
|
||||
ImmutableSet.of("APPLE", "MANGO"),
|
||||
ImmutableSet.of("ORANGE", "MANGO"),
|
||||
ImmutableSet.of("APPLE", "ORANGE", "MANGO")
|
||||
));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsLazyLoadGenerated_ThenItContainsAllSubsets() {
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
Set<Set<String>> powerSet = new PowerSetUtility<String>().lazyLoadPowerSet(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (Set<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsCalculated_ThenItContainsAllSubsets() {
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
|
||||
Set<Set<String>> powerSet = new PowerSetUtility<String>().recursivePowerSet(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (Set<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsCalculatedRecursiveByIndexRepresentation_ThenItContainsAllSubsets() {
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
|
||||
Set<Set<String>> powerSet = new PowerSetUtility<String>().recursivePowerSetIndexRepresentation(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (Set<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsCalculatedRecursiveByBinaryRepresentation_ThenItContainsAllSubsets() {
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
|
||||
Set<Set<String>> powerSet = new PowerSetUtility<String>().recursivePowerSetBinaryRepresentation(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (Set<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsCalculatedIterativePowerSetByLoopOverNumbers_ThenItContainsAllSubsets() {
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
|
||||
List<List<String>> powerSet = new PowerSetUtility<String>().iterativePowerSetByLoopOverNumbers(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (List<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
//To make sure that one subset is not generated twice
|
||||
Assertions.assertEquals(powerSet.size(), new HashSet<>(powerSet).size());
|
||||
//To make sure that each element in each subset is occurred once
|
||||
for (List<String> subset : powerSet) {
|
||||
Assertions.assertEquals(subset.size(), new HashSet<>(subset).size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSet_WhenPowerSetIsCalculatedIterativePowerSetByLoopOverNumbersMinimalChange_ThenItContainsAllSubsetsInGrayOrder() {
|
||||
|
||||
Set<String> set = RandomSetOfStringGenerator.generateRandomSet();
|
||||
List<List<String>> powerSet = new PowerSetUtility<String>().iterativePowerSetByLoopOverNumbersMinimalChange(set);
|
||||
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << set.size())));
|
||||
//To make sure that number of occurrence of each element is (2 power n-1)
|
||||
Map<String, Integer> counter = new HashMap<>();
|
||||
for (List<String> subset : powerSet) {
|
||||
for (String name : subset) {
|
||||
int num = counter.getOrDefault(name, 0);
|
||||
counter.put(name, num + 1);
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (set.size() - 1)), v.intValue()));
|
||||
//To make sure that one subset is not generated twice
|
||||
Assertions.assertEquals(powerSet.size(), new HashSet<>(powerSet).size());
|
||||
//To make sure that each element in each subset is occurred once
|
||||
for (List<String> subset : powerSet) {
|
||||
Assertions.assertEquals(subset.size(), new HashSet<>(subset).size());
|
||||
}
|
||||
//To make sure that difference of consecutive subsets is exactly 1
|
||||
for(int i=1; i<powerSet.size(); i++) {
|
||||
int diff = 0;
|
||||
for (String s : powerSet.get(i - 1))
|
||||
if (!powerSet.get(i).contains(s))
|
||||
diff++;
|
||||
for (String s : powerSet.get(i))
|
||||
if (!powerSet.get(i - 1).contains(s))
|
||||
diff++;
|
||||
Assertions.assertEquals(1, diff);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSubset_WhenPowerSetIsInLexicographicalOrder_ReturnCorrectRank() {
|
||||
int n = new Random().nextInt(5) + 5; //a number in [5, 10)
|
||||
for(int i = 0; i < ( 1 << n); i++) {
|
||||
Boolean[] subset = new Boolean[n];
|
||||
for(int j=0; j < n; j++) {
|
||||
subset[n - j - 1] = ((i & (1 << j)) > 0);
|
||||
}
|
||||
Assertions.assertEquals(i, PowerSetUtility.getRankInLexicographicalOrder(Arrays.asList(subset)));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRanking_WhenPowerSetIsInLexicographicalOrder_ReturnTheSubset() {
|
||||
int n = new Random().nextInt(5) + 5; //a number in [5, 10)
|
||||
List<List<Boolean>> powerSet = new ArrayList<>();
|
||||
for(int i = 0; i < (1 << n); i++) {
|
||||
powerSet.add(PowerSetUtility.getSubsetForRankInLexicographicalOrder(i, n));
|
||||
}
|
||||
//To make sure that the size of power set is (2 power n)
|
||||
MatcherAssert.assertThat(powerSet, IsCollectionWithSize.hasSize((1 << n)));
|
||||
//To make sure that number of occurrence of each index is (2 power n-1)
|
||||
Map<Integer, Integer> counter = new HashMap<>();
|
||||
for (List<Boolean> subset : powerSet) {
|
||||
for (int i = 0; i < subset.size(); i++) {
|
||||
if(subset.get(i)) {
|
||||
int num = counter.getOrDefault(i, 0);
|
||||
counter.put(i, num + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
counter.forEach((k, v) -> Assertions.assertEquals((1 << (n - 1)), v.intValue()));
|
||||
//To make sure that one subset is not generated twice
|
||||
Assertions.assertEquals(powerSet.size(), new HashSet<>(powerSet).size());
|
||||
}
|
||||
|
||||
static class RandomSetOfStringGenerator {
|
||||
private static List<String> fruits = Arrays.asList("Apples", "Avocados", "Banana", "Blueberry", "Cherry", "Clementine", "Cucumber", "Date", "Fig",
|
||||
"Grapefruit"/*, "Grape", "Kiwi", "Lemon", "Mango", "Mulberry", "Melon", "Nectarine", "Olive", "Orange"*/);
|
||||
|
||||
static Set<String> generateRandomSet() {
|
||||
Set<String> set = new HashSet<>();
|
||||
Random random = new Random();
|
||||
int size = random.nextInt(fruits.size());
|
||||
while (set.size() != size) {
|
||||
set.add(fruits.get(random.nextInt(fruits.size())));
|
||||
}
|
||||
return set;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -11,4 +11,5 @@ This module contains articles about Java operators
|
|||
- [Java Compound Operators](https://www.baeldung.com/java-compound-operators)
|
||||
- [The XOR Operator in Java](https://www.baeldung.com/java-xor-operator)
|
||||
- [Java Bitwise Operators](https://www.baeldung.com/java-bitwise-operators)
|
||||
- [Bitwise & vs Logical && Operators](https://www.baeldung.com/bitwise-vs-logical-operators/)
|
||||
|
||||
|
|
|
@ -0,0 +1,71 @@
|
|||
package com.baeldung.andoperators;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class BitwiseAndLogicalANDOperatorsUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenTwoTrueBooleans_whenBitwiseAndOperator_thenTrue() {
|
||||
boolean trueBool = true;
|
||||
boolean anotherTrueBool = true;
|
||||
boolean trueANDTrue = trueBool & anotherTrueBool;
|
||||
assertTrue(trueANDTrue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOneFalseAndOneTrueBooleans_whenBitwiseAndOperator_thenFalse() {
|
||||
boolean trueBool = true;
|
||||
boolean falseBool = false;
|
||||
boolean trueANDFalse = trueBool & falseBool;
|
||||
assertFalse(trueANDFalse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoFalseBooleans_whenBitwiseAndOperator_thenFalse() {
|
||||
boolean falseBool = false;
|
||||
boolean anotherFalseBool = false;
|
||||
boolean falseANDFalse = falseBool & anotherFalseBool;
|
||||
assertFalse(falseANDFalse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoIntegers_whenBitwiseAndOperator_thenNewDecimalNumber() {
|
||||
int six = 6;
|
||||
int five = 5;
|
||||
int shouldBeFour = six & five;
|
||||
assertEquals(4, shouldBeFour);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoTrueBooleans_whenLogicalAndOperator_thenTrue() {
|
||||
boolean trueBool = true;
|
||||
boolean anotherTrueBool = true;
|
||||
boolean trueANDTrue = trueBool && anotherTrueBool;
|
||||
assertTrue(trueANDTrue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOneFalseAndOneTrueBooleans_whenLogicalAndOperator_thenFalse() {
|
||||
boolean trueBool = true;
|
||||
boolean falseBool = false;
|
||||
boolean trueANDFalse = trueBool && falseBool;
|
||||
assertFalse(trueANDFalse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoFalseBooleans_whenLogicalAndOperator_thenFalse() {
|
||||
boolean falseBool = false;
|
||||
boolean anotherFalseBool = false;
|
||||
boolean falseANDFalse = falseBool && anotherFalseBool;
|
||||
assertFalse(falseANDFalse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTwoFalseExpressions_whenLogicalAndOperator_thenShortCircuitFalse() {
|
||||
boolean shortCircuitResult = (2<1) && (4<5);
|
||||
assertFalse(shortCircuitResult);
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,99 @@
|
|||
package com.baeldung.core.operators.notoperator;
|
||||
|
||||
/**
|
||||
* Examples used in the article `Using the Not Operator in If Conditions in Java`.
|
||||
*/
|
||||
public class NotOperator {
|
||||
|
||||
public static void ifElseStatementExample() {
|
||||
boolean isValid = true;
|
||||
|
||||
if (isValid) {
|
||||
System.out.println("Valid");
|
||||
} else {
|
||||
System.out.println("Invalid");
|
||||
}
|
||||
}
|
||||
|
||||
public static void checkIsValidIsFalseWithEmptyIfBlock() {
|
||||
boolean isValid = true;
|
||||
|
||||
if (isValid) {
|
||||
|
||||
} else {
|
||||
System.out.println("Invalid");
|
||||
}
|
||||
}
|
||||
|
||||
public static void checkIsValidIsFalseWithJustTheIfBlock() {
|
||||
boolean isValid = true;
|
||||
|
||||
if (isValid == false) {
|
||||
System.out.println("Invalid");
|
||||
}
|
||||
}
|
||||
|
||||
public static void checkIsValidIsFalseWithTheNotOperator() {
|
||||
boolean isValid = true;
|
||||
|
||||
if (!isValid) {
|
||||
System.out.println("Invalid");
|
||||
}
|
||||
}
|
||||
|
||||
public static void notOperatorWithBooleanValueAsOperand() {
|
||||
System.out.println(!true); // prints false
|
||||
System.out.println(!false); // prints true
|
||||
System.out.println(!!false); // prints false
|
||||
}
|
||||
|
||||
public static void applyNotOperatorToAnExpression_example1() {
|
||||
int count = 2;
|
||||
|
||||
System.out.println(!(count > 2)); // prints true
|
||||
System.out.println(!(count <= 2)); // prints false
|
||||
}
|
||||
|
||||
public static void applyNotOperatorToAnExpression_LogicalOperators() {
|
||||
boolean x = true;
|
||||
boolean y = false;
|
||||
|
||||
System.out.println(!(x && y)); // prints true
|
||||
System.out.println(!(x || y)); // prints false
|
||||
}
|
||||
|
||||
public static void precedence_example() {
|
||||
boolean x = true;
|
||||
boolean y = false;
|
||||
|
||||
System.out.println(!x && y); // prints false
|
||||
System.out.println(!(x && y)); // prints true
|
||||
}
|
||||
|
||||
public static void pitfalls_ComplexConditionsExample() {
|
||||
int count = 9;
|
||||
int total = 100;
|
||||
|
||||
if (!(count >= 10 || total >= 1000)) {
|
||||
System.out.println("Some more work to do");
|
||||
}
|
||||
}
|
||||
|
||||
public static void pitfalls_simplifyComplexConditionsByReversingLogicExample() {
|
||||
int count = 9;
|
||||
int total = 100;
|
||||
|
||||
if (count < 10 && total < 1000) {
|
||||
System.out.println("Some more work to do");
|
||||
}
|
||||
}
|
||||
|
||||
public static void exitEarlyExample() {
|
||||
boolean isValid = false;
|
||||
|
||||
if(!isValid) {
|
||||
throw new IllegalArgumentException("Invalid input");
|
||||
}
|
||||
// Code to execute when isValid == true goes here
|
||||
}
|
||||
}
|
|
@ -0,0 +1,57 @@
|
|||
package com.baeldung.branchprediction;
|
||||
|
||||
import java.util.stream.LongStream;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class CombiningUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(CombiningUnitTest.class);
|
||||
|
||||
public static final int TOP = 10000000;
|
||||
public static final double FRACTION = 0.1;
|
||||
|
||||
@Test
|
||||
public void combined() {
|
||||
long[] first = LongStream.range(0, TOP)
|
||||
.map(n -> Math.random() < FRACTION ? 0 : n)
|
||||
.toArray();
|
||||
long[] second = LongStream.range(0, TOP)
|
||||
.map(n -> Math.random() < FRACTION ? 0 : n)
|
||||
.toArray();
|
||||
|
||||
long count = 0;
|
||||
long start = System.currentTimeMillis();
|
||||
for (int i = 0; i < TOP; i++) {
|
||||
if (first[i] * second[i] != 0) {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
long end = System.currentTimeMillis();
|
||||
|
||||
LOG.info("Counted {}/{} numbers using combined mode in {}ms", count, TOP, end - start);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void separate() {
|
||||
long[] first = LongStream.range(0, TOP)
|
||||
.map(n -> Math.random() < FRACTION ? 0 : n)
|
||||
.toArray();
|
||||
long[] second = LongStream.range(0, TOP)
|
||||
.map(n -> Math.random() < FRACTION ? 0 : n)
|
||||
.toArray();
|
||||
|
||||
long count = 0;
|
||||
long start = System.currentTimeMillis();
|
||||
for (int i = 0; i < TOP; i++) {
|
||||
if (first[i] != 0 && second[i] != 0) {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
long end = System.currentTimeMillis();
|
||||
|
||||
LOG.info("Counted {}/{} numbers using separate mode in {}ms", count, TOP, end - start);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,92 @@
|
|||
package com.baeldung.branchprediction;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.LongStream;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class IfUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(IfUnitTest.class);
|
||||
|
||||
public static final int TOP = 10000000;
|
||||
|
||||
@Test
|
||||
public void majorBranchSorted() {
|
||||
test(TOP, 0.9, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void minorBranchSorted() {
|
||||
test(TOP, 0.1, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalBranchSorted() {
|
||||
test(TOP, 0.5, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void allBranchSorted() {
|
||||
test(TOP, 1, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void noneBranchSorted() {
|
||||
test(TOP, 0, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void majorBranchShuffled() {
|
||||
test(TOP, 0.9, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void minorBranchShuffled() {
|
||||
test(TOP, 0.1, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalBranchShuffled() {
|
||||
test(TOP, 0.5, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void allBranchShuffled() {
|
||||
test(TOP, 1, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void noneBranchShuffled() {
|
||||
test(TOP, 0, true);
|
||||
}
|
||||
|
||||
private void test(long top, double cutoffPercentage, boolean shuffle) {
|
||||
List<Long> numbers = LongStream.range(0, top)
|
||||
.boxed()
|
||||
.collect(Collectors.toList());
|
||||
if (shuffle) {
|
||||
Collections.shuffle(numbers);
|
||||
}
|
||||
|
||||
long cutoff = (long)(top * cutoffPercentage);
|
||||
long low = 0;
|
||||
long high = 0;
|
||||
|
||||
long start = System.currentTimeMillis();
|
||||
for (Long number : numbers) {
|
||||
if (number < cutoff) {
|
||||
++low;
|
||||
} else {
|
||||
++high;
|
||||
}
|
||||
}
|
||||
long end = System.currentTimeMillis();
|
||||
|
||||
LOG.info("Counted {}/{} {} numbers in {}ms", low, high, shuffle ? "shuffled" : "sorted", end - start);
|
||||
|
||||
}
|
||||
}
|
|
@ -0,0 +1,60 @@
|
|||
package com.baeldung.branchprediction;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.LongStream;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class SortingUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(SortingUnitTest.class);
|
||||
public static final int BIG = 10000000;
|
||||
public static final int SMALL = 100000;
|
||||
|
||||
@Test
|
||||
public void sortedBig() {
|
||||
test(BIG, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shuffledBig() {
|
||||
test(BIG, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sortedSmall() {
|
||||
test(SMALL, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shuffledSmall() {
|
||||
test(SMALL, true);
|
||||
}
|
||||
|
||||
private void test(long top, boolean shuffle) {
|
||||
List<Long> numbers = LongStream.range(0, top)
|
||||
.boxed()
|
||||
.collect(Collectors.toList());
|
||||
|
||||
if (shuffle) {
|
||||
Collections.shuffle(numbers);
|
||||
}
|
||||
|
||||
long cutoff = top / 2;
|
||||
long count = 0;
|
||||
|
||||
long start = System.currentTimeMillis();
|
||||
for (Long number : numbers) {
|
||||
if (number < cutoff) {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
long end = System.currentTimeMillis();
|
||||
|
||||
LOG.info("Counted {}/{} {} numbers in {}ms",
|
||||
count, top, shuffle ? "shuffled" : "sorted", end - start);
|
||||
}
|
||||
}
|
|
@ -1,3 +0,0 @@
|
|||
### Relevant Articles:
|
||||
|
||||
- [Intro to the Java SecurityManager](https://www.baeldung.com/java-security-manager)
|
|
@ -1,16 +0,0 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<artifactId>core-java-security-manager</artifactId>
|
||||
<version>0.1.0-SNAPSHOT</version>
|
||||
<name>core-java-security-manager</name>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung.core-java-modules</groupId>
|
||||
<artifactId>core-java-modules</artifactId>
|
||||
<version>1.0.0-SNAPSHOT</version>
|
||||
</parent>
|
||||
|
||||
</project>
|
|
@ -1,35 +0,0 @@
|
|||
package com.baeldung.security.manager;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.net.URL;
|
||||
import java.security.AccessControlException;
|
||||
import java.util.concurrent.Callable;
|
||||
|
||||
public class SecurityManagerUnitTest {
|
||||
|
||||
@Test(expected = AccessControlException.class)
|
||||
public void whenSecurityManagerIsActive_thenNetworkIsNotAccessibleByDefault() throws Exception {
|
||||
doTest(() -> {
|
||||
new URL("http://www.google.com").openConnection().connect();
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
@Test(expected = AccessControlException.class)
|
||||
public void whenUnauthorizedClassTriesToAccessProtectedOperation_thenAnExceptionIsThrown() throws Exception {
|
||||
doTest(() -> {
|
||||
new Service().operation();
|
||||
return null;
|
||||
});
|
||||
}
|
||||
|
||||
private void doTest(Callable<Void> action) throws Exception {
|
||||
System.setSecurityManager(new SecurityManager());
|
||||
try {
|
||||
action.call();
|
||||
} finally {
|
||||
System.setSecurityManager(null);
|
||||
}
|
||||
}
|
||||
}
|
|
@ -15,4 +15,5 @@ This module contains articles about core Java Security
|
|||
- [The Java SecureRandom Class](https://www.baeldung.com/java-secure-random)
|
||||
- [An Introduction to Java SASL](https://www.baeldung.com/java-sasl)
|
||||
- [A Guide to Java GSS API](https://www.baeldung.com/java-gss)
|
||||
- [Intro to the Java SecurityManager](https://www.baeldung.com/java-security-manager)
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
package com.baeldung.security.manager;
|
||||
package com.baeldung.securitymanager;
|
||||
|
||||
import java.security.BasicPermission;
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package com.baeldung.security.manager;
|
||||
package com.baeldung.securitymanager;
|
||||
|
||||
public class Service {
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
package org.baeldung.java.md5;
|
||||
package com.baeldung.java.md5;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
package com.baeldung.securitymanager;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.URL;
|
||||
import java.security.AccessControlException;
|
||||
|
||||
public class SecurityManagerUnitTest {
|
||||
|
||||
private static final String TESTING_SECURITY_POLICY = "file:src/test/resources/testing.policy";
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
System.setProperty("java.security.policy", TESTING_SECURITY_POLICY);
|
||||
System.setSecurityManager(new SecurityManager());
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
System.setSecurityManager(null);
|
||||
}
|
||||
|
||||
@Test(expected = AccessControlException.class)
|
||||
public void whenSecurityManagerIsActive_thenNetworkIsNotAccessibleByDefault() throws IOException {
|
||||
new URL("http://www.google.com").openConnection().connect();
|
||||
}
|
||||
|
||||
@Test(expected = AccessControlException.class)
|
||||
public void whenUnauthorizedClassTriesToAccessProtectedOperation_thenAnExceptionIsThrown() {
|
||||
new Service().operation();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,5 @@
|
|||
grant {
|
||||
// This is for testing purposes only.
|
||||
// It allows us to properly reset the security manager after the unit test completes.
|
||||
permission java.lang.RuntimePermission "setSecurityManager";
|
||||
};
|
|
@ -1,72 +1,103 @@
|
|||
package com.baeldung.randomstrings;
|
||||
|
||||
import org.apache.commons.lang3.RandomStringUtils;
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.nio.charset.Charset;
|
||||
import java.util.Random;
|
||||
|
||||
public class RandomStringsUnitTest {
|
||||
|
||||
private static final Logger LOG = LoggerFactory.getLogger(RandomStringsUnitTest.class);
|
||||
|
||||
@Test
|
||||
public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
|
||||
final byte[] array = new byte[7]; // length is bounded by 7
|
||||
new Random().nextBytes(array);
|
||||
final String generatedString = new String(array, Charset.forName("UTF-8"));
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
|
||||
final int leftLimit = 97; // letter 'a'
|
||||
final int rightLimit = 122; // letter 'z'
|
||||
final int targetStringLength = 10;
|
||||
final Random random = new Random();
|
||||
final StringBuilder buffer = new StringBuilder(targetStringLength);
|
||||
|
||||
for (int i = 0; i < targetStringLength; i++) {
|
||||
final int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
|
||||
buffer.append((char) randomLimitedInt);
|
||||
}
|
||||
final String generatedString = buffer.toString();
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
|
||||
final String generatedString = RandomStringUtils.random(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
|
||||
final String generatedString = RandomStringUtils.randomAlphabetic(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
|
||||
final String generatedString = RandomStringUtils.randomAlphanumeric(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
|
||||
final int length = 10;
|
||||
final boolean useLetters = true;
|
||||
final boolean useNumbers = false;
|
||||
final String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
}
|
||||
package com.baeldung.randomstrings;
|
||||
|
||||
import org.apache.commons.lang3.RandomStringUtils;
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.nio.charset.Charset;
|
||||
import java.util.Random;
|
||||
|
||||
public class RandomStringsUnitTest {
|
||||
|
||||
private static final Logger LOG = LoggerFactory.getLogger(RandomStringsUnitTest.class);
|
||||
|
||||
@Test
|
||||
public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() {
|
||||
byte[] array = new byte[7]; // length is bounded by 7
|
||||
new Random().nextBytes(array);
|
||||
String generatedString = new String(array, Charset.forName("UTF-8"));
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingPlainJava_whenGeneratingRandomStringBounded_thenCorrect() {
|
||||
int leftLimit = 97; // letter 'a'
|
||||
int rightLimit = 122; // letter 'z'
|
||||
int targetStringLength = 10;
|
||||
Random random = new Random();
|
||||
StringBuilder buffer = new StringBuilder(targetStringLength);
|
||||
|
||||
for (int i = 0; i < targetStringLength; i++) {
|
||||
int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
|
||||
buffer.append((char) randomLimitedInt);
|
||||
}
|
||||
String generatedString = buffer.toString();
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingJava8_whenGeneratingRandomAlphabeticString_thenCorrect() {
|
||||
int leftLimit = 97; // letter 'a'
|
||||
int rightLimit = 122; // letter 'z'
|
||||
int targetStringLength = 10;
|
||||
Random random = new Random();
|
||||
|
||||
String generatedString = random.ints(leftLimit, rightLimit + 1)
|
||||
.limit(targetStringLength)
|
||||
.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
|
||||
.toString();
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingJava8_whenGeneratingRandomAlphanumericString_thenCorrect() {
|
||||
int leftLimit = 48; // numeral '0'
|
||||
int rightLimit = 122; // letter 'z'
|
||||
int targetStringLength = 10;
|
||||
Random random = new Random();
|
||||
|
||||
String generatedString = random.ints(leftLimit, rightLimit + 1)
|
||||
.filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
|
||||
.limit(targetStringLength)
|
||||
.collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
|
||||
.toString();
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomString_thenCorrect() {
|
||||
String generatedString = RandomStringUtils.random(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomAlphabeticString_thenCorrect() {
|
||||
String generatedString = RandomStringUtils.randomAlphabetic(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomAlphanumericString_thenCorrect() {
|
||||
String generatedString = RandomStringUtils.randomAlphanumeric(10);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApache_whenGeneratingRandomStringBounded_thenCorrect() {
|
||||
int length = 10;
|
||||
boolean useLetters = true;
|
||||
boolean useNumbers = false;
|
||||
String generatedString = RandomStringUtils.random(length, useLetters, useNumbers);
|
||||
|
||||
LOG.debug(generatedString);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue