Argthtjtr

There is needed to return a stream of all words that have 3letters and more from a file. Is there better way then following, maybe using Stream.iterate:

private Stream<String> getWordsStream(String path){

    Stream.Builder<String> wordsStream = Stream.builder();

    FileInputStream inputStream = null;

    try {

        inputStream = new FileInputStream(path);

    } catch (FileNotFoundException e) {

        e.printStackTrace();

    }

    Scanner s = new Scanner(inputStream);

    s.useDelimiter("([^a-zA-Z])");

    Pattern pattern = Pattern.compile("([a-zA-Z]{3,})");

    while ((s.hasNext())){

        if(s.hasNext(pattern)){

            wordsStream.add(s.next().toUpperCase());

        }

        else {

            s.next();

        }

    }

    s.close();

    return wordsStream.build();

}

You can use Files.lines() and a Pattern:

private static final Pattern SPACES = Pattern.compile("[^a-zA-Z]+");



public static Stream<String> getWordStream(String path) throws IOException{

    return Files.lines(Paths.get(path))

        .flatMap(SPACES::splitAsStream)

        .filter(word -> word.length() >= 3);

}

The worst part of your code is the following part

FileInputStream inputStream = null;

try {

    inputStream = new FileInputStream(path);

} catch (FileNotFoundException e) {

    e.printStackTrace();

}

Scanner s = new Scanner(inputStream);

So when the file is absent, you will print the FileNotFoundException stack trace and proceed with a null input stream, leading to a NullPointerException. Instead of requiring the caller to deal with a spurious NullPointerException, you should declare the FileNotFoundException in the method signature. Otherwise, return an empty stream in the erroneous case.

But you don’t need to contruct a FileInputStream at all, as Scanner offers constructors accepting a File or Path. Combine this with the capability of returning a stream of matches (since Java 9) and you get:

private Stream<String> getWordsStream(String path) {

    try {

        Scanner s = new Scanner(Paths.get(path));

        return s.findAll("([a-zA-Z]{3,})").map(mr -> mr.group().toUpperCase());

    } catch(IOException ex) {

        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

        return Stream.empty();

    }

}

or preferably

private Stream<String> getWordsStream(String path) throws IOException {

    Scanner s = new Scanner(Paths.get(path));

    return s.findAll("([a-zA-Z]{3,})").map(mr -> mr.group().toUpperCase());

}

You don’t even need .useDelimiter("([^a-zA-Z])") here, as skipping all nonmatching stuff is the default behavior.

Closing the returned Stream will also close the Scanner.

So the caller should use it like this

try(Stream<String> s = getWordsStream("path/to/file")) {

    s.forEach(System.out::println);

}

Thre're much easier approach: read lines from file to the Stream and filter it with required condition (e.g. length >= 3). Files.lines() has lazy loading, so it does not ready all words from the file at the beginning, it does it every time when next word is required

public static void main(String... args) throws IOException {

    getWordsStream(Paths.get("d:/words.txt")).forEach(System.out::println);

}



public static Stream<String> getWordsStream(Path path) throws IOException {

    final Scanner scan = new Scanner(path);



    return StreamSupport.stream(new Spliterators.AbstractSpliterator<String>(Long.MAX_VALUE,

            Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL | Spliterator.ORDERED) {

        @Override

        public boolean tryAdvance(Consumer<? super String> action) {

            while (scan.hasNext()) {

                String word = scan.next();



                // you can use RegExp if you have more complicated condition

                if (word.length() < 3)

                    continue;



                action.accept(word);

                return true;

            }



            return false;

        }

    }, false).onClose(scan::close);

}