BAEL-1889 - Let's move the Java Number articles into a new module (#4619)

* BAEL-1849 - Convert from String to Date in Java * BAEL-1863 - Calling Callbacks with Mockito * BAEL-1889 - Let's move the Java Number articles into a new module * BAEL-1889 - Let's move the Java Number articles into a new module
2018-07-14 15:00:37 +02:00
parent de2afd7da8
commit b44883b364
41 changed files with 380 additions and 188 deletions
@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.primechecker;
+
+import java.math.BigInteger;
+
+public class BigIntegerPrimeChecker implements PrimeChecker<Long>{
+
+    @Override
+    public boolean isPrime(Long number) {
+        BigInteger bigInt = BigInteger.valueOf(number);
+        return bigInt.isProbablePrime(100);
+    }
+
+}
@@ -0,0 +1,14 @@
+package com.baeldung.algorithms.primechecker;
+
+import java.util.stream.IntStream;
+
+public class BruteForcePrimeChecker implements PrimeChecker<Integer> {
+
+    @Override
+    public boolean isPrime(Integer number) {
+
+        return number > 2 ? IntStream.range(2, number)
+            .noneMatch(n -> (number % n == 0)) : false;
+    }
+
+}
@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.primechecker;
+
+import java.util.stream.IntStream;
+
+public class OptimisedPrimeChecker implements PrimeChecker<Integer> {
+
+    @Override
+    public boolean isPrime(Integer number) {
+        return number > 2 ? IntStream.rangeClosed(2, (int) Math.sqrt(number))
+            .noneMatch(n -> (number % n == 0)) : false;
+    }
+
+}
@@ -0,0 +1,6 @@
+package com.baeldung.algorithms.primechecker;
+
+public interface PrimeChecker <T> {
+    
+    public boolean isPrime( T number );
+}
@@ -0,0 +1,12 @@
+package com.baeldung.algorithms.primechecker;
+
+import org.apache.commons.math3.primes.Primes;
+
+public class PrimesPrimeChecker implements PrimeChecker<Integer>{
+
+    @Override
+    public boolean isPrime(Integer number) {
+        return Primes.isPrime(number);
+    }
+
+}
@@ -0,0 +1,51 @@
+package com.baeldung.maths;
+
+import java.math.BigDecimal;
+
+public class FloatingPointArithmetic {
+    public static void main(String[] args) {
+        
+        double a = 13.22;
+        double b = 4.88;
+        double c = 21.45;
+        
+        System.out.println("a =         " + a);
+        System.out.println("b =         " + b);
+        System.out.println("c =         " + c);
+        
+        double sum_ab = a + b;
+        System.out.println("a + b =     " + sum_ab);
+        
+        double abc =  a + b + c;
+        System.out.println("a + b + c = " + abc);
+        
+        double ab_c = sum_ab + c;
+        System.out.println("ab + c =    " + ab_c);
+        
+        double sum_ac = a + c;
+        System.out.println("a + c =     " + sum_ac);
+        
+        double acb = a + c + b;
+        System.out.println("a + c + b = " + acb);
+        
+        double ac_b = sum_ac + b;
+        System.out.println("ac + b =    " + ac_b);
+        
+        double ab = 18.1;
+        double ac = 34.67;
+        double sum_ab_c = ab + c;
+        double sum_ac_b = ac + b;
+        System.out.println("ab + c =    " + sum_ab_c);
+        System.out.println("ac + b =    " + sum_ac_b);
+        
+        BigDecimal d = new BigDecimal(String.valueOf(a));
+        BigDecimal e = new BigDecimal(String.valueOf(b));
+        BigDecimal f = new BigDecimal(String.valueOf(c));
+        
+        BigDecimal def = d.add(e).add(f);
+        BigDecimal dfe = d.add(f).add(e);
+        
+        System.out.println("d + e + f = " + def);
+        System.out.println("d + f + e = " + dfe);
+    }
+}
@@ -0,0 +1,47 @@
+package com.baeldung.maths;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+
+import org.apache.commons.math3.util.Precision;
+import org.decimal4j.util.DoubleRounder;
+
+public class Round {
+    private static final double PI = 3.1415d;
+    
+    public static void main (String args[]) {
+        System.out.println("PI: " + PI);
+        System.out.printf("Value with 3 digits after decimal point %.3f %n", PI);
+        // OUTPUTS: Value with 3 digits after decimal point 3.142
+        DecimalFormat df = new DecimalFormat("###.###");
+        System.out.println(df.format(PI));
+        System.out.println(round(PI, 3));
+        System.out.println(roundNotPrecise(PI, 3));
+        System.out.println(roundAvoid(PI, 3));
+        System.out.println(Precision.round(PI, 3));
+        System.out.println(DoubleRounder.round(PI, 3));
+    }
+    
+    public static double round(double value, int places) {
+        if (places < 0) throw new IllegalArgumentException();
+        
+        BigDecimal bd = new BigDecimal(Double.toString(value));
+        bd = bd.setScale(places, RoundingMode.HALF_UP);
+        return bd.doubleValue();
+    }
+    
+    public static double roundNotPrecise(double value, int places) {
+        if (places < 0) throw new IllegalArgumentException();
+
+        BigDecimal bd = new BigDecimal(value);
+        bd = bd.setScale(places, RoundingMode.HALF_UP);
+        return bd.doubleValue();
+    }
+    
+    public static double roundAvoid(double value, int places) {
+        double scale = Math.pow(10, places);
+        double rounded = Math.round(value * scale) / scale;
+        return rounded;
+    }
+}
@@ -0,0 +1,81 @@
+package com.baeldung.nan;
+
+/**
+ * Sample usage of NaN.
+ *
+ */
+public class NaNExample {
+
+    public static void main(String[] args) {
+        NaNExample naNExample = new NaNExample();
+        naNExample.demo();
+    }
+
+    void demo() {
+        undefined_operations_produce_NaN();
+        operations_with_no_real_results_produce_NaN();
+        operations_with_NaN_produce_NaN();
+        comparison_with_NaN();
+        check_if_a_value_is_NaN();
+        assign_NaN_to_missing_values();
+    }
+
+    void undefined_operations_produce_NaN() {
+        System.out.println("Undefined Operations Produce NaN");
+        final double ZERO = 0;
+        System.out.println("ZERO / ZERO = " + (ZERO / ZERO));
+        System.out.println("INFINITY - INFINITY = " + (Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY));
+        System.out.println("INFINITY * ZERO = " + (Double.POSITIVE_INFINITY * ZERO));
+        System.out.println();
+    }
+
+    void operations_with_no_real_results_produce_NaN() {
+        System.out.println("Operations with no real results produce NaN");
+        System.out.println("SQUARE ROOT OF -1 = " + Math.sqrt(-1));
+        System.out.println("LOG OF -1 = " + Math.log(-1));
+        System.out.println();
+    }
+
+    void operations_with_NaN_produce_NaN() {
+        System.out.println("Operations with NaN produce NaN");
+        System.out.println("2 + NaN = " + (2 + Double.NaN));
+        System.out.println("2 - NaN = " + (2 - Double.NaN));
+        System.out.println("2 * NaN = " + (2 * Double.NaN));
+        System.out.println("2 / NaN = " + (2 / Double.NaN));
+        System.out.println();
+    }
+
+    void assign_NaN_to_missing_values() {
+        System.out.println("Assign NaN to Missing values");
+        double salaryRequired = Double.NaN;
+        System.out.println(salaryRequired);
+        System.out.println();
+    }
+
+    void comparison_with_NaN() {
+        System.out.println("Comparison with NaN");
+        final double NAN = Double.NaN;
+        System.out.println("NaN == 1 = " + (NAN == 1));
+        System.out.println("NaN > 1 = " + (NAN > 1));
+        System.out.println("NaN < 1 = " + (NAN < 1));
+        System.out.println("NaN != 1 = " + (NAN != 1));
+        System.out.println("NaN == NaN = " + (NAN == NAN));
+        System.out.println("NaN > NaN = " + (NAN > NAN));
+        System.out.println("NaN < NaN = " + (NAN < NAN));
+        System.out.println("NaN != NaN = " + (NAN != NAN));
+        System.out.println();
+    }
+
+    void check_if_a_value_is_NaN() {
+        System.out.println("Check if a value is NaN");
+        double x = 1;
+        System.out.println(x + " is NaN = " + (x != x));
+        System.out.println(x + " is NaN = " + (Double.isNaN(x)));
+
+        x = Double.NaN;
+        System.out.println(x + " is NaN = " + (x != x));
+        System.out.println(x + " is NaN = " + (Double.isNaN(x)));
+        System.out.println();
+    }
+
+}
@@ -0,0 +1,67 @@
+package com.baeldung.numberofdigits;
+
+import java.io.IOException;
+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.RunnerException;
+
+public class Benchmarking {
+    public static void main(String[] args) throws RunnerException, IOException {
+        org.openjdk.jmh.Main.main(args);
+    }
+
+    @State(Scope.Thread)
+    public static class ExecutionPlan {
+        public int number = Integer.MAX_VALUE;
+        public int length = 0;
+        public NumberOfDigits numberOfDigits= new NumberOfDigits();
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void stringBasedSolution(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.stringBasedSolution(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void logarithmicApproach(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.logarithmicApproach(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void repeatedMultiplication(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.repeatedMultiplication(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void shiftOperators(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.shiftOperators(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void dividingWithPowersOf2(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.dividingWithPowersOf2(plan.number);
+    }
+    
+    @Benchmark 
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.NANOSECONDS)
+    public void divideAndConquer(ExecutionPlan plan) {
+        plan.length = plan.numberOfDigits.divideAndConquer(plan.number);
+    }
+}
@@ -0,0 +1,97 @@
+package com.baeldung.numberofdigits;
+
+public class NumberOfDigits {
+    public int stringBasedSolution(int number) {
+        int length = String.valueOf(number).length();
+        return length;
+    }
+    
+    public int logarithmicApproach(int number) {
+        int length = (int) Math.log10(number) + 1;
+        return length;
+    }
+    
+    public int repeatedMultiplication(int number) {
+        int length = 0;
+        long temp = 1;
+        while(temp <= number) {
+            length++;
+            temp *= 10;
+        }
+        return length;
+    }
+
+    public int shiftOperators(int number) {
+        int length = 0;
+        long temp = 1;
+        while(temp <= number) {
+            length++;
+            temp = (temp << 3) + (temp << 1);
+        }
+        return length;
+    }
+    
+    public int dividingWithPowersOf2(int number) {
+        int length = 1;
+        if (number >= 100000000) {
+            length += 8;
+            number /= 100000000;
+        }
+        if (number >= 10000) {
+            length += 4;
+            number /= 10000;
+        }
+        if (number >= 100) {
+            length += 2;
+            number /= 100;
+        }
+        if (number >= 10) {
+            length += 1;
+        }
+        return length;
+    }
+    
+    public int divideAndConquer(int number) {
+        if (number < 100000){
+            // 5 digits or less
+            if (number < 100){
+                // 1 or 2
+                if (number < 10)
+                    return 1;
+                else
+                    return 2;
+            }else{
+                // 3 to 5 digits
+                if (number < 1000)
+                    return 3;
+                else{
+                    // 4 or 5 digits
+                    if (number < 10000)
+                        return 4;
+                    else
+                        return 5;
+                }
+            }
+        } else {
+            // 6 digits or more
+            if (number < 10000000) {
+                // 6 or 7 digits
+                if (number < 1000000)
+                    return 6;
+                else
+                    return 7;
+            } else {
+                // 8 to 10 digits
+                if (number < 100000000)
+                    return 8;
+                else {
+                    // 9 or 10 digits
+                    if (number < 1000000000)
+                        return 9;
+                    else
+                        return 10;
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,35 @@
+package com.baeldung.numberofdigits;
+
+import org.apache.log4j.Logger;
+
+public class NumberOfDigitsDriver {
+    private static NumberOfDigits numberOfDigits;
+
+    private static Logger LOG = Logger.getLogger(NumberOfDigitsDriver.class);
+
+    static {
+        numberOfDigits = new NumberOfDigits();
+    }
+
+    public static void main(String[] args) {
+        LOG.info("Testing all methods...");
+
+        long length = numberOfDigits.stringBasedSolution(602);
+        LOG.info("String Based Solution : " + length);
+
+        length = numberOfDigits.logarithmicApproach(602);
+        LOG.info("Logarithmic Approach : " + length);
+
+        length = numberOfDigits.repeatedMultiplication(602);
+        LOG.info("Repeated Multiplication : " + length);
+
+        length = numberOfDigits.shiftOperators(602);
+        LOG.info("Shift Operators : " + length);
+
+        length = numberOfDigits.dividingWithPowersOf2(602);
+        LOG.info("Dividing with Powers of 2 : " + length);
+
+        length = numberOfDigits.divideAndConquer(602);
+        LOG.info("Divide And Conquer : " + length);
+    }
+}
@@ -0,0 +1,72 @@
+package com.baeldung.pairsaddupnumber;
+
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.IntStream;
+
+/**
+ * Find all different pairs of numbers in an array that add up to a given sum - Complexity O(n)
+ */
+public class DifferentPairs {
+
+    /**
+     * Show all different pairs using traditional "for" loop
+     *
+     * @param input - number's array
+     * @param sum   - given sum
+     * @return - number's array with all existing pairs. This list will contain just one pair's element because
+     * the other one can be calculated with SUM - element_1 = element_2
+     */
+    public static List<Integer> findPairsWithForLoop(int[] input, int sum) {
+        final List<Integer> allDifferentPairs = new ArrayList<>();
+        // Aux. hash map
+        final Map<Integer, Integer> pairs = new HashMap<>();
+        for (int i : input) {
+            if (pairs.containsKey(i)) {
+                if (pairs.get(i) != null) {
+                    // Add pair to returned list
+                    allDifferentPairs.add(i);
+                }
+                // Mark pair as added to prevent duplicates
+                pairs.put(sum - i, null);
+            } else if (!pairs.containsValue(i)) {
+                // Add pair to aux. hash map
+                pairs.put(sum - i, i);
+            }
+        }
+        return allDifferentPairs;
+    }
+
+    /**
+     * Show all different pairs using Java 8 stream API
+     *
+     * @param input - number's array
+     * @param sum   - given sum
+     * @return - number's array with all existing pairs. This list will contain just one pair's element because
+     * the other one can be calculated with SUM - element_1 = element_2
+     */
+    public static List<Integer> findPairsWithStreamApi(int[] input, int sum) {
+        final List<Integer> allDifferentPairs = new ArrayList<>();
+        // Aux. hash map
+        final Map<Integer, Integer> pairs = new HashMap<>();
+        IntStream.range(0, input.length).forEach(i -> {
+                    if (pairs.containsKey(input[i])) {
+                        if (pairs.get(input[i]) != null) {
+                            // Add pair to returned list
+                            allDifferentPairs.add(input[i]);
+                        }
+                        // Mark pair as added to prevent duplicates
+                        pairs.put(sum - input[i], null);
+                    } else if (!pairs.containsValue(input[i])) {
+                        // Add pair to aux. hash map
+                        pairs.put(sum - input[i], input[i]);
+                    }
+                }
+        );
+        return allDifferentPairs;
+    }
+}
+
@@ -0,0 +1,51 @@
+package com.baeldung.pairsaddupnumber;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+
+/**
+ * Find all existing pairs of numbers in an array that add up to a given sum - Complexity O(n^2) "Brute force"
+ */
+public class ExistingPairs {
+
+    /**
+     * Show all existing pairs using traditional "for" loop
+     *
+     * @param input - number's array
+     * @param sum   - given sum
+     * @return - number's array with all existing pairs. This list will contain just one pair's element because
+     * the other one can be calculated with SUM - element_1 = element_2
+     */
+    public static List<Integer> findPairsWithForLoop(int[] input, int sum) {
+        final List<Integer> allExistingPairs = new ArrayList<>();
+        for (int i = 0; i < input.length; i++) {
+            for (int j = 0; j < input.length; j++) {
+                if (j != i && (input[i] + input[j]) == sum) {
+                    allExistingPairs.add(input[i]);
+                }
+            }
+        }
+        return allExistingPairs;
+    }
+
+    /**
+     * Show all existing pairs using Java 8 stream API
+     *
+     * @param input - number's array
+     * @param sum   - given sum
+     * @return - number's array with all existing pairs. This list will contain just one pair's element because
+     * the other one can be calculated with SUM - element_1 = element_2
+     */
+    public static List<Integer> findPairsWithStreamApi(int[] input, int sum) {
+        final List<Integer> allExistingPairs = new ArrayList<>();
+        IntStream.range(0, input.length).forEach(i ->
+                IntStream.range(0, input.length)
+                        .filter(j -> i != j && input[i] + input[j] == sum)
+                        .forEach(j -> allExistingPairs.add(input[i]))
+        );
+        return allExistingPairs;
+    }
+}
+
@@ -0,0 +1,74 @@
+package com.baeldung.pairsaddupnumber;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+
+
+public class FindPairs {
+
+    public void execute(int[] input, int sum) {
+        final StringBuilder inputArray = new StringBuilder();
+        inputArray.append("{");
+        IntStream.range(0, input.length).forEach(i -> inputArray.append(input[i] + ", "));
+        inputArray.append("}");
+        System.out.println(" Given number array: " + inputArray.toString());
+        System.out.println(" Given sum: " + sum);
+        /* Call services */
+        getDifferentPairs(input, sum);
+        getExistingPairs(input, sum);
+    }
+
+    /**
+     * Print all existing pairs for the given inputs: input array & sum number
+     */
+    private static void getExistingPairs(int[] input, int sum) {
+        List<Integer> pairs = new ArrayList<>();
+        System.out.println("~ All existing pairs ~");
+
+        /* Traditional FOR loop */
+        // Call method
+        pairs = ExistingPairs.findPairsWithForLoop(input, sum);
+        // Create a pretty printing
+        final StringBuilder output1 = new StringBuilder();
+        pairs.forEach((pair) -> output1.append("{" + pair + ", " + (sum - pair) + "}, "));
+        // Print result
+        System.out.println("Traditional \"for\" loop: " + output1.toString().substring(0, output1.length() - 2));
+
+        /* Java 8 stream API */
+        // Call the method
+        pairs = ExistingPairs.findPairsWithStreamApi(input, sum);
+        // Create a pretty printing
+        final StringBuilder output2 = new StringBuilder();
+        pairs.forEach((pair) -> output2.append("{" + pair + ", " + (sum - pair) + "}, "));
+        // Print result
+        System.out.println("Java 8 streams API: " + output2.toString().substring(0, output2.length() - 2));
+    }
+
+    /**
+     * Print all different pairs for the given inputs: input array & sum number
+     */
+    private static void getDifferentPairs(int[] input, int sum) {
+        List<Integer> pairs = new ArrayList<>();
+        System.out.println("~ All different pairs ~");
+
+        /* Traditional FOR loop */
+        // Call method
+        pairs = DifferentPairs.findPairsWithForLoop(input, sum);
+        // Create a pretty printing
+        final StringBuilder output3 = new StringBuilder();
+        pairs.forEach((pair) -> output3.append("{" + pair + ", " + (sum - pair) + "}, "));
+        // Print result
+        System.out.println("Traditional \"for\" loop: " + output3.toString().substring(0, output3.length() - 2));
+
+        /* Java 8 stream API */
+        // Call method
+        pairs = DifferentPairs.findPairsWithStreamApi(input, sum);
+        // Create a pretty printing
+        final StringBuilder output4 = new StringBuilder();
+        pairs.forEach((pair) -> output4.append("{" + pair + ", " + (sum - pair) + "}, "));
+        // Print result
+        System.out.println("Java 8 streams API: " + output4.toString().substring(0, output4.length() - 2));
+    }
+}
+
@@ -0,0 +1,19 @@
+package com.baeldung.pow;
+
+import java.text.DecimalFormat;
+
+public class PowerExample {
+
+    public static void main(String[] args) {
+
+        int intResult = (int) Math.pow(2, 3);
+        System.out.println("Math.pow(2, 3) = " + intResult);
+
+        double dblResult = Math.pow(4.2, 3);
+        System.out.println("Math.pow(4.2, 3) = " + Math.pow(4.2, 3));
+
+        DecimalFormat df = new DecimalFormat(".00");
+        System.out.println("Math.pow(4.2, 3) rounded = " + df.format(dblResult));
+
+    }
+}
@@ -0,0 +1,59 @@
+package com.baeldung.prime;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class PrimeGenerator {
+    public static List<Integer> sieveOfEratosthenes(int n) {
+        final boolean prime[] = new boolean[n + 1];
+        Arrays.fill(prime, true);
+
+        for (int p = 2; p * p <= n; p++) {
+            if (prime[p]) {
+                for (int i = p * 2; i <= n; i += p)
+                    prime[i] = false;
+            }
+        }
+
+        final List<Integer> primes = new LinkedList<>();
+        for (int i = 2; i <= n; i++) {
+            if (prime[i])
+                primes.add(i);
+        }
+        return primes;
+    }
+
+    public static List<Integer> primeNumbersBruteForce(int max) {
+        final List<Integer> primeNumbers = new LinkedList<Integer>();
+        for (int i = 2; i <= max; i++) {
+            if (isPrimeBruteForce(i)) {
+                primeNumbers.add(i);
+            }
+        }
+        return primeNumbers;
+    }
+
+    private static boolean isPrimeBruteForce(int x) {
+        for (int i = 2; i < x; i++) {
+            if (x % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static List<Integer> primeNumbersTill(int max) {
+        return IntStream.rangeClosed(2, max)
+            .filter(x -> isPrime(x))
+            .boxed()
+            .collect(Collectors.toList());
+    }
+
+    private static boolean isPrime(int x) {
+        return IntStream.rangeClosed(2, (int) (Math.sqrt(x)))
+            .allMatch(n -> x % n != 0);
+    }
+}
@@ -0,0 +1,6 @@
+log4j.rootLogger=DEBUG, A1
+
+log4j.appender.A1=org.apache.log4j.ConsoleAppender
+
+log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>