[BAEL-16045] - Renamed UserServiceIntegrationUnitTest to UserServiceUnitTest

java-strings-ops/src/main/java/com/baeldung/string/AppendCharAtPositionX.java

@@ -0,0 +1,44 @@
+/**
+ * 
+ */
+package com.baeldung.string;
+
+/**
+ * @author swpraman
+ *
+ */
+public class AppendCharAtPositionX {
+
+    public String addCharUsingCharArray(String str, char ch, int position) {
+        validate(str, position);
+        int len = str.length();
+        char[] updatedArr = new char[len + 1];
+        str.getChars(0, position, updatedArr, 0);
+        updatedArr[position] = ch;
+        str.getChars(position, len, updatedArr, position + 1);
+        return new String(updatedArr);
+    }
+
+    public String addCharUsingSubstring(String str, char ch, int position) {
+        validate(str, position);
+        return str.substring(0, position) + ch + str.substring(position);
+    }
+
+    public String addCharUsingStringBuilder(String str, char ch, int position) {
+        validate(str, position);
+        StringBuilder sb = new StringBuilder(str);
+        sb.insert(position, ch);
+        return sb.toString();
+    }
+
+    private void validate(String str, int position) {
+        if (str == null) {
+            throw new IllegalArgumentException("Str should not be null");
+        }
+        int len = str.length();
+        if (position < 0 || position > len) {
+            throw new IllegalArgumentException("position[" + position + "] should be " + "in the range 0.." + len + " for string " + str);
+        }
+    }
+
+}

java-strings-ops/src/main/java/com/baeldung/string/Palindrome.java

@@ -0,0 +1,66 @@
+package com.baeldung.string;
+
+import java.util.stream.IntStream;
+
+public class Palindrome {
+
+    public boolean isPalindrome(String text) {
+        String clean = text.replaceAll("\\s+", "").toLowerCase();
+        int length = clean.length();
+        int forward = 0;
+        int backward = length - 1;
+        while (backward > forward) {
+            char forwardChar = clean.charAt(forward++);
+            char backwardChar = clean.charAt(backward--);
+            if (forwardChar != backwardChar)
+                return false;
+        }
+        return true;
+    }
+
+    public boolean isPalindromeReverseTheString(String text) {
+        StringBuilder reverse = new StringBuilder();
+        String clean = text.replaceAll("\\s+", "").toLowerCase();
+        char[] plain = clean.toCharArray();
+        for (int i = plain.length - 1; i >= 0; i--)
+            reverse.append(plain[i]);
+        return (reverse.toString()).equals(clean);
+    }
+
+    public boolean isPalindromeUsingStringBuilder(String text) {
+        String clean = text.replaceAll("\\s+", "").toLowerCase();
+        StringBuilder plain = new StringBuilder(clean);
+        StringBuilder reverse = plain.reverse();
+        return (reverse.toString()).equals(clean);
+    }
+
+    public boolean isPalindromeUsingStringBuffer(String text) {
+        String clean = text.replaceAll("\\s+", "").toLowerCase();
+        StringBuffer plain = new StringBuffer(clean);
+        StringBuffer reverse = plain.reverse();
+        return (reverse.toString()).equals(clean);
+    }
+
+    public boolean isPalindromeRecursive(String text) {
+        String clean = text.replaceAll("\\s+", "").toLowerCase();
+        return recursivePalindrome(clean, 0, clean.length() - 1);
+    }
+
+    private boolean recursivePalindrome(String text, int forward, int backward) {
+        if (forward == backward)
+            return true;
+        if ((text.charAt(forward)) != (text.charAt(backward)))
+            return false;
+        if (forward < backward + 1) {
+            return recursivePalindrome(text, forward + 1, backward - 1);
+        }
+
+        return true;
+    }
+
+    public boolean isPalindromeUsingIntStream(String text) {
+        String temp = text.replaceAll("\\s+", "").toLowerCase();
+        return IntStream.range(0, temp.length() / 2)
+            .noneMatch(i -> temp.charAt(i) != temp.charAt(temp.length() - i - 1));
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/StringHelper.java

@@ -0,0 +1,26 @@
+package com.baeldung.string;
+
+import java.util.Optional;
+
+class StringHelper {
+    static String removeLastChar(String s) {
+        return (s == null || s.length() == 0) ? s : (s.substring(0, s.length() - 1));
+    }
+
+    static String removeLastCharRegex(String s) {
+        return (s == null) ? s : s.replaceAll(".$", "");
+    }
+
+    static String removeLastCharOptional(String s) {
+        return Optional.ofNullable(s)
+            .filter(str -> str.length() != 0)
+            .map(str -> str.substring(0, str.length() - 1))
+            .orElse(s);
+    }
+
+    static String removeLastCharRegexOptional(String s) {
+        return Optional.ofNullable(s)
+            .map(str -> str.replaceAll(".$", ""))
+            .orElse(s);
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/isnumeric/Benchmarking.java

@@ -0,0 +1,73 @@
+package com.baeldung.string.isnumeric;
+
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+public class Benchmarking {
+    public static void main(String[] args) throws RunnerException {
+        Options opt = new OptionsBuilder().include(Benchmarking.class.getSimpleName())
+            .forks(1)
+            .build();
+
+        new Runner(opt).run();
+    }
+
+    @State(Scope.Thread)
+    public static class ExecutionPlan {
+        public String number = Integer.toString(Integer.MAX_VALUE);
+        public boolean isNumber = false;
+        public IsNumeric isNumeric = new IsNumeric();
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingCoreJava(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingCoreJava(plan.number);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingRegularExpressions(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingRegularExpressions(plan.number);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingNumberUtils_isCreatable(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingNumberUtils_isCreatable(plan.number);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingNumberUtils_isParsable(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingNumberUtils_isParsable(plan.number);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingStringUtils_isNumeric(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingStringUtils_isNumeric(plan.number);
+    }
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void usingStringUtils_isNumericSpace(ExecutionPlan plan) {
+        plan.isNumber = plan.isNumeric.usingStringUtils_isNumericSpace(plan.number);
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/isnumeric/CheckIntegerInput.java

@@ -0,0 +1,18 @@
+package com.baeldung.string.isnumeric;
+
+import java.util.Scanner;
+
+public class CheckIntegerInput {
+
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            System.out.println("Enter an integer : ");
+
+            if (scanner.hasNextInt()) {
+                System.out.println("You entered : " + scanner.nextInt());
+            } else {
+                System.out.println("The input is not an integer");
+            }
+        }
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/isnumeric/IsNumeric.java

@@ -0,0 +1,35 @@
+package com.baeldung.string.isnumeric;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+
+public class IsNumeric {
+    public boolean usingCoreJava(String strNum) {
+        try {
+            Double.parseDouble(strNum);
+        } catch (NumberFormatException | NullPointerException nfe) {
+            return false;
+        }
+        return true;
+    }
+
+    public boolean usingRegularExpressions(String strNum) {
+        return strNum.matches("-?\\d+(\\.\\d+)?");
+    }
+
+    public boolean usingNumberUtils_isCreatable(String strNum) {
+        return NumberUtils.isCreatable(strNum);
+    }
+
+    public boolean usingNumberUtils_isParsable(String strNum) {
+        return NumberUtils.isParsable(strNum);
+    }
+
+    public boolean usingStringUtils_isNumeric(String strNum) {
+        return StringUtils.isNumeric(strNum);
+    }
+
+    public boolean usingStringUtils_isNumericSpace(String strNum) {
+        return StringUtils.isNumericSpace(strNum);
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/isnumeric/IsNumericDriver.java

@@ -0,0 +1,31 @@
+package com.baeldung.string.isnumeric;
+
+import org.apache.log4j.Logger;
+
+public class IsNumericDriver {
+    private static Logger LOG = Logger.getLogger(IsNumericDriver.class);
+
+    private static IsNumeric isNumeric = new IsNumeric();
+
+    public static void main(String[] args) {
+        LOG.info("Testing all methods...");
+
+        boolean res = isNumeric.usingCoreJava("1001");
+        LOG.info("Using Core Java : " + res);
+
+        res = isNumeric.usingRegularExpressions("1001");
+        LOG.info("Using Regular Expressions : " + res);
+
+        res = isNumeric.usingNumberUtils_isCreatable("1001");
+        LOG.info("Using NumberUtils.isCreatable : " + res);
+
+        res = isNumeric.usingNumberUtils_isParsable("1001");
+        LOG.info("Using NumberUtils.isParsable : " + res);
+
+        res = isNumeric.usingStringUtils_isNumeric("1001");
+        LOG.info("Using StringUtils.isNumeric : " + res);
+
+        res = isNumeric.usingStringUtils_isNumericSpace("1001");
+        LOG.info("Using StringUtils.isNumericSpace : " + res);
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/Customer.java

@@ -0,0 +1,22 @@
+package com.baeldung.string.tostring;
+
+public class Customer {
+    private String firstName;
+    private String lastName;
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/CustomerArrayToString.java

@@ -0,0 +1,20 @@
+package com.baeldung.string.tostring;
+
+import java.util.Arrays;
+
+public class CustomerArrayToString extends Customer {
+    private Order[] orders;
+
+    public Order[] getOrders() {
+        return orders;
+    }
+
+    public void setOrders(Order[] orders) {
+        this.orders = orders;
+    }
+
+    @Override
+    public String toString() {
+        return "Customer [orders=" + Arrays.toString(orders) + ", getFirstName()=" + getFirstName() + ", getLastName()=" + getLastName() + "]";
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/CustomerComplexObjectToString.java

@@ -0,0 +1,18 @@
+package com.baeldung.string.tostring;
+
+public class CustomerComplexObjectToString extends Customer {
+    private Order order;
+
+    public Order getOrder() {
+        return order;
+    }
+
+    public void setOrder(Order order) {
+        this.order = order;
+    }
+
+    @Override
+    public String toString() {
+        return "Customer [order=" + order + ", getFirstName()=" + getFirstName() + ", getLastName()=" + getLastName() + "]";
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/CustomerPrimitiveToString.java

@@ -0,0 +1,18 @@
+package com.baeldung.string.tostring;
+
+public class CustomerPrimitiveToString extends Customer {
+    private long balance;
+
+    public long getBalance() {
+        return balance;
+    }
+
+    public void setBalance(long balance) {
+        this.balance = balance;
+    }
+
+    @Override
+    public String toString() {
+        return "Customer [balance=" + balance + ", getFirstName()=" + getFirstName() + ", getLastName()=" + getLastName() + "]";
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/CustomerReflectionToString.java

@@ -0,0 +1,41 @@
+package com.baeldung.string.tostring;
+
+import java.util.List;
+
+import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
+
+public class CustomerReflectionToString extends Customer {
+
+    private Integer score;
+    private List<String> orders;
+    private StringBuffer fullname;
+
+    public Integer getScore() {
+        return score;
+    }
+
+    public void setScore(Integer score) {
+        this.score = score;
+    }
+
+    public List<String> getOrders() {
+        return orders;
+    }
+
+    public void setOrders(List<String> orders) {
+        this.orders = orders;
+    }
+
+    public StringBuffer getFullname() {
+        return fullname;
+    }
+
+    public void setFullname(StringBuffer fullname) {
+        this.fullname = fullname;
+    }
+
+    @Override
+    public String toString() {
+        return ReflectionToStringBuilder.toString(this);
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/CustomerWrapperCollectionToString.java

@@ -0,0 +1,38 @@
+package com.baeldung.string.tostring;
+
+import java.util.List;
+
+public class CustomerWrapperCollectionToString extends Customer {
+    private Integer score;
+    private List<String> orders;
+    private StringBuffer fullname;
+
+    public Integer getScore() {
+        return score;
+    }
+
+    public void setScore(Integer score) {
+        this.score = score;
+    }
+
+    public List<String> getOrders() {
+        return orders;
+    }
+
+    public void setOrders(List<String> orders) {
+        this.orders = orders;
+    }
+
+    public StringBuffer getFullname() {
+        return fullname;
+    }
+
+    public void setFullname(StringBuffer fullname) {
+        this.fullname = fullname;
+    }
+
+    @Override
+    public String toString() {
+        return "Customer [score=" + score + ", orders=" + orders + ", fullname=" + fullname + ", getFirstName()=" + getFirstName() + ", getLastName()=" + getLastName() + "]";
+    }
+}

java-strings-ops/src/main/java/com/baeldung/string/tostring/Order.java

@@ -0,0 +1,47 @@
+package com.baeldung.string.tostring;
+
+public class Order {
+
+    private String orderId;
+    private String desc;
+    private long value;
+    private String status;
+
+    public String getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(String orderId) {
+        this.orderId = orderId;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public void setDesc(String desc) {
+        this.desc = desc;
+    }
+
+    public long getValue() {
+        return value;
+    }
+
+    public void setValue(long value) {
+        this.value = value;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    @Override
+    public String toString() {
+        return "Order [orderId=" + orderId + ", desc=" + desc + ", value=" + value + "]";
+    }
+
+}