Java Reader Read Line readLines(Reader reader)

Here you can find the source of readLines(Reader reader)

Description

read Lines

License

Open Source License

Declaration

public static List<String> readLines(Reader reader) 

Method Source Code

//package com.java2s;
/*//from   ww w  .ja v  a 2 s.c o  m
 * $Id$
 *
 * Copyright (C) 2003-2015 JNode.org
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; If not, write to the Free Software Foundation, Inc., 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;
import java.io.Flushable;

import java.io.IOException;

import java.io.Reader;
import java.util.List;
import java.util.LinkedList;

public class Main {
    private static final int BUFFER_SIZE = 4096;
    private static final String ex_null_param = "A required paramater is null";

    public static List<String> readLines(File file) {
        BufferedReader reader = openBufferedReader(file);
        if (reader == null) {
            return null;
        }
        try {
            return readLines(reader);
        } finally {
            close(reader);
        }
    }

    public static List<String> readLines(Reader reader) {
        return readLines(new BufferedReader(reader, BUFFER_SIZE), -1);
    }

    public static List<String> readLines(BufferedReader reader) {
        return readLines(reader, -1);
    }

    /**
     * Read all of the lines from a Reader.
     *
     * Calling this is the same as readLines(new BufferedReader(reader), max)
     *
     * @param reader the source to read from
     * @param max the max number of lines to read, if this is -1 Integer.MAX_VALUE is used
     * @return a list of strings, possibly empty, or null if there was an exception.
     * @throws NullPointerException if reader is null
     */
    public static List<String> readLines(Reader reader, int max) {
        return readLines(new BufferedReader(reader, BUFFER_SIZE), max);
    }

    /**
     * Read all of the lines from a Reader.
     *
     * If there are no lines to read, an empty List will be returned.
     *
     * If there was an exception while reading, null will be returned.
     *
     * @param reader the source to read from
     * @param max the max number of lines to read, if this is -1 Integer.MAX_VALUE is used
     * @return a list of strings, possibly empty, or null if there was an exception.
     * @throws NullPointerException if reader is null
     */
    public static List<String> readLines(BufferedReader reader, int max) {
        checkNull(reader);
        List<String> ret = new LinkedList<String>();
        String line;
        int count = 0;

        try {
            if (max > 0) {
                while ((count++ < max) && (line = reader.readLine()) != null) {
                    ret.add(line);
                }
            } else {
                while ((line = reader.readLine()) != null) {
                    ret.add(line);
                }
            }
        } catch (IOException e) {
            return null;
        }

        return ret;
    }

    /**
     * Opens a BufferedReader on a file.
     *
     * This method will not throw a FileNotFoundException like the FileReader
     * constructor would.
     *
     * @param file the file to open the reader on
     * @return the reader, or null if the file could not be opened
     * @throws NullPointerException if file is null
     */
    public static BufferedReader openBufferedReader(File file) {
        return openBufferedReader(file, BUFFER_SIZE);
    }

    /**
     * Opens a BufferedReader on a file.
     * 
     * This method will not throw a FileNotFoundException like the FileReader
     * constructor would.
     *
     * @param file the file to open the reader on
     * @param bufferSize the buffer size to use for this reader
     * @return the reader, or null if the file could not be opened
     * @throws NullPointerException if file is null
     */
    public static BufferedReader openBufferedReader(File file, int bufferSize) {
        Reader reader = openReader(file);
        if (reader != null) {
            return new BufferedReader(reader, bufferSize);
        }
        return null;
    }

    /**
     * Wraps a {@code Reader} with a {@code BufferedReader}.
     *
     * @param reader the reader to wrap
     * @return a {@code BufferedReader}
     * @throws NullPointerException if reader is null
     */
    public static BufferedReader openBufferedReader(Reader reader) {
        return openBufferedReader(reader, BUFFER_SIZE);
    }

    /**
     * Wraps a {@code Reader} with a {@code BufferedReader}.
     *
     * @param reader the reader to wrap
     * @param bufferSize the size of buffer to use
     * @return a {@code BufferedReader}
     * @throws NullPointerException if reader is null
     */
    public static BufferedReader openBufferedReader(Reader reader, int bufferSize) {
        checkNull(reader);
        return new BufferedReader(reader, bufferSize);
    }

    /**
     * Call the close method of a list of Closeable objects.
     *
     * This will not throw a NullPointerException if any of the objects are null.
     * 
     * This is a convenience method that traps the exception from various
     * stream close() methods.
     *
     * @param objs one or more Closeable objects.
     */
    public static void close(Closeable... objs) {
        close(false, objs);
    }

    /**
     * Call the close method of a list of Closeable objects.
     *
     * If the flush parameter is set to true, and an object implements
     * the Flushable interface, then the flush method will be called before
     * the close method is called.
     *
     * This will not throw a NullPointerException if any of the objects are null.
     *
     * This will not throw an IOException if either the close or flush methods throw
     * an IOException.
     *
     * If calling flush causes an IOException, close will still be called.
     *
     * @param flush if true, check if the object is Flushable
     * @param objs one or more Closeable objects
     */
    public static void close(boolean flush, Closeable... objs) {
        for (Closeable obj : objs) {
            if (obj != null) {
                if (flush && (obj instanceof Flushable)) {
                    try {
                        ((Flushable) obj).flush();
                    } catch (IOException _) {
                        // ignore
                    }
                }
                try {
                    obj.close();
                } catch (IOException _) {
                    // ignore
                }
            }
        }
    }

    /**
     * Check for null objects in a list of objects.
     */
    private static void checkNull(Object... objs) {
        for (Object obj : objs) {
            if (obj == null)
                throw new NullPointerException(ex_null_param);
        }
    }

    /**
     * Opens a Reader on a file.
     * 
     * This method will not throw a FileNotFoundException like the FileReader
     * constructor would.
     *
     * @param file the file to open the reader on
     * @return the reader, or null if the file could not be opened
     * @throws NullPointerException if file is null
     */
    public static Reader openReader(File file) {
        checkNull(file);

        try {
            return new FileReader(file);
        } catch (FileNotFoundException e) {
            // fall through
        }

        return null;
    }

    /**
     * Call the flush method of a list of Flushable objects.
     *
     * This method will not throw a NullPointerException if any of the objects are null.
     *
     * This method will trap the IOException from flush.
     *
     * @param objs one or more Flushable objects
     */
    public static void flush(Flushable... objs) {
        for (Flushable obj : objs) {
            if (obj != null) {
                try {
                    obj.flush();
                } catch (IOException e) {
                    // ignore
                }
            }
        }
    }
}

Related

  1. readLines(Reader input)
  2. readLines(Reader input)
  3. readLines(Reader input)
  4. readLines(Reader input)
  5. readLines(Reader r, List lines)
  6. readLines(Reader reader)
  7. readLines(Reader reader)
  8. readLines(Reader reader)
  9. readLines(Reader reader)