package stdlib; /* *********************************************************************** * Compilation: javac In.java * Execution: java In (basic test --- see source for required files) * * Reads in data of various types from standard input, files, and URLs. * *************************************************************************/ import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.net.URISyntaxException; import java.net.URL; import java.net.URLConnection; import java.util.Scanner; import java.util.regex.Pattern; /** * Input. This class provides methods for reading strings * and numbers from standard input, file input, URLs, and sockets. *
* The Locale used is: language = English, country = US. This is consistent * with the formatting conventions with Java floating-point literals, * command-line arguments (via {@link Double#parseDouble(String)}) * and standard output. *
* For additional documentation, see * Section 3.1 of * Introduction to Programming in Java: An Interdisciplinary Approach * by Robert Sedgewick and Kevin Wayne. *
* Like {@link Scanner}, reading a token also consumes preceding Java * whitespace, reading a full line consumes * the following end-of-line delimeter, while reading a character consumes * nothing extra. *
* Whitespace is defined in {@link Character#isWhitespace(char)}. Newlines * consist of \n, \r, \r\n, and Unicode hex code points 0x2028, 0x2029, 0x0085; * see * {@code Scanner.java} (NB: Java 6u23 and earlier uses only \r, \r, \r\n). */ public final class In { private Scanner scanner; /* * begin: section (1 of 2) of code duplicated from In to StdIn */ // assume Unicode UTF-8 encoding private static final String charsetName = "UTF-8"; // assume language = English, country = US for consistency with System.out. private static final java.util.Locale usLocale = new java.util.Locale("en", "US"); // the default token separator; we maintain the invariant that this value // is held by the scanner's delimiter between calls private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\p{javaWhitespace}+"); // makes whitespace characters significant private static final Pattern EMPTY_PATTERN = Pattern.compile(""); // used to read the entire input. source: // http://weblogs.java.net/blog/pat/archive/2004/10/stupid_scanner_1.html private static final Pattern EVERYTHING_PATTERN = Pattern.compile("\\A"); /* * end: section (1 of 2) of code duplicated from In to StdIn */ /** * Create an input stream from standard input. */ public In() { scanner = new Scanner(new BufferedInputStream(System.in), charsetName); scanner.useLocale(usLocale); } /** * Create an input stream from a socket. */ public In(java.net.Socket socket) { try { InputStream is = socket.getInputStream(); scanner = new Scanner(new BufferedInputStream(is), charsetName); scanner.useLocale(usLocale); } catch (IOException ioe) { System.err.println("Could not open " + socket); } } /** * Create an input stream from a URL. */ public In(URL url) { try { URLConnection site = url.openConnection(); InputStream is = site.getInputStream(); scanner = new Scanner(new BufferedInputStream(is), charsetName); scanner.useLocale(usLocale); } catch (IOException ioe) { System.err.println("Could not open " + url); } } /** * Create an input stream from a file. */ public In(File file) { try { scanner = new Scanner(file, charsetName); scanner.useLocale(usLocale); } catch (IOException ioe) { System.err.println("Could not open " + file); } } /** * Create an input stream from a filename or web page name. */ public In(String s) { try { // first try to read file from local file system File file = new File(s); if (file.exists()) { scanner = new Scanner(file, charsetName); scanner.useLocale(usLocale); return; } // next try for files included in jar URL url = getClass().getResource(s); // or URL from web if (url == null) { url = new java.net.URI(s).toURL(); } URLConnection site = url.openConnection(); InputStream is = site.getInputStream(); scanner = new Scanner(new BufferedInputStream(is), charsetName); scanner.useLocale(usLocale); } catch (IOException ioe) { System.err.println("Could not open " + s); } catch (URISyntaxException e) { System.err.println("Could not open " + s); } } /** * Create an input stream from a given Scanner source; use with * {@code new Scanner(String)} to read from a string. *
* Note that this does not create a defensive copy, so the * scanner will be mutated as you read on. */ public In(Scanner scanner) { this.scanner = scanner; } /** * Does the input stream exist? */ public boolean exists() { return scanner != null; } /* * begin: section (2 of 2) of code duplicated from In to StdIn, * with all methods changed from "public" to "public static" ***/ /** * Is the input empty (except possibly for whitespace)? Use this * to know whether the next call to {@link #readString()}, * {@link #readDouble()}, etc will succeed. */ public boolean isEmpty() { return !scanner.hasNext(); } /** * Does the input have a next line? Use this to know whether the * next call to {@link #readLine()} will succeed.
Functionally * equivalent to {@link #hasNextChar()}. */ public boolean hasNextLine() { return scanner.hasNextLine(); } /** * Is the input empty (including whitespace)? Use this to know * whether the next call to {@link #readChar()} will succeed.
Functionally * equivalent to {@link #hasNextLine()}. */ public boolean hasNextChar() { scanner.useDelimiter(EMPTY_PATTERN); boolean result = scanner.hasNext(); scanner.useDelimiter(WHITESPACE_PATTERN); return result; } /** * Read and return the next line. */ public String readLine() { String line; try { line = scanner.nextLine(); } catch (Exception e) { line = null; } return line; } /** * Read and return the next character. */ public char readChar() { scanner.useDelimiter(EMPTY_PATTERN); String ch = scanner.next(); assert (ch.length() == 1) : "Internal (Std)In.readChar() error!" + " Please contact the authors."; scanner.useDelimiter(WHITESPACE_PATTERN); return ch.charAt(0); } /** * Read and return the remainder of the input as a string. */ public String readAll() { if (!scanner.hasNextLine()) return ""; String result = scanner.useDelimiter(EVERYTHING_PATTERN).next(); // not that important to reset delimeter, since now scanner is empty scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway return result; } /** * Read and return the next string. */ public String readString() { return scanner.next(); } /** * Read and return the next int. */ public int readInt() { return scanner.nextInt(); } /** * Read and return the next double. */ public double readDouble() { return scanner.nextDouble(); } /** * Read and return the next float. */ public float readFloat() { return scanner.nextFloat(); } /** * Read and return the next long. */ public long readLong() { return scanner.nextLong(); } /** * Read and return the next short. */ public short readShort() { return scanner.nextShort(); } /** * Read and return the next byte. */ public byte readByte() { return scanner.nextByte(); } /** * Read and return the next boolean, allowing case-insensitive * "true" or "1" for true, and "false" or "0" for false. */ public boolean readBoolean() { String s = readString(); if (s.equalsIgnoreCase("true")) return true; if (s.equalsIgnoreCase("false")) return false; if (s.equals("1")) return true; if (s.equals("0")) return false; throw new java.util.InputMismatchException(); } /** * Read all strings until the end of input is reached, and return them. */ public String[] readAllStrings() { // we could use readAll.trim().split(), but that's not consistent // since trim() uses characters 0x00..0x20 as whitespace String[] tokens = WHITESPACE_PATTERN.split(readAll()); if (tokens.length == 0 || tokens[0].length() > 0) return tokens; String[] decapitokens = new String[tokens.length-1]; for (int i = 0; i < tokens.length-1; i++) decapitokens[i] = tokens[i+1]; return decapitokens; } /** * Read all ints until the end of input is reached, and return them. */ public int[] readAllInts() { String[] fields = readAllStrings(); int[] vals = new int[fields.length]; for (int i = 0; i < fields.length; i++) vals[i] = Integer.parseInt(fields[i]); return vals; } /** * Read all doubles until the end of input is reached, and return them. */ public double[] readAllDoubles() { String[] fields = readAllStrings(); double[] vals = new double[fields.length]; for (int i = 0; i < fields.length; i++) vals[i] = Double.parseDouble(fields[i]); return vals; } /* * end: section (2 of 2) of code duplicated from In to StdIn */ /** * Close the input stream. */ public void close() { scanner.close(); } /** * Reads all ints from a file * @deprecated Clearer to use * {@code new In(filename)}.{@link #readAllInts()} */ @Deprecated public static int[] readInts(String filename) { return new In(filename).readAllInts(); } /** * Reads all doubles from a file * @deprecated Clearer to use * {@code new In(filename)}.{@link #readAllDoubles()} */ @Deprecated public static double[] readDoubles(String filename) { return new In(filename).readAllDoubles(); } /** * Reads all strings from a file * @deprecated Clearer to use * {@code new In(filename)}.{@link #readAllStrings()} */ @Deprecated public static String[] readStrings(String filename) { return new In(filename).readAllStrings(); } /** * Reads all ints from stdin * @deprecated Clearer to use {@link StdIn#readAllInts()} */ @Deprecated public static int[] readInts() { return new In().readAllInts(); } /** * Reads all doubles from stdin * @deprecated Clearer to use {@link StdIn#readAllDoubles()} */ @Deprecated public static double[] readDoubles() { return new In().readAllDoubles(); } /** * Reads all strings from stdin * @deprecated Clearer to use {@link StdIn#readAllStrings()} */ @Deprecated public static String[] readStrings() { return new In().readAllStrings(); } /** * Return true if the next value from the input stream can be interpreted as an int */ public boolean hasNextInt() { return scanner.hasNextInt(); } /** * Return true if the next value from the input stream can be interpreted as an double */ public boolean hasNextDouble() { return scanner.hasNextDouble(); } /** * Return true if the next value from the input stream can be interpreted as an float */ public boolean hasNextFloat() { return scanner.hasNextFloat(); } /** * Return true if the next value from the input stream can be interpreted as a long */ public boolean hasNextLong() { return scanner.hasNextLong(); } /** * Return true if the next value from the input stream can be interpreted as a byte */ public boolean hasNextByte() { return scanner.hasNextByte(); } /** * Test client. */ public static void main(String[] args) { In in; String urlName = "http://introcs.cs.princeton.edu/stdlib/InTest.txt"; // read from a URL System.out.println("readAll() from URL " + urlName); System.out.println("---------------------------------------------------------------------------"); try { in = new In(urlName); System.out.println(in.readAll()); } catch (Exception e) { System.out.println(e); } System.out.println(); // read one line at a time from URL System.out.println("readLine() from URL " + urlName); System.out.println("---------------------------------------------------------------------------"); try { in = new In(urlName); while (!in.isEmpty()) { String s = in.readLine(); System.out.println(s); } } catch (Exception e) { System.out.println(e); } System.out.println(); // read one string at a time from URL System.out.println("readString() from URL " + urlName); System.out.println("---------------------------------------------------------------------------"); try { in = new In(urlName); while (!in.isEmpty()) { String s = in.readString(); System.out.println(s); } } catch (Exception e) { System.out.println(e); } System.out.println(); // read one line at a time from file in current directory System.out.println("readLine() from current directory"); System.out.println("---------------------------------------------------------------------------"); try { in = new In("./InTest.txt"); while (!in.isEmpty()) { String s = in.readLine(); System.out.println(s); } } catch (Exception e) { System.out.println(e); } System.out.println(); // read one line at a time from file using relative path System.out.println("readLine() from relative path"); System.out.println("---------------------------------------------------------------------------"); try { in = new In("../stdlib/InTest.txt"); while (!in.isEmpty()) { String s = in.readLine(); System.out.println(s); } } catch (Exception e) { System.out.println(e); } System.out.println(); // read one char at a time System.out.println("readChar() from file"); System.out.println("---------------------------------------------------------------------------"); try { in = new In("InTest.txt"); while (!in.isEmpty()) { char c = in.readChar(); System.out.print(c); } } catch (Exception e) { System.out.println(e); } System.out.println(); System.out.println(); // read one line at a time from absolute OS X / Linux path System.out.println("readLine() from absolute OS X / Linux path"); System.out.println("---------------------------------------------------------------------------"); in = new In("/n/fs/introcs/www/java/stdlib/InTest.txt"); try { while (!in.isEmpty()) { String s = in.readLine(); System.out.println(s); } } catch (Exception e) { System.out.println(e); } System.out.println(); // read one line at a time from absolute Windows path System.out.println("readLine() from absolute Windows path"); System.out.println("---------------------------------------------------------------------------"); try { in = new In("G:\\www\\introcs\\stdlib\\InTest.txt"); while (!in.isEmpty()) { String s = in.readLine(); System.out.println(s); } System.out.println(); } catch (Exception e) { System.out.println(e); } System.out.println(); } }