[BAEL-8232] - Moved java string related code and github links into new module java-strings

2018-08-18 20:54:24 +05:30
parent 3a6638074f
commit ab17b8e697
51 changed files with 284 additions and 80 deletions
@@ -0,0 +1,11 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class UseLocalDateTime {
+
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation) {
+        return LocalDateTime.parse(representation);
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.java9.compactstring;
+
+import java.util.List;
+import static java.util.stream.Collectors.toList;
+import java.util.stream.IntStream;
+
+public class CompactStringDemo {
+
+    public static void main(String[] args) {
+        long startTime = System.currentTimeMillis();
+        List strings = IntStream.rangeClosed(1, 10_000_000)
+          .mapToObj(Integer::toString).collect(toList());
+        long totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Generated " + strings.size() + " strings in " 
+          + totalTime + " ms.");
+
+        startTime = System.currentTimeMillis();
+        String appended = (String) strings.stream().limit(100_000)
+          .reduce("", (left, right) -> left.toString() + right.toString());
+        totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Created string of length " + appended.length() 
+          + " in " + totalTime + " ms.");
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.string;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class JoinerSplitter {
+
+	public static String join ( String[] arrayOfString ) {
+		return Arrays.asList(arrayOfString)
+				.stream()
+				.map(x -> x)
+				.collect(Collectors.joining(","));
+	}
+	
+	public static String joinWithPrefixPostFix ( String[] arrayOfString ) {
+		return Arrays.asList(arrayOfString)
+				.stream()
+				.map(x -> x)
+				.collect(Collectors.joining(",","[","]"));
+	}
+	
+	public static List<String> split ( String str ) {
+		return Stream.of(str.split(","))
+				.map (elem -> new String(elem))
+				.collect(Collectors.toList());
+	}
+	
+	public static List<Character> splitToListOfChar ( String str ) {
+		return str.chars()
+				.mapToObj(item -> (char) item)
+				.collect(Collectors.toList());
+	}
+		
+}
@@ -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));
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung.string;
+
+import org.openjdk.jmh.annotations.Benchmark;
+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 StringBufferStringBuilder {
+
+    public static void main(String[] args) throws RunnerException {
+
+        Options opt = new OptionsBuilder()
+            .include(StringBufferStringBuilder.class.getSimpleName())
+            .build();
+
+        new Runner(opt).run();
+    }
+    
+    @State(Scope.Benchmark)
+    public static class MyState {
+        int iterations = 1000;
+        String initial = "abc";
+        String suffix = "def";
+    }
+     
+    @Benchmark
+    public StringBuffer benchmarkStringBuffer(MyState state) {
+        StringBuffer stringBuffer = new StringBuffer(state.initial);
+        for (int i = 0; i < state.iterations; i++) {
+            stringBuffer.append(state.suffix);
+        }
+        return stringBuffer;
+    }
+
+    @Benchmark
+    public StringBuilder benchmarkStringBuilder(MyState state) {
+        StringBuilder stringBuilder = new StringBuilder(state.initial);
+        for (int i = 0; i < state.iterations; i++) {
+            stringBuilder.append(state.suffix);
+        }
+        return stringBuilder;
+    }
+}
@@ -0,0 +1,21 @@
+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);
+    }
+}
@@ -0,0 +1,69 @@
+package com.baeldung.string;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.text.WordUtils;
+
+import com.ibm.icu.lang.UCharacter;
+import com.ibm.icu.text.BreakIterator;
+
+public class TitleCaseConverter {
+
+    private static final String WORD_SEPARATOR = " ";
+
+    public static String convertToTitleCaseIteratingChars(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        StringBuilder converted = new StringBuilder();
+
+        boolean convertNext = true;
+        for (char ch : text.toCharArray()) {
+            if (Character.isSpaceChar(ch)) {
+                convertNext = true;
+            } else if (convertNext) {
+                ch = Character.toTitleCase(ch);
+                convertNext = false;
+            } else {
+                ch = Character.toLowerCase(ch);
+            }
+            converted.append(ch);
+        }
+
+        return converted.toString();
+    }
+
+    public static String convertToTitleCaseSplitting(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        return Arrays
+          .stream(text.split(WORD_SEPARATOR))
+          .map(word -> word.isEmpty()
+            ? word
+            : Character.toTitleCase(word.charAt(0)) + word
+              .substring(1)
+              .toLowerCase())
+          .collect(Collectors.joining(WORD_SEPARATOR));
+    }
+
+    public static String convertToTitleCaseIcu4j(String text) {
+        if (text == null || text.isEmpty()) {
+            return text;
+        }
+
+        return UCharacter.toTitleCase(text, BreakIterator.getTitleInstance());
+    }
+
+    public static String convertToTileCaseWordUtilsFull(String text) {
+        return WordUtils.capitalizeFully(text);
+    }
+
+    public static String convertToTileCaseWordUtils(String text) {
+        return WordUtils.capitalize(text);
+    }
+
+}
@@ -0,0 +1,75 @@
+package com.baeldung.stringisnumeric;
+
+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);
+    }
+}
@@ -0,0 +1,35 @@
+package com.baeldung.stringisnumeric;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+
+public class IsNumeric {
+    public boolean usingCoreJava(String strNum) {
+        try {
+            double d = 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);
+    }
+}
@@ -0,0 +1,34 @@
+package com.baeldung.stringisnumeric;
+
+import org.apache.log4j.Logger;
+
+public class IsNumericDriver {
+    private static IsNumeric isNumeric;
+    private static Logger LOG = Logger.getLogger(IsNumericDriver.class);
+    static {
+        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);
+    }
+}
@@ -0,0 +1,48 @@
+package com.baeldung.stringtokenizer;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.stream.Collectors;
+
+public class MyTokenizer {
+
+    public List<String> getTokens(String str) {
+        List<String> tokens = new ArrayList<>();
+        // StringTokenizer tokenizer = new StringTokenizer( str );
+        StringTokenizer tokenizer = new StringTokenizer(str, ",");
+        // StringTokenizer tokenizer = new StringTokenizer( str , "," , true );
+        while (tokenizer.hasMoreElements()) {
+            tokens.add(tokenizer.nextToken());
+            // tokens.add( tokenizer.nextToken("e") );
+        }
+        int tokenLength = tokens.size();
+        return tokens;
+    }
+
+    public List<String> getTokensWithCollection(String str) {
+        return Collections.list(new StringTokenizer(str, ",")).stream().map(token -> (String) token).collect(Collectors.toList());
+    }
+
+    public List<String> getTokensFromFile(String path, String delim) {
+        List<String> tokens = new ArrayList<>();
+        String currLine;
+        StringTokenizer tokenizer;
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(MyTokenizer.class.getResourceAsStream("/" + path)))) {
+            while ((currLine = br.readLine()) != null) {
+                tokenizer = new StringTokenizer(currLine, delim);
+                while (tokenizer.hasMoreElements()) {
+                    tokens.add(tokenizer.nextToken());
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return tokens;
+    }
+
+}