WC.java

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/*
 * This source code is provided to illustrate the usage of a given feature
 * or technique and has been deliberately simplified. Additional steps
 * required for a production-quality application, such as security checks,
 * input validation, and proper error handling, might not be present in
 * this sample code.
 */
 
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.function.Consumer;
import java.util.regex.Pattern;
 
public class WC {
 
    //The number of characters that may be read.
    private static final int READ_AHEAD_LIMIT = 100_000_000;
 
    //The pattern for splitting strings by non word characters to get words.
    private static final Pattern nonWordPattern = Pattern.compile("\\W");
 
    public static void main(String[] args) throws IOException {
 
        if (args.length != 1) {
            usage();
            return;
        }
 
        try (BufferedReader reader = new BufferedReader(
                new FileReader(args[0]))) {
            reader.mark(READ_AHEAD_LIMIT);
            /*
             * Statistics can be gathered in four passes using a built-in API.
             * The method demonstrates how separate operations can be
             * implemented using a built-in API.
             */
            collectInFourPasses(reader);
            /*
             * Usage of several passes to collect data is not the best way.
             * Statistics can be gathered by a custom collector in one pass.
             */
            reader.reset();
            collectInOnePass(reader);
        } catch (FileNotFoundException e) {
            usage();
            System.err.println(e);
        }
    }
 
    private static void collectInFourPasses(BufferedReader reader)
            throws IOException {
        /*
         * Input is read as a stream of lines by lines().
         * Every line is turned into a stream of chars by the flatMapToInt(...)
         * method.
         * Length of the stream is counted by count().
         */
        System.out.println("Character count = "
                + reader.lines().flatMapToInt(String::chars).count());
        /*
         * Input is read as a stream of lines by lines().
         * Every line is split by nonWordPattern into words by flatMap(...)
         * method.
         * Empty lines are removed by the filter(...) method.
         * Length of the stream is counted by count().
         */
        reader.reset();
        System.out.println("Word count = "
                + reader.lines()
                .flatMap(nonWordPattern::splitAsStream)
                .filter(str -> !str.isEmpty()).count());
 
        reader.reset();
        System.out.println("Newline count = " + reader.lines().count());
        /*
         * Input is read as a stream of lines by lines().
         * Every line is mapped to its length.
         * Maximum of the lengths is calculated.
         */
        reader.reset();
        System.out.println("Max line length = "
                + reader.lines().mapToInt(String::length).max().getAsInt());
    }
 
    private static void collectInOnePass(BufferedReader reader) {
        /*
         * The collect() method has three parameters:
         * The first parameter is the {@code WCStatistic} constructor reference.
         * collect() will create {@code WCStatistics} instances, where
         * statistics will be aggregated.
         * The second parameter shows how {@code WCStatistics} will process
         * String.
         * The third parameter shows how to merge two {@code WCStatistic}
         * instances.
         *
         * Also {@code Collector} can be used, which would be more reusable
         * solution. See {@code CSVProcessor} example for how {@code Collector}
         * can be implemented.
         *
         * Note that the any performance increase when going parallel will
         * depend on the size of the input (lines) and the cost per-element.
         */
        WCStatistics wc = reader.lines().parallel()
                .collect(WCStatistics::new,
                        WCStatistics::accept,
                        WCStatistics::combine);
        System.out.println(wc);
    }
 
    private static void usage() {
        System.out.println("Usage: " + WC.class.getSimpleName() + " FILE");
        System.out.println("Print newline, word,"
                + "  character counts and max line length for FILE.");
    }
 
    private static class WCStatistics implements Consumer<String> {
        /*
         * @implNote This implementation does not need to be thread safe because
         * the parallel implementation of
         * {@link java.util.stream.Stream#collect Stream.collect()}
         * provides the necessary partitioning and isolation for safe parallel
         * execution.
         */
 
        private long characterCount;
        private long lineCount;
        private long wordCount;
        private long maxLineLength;
 
 
        /*
         * Processes line.
         */
        @Override
        public void accept(String line) {
            characterCount += line.length();
            lineCount++;
            wordCount += nonWordPattern.splitAsStream(line)
                    .filter(str -> !str.isEmpty()).count();
            maxLineLength = Math.max(maxLineLength, line.length());
        }
 
        /*
         * Merges two WCStatistics.
         */
        public void combine(WCStatistics stat) {
            wordCount += stat.wordCount;
            lineCount += stat.lineCount;
            characterCount += stat.characterCount;
            maxLineLength = Math.max(maxLineLength, stat.maxLineLength);
        }
 
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("#------WCStatistic------#\n");
            sb.append("Character count = ").append(characterCount).append('\n');
            sb.append("Word count = ").append(wordCount).append('\n');
            sb.append("Newline count = ").append(lineCount).append('\n');
            sb.append("Max line length = ").append(maxLineLength).append('\n');
            return sb.toString();
        }
    }
}