Java 8 Streams

Réussis tes devoirs et examens dès maintenant avec Quizwiz!

List seven methods of PrintWriter

*F-P-P-P-W-F-C* format() printf() println() print() write() flush() close()

List six methods of Files class located in java.nio.file.Files

*M-C-N-E-D-D* - ALL *Static methods* path *move*(Path scr, Path des, CopyOption... options) path *copy*(Path scr, Path des, CopyOption... options) boolean *notExists*( Path path, LinkOption... options) boolean *exists*( Path path, LinkOption... options) void *delete*(Path path) boolean *deleteIfExists*( Path path)

List 8 methods in File class

*M-E-D-I-I-C-L-R* mkdir() exists() delete() isDirectory() isFile() createNewFile() list() renameTo()

List 4 methods of BufferedWriter

*N-W-F-C* newLine() write() flush() close()

List 3 methods of FileWriter

*W-F-C* write() flush() close()

What method am I? Closes the stream and releases any system resources associated with it.

*close()* located in: FileWriter BufferedWriter PrintWriter

FileWriter BufferedWriter PrintWriter All contain two common methods. Named them.

*flush()* and *close()*. *flush()*: guarantees that the last of the data gets written to disk. *close()*: Closes the stream and releases any system resources associated with it.

What method am I? guarantees that the last of the data gets written to disk.

*flush()* located in: FileWriter BufferedWriter PrintWriter

What is the output of this program? class output { public static void main(String args[]) { StringBuffer s1 = new StringBuffer("Hello World"); s1.insert(6 , "Good "); System.out.println(s1); } } a) HelloGoodWorld b) HellGoodoWorld c) HellGood oWorld d) Hello Good World

What is the output of this program? class output { public static void main(String args[]) { StringBuffer c = new StringBuffer("Hello"); StringBuffer c1 = new StringBuffer(" World"); c.append(c1); System.out.println(c); } } a) Hello b) World c) Helloworld d) Hello World

What is the output of this program? import java.io.*; class Chararrayinput { public static void main(String[] args) { String obj = "abcdefgh"; int length = obj.length(); char c[] = new char[length]; obj.getChars(0, length, c, 0); CharArrayReader input1 = new CharArrayReader(c); CharArrayReader input2 = new CharArrayReader(c, 1, 4); int i; int j; try { while((i = input1.read()) == (j = input2.read())) { System.out.print((char)i); } } catch (IOException e) { e.printStackTrace(); } } } a) abc b) abcd c) abcde d) None of the mentioned

What is the output of this program? import java.io.*; public class filesinputoutput { public static void main(String[] args) { String obj = "abc"; byte b[] = obj.getBytes(); ByteArrayInputStream obj1 = new ByteArrayInputStream(b); for (int i = 0; i < 2; ++ i) { int c; while((c = obj1.read()) != -1) { if(i == 0) { System.out.print(Character.toUpperCase((char)c)); obj2.write(1); } } System.out.print(obj2); } } } a) AaBaCa b) ABCaaa c) AaaBaaCaa d) AaBaaCaaa

OutputStream object's helper methods

- can be used to write to stream or to do other operations on the stream. - public void close() throws IOException{} -protected void finalize()throws IOException {} -public void write(int w)throws IOException{} -public void write(byte[] w)

java.io package

- contains nearly every class you might ever need to perform input and output (I/O) in Java - All these streams represent an input source and an output destination - The stream in the java.io package supports many data such as primitives, object, localized characters, etc.

what is optional

- either a wrapper for an object or no object - intended to be null safe

FileInputStream

- is used for reading data from the files. - Objects can be created using the keyword new and there are several types of constructors available. InputStream f = new FileInputStream("C:/java/hello"); or File f = new File("C:/java/hello"); InputStream f = new FileInputStream(f);

FileOutputStream

- is used to create a file and write data into it. - The stream would create a file, if it doesn't already exist, before opening it for output. ex1: OutputStream f = new FileOutputStream("C:/java/hello") ex2: File f = new File("C:/java/hello"); OutputStream f = new FileOutputStream(f);

define stateful vs stateless operation

-incorporate state from previously processed elements when processing the current element -cannot be processed individually, they need to be compared with one another thus requiring information to be retained -can be processed without the need for sharing information between them for processing -retain no state during the execution of the pipeline.

Flush in Buffer Steams

1. Flush is valid for only Output streams. 2. Some buffered output classes support autoflush, specified by an optional constructor argument 3. When auto-flush is enabled certain key events cause the buffer to be flushed. e.g autoflush Printwriter object flushes the buffer on every invocation of println or format.

Which of the following exceptions will be thrown by the reset() method if the markSupported() method returns false? A IOException B UnsupportedEncodingException C InterruptedException D SocketException

A IOException

Which subclass of OutputStream is used to write data onto a network connection? A TelnetOutputStream B FileOutputStream C ByteArrayOutputStream D NetworkOutputStream

A TelnetOutputStream

LineNumberReader

A buffered character-input stream that keeps track of line numbers.

StringWriter

A character stream that collects its output in a string buffer, which can then be used to construct a string.

Which of the following methods forcefully breaks the deadlock to send the buffered stream data even if the buffer isn't yet filled? A flush() B read() C close() D write()

A flush()

PipedInputStream

A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream.

Which of the following is a valid PrintStream method? A public void println() B public void print() C public void printerln() D public void printer()

A public void println()

What is a method of the Writer class? A public void write(int c) throws IOException B public void writen(char[] text) throws IOException C public void writer(String s) throws IOException D public void writer(String s, int offset, int length) throws IOException

A public void write(int c) throws IOException

List the six main I/O classes in Java 7 API

Abbreviation: *F-F-F-B-B-P* File FileWriter FileReader BufferedReader BufferedWriter PrintWriter

Reader

Abstract class for reading character streams.

FilterReader

Abstract class for reading filtered character streams.

FilterWriter

Abstract class for writing filtered character streams.

Writer

Abstract class for writing to character streams.

ObjectOutputStream

An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.

OutputStreamWriter

An OutputStreamWriter is a bridge from character streams to byte streams: Characters written to it are encoded into bytes using a specified charset.

What class am I? Low-level FileWriter more efficient

BufferedWriter class

BufferedWriter makes low - level _____ more _____

BufferedWriter makes low - level *FileWriter* more *EFFICIENT*

15.7.2 Q2: Which of the following statements is false? a. A LineNumberReader is a buffered character stream that tracks the number of lines read. b. Classes FileReader and FileWriter perform character-based file I/O. c. Class PipedReader and class PipedWriter implement piped-character streams for transferring data between threads. d. Class StringReader and StringWriter read characters from and write characters to Streams, respectively.

Class StringReader and StringWriter read characters from and write characters to Streams, respectively. Actually, class StringReader and StringWriter read characters from and write characters to Strings, respectively.

collectors - string

Collectors.joining() Collectors.joining(CharSequence delimiter) Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

collectors - optional

Collectors.maxBy(Predicate<T> test) Collectors.minBy(Predicate<T> test) Collectors.reducing(BinaryOperator<T> op)

collectors - partitioningBy

Collectors.partitioningBy(Predicate<T> classifier) Collectors.partitioningBy(Predicate<T> classifier, Collector downstreamCollector) e.g. Map<Boolean, List<Locale>> englishAndOtherLocales = locales.collect(Collectors.partitioningBy(l -> l.getLanguage().equals("en"))); List<Locale>> englishLocales = englishAndOtherLocales.get(true);

collectors - reducing overloaded

Collectors.reducing(T seed, BinaryOperator<T> op) Collectors.reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator op)

Console is useful to write _____ engines for _____ _____

Console is useful to write *TEST* engines for *UNIT TESTING*

Console makes it easy to accept input from _____ _____

Console makes it easy to accept input from *COMMAND LINE*

C.R.U.D

Create Retrieve Update Delete

Which of the following is not a valid method of the DataOutputStream? A public final void writeInt(int i) throws IOException B public final void writeLong(long l) throws IOException C public final void writeFloat(float f) throws IOException D public final void writeChar(String s) throws IOException

D public final void writeChar(String s) throws IOException

In File class close() method guarantees the last data gets written to disk. True or false

False. *close() frees* up expensive operating *system resources*

What class do you need to use to work with Files?

File Class ---> import java.io.FILE

What class am I? I make a new empty file but not the data. I search for files and delete files

File class

File class makes a new _____file but not the _____ .

File class makes a new *EMPTY* file but not the *DATA*. It contains a number of other functions in methods: *exists()*- Tests whether the file or directory denoted by this abstract pathname exists. *isFile()* - Tests whether the file denoted by this abstract pathname is a normal file. *isDirectory()* - Tests whether the file denoted by this abstract pathname is a directory. *mkdirs()* - Creates the directory named by this abstract pathname, including any necessary but nonexistent parent directories. *mkdir()* - Creates the directory named by this abstract pathname. etc.

FileWriter class _____ characters (single or _____ ) in a stream of _____ to a file.

FileWriter class *WRITES* characters (single or *WHOLE*) in a stream of *CHARS* to a file.

FileWriter writes single _________ at a time to file

FileWriter writes single *chars* at a time to file

binary files

Files created using byte-based streams - are read by programs that understand the specific content of the file and the ordering of that content.

text files

Files created using character-based streams - can be read by text editors

JDK 1.0's I/O capabilities are suitable for streaming bytes, but cannot properly stream characters because they don't account for character encodings. JDK 1.1 overcame this problem by introducing writer/reader classes that take character encodings into account. For example, the java.io package includes FileWriter and FileReader classes for writing and reading character streams.

How are character encodings handled in classic I/O?

File content can be accessed sequentially or randomly.

How can file content be accessed?

using parsing methods

How can you convert a numeric string such as "123.23" into its binary equivalent?

The java.io package's classes default to resolving relative paths against the current user (also known as working) directory, which is identified by the system property user.dir and which is typically the directory in which the JVM was launched. (You obtain a system property value by calling the java.lang.System class's getProperty() method.)

How do you obtain the current user (also known as working) directory?

JDK 1.4 supports readiness selection by providing selectors, which are instances of the java.nio.channels.Selector class that can examine one or more channels and determine which channels are ready for reading or writing. This way a single thread can manage multiple channels (and, therefore, multiple network connections) efficiently. Being able to use fewer threads is advantageous where thread creation and thread context switching is expensive in terms of performance and/or memory use.

How does JDK support "readiness selection"?

JDK 1.4 supports regular expressions via the java.util.regex package and its Pattern and Matcher classes.

How does JDK support regular expressions?

Java provides the java.nio.channels.ScatteringByteChannel interface to support scattering and the java.nio.channels.GatheringByteChannel interface to support gathering. ScatteringByteChannel offers the following methods: long read(ByteBuffer[] buffers, int offset, int length) long read(ByteBuffer[] buffers) GatheringByteChannel offers the following methods: long write(ByteBuffer[] buffers, int offset, int length) long write(ByteBuffer[] buffers)

How does Java support Scatter/Gather I/O?

Java supports channels via its java.nio.channels and java.nio.channels.spi packages. Applications interact with the types located in the former package; developers who are defining new selector providers work with the latter package.

How does Java support channels?

Files can be created and/or opened for random access in which a mixture of write and read operations at various locations can occur until the file is closed. Java supports this random access by providing a java.io.RandomAccessFile class.

How does Java support random access?

I/O is classified as block-oriented or stream-oriented. Reading from or writing to a file is an example of block-oriented I/O. In contrast, reading from the keyboard or writing to a network connection is an example of stream-oriented I/O.

How is I/O classified?

1. RandomAccessFile(File file, String mode): Create and open a new file when it doesn't exist or open an existing file. The file is identified by file's abstract path and is created and/or opened according to mode. 2. RandomAccessFile(String path, String mode): Create and open a new file when it doesn't exist or open an existing file. The file is identified by path and is created and/or opened according to mode.

How many constructors were declared in RandomAccessFile class?

Buffers possess four properties: - Capacity: The total number of data items that can be stored in the buffer. The capacity is specified when the buffer is created and cannot be changed later. - Limit: The zero-based index of the first element that should not be read or written. In other words, it identifies the number of "live" data items in the buffer. - Position: The zero-based index of the next data item that can be read or the location where the data item can be written. - Mark: A zero-based index to which the buffer's position will be reset when the buffer's reset() method (presented shortly) is called. The mark is initially undefined. These four properties are related as follows: 0 <= mark <= position <= limit <= capacity

How many properties does a buffer posses?

When you are done with a stream, you will often want to look at its elements. You can call the iterator method, which yields an old-fashioned iterator that you can use to visit the elements. Alternatively, you can call the forEach method to apply a function to each element: stream.forEach(System.out::println); On a parallel stream, the forEach method traverses elements in arbitrary order. If you want to process them in stream order, call forEachOrdered instead.

How to collect results from a stream?

For collecting stream elements to another target, there is a convenient collect method that takes an instance of the Collector interface. The Collectors class provides a large number of factory methods for common collectors. To collect a stream into a list or set, simply call List<String> result = stream.collect(Collectors.toList()); Set<String> result = stream.collect(Collectors.toSet()); TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet::new));

How to collect stream result to collection?

Use Collectors.toMap: Map<Integer, String> idToName = people.collect( Collectors.toMap(Person::getId, Person::getName));

How to collect stream results to a map?

String[] result = stream.toArray(String[]::new);

How to collect stream results to an array?

To create a File instance, call a constructor such as File(String path), which creates a File instance that stores the path string: File file1 = new File("/x/y");

How to create a File instance?

ByteBuffer and the other primitive-type buffer classes declare various class methods for creating a buffer of that type. For example, ByteBuffer declares the following class methods for creating ByteBuffer instances: - ByteBuffer allocate(int capacity) - ByteBuffer allocateDirect(int capacity) - ByteBuffer wrap(byte[] array) - ByteBuffer wrap(byte[] array, int offset, int length) ByteBuffer buffer = ByteBuffer.allocate(10); byte[] bytes = new byte[200]; ByteBuffer buffer2 = ByteBuffer.wrap(bytes);

How to create a buffer?

If you want to write a method that creates an Optional object, there are several static methods for that purpose, including Optional.of(result) and Optional.empty(). public static Optional<Double> inverse(Double x) { return x == 0 ? Optional.empty() : Optional.of(1 / x); }

How to create optional values?

IntStream stream = IntStream.of(1, 1, 2, 3, 5); stream = Arrays.stream(values, from, to); // values is an int[] array IntStream zeroToNinetyNine = IntStream.range(0, 100); // Upper bound is excluded IntStream zeroToHundred = IntStream.rangeClosed(0, 100); // Upper bound is included

How to create primitive type streams?

Read-only view buffers can be created by calling a method such as ByteBuffer asReadOnlyBuffer(). Any attempt to change a read-only view buffer's content results in ReadOnlyBufferException. However, the original buffer content (provided that it isn't read-only) can be changed, and the read-only view buffer will reflect these changes.

How to create read-only view buffer?

Using stream() or parallelStream() methods

How to create stream from Collection interface?

Using the static Stream.of() method. Stream<String> words = Stream.of(contents.split("\\PL+")); Stream<String> song = Stream.of("gently", "down", "the", "stream"); Use Arrays.stream(array, from, to) to make a stream from array elements between positions from (inclusive) and to (exclusive). To make a stream with no elements, use the static Stream.empty method

How to create stream from an array?

The JDK provides a serialver tool for calculating the SUID. For example, to generate an SUID for Employee class, change to the directory containing Employee.class and execute the following command: $ serialver Employee

How to generate SUID?

Normally, the serialization mechanism writes out a class's instance fields to the underlying output stream. However, you can prevent this from happening by declaring a private void writeObject(ObjectOutputStream oos) method in that class. When the serialization mechanism discovers this method, it calls the method instead of automatically outputting instance field values. The only values that are output are those explicitly output via the method. Conversely, the deserialization mechanism assigns values to a class's instance fields that it reads from the underlying input stream. However, you can prevent this from happening by declaring a private void readObject(ObjectInputStream ois) method. When the deserialization mechanism discovers this method, it calls the method instead of automatically assigning values to instance fields. The only values that are assigned to instance fields are those explicitly assigned via the method.

How to implement custom serialization and deserialization in Java?

You can mark a buffer by invoking the mark() method and later return to the marked position by invoking reset().

How to mark a buffer?

There are two ways to obtain a channel: - The java.nio.channels package provides a Channels utility class that offers two methods for obtaining channels from streams. For each of the following methods, the underlying stream is closed when the channel is closed, and the channel isn't buffered: 1. WritableByteChannel newChannel(OutputStream outputStream) returns a writable byte channel for the given outputStream. 2. ReadableByteChannel newChannel(InputStream inputStream) returns a readable byte channel for the given inputStream. - Various classic I/O classes have been retrofitted to support channel creation. For example, java.io.RandomAccessFile declares a FileChannel getChannel() method for returning a file channel, and java.net.Socket declares a SocketChannel getChannel() method for returning a socket channel.

How to obtain a channel?

Use one of the summarizing(Int|Long|Double) methods: IntSummaryStatistics summary = stream.collect( Collectors.summarizingInt(String::length)); double averageWordLength = summary.getAverage(); double maxWordLength = summary.getMax();

How to reduce the stream results to a sum, average, maximum, or minimum?

For sorting a stream, there are several variations of the sorted method. One works for streams of Comparable elements, and another accepts a Comparator. Stream<String> longestFirst = words.stream().sorted(Comparator.comparing(String::length).reversed());

How to sort a stream?

Your first task is to have the class of the object that's to be serialized implement the java.io.Serializable interface, either directly or indirectly via the class's superclass. The rationale for implementing Serializable is to avoid unlimited serialization. Your second task is to work with the ObjectOutputStream class and its writeObject() method to serialize an object and the OutputInputStream class and its readObject() method to deserialize the object. ObjectOutputStream oos = null; ObjectInputStream ois = null; try { FileOutputStream fos = new FileOutputStream(FILENAME); oos = new ObjectOutputStream(fos); Employee emp = new Employee("John Doe", 36); oos.writeObject(emp); oos.close(); oos = null; FileInputStream fis = new FileInputStream(FILENAME); ois = new ObjectInputStream(fis); emp = (Employee) ois.readObject(); // (Employee) cast is necessary. ois.close(); System.out.println(emp.getName()); System.out.println(emp.getAge()); } catch (ClassNotFoundException cnfe) { System.err.println(cnfe.getMessage()); } catch (IOException ioe) { System.err.println(ioe.getMessage()); } finally { if (oos != null) try { oos.close(); } catch (IOException ioe) { assert false; // shouldn't happen in this context } if (ois != null) try { ois.close(); } catch (IOException ioe) { assert false; // shouldn't happen in this context } }

How to use default serialization and deserialization?

The key to using Optional effectively is to use a method that either produces an alternative if the value is not present, or consumes the value only if it is present. String result = optionalString.orElse(""); String result = optionalString.orElseGet(() -> Locale.getDefault().getDisplayName()); String result = optionalString.orElseThrow(IllegalStateException::new); optionalValue.ifPresent(v -> results.add(v)); or optionalValue.ifPresent(results::add);

How to use optionals?

ByteBuffer and the other primitive-type buffer classes declare several overloaded put() and get() methods for writing data items to and reading data items from a buffer. These methods are absolute when they require an index argument or relative when they don't require an index. ByteBuffer buffer = ByteBuffer.allocate(7); buffer.put((byte) 10).put((byte) 20).put((byte) 30); for (int i = 0; i < buffer.position(); i++) System.out.println(buffer.get(i));

How to write to and read from a buffer?

The InputStream class also has three less commonly used methods that allow programs to back up and reread data they've already read. These are:

In order to reread data, mark the current position in the stream with the mark() method. At a later point, you can reset the stream to the marked position using the reset() method *In practice, more streams don't support marking and resetting than do (check via "markSupported()")

throw IOException

Industrial strength file, and directory, processing programs require extensive exception handling to recover from such possibilities

What kind of stream would you use to read data into a program?

Input stream

InputStreamReader and OutputStreamWriter mechanism

InputStreamReader contains an underlying input stream from which it reads raw bytes. It translates these bytes into Unicode characters according to a specified encoding. An OutputStreamWriter receives Unicode characters from a running program. It then translates those characters into bytes using a specified encoding and writes the bytes onto an underlying output stream

FilenameFilter

Instances of classes that implement this interface are used to filter filenames.

FileDescriptor

Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific structure representing an open file, an open socket, or another source or sink of bytes.

RandomAccessFile

Instances of this class support both reading and writing to a random access file.

Primitive Supplier classes and method

IntSupplier - getAsInt() LongSupplier - getAsLong() DoubleSupplier - getAsDouble()

how to create Primitive Stream

EOFException

Method readObject throws if an attempt is made to read beyond the end of the file

ClassNotFoundException

Method readObject throws if the class for the object being read cannot be located

What does the File class contain?

Methods for obtaining file and directory properties ->length of a file ->path of a file ->check if file exists

Console

Methods to access the character-based console device, if any, associated with the current Java virtual machine.

Chaining a BufferedReader to the InputStreamReader example

Methods: public BufferedReader(Reader in, int bufferSize) public BufferedReader(Reader in)public BufferedWriter(Writer out)public BufferedWriter(Writer out, int bufferSize)

ObjectInput

ObjectInput extends the DataInput interface to include the reading of objects.

readObject

ObjectInput interface method reads and returns a reference to an Object from an InputStream.

ObjectOutput

ObjectOutput extends the DataOutput interface to include writing of objects.

writeObject

ObjectOutput interface method takes an Object as an argument and writes its information to an OutputStream.

DirectoryStream interface

Objects of classes that implement this interface enable a program to iterate through the contents of a directory.

Path interface

Objects of classes that implement this interface represent the location of a file or directory. Path objects do not open files or provide any file-processing capabilities.

Which of these class contains the methods print() & println()? a) System b) System.out c) BUfferedOutputStream d) PrintStream

Which of these class is used to read from byte array? a) InputStream. b) BufferedInputStream. c) ArrayInputStream. d) ByteArrayInputStream.

Which of these is used to read a string from the input stream? a) get() b) getLine() c) read() d) readLine()

Which of these methods can be used to writing console output? a) print() b) println() c) write() d) All of the mentioned

15.3 Q7: Which of the following statements is false? a. Path method isAbsolute returns a boolean indicating whether a Path represents an absolute path to a file or directory. b. Files static method getLastModifiedTime receives a Path and returns a FileTime (package java.nio.file.attribute) indicating when the file was last modified. c. Files static method size receives a Path and returns a long representing the number of bytes in the file or directory. For directories, the value returned is platform specific. d. All of the above are true.

d All of the above are true.

Path is an: a) abstract class b) static class c) class d) interface

d is correct

Externalizable

Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.

Pipe lining

Operations can be viewed as a database-like query on the data source.

3 ways to create Optional<T>

Optional.of(T t) Optional.empty() Optional.ofNullable(T t)

optional reduction operations

Optional<T> max(Comparator<? super T> comparator) Optional<T> min(Comparator<? super T> comparator) Optional<T> findAny() Optional<T> findFirst() Optional<T> reduce(BinaryOperator<T> accumulator) e.g. values.reduce((x,y) -> x+y)

What kind of stream would you use to write data from a program?

Output stream

We can write data to a file by using a/an ______

OutputStream

Look at the following header void displayPoint(Point<Number> myPoint) Which of the following objects would we be allowed to pass as an argument to the displayPoint method?

Point<Number> p;

What class am I? Prints formatted representations of objects to a text-output stream.

PrintWriter class

PrintWriter class prints _____ representations of _____ to a text output stream

PrintWriter class prints *FORMATTED* representations of *OBJECTS* to a text output stream

A.java and Log.txt below are located in folder: C:\a What is the output when code run? import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 =Paths.get("Log.txt"); System.out.println( p1.isAbsolute()); }}

Prints false As Paths.get("*Log.txt*"); is *not* an *absolute path* it is a *relative* path. The following would return true: Path p1 = Paths.get("*C:\\a\\Log.txt*"); indicating an *absolute path* to Log.txt

ObjectInputStream.GetField

Provide access to the persistent fields read from the input stream.

ObjectOutputStream.PutField

Provide programmatic access to the persistent fields to be written to ObjectOutput.

Paths class

Provides static methods used to get a Path object representing a file or directory location.

BufferedReader

Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

Draw an Input stream diagram

SOURCE ---> INPUT STREAM ---> PROGRAM In the input stream there is data that is waiting to be consumed by something, in this case, the program

Standard Streams

STDIN, STDOUT and STDERR.

ObjectStreamClass

Serialization's descriptor for classes.

A/An ______ is used to accept connections from remote Sockets

ServerSocket

Data processing operations

Stream operations can be executed either sequentially or in parallel

2 ways to create infinite streams

Stream.generate(Supplier<T> s) Stream.iterate(T seed, UnaryOperator<T> f) e.g. Stream<String> s1 = Stream.generate(()->"echo"); Stream<String> s2 = Stream.generate(Math::random); Stream<BigInteger> s3 = Stream.iterate(BigInteger.ZERO, n -> n .add(BigInteger.ONE)); p.s. using infinite streams can cause hang

3 ways to create finite streams

Stream.of(T t) Stream.of(T... t) Stream.empty()

Source

Streams consume from a data-providing source such as collections, arrays, or I/O resources.

What is the most important concept about FILE IO?

Streams, the core concept in Java IO.

InputStream

This abstract class is the superclass of all classes representing an input stream of bytes.

OutputStream

This abstract class is the superclass of all classes representing an output stream of bytes.

StringBufferInputStream Deprecated

This class does not properly convert characters into bytes.

CharArrayReader

This class implements a character buffer that can be used as a character-input stream.

CharArrayWriter

This class implements a character buffer that can be used as an Writer.

SerializablePermission

This class is for Serializable permissions.

FilterOutputStream

This class is the superclass of all classes that filter output streams.

What are some properties of the FileOutputStream?

This class makes it possible to write to a file as a stream of bytes

Standard Streams : Standard Output

This is used to output the data produced by the user's program and usually a computer screen is used for standard output stream and represented as System.out.

Standard Streams : Standard Error

This is used to output the error data produced by the user's program and usually a computer screen is used for standard error stream and represented as System.err.

T/F: In Java all output streams have the same basic methods to write data and all input streams use the same basic methods to read data

True

File offers additional constructors for instantiating this class. For example, the following constructors merge parent and child paths into combined paths that are stored in File objects: - File(String parent, String child) creates a new File instance from a parent path string and a child path string. - File(File parent, String child) creates a new File instance from a parent path File instance and a child path string. File file3 = new File("prj/books/", "io");

What are additional constructors for File class?

Buffers are the foundation for NIO operations. Essentially, NIO is all about moving data into and out of buffers. A process such as the JVM performs I/O by asking the operating system to drain a buffer's contents to storage via a write operation. Similarly, it asks the operating system to fill a buffer with data read from a storage device.

What are buffers?

- "r" informs the constructor to open an existing file for reading only. Any attempt to write to the file results in a thrown instance of the java.io.IOException class. - "rw" informs the constructor to create and open a new file when it doesn't exist for reading and writing or open an existing file for reading and writing. - "rwd" informs the constructor to create and open a new file when it doesn't exist for reading and writing or open an existing file for reading and writing. Furthermore, each update to the file's content must be written synchronously to the underlying storage device. - "rws" informs the constructor to create and open a new file when it doesn't exist for reading and writing or open an existing file for reading and writing. Furthermore, each update to the file's content or metadata must be written synchronously to the underlying storage device.

What are constructor's mode argument for RandomAccessFile?

1. A stream does not store its elements. They may be stored in an underlying collection or generated on demand. 2. Stream operations don't mutate their source. For example, the filter method does not remove elements from a new stream, but it yields a new stream in which they are not present. 3. Stream operations are lazy when possible. This means they are not executed until their result is needed. For example, if you only ask for the first five long words instead of all, the filter method will stop filtering after the fifth match. As a consequence, you can even have infinite streams!

What are differences between streams and collections?

- max/min methods Optional<String> largest = words.max(String::compareToIgnoreCase); The findFirst returns the first value in a nonempty collection. It is often useful when combined with filter. Optional<String> startsWithQ = words.filter(s -> s.startsWith("Q")).findFirst();

What are simple reduction method examples?

- close() - flush() - write()

What are some methods of OutputStream class?

by an error in JMV, error in program, or throw statement.

What are three ways that an exception can be generated?

Exception and Error

What are two direct subclasses of a Throwable?

Although the primitive-type buffer classes have similar capabilities, ByteBuffer is the largest and most versatile. After all, bytes are the basic unit used by operating systems to transfer data items.

What buffer implementation is most versatile?

An instance of the java.io.File class abstracts a file or directory path. This instance provides access to the file system to perform tasks on this path such as removing the underlying file or directory. new File("temp").mkdir();

What class abstracts a file or directory path?

An instance of the java.io.RandomAccessFile class provides random access to a file. RandomAccessFile raf = new RandomAccessFile("employees.dat", "r"); int empIndex = 10; raf.seek(empIndex * EMP_REC_LEN);

What class provides random access to a file?

JDK 1.0 introduced rudimentary I/O facilities for accessing the file system (to create a directory, remove a file, or perform another task), accessing file content randomly (as opposed to sequentially), and streaming byte-oriented data between sources and destinations in a sequential manner.

What classic I/O facilities did JDK 1.0 introduce?

The Stream interface has two static methods for making infinite streams. The generate method takes a function with no arguments (or, technically, an object of the Supplier<T> interface). Whenever a stream value is needed, that function is called to produce a value. You can get a stream of constant values as Stream<String> echos = Stream.generate(() -> "Echo"); or a stream of random numbers as Stream<Double> randoms = Stream.generate(Math::random); To produce infinite sequences, such as 0 1 2 3 . . . , use the iterate method instead. It takes a "seed" value and a function (technically, a UnaryOperator<T>) and repeatedly applies the function to the previous result. For example, Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

What do generate and iterate methods of Stream interface do?

What does AWT stands for? a) All Window Tools b) All Writing Tools c) Abstract Window Toolkit d) Abstract Writing Toolkit

FileOutputStream and FileInputStream have a performance problem. Each file output stream write() method call and file input stream read() method call results in a native method call to one of the underlying operating system's functions, and these native method calls slow down I/O. The concrete BufferedOutputStream and BufferedInputStream filter stream classes improve performance by minimizing underlying output stream write() and underlying input stream read() method calls. Instead, calls to BufferedOutputStream's write() and BufferedInputStream's read() methods take Java buffers into account: When a write buffer is full, write() calls the underlying output stream write() method to empty the buffer. Subsequent calls to BufferedOutputStream's write() methods store bytes in this buffer until it's once again full. When the read buffer is empty, read() calls the underlying input stream read() method to fill the buffer. Subsequent calls to BufferedInputStream's read() methods return bytes from this buffer until it's once again empty. BufferedOutputStream declares the following constructors: BufferedOutputStream(OutputStream out) creates a buffered output stream that streams its output to out. An internal buffer is created to store bytes written to out. BufferedOutputStream(OutputStream out, int size) creates a buffered output stream that streams its output to out. An internal buffer of length size is created to store bytes written to out.

What does BufferedOutputStream and BufferedInputStream do?

The concrete OutputStreamWriter class (a Writer subclass) is a bridge between an incoming sequence of characters and an outgoing stream of bytes. Characters written to this writer are encoded into bytes according to the default or specified character encoding. Each call to one of OutputStreamWriter's write() methods causes an encoder to be called on the given character(s). The resulting bytes are accumulated in a buffer before being written to the underlying output stream. The characters passed to the write() methods are not buffered. The concrete InputStreamReader class (a Reader subclass) is a bridge between an incoming stream of bytes and an outgoing sequence of characters. Characters read from this reader are decoded from bytes according to the default or specified character encoding. Each call to one of InputStreamReader's read() methods may cause one or more bytes to be read from the underlying input stream. To enable the efficient conversion of bytes to characters, more bytes may be read ahead from the underlying stream than are necessary to satisfy the current read operation.

What does OutputStreamWriter and InputStreamReader do?

Return a potentially empty array of strings naming the files and directories in the directory denoted by this File object's abstract path. If the path doesn't denote a directory, or if an I/O error occurs, this method returns null. Otherwise, it returns an array of strings, one string for each file or directory in the directory. Names denoting the directory itself and the directory's parent directory are not included in the result. Each string is a file name rather than a complete path. Also, there is no guarantee that the name strings in the resulting array will appear in alphabetical or any other order.

What does String[] list() method of the File class do?

Return true if and only if the file or directory that's denoted by this File object's abstract path exists.

What does exists() method of the File class do?

Unlike default/custom serialization/deserialization, externalization offers complete control over the serialization and deserialization tasks. Note Externalization helps you improve the performance of the reflection-based serialization and deserialization mechanisms by giving you complete control over what fields are serialized and deserialized. Java supports externalization via java.io.Externalizable.

What does externalization do?

the peek method yields another stream with the same elements as the original, but a function is invoked every time an element is retrieved. That is handy for debugging: Object[] powers = Stream.iterate(1.0, p -> p * 2) .peek(e -> System.out.println("Fetching " + e)) .limit(20).toArray(); When an element is actually accessed, a message is printed. This way you can verify that the infinite stream returned by iterate is processed lazily.

What does peek method do?

The call stream.skip(n) does the exact opposite of stream.limit(n): It discards the first n elements. This is handy when splitting text into words since, due to the way the split method works, the first element is an unwanted empty string. Stream<String> words = Stream.of(contents.split("\\PL+")).skip(1);

What does stream.skip(n) do?

The transient keyword prevents the values of instance fields that are declared with this keyword from being persisted when an object is serialized (written as a sequence of bytes to some destination). The values of such instance fields shouldn't be persisted and later restored when an object is deserialized (reconstituted from a sequence of bytes read from some source). For example, if your object has a field of type java.io.InputStream, you don't serialize this field's reference because the stream won't be open for input when you deserialize the object -- the stream source (e.g., a file) might not exist.

What does the transient keyword accomplish?

ll channels are instances of classes that ultimately implement the java.nio.channels.Channel interface. Channel declares the following methods: - void close(): Close this channel. When this channel is already closed, invoking close() has no effect. When another thread has already invoked close(), a new close() invocation blocks until the first invocation finishes, after which close() returns without effect. This method throws java.io.IOException when an I/O error occurs. After the channel is closed, any further attempts to invoke I/O operations on it result in java.nio.channels.ClosedChannelException being thrown. - boolean isOpen(): Return this channel's open status. This method returns true when the channel is open; otherwise, it returns false.

What interface do all channels implement?

Many operating systems allow streams to be configured to operate in nonblocking mode in which a thread continually checks for available input without blocking when no input is available. The thread can handle incoming data or perform other tasks until data arrives. This "polling for available input" activity can be wasteful, especially when the thread needs to monitor many input streams (such as in a web server context).

What is "polling for available input"?

Nonblocking mode improves performance by preventing a thread that performs a read or write operation on a channel from blocking until input is available or the output has been fully written. However, it doesn't let an application determine if it can perform an operation without actually performing the operation. For example, when a nonblocking read operation succeeds, the application learns that the read operation is possible but also has read some data that must be managed. This duality prevents you from separating code that checks for stream readiness from the data-processing code without making your code significantly complicated. Asynchronous I/O overcomes this problem by letting the thread initiate the operation and immediately proceed to other work. The thread specifies some kind of callback function that is invoked when the operation finishes.

What is Asynchronous I/O?

Modern operating systems offer sophisticated I/O services (such as readiness selection) for improving I/O performance and simplifying I/O. Java Specification Request (JSR) 51 was created to address these capabilities. JSR 51's description indicates that it provides APIs for scalable I/O, fast buffered binary and character I/O, regular expressions, and charset conversion. Collectively, these APIs are known as NIO.

What is NIO?

RandomAccessFile is useful for creating a flat file database, a single file organized into records and fields. A record stores a single entry (such as a part in a parts database) and a field stores a single attribute of the entry (such as a part number).

What is RandomAccessFile useful for?

Channels provide the ability to perform a single I/O operation across multiple buffers. This capability is known as scatter/gather I/O (and is also known as vectored I/O). In the context of a write operation, the contents of several buffers are gathered (drained) in sequence and then sent through the channel to a destination. These buffers are not required to have identical capacities. In the context of a read operation, the contents of a channel are scattered (filled) to multiple buffers in sequence; each buffer is filled to its limit until the channel is empty or until the total buffer space is used.

What is Scatter/Gather I/O?

To support I/O, Channel is extended by the java.nio.channels.WritableByteChannel and java.nio.channels.ReadableByteChannel interfaces: - WritableByteChannel declares an abstract int write(ByteBuffer buffer) method that writes a sequence of bytes from buffer to the current channel. This method returns the number of bytes actually written. It throws java.nio.channels.NonWritableChannelException when the channel was not opened for writing, java.nio.channels.ClosedChannelException when the channel is closed, java.nio.channels.AsynchronousCloseException when another thread closes the channel during the write, java.nio.channels.ClosedByInterruptException when another thread interrupts the current thread while the write operation is in progress (thereby closing the channel and setting the current thread's interrupt status), and IOException when some other I/O error occurs. - ReadableByteChannel declares an abstract int read(ByteBuffer buffer) method that reads bytes from the current channel into buffer. This method returns the number of bytes actually read (or -1 when there are no more bytes to read). It throws java.nio.channels.NonReadableChannelException when the channel was not opened for reading; ClosedChannelException when the channel is closed; AsynchronousCloseException when another thread closes the channel during the read; ClosedByInterruptException when another thread interrupts the current thread while the write operation is in progress, thereby closing the channel and setting the current thread's interrupt status; and IOException when some other I/O error occurs.

What is WritableByteChannel and ReadableByteChannel?

File locking lets a process prevent or limit access to a file while the process is accessing the file. Although file locking can be applied to an entire file, it is often narrowed to a smaller region. A lock ranges from a starting byte offset in the file and continues for a specific number of bytes.

What is a file locking?

A file system is an operating system component that manages data storage and subsequent retrieval.

What is a file system?

A file system stores data in files, which are stored in directories. Its file and directory objects are accessed by specifying paths, which are compact maps that locate and identify file system objects. Paths are either absolute or relative: - An absolute path is a path relative to the file system's root directory. It's expressed as the root directory symbol followed by a delimited hierarchy of directory names that ends in the target directory or file name. - A relative path is a path relative to some other directory. It's expressed similarly to an absolute path but without the initial root directory symbol. In contrast, it's often prefixed with one or more delimited ".." character sequences, where each sequence refers to a parent directory.

What is a path?

Relative path doesn't start with the root directory symbol; it's interpreted via information taken from another path.

What is a relative path?

A stream is an ordered sequence of bytes of an arbitrary length. Bytes flow over an output stream from an application to a destination and flow over an input stream from a source to an application.

What is a stream in Java?

As well as managing data elements stored in external arrays (via the wrap() methods), buffers can manage data stored in other buffers. When you create a buffer that manages another buffer's data, the created buffer is known as a view buffer. Changes made in either buffer are reflected in the other. View buffers are created by calling a Buffer subclass's duplicate() method. The resulting view buffer is equivalent to the original buffer; both buffers share the same data items and have equivalent capacities. However, each buffer has its own position, limit, and mark. When the buffer being duplicated is read-only or direct, the view buffer is also read-only or direct. ByteBuffer buffer = ByteBuffer.allocate(10); ByteBuffer bufferView = buffer.duplicate(); View buffers are also created by calling one of ByteBuffer's asxBuffer() methods. For example, LongBuffer asLongBuffer() returns a view buffer that conceptualizes the byte buffer as a buffer of long integers.

What is a view buffer?

The legacy File class suffers from various problems. For example, the renameTo() method doesn't work consistently across operating systems. Also, many of File's methods don't scale; requesting a large directory listing from a server could result in a hang. The new file system interface mentioned in JSR 203 fixes these and other problems.

What is an improved filesystem interface introduced in NIO.2?

Bytes flow over an input stream from a source to an application.

What is an input stream?

Bytes flow over an output stream from an application to a destination.

What is an output stream?

A stream transformation produces a stream whose elements are derived from those of another stream. - filter() - filter transformation yields a stream with those elements that match a certain condition. Stream<String> longWords = wordList.stream().filter(w -> w.length() > 12); - map() - Often, you want to transform the values in a stream in some way. Use the map method and pass the function that carries out the transformation. Stream<String> lowercaseWords = words.stream().map(String::toLowerCase); When you use map, a function is applied to each element, and the result is a new stream with the results. -flatMap() - yields a stream obtained by concatenating the results of applying mapper to the elements of this stream. (Note that each result is a stream.)

What is stream transformation?

Every serialized object has an identifier. The deserialization mechanism compares the identifier of the object being deserialized with the serialized identifier of its class (all serializable classes are automatically given unique identifiers unless they explicitly specify their own identifiers) and causes InvalidClassException to be thrown when it detects a mismatch. You can avoid the thrown InvalidClassException instance by adding a static final long serialVersionUID = long integer value; declaration to the class. The long integer value must be unique and is known as a stream unique identifier (SUID). During deserialization, the JVM will compare the deserialized object's SUID to its class's SUID. If they match, readObject() will not throw InvalidClassException when it encounters a compatible class change (such as adding an instance field). However, it will still throw this exception when it encounters an incompatible class change (such as changing an instance field's name or type).

What is stream unique identifier (SUID)?

Although getFreeSpace() and getUsableSpace() appear to be equivalent, they differ in the following respect: unlike getFreeSpace(), getUsableSpace() checks for write permissions and other operating system restrictions, resulting in a more accurate estimate.

What is the difference between getFreeSpace() and getUsableSpace methods of the File class?

The clear() method marks a buffer as empty whereas reset() changes the buffer's current position to the previously set mark, or throws InvalidMarkException when there's no previously set mark.

What is the difference between reset() and clear() methods on buffer?

An Optional<T> object is a wrapper for either an object of type T or no object. In the former case, we say that the value is present. The Optional<T> type is intended as a safer alternative for a reference of type T that either refers to an object or is null.

What is the optional type?

What is the output of this program if input given is "Hello stop World"? class Input_Output { public static void main(String args[]) throws IOException { string str; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); do { str = (char) obj.readLine(); System.out.print(str); } while(!str.equals("strong")); } } a) Hello b) Hello stop c) World d) Hello stop World

What is the output of this program if input given is "abc'def/'egh"? class Input_Output { public static void main(String args[]) throws IOException { char c; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); do { c = (char) obj.read(); System.out.print(c); } while(c != '\''); } } a) abc' b) abcdef/' c) abc'def/'egh d) abcqfghq

What is the output of this program if input given is "abc'def/'egh"? class Input_Output { public static void main(String args[]) throws IOException { char c; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); do { c = (char) obj.read(); System.out.print(c); } while(c!='\''); } } a) abc' b) abcdef/' c) abc'def/'egh d) abcqfghq

What is the output of this program if input given is 'abcqfghqbcd'? class Input_Output { public static void main(String args[]) throws IOException { char c; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); do { c = (char) obj.read(); System.out.print(c); } while(c != 'q'); } } a) abcqfgh b) abc c) abcq d) abcqfghq

What is the output of this program? class output { public static void main(String args[]) { String a="hello i love java"; System.out.println(indexof('i')+" "+indexof('o')+" "+lastIndexof('i')+" "+lastIndexof('o') )); } } a) 6 4 6 9 b) 5 4 5 9 c) 7 8 8 9 d) 4 3 6 9

What is the output of this program? class output { public static void main(String args[]) { char c[]={'a','1','b',' ','A','0']; for (int i = 0; i < 5; ++i) { if(Character.isDigit(c[i])) System.out.println(c[i]" is a digit"); if(Character.isWhitespace(c[i])) System.out.println(c[i]" is a Whitespace character"); if(Character.isUpperCase(c[i])) System.out.println(c[i]" is an Upper case Letter"); if(Character.isUpperCase(c[i])) System.out.println(c[i]" is a lower case Letter"); i = i + 3; } } } a) a is a lower case Letter is White space character b) b is a lower case Letter is White space characte c) a is a lower case Letter A is a upper case Letter d) a is a lower case Letter 0 is a digit

What is the output of this program? import java.io.*; class Chararrayinput { public static void main(String[] args) { String obj = "abcdef"; int length = obj.length(); char c[] = new char[length]; obj.getChars(0, length, c, 0); CharArrayReader input1 = new CharArrayReader(c); CharArrayReader input2 = new CharArrayReader(c, 0, 3); int i; try { while((i = input2.read()) != -1) { System.out.print((char)i); } } catch (IOException e) { e.printStackTrace(); } } } a) abc b) abcd c) abcde d) abcdef

What is the output of this program? import java.io.*; class filesinputoutput { public static void main(String args[]) { InputStream obj = new FileInputStream("inputoutput.java"); System.out.print(obj.available()); } } a) true b) false c) prints number of bytes in file d) prints number of characters in the file

1. Create a stream. 2. Specify intermediate operations for transforming the initial stream into others, possibly in multiple steps. 3. Apply a terminal operation to produce a result. This operation forces the execution of the lazy operations that precede it. Afterwards, the stream can no longer be used. List<String> words = ... long count = words.stream().filter(w -> w.length() > 12).count(); or you can use parallelStream() instead of stream() In the example, the stream is created with the stream or parallelStream method. The filter method transforms it, and count is the terminal operation.

What is the typical workflow when you work with streams?

Unlimited serialization is the process of serializing an entire object graph. Java doesn't support unlimited serialization for the following reasons: - Security: If Java automatically serialized an object containing sensitive information (such as a password or a credit card number), it would be easy for a hacker to discover this information and wreak havoc. It's better to give the developer a choice to prevent this from happening. - Performance: Serialization leverages the Reflection API, which tends to slow down application performance. Unlimited serialization could really hurt an application's performance. - Objects not amenable to serialization: Some objects exist only in the context of a running application and it's meaningless to serialize them. For example, a file stream object that's deserialized no longer represents a connection to a file.

What is unlimited serialization?

inputStream

What type of stream is System.in?

DataInputStream

What type of stream is used to read binary data?

What is a race condition?

When 2 or more threads are trying to access data at the same time. This can cause thread interference.

Which of these class contains the methods print() & println()? a) System b) System.out c) BUfferedOutputStream d) PrintStream

Which of these class contains the methods used to write in a file? a) FileStream b) FileInputStream c) BUfferedOutputStream d) FileBufferStream

Which of these class is implemented by FilterInputStream class? a) InputStream b) InputOutputStream c) BufferedInputStream d) SequenceInputStream

Which of these class is used to create an object whose character sequence is mutable? a) String() b) StringBuffer() c) Both of the mentioned d) None of the mentioned

Which of these class is used to read characters and strings in Java from console? a) BufferedReader b) StringReader c) BufferedStreamReader d) InputStreamReader

Which of these class is used to read from byte array? a) InputStream. b) BufferedInputStream. c) ArrayInputStream. d) ByteArrayInputStream.

Which of these classes are used by Byte streams for input and output operation? a) InputStream b) InputOutputStream c) Reader d) All of the mentioned

Which of these classes are used by character streams for input and output operations? a) InputStream b) Writer c) ReadStream d) InputOutputStream

Which of these classes are used by character streams output operations? a) InputStream b) Writer c) ReadStream d) InputOutputStream

Which of these exception is thrown by close() and read() methods? a) IOException b) FileException c) FileNotFoundException d) FileInputOutputException

Which of these exception is thrown in cases when the file specified for writing it not found? a) IOException b) FileException c) FileNotFoundException d) FileInputException

Which of these is a type of stream in Java? a) Integer stream b) Short stream c) Byte stream d) Long stream

Which of these is used to perform all input & output operations in Java? a) streams b) Variables c) classes d) Methods

Which of these is used to read a string from the input stream? a) get() b) getLine() c) read() d) readLine()

Which of these method of class StringBuffer is used to reverse sequence of characters? a) reverse() b) reverseall() c) Reverse() d) reverseAll()

Which of these methods are used to read in from file? a) get() b) read() c) scan() d) readFileInput()

Which of these methods can be used to writing console output? a) print() b) println() c) write() d) All of the mentioned

Which of these methods is used to write() into a file? a) put() b) putFile() c) write() d) writeFile()

Which of these values is returned by read() method is end of file (EOF) is encountered? a) 0 b) 1 c) -1 d) Null

Java's stream classes are good for streaming sequences of bytes, but they're not good for streaming sequences of characters because bytes and characters are two different things: a byte represents an 8-bit data item and a character represents a 16-bit data item. Also, Java's char and java.lang.String types naturally handle characters instead of bytes. More importantly, byte streams have no knowledge of character sets (sets of mappings between integer values, known as code points, and symbols, such as Unicode) and their character encodings (mappings between the members of a character set and sequences of bytes that encode these characters for efficiency, such as UTF-8). If you need to stream characters, you should take advantage of Java's writer and reader classes, which were designed to support character I/O (they work with char instead of byte). Furthermore, the writer and reader classes take character encodings into account.

Why do we need writers and readers?

Because File(String path), File(String parent, String child), and File(File parent, String child) don't detect invalid path arguments (apart from throwing a java.lang.NullPointerException when path or child is null), you must be careful when specifying paths. You should strive to only specify paths that are valid for all operating systems on which the application will run. For example, instead of hard-coding a drive specifier (such as C:) in a path, use a root returned from listRoots(), which I discuss later. Even better, keep your paths relative to the current user/working directory (returned from the user.dir system property).

Why only specify paths that are valid for all operating systems on which the application will run?

After filling a buffer, you must prepare it for draining by a channel. When you pass the buffer as is, the channel accesses undefined data beyond the current position. To solve this problem, you could reset the position to 0, but how would the channel know when the end of the inserted data had been reached? The solution is to work with the limit property, which indicates the end of the active portion of the buffer. Basically, you set the limit to the current position and then reset the current position to 0. You could accomplish this task by executing the following code, which also clears any defined mark: buffer.limit(buffer.position()).position(0); However, there's an easier way to accomplish the same task, as shown here: buffer.flip(); String[] poem = { "Roses are red", "Violets are blue", "Sugar is sweet", "And so are you." }; CharBuffer buffer = CharBuffer.allocate(50); for (int i = 0; i < poem.length; i++) { // Fill the buffer. for (int j = 0; j < poem[i].length(); j++) buffer.put(poem[i].charAt(j)); // Flip the buffer so that its contents can be read. buffer.flip(); // Drain the buffer. while (buffer.hasRemaining()) System.out.print(buffer.get()); // Empty the buffer to prevent BufferOverflowException. buffer.clear(); System.out.println(); }

Why to flip a buffer?

Regular expressions were introduced as part of NIO. Although you might wonder about the rationale for doing this (what have regular expressions got to do with I/O?), regular expressions are commonly used to scan textual data that is read from a file or other source. The need to perform these scans as quickly as possible mandated their inclusion.

Why were regular expressions introduced as part of NIO?

You would use FileInputStream to open an existing file and connect an input stream to it. You would then invoke various read() methods to read bytes from the file over the input stream. Lastly, you would invoke close() to close the stream and file. FileInputStream fis = null; try { fis = new FileInputStream("image.jpg"); // Read bytes from file. int _byte; while ((_byte = fis.read()) != -1) // -1 signifies EOF ; // Process _byte in some way. } catch (IOException ioe) { // Handle exception. } finally { if (fis != null) try { fis.close(); } }

Why would you use FileInputStream?

public static void main(String[] args) { ReadableByteChannel src = Channels.newChannel(System.in); WritableByteChannel dest = Channels.newChannel(System.out); try { copy(src, dest); } catch (IOException ioe) { System.err.println("I/O error: " + ioe.getMessage()); } finally { try { src.close(); dest.close(); } catch (IOException ioe) { ioe.printStackTrace(); } } } static void copy(ReadableByteChannel src, WritableByteChannel dest) throws IOException { ByteBuffer buffer = ByteBuffer.allocateDirect(2048); while (src.read(buffer) != -1) { buffer.flip(); dest.write(buffer); buffer.compact(); } buffer.flip(); while (buffer.hasRemaining()) dest.write(buffer); }

Write an example for channels and buffers

What is the output of this program if input given is "abc'def/'egh"? class Input_Output { public static void main(String args[]) throws IOException { char c; BufferedReader obj = new BufferedReader(new InputStreamReader(System.in)); do { c = (char) obj.read(); System.out.print(c); } while(c!='\''); } } a) abc' b) abcdef/' c) abc'def/'egh d) abcqfghq

Which of the following statement is correct? a) reverse() method reverses all characters. b) reverseall() method reverses all characters. c) replace() method replaces first occurrence of a character in invoking string with another character. d) replace() method replaces last occurrence of a character in invoking string with another character.

Which of these exception is thrown by close() and read() methods? a) IOException b) FileException c) FileNotFoundException d) FileInputOutputException

Which of these is used to perform all input & output operations in Java? a) streams b) Variables c) classes d) Methods

Files: a) contains only static methods b) contains static and non=static methods

a correct

Paths: a) creates Paths object that contain static methods b) creates Paths objects that contain non-static methods

a correct. creates Paths object that contain static methods static Path methods: *static Path get( String first, String... more)* - *Converts* a *path string*, or a sequence of strings that when joined form a path string, *to a Path*. *static Path get(URI uri)* - *Converts* the given *URI* to a *Path object*. Note: URI is Uniform Resource Identifier (URI) reference e.g. *opaque* URIs are: mailto:[email protected] news:comp.lang.java urn:isbn:096139210x *hierarchical* URIs are: http://java.sun.com/j2se/1.3/ docs/guide/collections/faq.html#28 ../../../demo/jfc/SwingSet2/src/SwingSet2.java file:///~/calendar

Which of the below can be created using "new": a) File b) Path c) Paths d) Files

a correct. *Path* is an *interface*. *Files* and *Paths* are *final classes*. These final classes *consists* exclusively of *static methods* that operate on files, directories, or other types of files.

import java.io.File; class A { public static void main( String[] args) { File f = new File("C:\\a\\b\\Log.txt" ); f.createNewFile(); } } The above code will give: a) compiler error b) runtime error c) compile and create a new file Log.txt d) none of the above

a correct. *compiler error* complains that method *createNewFile()*; should be placed in a *try catch block* or *main()* class should *declare* that it *throws Exception*

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println( i.createdirectory()); } Directory b does not exist. The above code will give: a) compiler error b) runtime error c) compile and print true. d) none of the above

a correct. *createdirectory()* is *not* a *method* within the *File class*. To create a new directory: call the method *mkdir()* or *mkdirs()* for the creation of subdirectories

import java.io.Console; class A { public static void main(String[] args) { Console c = System.console(); char[] n = c.readLine("%c", "Enter Name: "); System.out.println( "Welcome "+n); } } The above code will give: a) compiler error b) runtime error c) compile and echo whatever you entered to the screen d) none of the above

a correct. *readLine*("%c", "Enter Name: "); *returns a String* var. *char[] n* = c.readLine(...); You *cannot store* variable as a *char* variable. ----> Compiler error. Solution: *String *n = c.readLine(*"%s"*, "Enter Name: "); or *String* n = c.readLine(*"Enter Name: "*);

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); char n = c.readPassword( "%c", "Enter password: "); } } The above code will give: a) compiler error b) runtime error c) compile and store user input to char n d) none of the above

a correct. *readPassword()* returns *char array* You *cannot store* (*char[]*) and read *in* a variable (*char*) ----> *compiler error.* Solution: *char[]* n = c.readPassword("%c", "Enter password: ");

File a = new File("c:\\a"); File b = new File("c:\\a\\b"); File f = new File(a,b,"f.txt"); System.out.println( f.createNewFile()); System.out.println(f.exists()); The folders exist and the file already exists. The above code will give: a) compiler error b) runtime error c) Compile and Print "false true" d) None of the above

a correct. Remember *File constructor* can take params : new File(*File, String*) new File(*String*) new File(*String,String*) However, the following will not compile: new File(*a,b,"f.txt"*); gives *compiler error*

public static void main(String[] args) throws Exception { File i=new File("C:\\a\\b\\m.txt"); System.out.println( i.renameTo("C:\\a\\b\\a.txt")); } Assuming both files exist. The above code will give: a) compiler error b) runtime error c) compile and rename m.txt to a.txt d) none of the above

a correct. i.*renameTo()* *doesn't* take *string* parameter. Solution: *Wrap* the new file name *in* a *File object* i.e. i.renameTo( *new File("C:\\a\\b\\a.txt")*) Note: you can *also change folder* the same way. if *m.txt* does *not exist* then it does *not rename* the file and *returns false*

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println(i.del()); } Assume the above folders exist. The above code will give: a) compiler error b) runtime error c) compile and delete b folder and return true d) none of the above

a correct. it will give a compiler error as the *del()* method does not exist* in *File*. Replace del() with *i.delete()* and it will *work*.

The set of all descendants of a node in a binary tree form

a subtree rooted at that node

in the generic type notation <T extends Number> to what type of bound is T constrained?

an upper bound

InputStream and OutputStream

are abstract classes that declare methods for performing byte-based input and output, respectively.

import java.io.Console; class A { public static void main(String[] args) { Console c = System.console(); char[] n =c.readPassword( "%s", "Enter password: "); System.out.println( "Password is: "+n); } } Consider the user entered mark. The above code will give: a) compiler error b) runtime error c) compile and print mark d) Address of password e.g. [C@139eeda

d is correct. Password chars are *encrypted* with the method *readPassword*( "%s", "Enter password: ");

public static void main(String[] args) throws Exception { File i = new File("C:\\a\\b\\"); i.mkdir(); System.out.println( i.isDirectory()); } Assume folders "a" and "b" do not exist prior to execution. The above code will give: a) compiler error b) runtime error c) compile and print true d) none of the above

d is correct. *i.mkdir();* doesn't create folders it *makes one folder only*. however if i.mkdir(); is replaced with *i.mkdirs();* this would *work fine*.

public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("a1"); bw.write("b1"); } Where "myFile.txt" already exists in folder "a". The above code will give: a) compiler error b) runtime error c) compile and print "a1b1" d) none of the above

d is correct. *myFile.txt* is still *open*. You must call *bw.flush();* *bw.close();* *after* completing *writing* to the *file*. Note: If the *bw.flush();* and *bw.close();* were in the original code then the *file* would be *completely overwritten* with "a1b1"

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println(i.delete()); System.out.println(i.delete()); } Assume the above folders exist. The above code will give: a) compiler error b) runtime error c) compile and delete a and b folders and return true d) none of the above

d is correct. It *deletes b subfolder* and *returns true*. The *second call* to the delete method *i.delete()* attempts to *delete* the *same* subfolder *b* but it *does not exist* therefore returns* false*

import java.io.File; class A { public static void main(String[] args) throws Exception { File dir =new File("C:\\a\\b\\"); dir.mkdirs(); File f = new File(dir,"MyFile.txt"); } } The above code will give: a) compiler error b) runtime error c) compile and print create an empty file "MyFile.txt" in a\b folder d) none of the above

d is correct. It will *create* the *folders a* and *b* but *not* the file "*MyFile.txt*" f.*createNewFile()* should be *declared after:* *File f=new File(dir, "MyFile.txt");*

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); File f =new File(i,"m.txt"); System.out.println(f.isFile()); } Assuming "m.txt" does not exist. The above code will give: a) compiler error b) runtime error c) compile and print true d) none of the above

d is correct. It will return false. You need to call the method *f.createNewFile();* *after:* File f = new File(i,"m.txt"); it will then *create* the file "*m.txt*" and return *true*

public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("a"); bw.write("b"); bw.flush(); bw.close(); } Where "myFile.txt" does not exist but folder "a" does. The above code will give: a) compiler error b) runtime error c) compile and write a b (On separate lines) d) none of the above

d is correct. Will *write* "ab" (without spaces). To *write a* and *b* on *separate lines* you need to *get* the *character* for your particular operating system e.g. bw.write("a"); bw.write( *System.lineSeparator()*); bw.write("b"); Note: If "myFile.txt" *does not exist*, it gets *created* and then *written* to it. This is *provided* the *folder* does *exist*. If "myFile.txt" *does exist* then *all contents* get *erased* and the *file is *completely overwritten* with "ab" on same line. If *folder* does *not exist* then a *run time error* will be *thrown*: java.io.*FileNotFoundException*

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println(i.delete()); } Assume the above folders exist. The above code will give: a) compiler error b) runtime error c) compile and delete a and b folders and return true d) none of the above

d is correct. it will *delete b sub folder* only.

15.1 Q1: Which of the following statements is false? a. Storage of data variables and arrays is temporary. b. Data is lost when a local variable "goes out of scope." c. Files are used for long-term retention of large amounts of data. d. Data maintained in files is often called transient data.

d. Data maintained in files is often called transient data.

15.2 Q1: Which of the following classes is not used for file input? a. FileInputStream b. FileReader c. ObjectInputStream d. Formatter

d. Formatter

Which of the following classes is not used for file input? a. FileInputStream b. FileReader c. ObjectInputStream d. Formatter

d. Formatter

15.4.1 Q1: Which statement regarding Java files is false? a. Java imposes no structure on a file. b. Notions like "record" do not exist in Java files. c. The programmer must structure files to meet the requirements of applications. d. Records in a Java sequential file are stored in order by record key.

d. Records in a Java sequential file are stored in order by record key.

15.4.1 Q2: When all the contents of a file are truncated, this means that ________. a. the data in the file is saved to a backup file b. the file is deleted c. a FileNotFoundException occurs d. all the data in the file is discarded

d. all the data in the file is discarded

When all the contents of a file are truncated, this means that ________. a. the data in the file is saved to a backup file b. the file is deleted c. a FileNotFoundException occurs d. all the data in the file is discarded

d. all the data in the file is discarded.

________ is an I/O-performance-enhancement technique—it reduces the number of I/O operations by combining smaller outputs together in memory; the number of physical I/O operations is much smaller than the number of I/O requests issued by the program. a. Aggregating b. Accumulating c. Amassing d. Buffering

d. buffering

If you do not want to wait until all the bytes you need are immediately available, you can use the _____________ method to determine how many bytes can be read without blocking

available()

What is the output of this program? class output { public static void main(String args[]) { StringBuffer c = new StringBuffer("Hello"); System.out.println(c.length()); } } a) 4 b) 5 c) 6 d) 7

What is the output of this program? class output { public static void main(String args[]) { StringBuffer s1 = new StringBuffer("Hello"); StringBuffer s2 = s1.reverse(); System.out.println(s2); } } a) Hello b) olleH c) HelloolleH d) olleHHello

Which of these class contains the methods used to write in a file? a) FileStream b) FileInputStream c) BUfferedOutputStream d) FileBufferStream

Which of these classes are used by character streams output operations? a) InputStream b) Writer c) ReadStream d) InputOutputStream

Which of these methods are used to read in from file? a) get() b) read() c) scan() d) readFileInput()

Paths is located in: a) java.io.file.Paths. b) java.nio.file.Paths

b correct

Files is an: a) abstract class b) final class c) class d) interface

b correct.

Files and Path and Paths: a) can be created using "new" b) cannot be created using "new"

b correct. *Path* is an *interface*. *Files* and *Paths* are *final classes*. These final classes consists exclusively of *static methods* that operate on files, directories, or other types of files.

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); String n = c.readLine("%c", "Enter Name: "); System.out.println( "Welcome "+n); } } The above code will give: a) compiler error b) runtime error c) compile and echo whatever you entered to the screen d) none of the above

b correct. String n = c.readLine( "*%c*", "Enter Name: "); Throws *java.util.IllegalFormatConversionException* Attempting to *convert char c* formatted type *to string n* throws *exception*. Solution: c.readLine( "*%s*", "Enter Name: ");

import java.io.File; class B { public static void main(String[] args) throws Exception { File f = new File( "c:\\a\\b\\MyFile.txt"); System.out.println(f.exists()); System.out.println( f.createNewFile() ); } } Assume the above path does not exist. The above code will give: a) compiler error b) runtime error c) Compile and Print "false true" d) None of the above

b correct. Will print "false *java.io.IOException*: The system cannot find the path specified"

import java.io.File; class A { public static void main(String[] args) throws Exception { File dir = new File("C:\\a\\b\\"); File f=new File(dir, "MyFile.txt"); f.createNewFile(); } } Considering the above directories a and b do not exist prior to execution. The above code will give: a) compiler error b) runtime error c) compile and print create an empty file "MyFile.txt" in a\b folder d) none of the above

b correct. f.*createNewFile()*; will *throw an IOException* As *directories* *a* and *b* do *not exist* prior to execution Solution: *insert:* dir.*mkdirs()*; AFTER *File dir* = new File("C:\\a\\b\\"); i.e. File dir = new File("C:\\a\\b\\"); *dir.mkdirs();* File f=new File(dir, "MyFile.txt"); f.createNewFile();

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); char[] pw =c.readPassword( null, "Enter password: "); } } The above code will give: a) compiler error b) runtime error c) compile and print "Enter password: " d) none of the above

b is correct. It will *throw* an *NullPointerException*. replace: readPassword(*null*,"Enter password: "); with: readPassword(*"%s"*,"Enter password: "); or readPassword(* "Enter password: *"); and it will *compile* and run *fine*.

import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get( "file:///C://a//File.txt"); System.out.println(p1); } } Consider the above code running on Windows. The above code will give: a) compiler error b) runtime error c) compile and print C://a//File.txt d) none of the above

b is correct. Will throw *InvalidPathException* because *file:///C://a//* on Windows is a URL. Solution: *Convert* the string to *URI Universal Resource Identifier*- Path p1 = Paths. get( *URI.create*( "file:///C://a//File.txt")); making sure to *import java.net.URI*;

15.5 Q1: Which of the following classes enable input and output of entire objects to or from a file? A. SerializedInputStream B. SerializedOutputStream C. ObjectInputStream D. ObjectOutputStream E. Scanner F. Formatter a. A and B. b. C and D. c. C, D, E, F. d. E and F.

b. C and D.

15.3 Q1: Which of the following statements is false? a. A Path represents the location of a file or directory. b. Path objects open files and provide file-processing capabilities. c. Class Paths is used to get a Path object representing a file or directory location. d. The static method get of class Paths converts a String representing a file's or directory's location into a Path object.

b. Path objects open files and provide file-processing capabilities. Actually, Path objects do not open files nor do they provide any file-processing capabilities. They specify only the location of a file or directory.

Which of the following statements is false? a. InputStream and OutputStream are abstract classes for performing byte-based I/O. b. Tubes are synchronized communication channels between threads. c. A filter stream provides additional functionality, such as aggregating data bytes into meaningful primitive-type units. FilterInputStream and FilterOutputStream are typically extended, so some of their filtering capabilities are provided by their concrete subclasses. d. A PrintStream performs text output. System.out and System.err are PrintStreams.

b. Tubes are synchronized communication channels between threads.

Which of the following statements is false? a. With a BufferedOutputStream each output operation is directed to a buffer large enough to hold the data of many output operations. Transfer to the output device is performed in one large physical output operation when the buffer fills. b. With a BufferedOutputStream, a partially filled buffer can be forced out to the device at any time by invoking the stream object's force method. c. With a BufferedInputStream, many "logical" chunks of data from a file are read as one large physical input operation into a memory buffer. d. With a BufferedInputStream, as a program requests data, it's taken from the buffer. When the buffer is empty, the next actual physical input operation is performed.

b. With a BufferedOutputStream, a partially filled buffer can be forced out to the device at any time by invoking the stream object's force method.

A(n) ________ path starts from the directory in which the application began executing. a. absolute b. relative c. parallel d. comparative

b. relative

15.3 Q4: A(n) ________ path starts from the directory in which the application began executing. a. absolute b. relative c. parallel d. comparative

b. relative.

This sorting algorithm makes several passes through an array and causes the larger values to gradually move towards the end of the array with each pass

bubble sort

BufferedInputStream

buffers data

What does AWT stands for? a) All Window Tools b) All Writing Tools c) Abstract Window Toolkit d) Abstract Writing Toolkit

What is the output of this program? class output { public static void main(String args[]) { StringBuffer s1 = new StringBuffer("Hello"); s1.setCharAt(1,x); System.out.println(s1); } } a) xello b) xxxxx c) Hxllo d) Hexlo

What is the output of this program? import java.io.*; class filesinputoutput { public static void main(String args[]) { InputStream obj = new FileInputStream("inputoutput.java"); System.out.print(obj.available()); } } Note: inputoutput.java is stored in the disk. a) true b) false c) prints number of bytes in file d) prints number of characters in the file

Which of these class is used to read from a file? a) InputStream b) BufferedInputStream c) FileInputStream d) BufferedFileInputStream

Which of these exception is thrown in cases when the file specified for writing it not found? a) IOException b) FileException c) FileNotFoundException d) FileInputException

Which of these is a type of stream in Java? a) Integer stream b) Short stream c) Byte stream d) Long stream

Which of these methods is used to write() into a file? a) put() b) putFile() c) write() d) writeFile()

Which of these values is returned by read() method is end of file (EOF) is encountered? a) 0 b) 1 c) -1 d) Null

Paths is an: a) abstract class b) static class c) class d) interface

c correct

Path contains: a) only static methods b) static and nonstatic methods c) nonstatic methods only

c correct.

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); String n = c.readLine("%s", "Enter Name: "); System.out.println( "Welcome "+n); } } The above code will give: a) compiler error b) runtime error c) compile and echo whatever you entered to the screen d) none of the above

c correct. e.g. c:> *java A * c:> *Enter Name:* Mark c:> Welcome Mark

import java.io.File; class B { public static void main(String[] args) throws Exception { File f = new File( "c:\\a\\b\\MyFile.txt"); System.out.println( f.exists()); System.out.println( f.createNewFile()); } } Assume the above path does exist. The above code will give: a) compiler error b) runtime error c) Compile and Print "false true" d) None of the above

c correct. It's important to ensure that the path/folders *exist beforehand*. *f.exists()* --> returns false. *f.createNewFile()* --> returns true when MyFile.txt successfully created

import java.nio.file.*; class A { public static void main ( String[] args) throws Exception { Path src = Paths.get( "C:\\a\\log1.txt"); Path des = Paths.get( "C:\\a\\log2.txt"); Files.copy(src, des); } } Where log2.txt does not exist but log1.txt doe exist. The above code will give: a) compiler error b) runtime error c) compile and copy the content successfully d) none of the above

c correct. compile and copy the content successfully Note: if *log2.txt* already *exists* it will *throw* a *FileAlreadyExistsException*. It the file to be written to *must not exist* prior to *copy*.

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); char[] pw =c.readPassword( "%s", "Enter password: "); } } The above code will give: a) compiler error b) runtime error c) compile and print "Enter password: " d) none of the above

c is correct.

public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileReader fr =new FileReader(f); BufferedReader br = new BufferedReader(fr); System.out.println( br.readLine()); br.close(); } considering "hello world" is in file myFile.txt (where "hello" is on the first line and "world" on the second) The above code will give: a) compiler error b) runtime error c) compile and print "hello" d) none of the above

c is correct. Note: *File* object f needs to be *wrapped* in *FileReader* fr object which needs to be *wrapped* in *BufferedReader* br object in order to compile i.e. *File* wrapped in *FileReader* wrapped in *BufferedReader* e.g. File *f* = new File("C:\\a\\ myFile.txt"); FileReader *fr* = new FileReader(*f*); BufferedReader br = new BufferedReader(*fr*); otherwise compiler error.

public static void main(String[] args) throws Exception { File i= new File("C:\\a\\b\\m.txt"); System.out.println( i.renameTo( new File("C:\\a\\b\\a.txt"))); } Assuming both files exist. The above code will give: a) compiler error b) runtime error c) compile and rename m.txt to a.txt d) none of the above

c is correct. if *m.txt* does *not exist* then it does *not rename* the file and *returns false*

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println(i.isDirectory()); } Assume folders "a" and "b" do not exist prior to execution. The above code will give: a) compiler error b) runtime error c) compile and print false d) compile and print true

c is correct. File i = *new File("C:\\a\\b\\");* is an *object* *not* a *folder*. In order to *create* the *folder* you need to state: *File i* = new File("C:\\a\\b\\"); *i.mkdirs();* System.out.println( i.isDirectory()); ----> will return *true*

import java.nio.file.*; class A { public static void main ( String[] args) throws Exception { Path src = Paths.get( "C:\\a\\log1.txt"); Path des = Paths.get( "C:\\a\\log2.txt"); Files.copy(src, des); } } Where log1.txt does not exist but log2.txt does exist. The above code will give: a) compiler error b) runtime error c) compile and will copy the contents of log1.txt to log2.txt d) none of the above

c is correct. Note: *if log2.txt does exists* then it will *throw* a *FileAlreadyExistsException* Solution: *delete log2.txt* in the folder location and it *will* then *create* a *new log2.txt* and copy the contents of log1.txt to log2.txt

import java.io.File; class A { public static void main( String [] args) { File f =new File( "C:\\a\\b\\"); f.mkdirs(); } } The above code will give: a) compiler error b) runtime error c) compile and create the subfolders a and b d) none of the above

c is correct. Note: The *main()* method does *not need* to *declare* that it *throws Exception* But *it does* if creating *via* import *java.nio.file.Files*; i.e. File f = new File( "C:\\a\\b\\*Log.txt*"); f.*createNewFile()*;

import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get("C:\\a\\","b\\File.txt"); System.out.println(p1); } } File location does not exist physically in memory. The above code will give: a) compiler error b) runtime error c) compile and print "C:\\a\\b\\File.txt" d) none of the above

c is correct. Paths.get( *"C:\\a\\*","*b\\File.txt*"); is *syntactically correct.* You can also use: Paths.get( "*C:\\a\\*", "*b\\*","*File.txt*"); or Path p1 = Paths.get( "*C:\\a\\b\\*","*File.txt*");

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); System.out.println(i.delete()); System.out.println(i.delete()); i = new File("C:\\a\\"); System.out.println(i.delete()); } Assume the above folders exist. The above code will give: a) compiler error b) runtime error c) compile and delete a and b folders and return true d) none of the above

c is correct. The *first delete()* method call *delete subfolder b*. A *File reference i* is then *reappointed* to a *new File Object* containing folder a. The *second delete() method call* then *deletes* this folder* a*.

public static void main(String[] args) throws Exception { File i =new File("C:\\a\\b\\"); File f =new File(i,"m.txt"); f.createNewFile(); System.out.println(f.createNewFile()); } Assuming "m.txt" does exist. The above code will give: a) compiler error b) runtime error c) compile and print true d) none of the above

c is correct. This code *creates a new file* in the *subdirectory b*

15.3 Q3: Which of the following statements is false? a. A DirectoryStream enables a program to iterate through the contents of a directory. b. Character-based input and output can be performed with classes Scanner and Formatter. c. A relative path contains all the directories, starting with the root directory, that lead to a specific file or directory. d. Every file or directory on a disk drive has the same root directory in its path.

c. A relative path contains all the directories, starting with the root directory, that lead to a specific file or directory. Actually, an absolute path contains all the directories, starting with the root directory, that lead to a specific file or directory.

15.4.3 Q1: Which of the following statements is true? a. Class Scanner provides the ability to reposition to the beginning of a file with method seek. b. Class Scanner provides the ability to reposition to the beginning of a file with method reposition. c. Class Scanner does not provide the ability to reposition to the beginning of the file. d. If it is necessary to read a sequential file again, the program can simply keep reading—when the end of the file is reached, the Scanner is automatically set to point back to the beginning of the file.

c. Class Scanner does not provide the ability to reposition to the beginning of the file.

15.5.1 Q2: Instance variables that are not to be output with a Serializable object are declared using which keyword? a. private b. ignoreme c. transient d. persistent

c. transient

Instance variables that are not to be output with a Serializable object are declared using which keyword? a. private b. ignoreme c. transient d. persistent

c. transient

File streams

can be used to input and output data as bytes or characters

The stack empty operation

checks to see if there is at least one item on the stack

two collect terminal operations

collect(Collector collector) collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) e.g. HashSet<String> result = stream.collect(HashSet::new, HashSet::add, HashSet::addAll);

how to create parallelism in stream

collection.parallelStream() stream.parallel()

Java's native character set is

the UTF-16 encoding of Unicode

Filtering

the filter stream provides additional functionality, such as aggregating bytes into meaningful primitive-type units.

In a list implementation of a queue, the end of the list from which elements are removed is called

the front of the queue

The getSelectedIndex method returns

the index of the selected item and -1 if no item is selected.

This method reads a single byte of data from the input stream's source and returns it as an int from 0 to 255.

the noargs "read()" method

To force the JFrame that encloses a window to resize itself automatically when a larger object is placed in the frame, use

the pack method

When a node with two children is removed from a binary search tree, it can be replaced with

the smallest node in its right subtree

In a list implementation of a stack, the end of the list at which elements are added and removed is called

the top of the stack

These data types are comprised of eight bytes:

unsigned byte and signed byte They're both made up of eight bits, and when you write an int onto a network connection using write(int b), only eight bits are placed on the wire. If an int outside the range 0-255 is passed to write(int b), the least significant byte of the number is written and the remaining three bytes are ignored. (This is the effect of casting an int to a byte.)

OutputStream's fundamental method is:

write(int b) This method takes an integer from 0 to 255 as an argument and writes the corresponding byte to the output stream. Take note that although this method takes an int as an argument, it actually writes an unsigned byte. Java doesn't have an unsigned byte data type, so an int has to be used here instead.

DataInputStream and RandomAccessFile

each implement this interface to read sets of bytes and process them as primitive-type values.

A binary tree is a collection of nodes in which

each node has at most one predecessor and at most two successors

In File class flush() frees up expensive operating system resources. True or false

false. *flush() guarantees* last *data* gets *written* to *disk*. *close() frees* up expensive operating system *resources*.

Files Path and Paths existed in Java 6. True or false

false. All were created in *Java 7*. Only *File* existed in *Java 6*

Compilers less than Java 7 uses static methods on File to create files and directories. True or false

false. Compilers <Java 7 use *instance methods* on File to *create files* and *directories*. e.g. File f = new File("C:\\a\\b\\Log.txt"); f.*mkdirs()*; f.*createNewFile()*;

Console is located in java.lang.console true or false

false. Console is located in* java.io.*Console

Java 7 Compilers use instance methods in Paths to create files and directories. True or false

false. Java 7 Compilers use *static methods* in *Paths* to create files and directories. e.g. import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main( String[] args) { Path p = Paths.*get*("C:\\a\\b\\Log.txt"); Files.*createFile*(p);} } Note: Compilers <Java 7 uses *instance methods* on File to *create files* and *directories*. e.g. File f = new File("C:\\a\\b\\Log.txt"); f.mkdirs(); f.*createNewFile()*;

secondary storage devices

hard disks, flash drives, DVDs and more

A binary tree is a collection of items in which each item

has at most two successors

Complete the following code to create an empty file using only java.nio.file; for "C:\\a\\b\\Log.txt" file import java.nio._____._____; import java.nio._____._____; import java.nio._____._____; class A { public static void main( String[] args) { Path p = _____.get("C:\\a\\b\\Log.txt"); Files._____(p);} }

import *java.nio.file.Files*; import *java.nio.file.Path*; import *java.nio.file.Paths*; class A { public static void main( String[] args) { Path p = Paths.get("*C:\\a\\b\\Log.txt*"); Files.*createFile(p)*;} }

Fill in the below blanks to enable the file path to be printed to screen on Windows OS import java._____ ._____ ; import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get(_____ ._____ ( "file:///C://a//File.txt")); System. out. println(p1); } }

import java.*net.URI*; import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths. get(*URI.create*( "file:///C://a//File.txt"*)*); System.out.println(p1); } } This results in *C:\a\File.txt* getting *printed screen* Note: URI is Uniform Resource Identifier (URI) reference e.g. *opaque* URIs are: mailto:[email protected] news:comp.lang.java urn:isbn:096139210x *hierarchical* URIs are: http://java.sun.com/j2se/1.3/ docs/guide/collections/faq.html#28 ../../../demo/jfc/SwingSet2/src/SwingSet2.java file:///~/calendar

Complete the below code that copies the contents of log1.txt to log2.txt (where log2.txt does not exist) import java._____ ._____ .Files; import java._____ ._____ .Path; import java._____ ._____ ._____ ; class A { public static void main ( String[] args) throws Exception { Path src = _____ ._____ ( "C:\\a\\log1.txt"); _____ des = _____ ._____ ( "C:\\a\\log2.txt"); _____ ._____ (src, des); } }

import java.*nio.file*.Files; import java.*nio.file*.Path; import java.*nio.file.Paths*; class A { public static void main ( String[] args) throws Exception { Path src = *Paths.get*("C:\\a\\log1.txt"); *Path* des = *Paths.get*( "C:\\a\\log2.txt"); *Files.copy*(src, des); } }

Complete the below code that deletes the file log1.txt import java._____ ._____ .Files; import java._____ ._____ .Path; import java._____ ._____ ._____ ; class A { public static void main ( String[] args) throws Exception { Path src = Paths.get( "C:\\a\\log1.txt"); Files.delete(src); }

import java.*nio.file.*Files; import java.*nio.file.*Path; import java.*nio. file.Paths*; class A { public static void main ( String[] args) throws Exception { Path src = Paths.get("*C:\\a\\log1.txt*"); Files.delete(src); }

Complete the below code that copies the contents of log1.txt to log2.txt import java._____ ._____ .Files; import java._____ ._____ .Path; import java._____ ._____ ._____ ; class A { public static void main ( String[] args) throws Exception { Path src = _____ ._____ ( "C:\\a\\log1.txt"); _____ des = _____ ._____ ( "C:\\a\\log2.txt"); _____ ._____ (src, des); } }

import java.*nio.file.*Files; import java.*nio.file.*Path; import java.*nio.file.Paths*; class A { public static void main ( String[] args) throws Exception { Path src = *Paths.get*("C:\\a\\log1.txt"); *Path* des = *Paths.get*("C:\\a\\log2.txt"); *Files.copy*(src, des); } }

Byte Streams : FileInputStream and FileOutputStream Example

import java.io.*; public class CopyFile { public static void main(String args[]) throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("input.txt"); out = new FileOutputStream("output.txt"); int c; while ((c = in.read()) != -1) { out.write(c); } }finally { if (in != null) { in.close(); } if (out != null) { out.close(); } } } }

Fill in the blanks to write the string Hello to the file f.txt (Assume the file exists). import ___.___.*; class B { public static void main(String[] args) throws Exception { File a = new File("c:\\a\\f.txt"); FileWriter writer = _______; writer._______("Hello"); writer.________; writer._________; } }

import java.io.*; class B { public static void main(String[] args) throws Exception { File a = new File("c:\\a\\f.txt"); FileWriter writer = *new FileWriter(a)*; writer.*write*("Hello"); writer.*flush*(); writer.*close*(); } }

Using BufferedReader and FileReader fill in the blanks below to read the first line within the file myFile.txt import java.io._____ ; import java.io._____ ; import java.io._____ ; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); _____ fr = new _____ (f); _____ br = new _____ (fr); System. out. println(br._____ ()); } }

import java.io.*BufferedReader*; import java.io.*File*; import java.io.*FileReader*; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); *FileReader* fr = new *FileReader(f)*; *BufferedReader* br = new *BufferedReader(fr)*; System.out.println( br.*readLine()*); } }

Fill in the blanks below to create a new file "MyFile.txt" within the newly created directories a\b import java.io._____ ; class A { public static void main(String[] args) throws Exception { _____ dir = new _____("C:\\a\\b\\"); dir._____ (); _____ f =new ____(dir,"MyFile.txt"); _____ . _____ (); } }

import java.io.*File*; class A { public static void main(String[] args) throws Exception { *File* dir=new *File*("C:\\a\\b\\"); dir.*mkdirs*(); *File* f=new *File*(dir, "MyFile.txt"); *f.createNewFile()*;} } Note: *createNewFile()* must be wrapped in a *try catch block* or the method must declare the it *throws an Exception*

Fill-in the below spaces which writes text to a file named "myFile.txt" (one line at a time). Note: "myFile.txt" exists. import java.io.____; import java.io._____; import java.io. ____; class A { public static void main( String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); ______ i = new _____(f); ______ j = new _____(i); j.println("Hello2"); j.println("World2"); j.flush(); j.close(); } }

import java.io.*File*; import java.io.*FileWriter*; import java.io.*PrintWriter*; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); *FileWriter* i=new *FileWriter*(f); *PrintWriter* j= new *PrintWriter*(i); j.println("Hello2"); j.println("World2"); j.flush(); j.close(); } } Note: Difference between *PrintWriter* and *BufferedWriter* *PrintWriter*- To get access to the *printXXX* methods (like *println(int)*) like you would use *System.out* to *write* to the *console*. *BufferedWriter* - *Efficient* way to *write* to a file as it *buffers characters* in Java *memory* before dropping to C to do the writing to the file.

Complete the code below to convert File f into the Path new class. import java.io._____ ; import java.nio._____ ._____ ; class A { public static void main(String[] args) { File f = new File("C:\\a\\b"); _____ p = f._____ (); System. out. println(p); } }

import java.io.*File*; import java.nio.*file.Path*; class A { public static void main(String[] args) { File f =new File("C:\\a\\b"); *Path* p =f.*toPath*(); System.out.println(p); } } Used to get Path with compiler less than Java 7

Complete the code below to convert Path p into the old File object. import java.io._____ ; import java.nio._____ ._____ ; class A { public static void main(String[] args) { Path p = Paths.get("C:\\a\\b"); _____ f2 = p._____ (); System. out. println(f2); } }

import java.io.*File*; import java.nio.*file.Path*; class A { public static void main(String[] args) { Path p =Paths.get("C:\\a\\b"); *File* f2 = p.*toFile*(); System.out.println(f2); } }

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); char[] pw =c.readPassword( "Enter password: "); System.out.println(___); } } Consider the user entering "Hello". fill-in the code to output what the user entered to the screen.

import java.io.Console; class A { public static void main(String[] args) { Console c =System.console(); char[] *pw*=c.readPassword( "Enter password: "); System.out.println(*pw*); } } Simply *prints* the *char array* to the screen. e.g. prompt> *Enter password:* *hello* After typing the string and pressing return it prints to the screen.

Complete the following to check if a file exists using only java.io.File; C:\\a\\b\\log.txt import java.io._____; class A { public static void main( String [] args) { _____f = new _____("C:\\a\\b\\log.txt"); System.out.println( f._____()); } }

import java.io.File; class A { public static void main( String [] args) { File f = new File("*C:\\a\\b\\log.txt*"); System.out.println( f.*exists()*); } } Will return true if file exists

Complete the following to create an empty directory using only java.io.File; for "C:\\a\\b\\" folders import java.io._____; class A { public static void main( String[] args) { File f =new _____("C:\\a\\b\\"); f._____(); } }

import java.io.File; class A { public static void main( String[] args) { File f =new File("*C:\\a\\b\\*"); f.*mkdirs()*; } } Note: The *main()* method *does not* need to declare that it *throws Exception* only when using certain File methods like *f.createNewFile()*

This is when method A calls method B, which calls method A.

indirect recursion

relative path

is "relative" to another directory, for example, a path relative to the directory in which the application began executing.

Uniform Resource Identifier (URI)

is a more general form of the Uniform Resource Locators (URLs) that are used to locate websites.

Buffering

is an I/O-performance-enhancement technique

A Java collection

is an object that is is used as a container for other objects

convert Stream to primitive stream

mapToInt(ToIntFunction<? super T> mapper) mapToLong(ToLongFunction<? super T> mapper) mapToDouble(ToDoubleFunction<? super T> mapper)

Collectors.mapping

mapping(Function, Collector)

mkdir( )

method creates a directory, returning true on success and false on failure. Failure indicates that the path specified in the File object already exists, or that the directory cannot be created because the entire path does not exist yet.

mkdirs()

method creates both a directory and all the parents of the directory.

When writing a string to a binary file or reading a string from a binary file, it is recommended that you use

methods that use UTF-8 encoding

SecurityException

occurs if the user does not have permission to write data to the file

A race condition occurs when the correctness of a computation depends on the:

relative timing or interleaving of multiple threads at runtime

In this sorting algorithm, the smallest value in the array is located and moved to position 0. Then the next smallest value is located and moved to position 1. This process continues until all of the elements have been placed in their proper order.

selection sort

This search algorithm steps sequentially through an array, comparing each item with the search value.

sequential search

This search algorithm will search half the array on average.

sequential search

3 stream intermediate operations for transformation

filter(Predicate<? super T> predicate) map(Function<? super T, ? extends R> mapper) flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) e.g. List<String> zero = Arrays.asList(); List<String> one = Arrays.asList("Bonobo"); List<String> two = Arrays.asList("Mama Gorilla", "Baby Gorilla"); Stream<List<String>> animals = Stream.of(zero, one, two); animals.flatMap(l -> l.stream()).forEach(System.out::println);

Common operations

filter, map, reduce, find, match, sort, etc

FilterInputStream

filters an InputStream

FilterOutputStream

filters an OutputStream.

A/An ______ block will still execute even if it is placed after a return statement

finally

We typically use a/an ______ block to execute final clean up commands when using a try/catch block

finally

In Java 6 and earlier, it's wise to close a stream in a _______ _______.

finally block (sometimes called the dispose pattern)

Always ______ and close your buffered streams

flush

If we want to clear the data in a buffer, we need to use the ______ method

flush

A binary search tree is structured in such a way that

for each node, the left child holds a value that is less than the node, and the right child holds a value that is greater

If we want to read data from a client Socket, we must first call the ______ method on that Socket

getInputStream()

If we want to write data to a client Socket, we must first call the ______ method on that Socket

getOutputStream()

collectors - groupingBy

groupingBy(Function<T, K> classifier) groupingBy(Function<T, K> classifier, Collector downstream) groupingBy(Function<T,K> classifier, Supplier<M> mapFactory, Collector downstream) e.g. Map<String, List<Locale>> countryToLocales = locales.collect(Collectors.groupingBy(Locale::getCountry)); Map<String, City> stateToLargestCity = cities.collect(groupingBy(City::getState, maxBy(Comparator.comparing(City::getPopulation))));

The method findMax shown below is supposed to return the position of the largest value in the portion of an array between 0 and last, inclusive: int findMax(int array[ ], int last) { int maxPos = 0; for (int k = 1; k <= last; k++) { // Code is Missing } return maxPos; } The missing code is

if (array[k] > array[maxPos]) maxPos = k;

A list can be considered a recursive data structure because

if you remove the head of the list, what remains is also a list

The code executed by the method run() depends on the:

implementation provided for run() in a derived class

What do you need to import to use File FileWriter FileReader BufferedReader BufferedWriter PrintWriter in your code

import *java.io.**;

Complete the following code to create an empty file using only java.io.File; for "C:\\a\\b\\Log.txt" folders: import java.io._____; class A { public static void main(String[] args) throws Exception { _____f = new _____("C:\\a\\b\\Log.txt"); f._____(); } }

import *java.io.File;* class A { public static void main(String[] args) *throws Exception* { File f = new File("*C:\\a\\b\\Log.txt*"); f.*createNewFile();* } } Note: *createNewFile()* must be wrapped in a *try catch block* or the method must declare the it *throws an Exception*

Complete the following to create an empty directory using with java.nio.file; for C:\\a\\b\\ import java._____._____._____; import java._____._____._____; import java._____._____.Paths; class A { public static void main( String [] args) throws Exception { Path p=_____._____( "C:\\a\\b\\"); Files._____(p); } }

import *java.nio.file.Files*; import *java.nio.file.Path*; import *java.nio.file.Paths*; class A { public static void main( String [] args) throws Exception { Path p=Paths.get( "*C:\\a\\b\\*"); Files.*createDirectories*(p); } } Note: it's best to *declare* that the *main() method throws Exception* when dealing *createDirectories*(p);

Complete the following to create an empty directory using only java.io.File; for C:\\a\\ import java._____.File; class A { public static void main( String [] args) { _____f =new _____( "C:\\a\\"); f._____(); } }

import java.io.File; class A { public static void main( String [] args) { File f =new File( "*C:\\a\\b\\*"); f.*mkdir()*; } }

Complete code to check if a file named MyFile.txt exists within the directory C:\a\b import java.io._____; class B { public static void main(String[] args) { File f = new File("_______"); System.out.println(f._____()); } }

import java.io.File; class B { public static void main(String[] args) { File f = new File("*c:\\a\\b\\MyFile.txt*"); System.out.println( *f.exists()*); } }

Complete the following to check if a file exists using only java.nio.file; C:\\a\\b\\log.txt import java.nio.file._____; import java.nio.file._____; import java.nio.file._____; class A { public static void main(String[] args) { _____ p = Paths.get("*C:\\a\\b\\log.txt*"); System.out.println( Files._____(p)); } }

import java.nio.file.*Files*; import java.nio.file.*Path*; import java.nio.file.*Paths*; class A { public static void main(String[] args) { Path p = Paths.get("*C:\\a\\b\\log.txt*"); System.out.println( *Files.exists(p)*); } } Will return true if file exists

Complete the code below that builds the path for a file location. import java.____.file.____; import java.____.file.____; class A { public static void main(String[] args) { Path p1 = _____ ._____ ( "C:\\a\\b\\File.txt"); System. out. println(_____ ); } }

import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = *Paths.get*( "C:\\a\\b\\File.txt"); System.out.println(*p1*); } } Note: the file location does not need to exist physically.

A queue is a container that allows elements to be stored and removed

in a first-in-first-out fashion

A stack is a container that allows elements to be stored and removed

in a last-in-first-out fashion

This sorting algorithm begins by sorting the initial portion of the array consisting of 2 elements. Then, the third element is moved to its correct position, relative to the first two elements.

insertion sert

Code to convert a signed byte into an unsigned byte example:

int i = b >= 0 ? b : 256 b;

InputStream is a/an ______

interface

OutputStream is a/an ______

interface

In a linked list, the predecessor of a node X

is undefined if X is the first node, otherwise it is the node whose index is one less than the index of X

Class Scanner

is used extensively to input data from the keyboard. This class can also read data from a file

separator character

is used to separate directories and files in a path.

An ArrayList is so called because

it is implemented as a class that uses an internal array to hold the elements of the list

Java's basic input class is

java.io.InputStream

Java's basic output class is

java.io.OutputStream

The two abstract superclasses that define the basic API for reading and writing characters

java.io.Reader and java.io.Writer

If you are writing an iterator class, it must implement this interface

java.util.Iterator

3 stream intermediate operations for extracting/combining substreams

limit(long n) skip(long n) Stream.concat(Stream<? extends T> s1, Stream<? extends T> s2) p.s. stateful operation limit and skip

This is the number of elements actually stored in a list

list size

other terminal operations aside from collect

long count() void forEach(Consumer<? super T> action) void forEachOrdered(Consumer<? super T> action) Object[] toArray()<A> A[] toArray(IntFunction<A[]> generator) e.g. String[] result = words.toArray(String[]::new);

A binary tree with no root

must be empty

Method that inserts a platform-dependent line-separator string into the output

newLine()

The objects that form the units of memory allocation in a linked lists are called

nodes

FormatterClosedException

occurs if the Formatter is closed when you attempt to output.

NoSuchElementException

occurs if the data being read by a Scanner method is in the wrong format or if there is no more data to input.

FileNotFoundException

occurs if the file does not exist and a new file cannot be created.

Java program

opens a file by creating an object and associating a stream of bytes or characters with it.

Monitor Pattern serializes:

operation on shared objects

Character-based streams

output and input data as a sequence of characters in which every character is two bytes—the number of bytes for a given value depends on the number of characters in that value.

Byte-based streams

output and input data in its binary format—a char is two bytes, an int is four bytes, a double is eight bytes, etc.

Formatter

outputs formatted Strings to the specified stream.

The predecessor of a node in a binary tree is called its

parent

stream intermediate operation that is useful for debugging

peek(Consumer<? super T> action) p.s. stateless operation

The constructor for a ServerSocket takes one parameter, which is the ______

port

The three standard techniques for traversing a binary tree are

preorder, inorder, and postorder

A.java and Log.txt below are located in folder: C:\a What is the the output when code run? import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get("C:\\a\\Log.txt"); System. out. println( p1.isAbsolute()); }}

prints true. Paths.get("*C:\\a\\Log.txt*"); is an *absolute path*

Each thread in java has it's own call stack and:

program counter

list( ) method

provided by File object to list down all the files and directories

Class System

provides methods setIn, setOut and setErr to redirect the standard input, output and error streams, respectively.

Files class

provides static methods for common file and directory manipulations, such as copying files; creating and deleting files and directories; getting information about files and directories; reading the contents of files; getting objects that allow you to manipulate the contents of files and directories; and more

Fill in the blank below to get in separator on your particular operating system: public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("a"); bw.write(______.________()); bw.write("b"); bw. flush(); bw.close(); }

public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); BufferedWriter bw = new BufferedWriter(fw); bw.write("a"); bw.write( *System.lineSeparator()*); bw.write("b"); bw.flush(); bw.close(); } The above called will *print a* and *b* (on *separate lines*).

A stream of cars going through a toll booth is an example of a

queue

List two methods from BufferedReader

read() - Reads a *single character*. readLine() - Reads a *line of text*.

The two overloaded read() methods that fill a specified array with multiple bytes of data read from the stream:

read(byte[] input) *attempts to fill the specified array input. read(byte[] input, int offset, int length) *attempts to fill the specified subarray of input, starting at offset and continuing for length bytes.

Method that reads a single line of text and returns it as a string

readLine()

To add an element e just after a node referenced by ref, you should use the statement

ref.next = new Node(e, ref.next);

When you create an instance of a generic class, what types can you pass as arguments to the class's type parameter?

reference types only

when you create an instance of a generic class, what types can you pass as arguments to the class's type parameter?

reference types only

serialized object

represented as a sequence of bytes that includes the object's data and its type information.

the stack peek operation

returns the item at the top of the stack, but does not remove it

describe Optional get instance method

returns the wrapped element or NoSuchElementException

A thread class manages a single:

sequential execution

This listiterator method replaces an existing element with a new element

set

Difference between signed byte and unsigned byte:

signed byte values: -128 to 127 unsigned byte values: 0 to 255

Compilers of modern programming languages support method calls and returns with an internal

stack

enumerate stateful vs stateless operations

stateful -distinct() -sorted() / sorted(Comparator<T> c) -skip(long n) -limit(long n) stateless -all other

System.exit

static method terminates an application

Sequential-access files

store records in order by the record-key field.

TelnetInputStream and TelnetOutputStream are undocumented classes hidden inside the:

sun.net package

In a list implementation of a queue, the end of the list at which elements are added is called

the rear of the queue

In a binary tree,

there must be at most one node with no predecessor

If we don't want to use a try/catch block in our method despite the risk of a checked exception being thrown, we can instead use the ______ keyword to pass the responsibility of handling the exception to the caller of our method

throws

If we want to indicate that a method can produce a particular exception type, we need to use the ______ keyword

throws

another version of toMap() for parallel processing

toConcurrentMap(**)

A systematic method that starts at the beginning of the list and processes every node is called

traversal

File FileWriter FileReader BufferedReader BufferedWriter PrintWriter are located in java.io true or false

true

File FileWriter FileReader BufferedReader BufferedWriter PrintWriter need to have be wrapped in a try/catch block or declare that method throws an Exception. true or false

true

Files and Paths contain only static methods. true or false?

true

In File class flush() guarantees last data gets written to disk. close() frees up expensive operating system resources. true or false

true

Path is located in java.nio.file.Path true or false

true

The file "myFile.txt" has two lines containing the following on separate lines: a b When the below code executes "a" and "b" get overwritten resulting in the following on separate lines. c d True or false import java.io.File; import java.io.FileWriter; import java.io.PrintWriter; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); PrintWriter pw = new PrintWriter(fw); pw.println("c"); pw.println("d"); pw.flush(); pw.close(); } }

true

BufferedWriter is more efficient than FileWriter true or false

true. *BufferedWriter* is *more efficient* FileWriter As *FileWriter* writes *single chars* at a time Whereas BufferedWriter *writes chunks* of data to file

Console is located in java.io.Console true or false

true. Console contains methods to access the *PHYSICAL DEVICES* i.e. *keyboard/monitor*

Java 7 Compilers use static methods in Paths to create files and directories.

true. e.g. Path p = Paths.get("C:\\a\\b"); Files.*createDirectories*(p);

In Java 8 we can use a/an _____ to automatically close designated resources when a try/catch block finishes executing

try-with-resources

When accessing resources outside of the managed memory of the JVM, Java requires you to use ______

try/catch blocks

To compare String objects for the purpose of sorting, a programmer should

use the compareTo method of the Comparable interface

File.separator

use to obtain the local computer's proper seperator character rather than explicitly using /or\.

How do you write a byte to an output stream? How do you write multiple bytes to output stream?

write(byte) write(byte[ ])

Look at the following method. public static int Test2(int x, int y) { if ( x < y) { return -5; } else { return (Test2(x - y, y + 5) + 6); } } What is the base case for the method?

x<y

When you create an instance of the JList class,

you pass an array of objects to the constructor

In Java 7, closing a stream is possible with:

"try with resources" The finally clause is no longer needed. Java automatically invokes close() on any AutoCloseable objects declared inside the argument list of the try block. *try with resources can be used with any object that implements the Closeable interface,

List two constructors with parameters of File class

#1 *File(File parent, String child)* - Creates a new File instance from a parent abstract pathname and a child pathname string. #2 *File(String pathname)* - Creates a new File instance by converting the given pathname string into an abstract pathname.

PrintStream

(a subclass of FilterOutputStream) performs text output to the specified stream.

System.in

(standard input stream) object normally inputs bytes from the keyboard

System.err

(the standard error stream object) normally outputs character-based error messages to the screen.

System.out

(the standard output stream object) normally outputs character data to the screen

Console contained a method a returns a string containing whatever the user entered. What is the name of this method?

*readLine()* - Reads a single line of text from the console.

Console input method can be used to not echo password. What is the name of this method?

*readPassword()* - Reads a password or passphrase from the console with *echoing disabled*

three stream objects

- System.in - System.out - System.err

Stream

- a sequence of data - two kinds of Streams = InPutStream, OutPutStream

Creating Directories: 2 useful File utility methods

- mkdir( ) - mkdirs()

Character Streams

- perform input and output for 16-bit unicode - most frequently used classes are, FileReader and FileWriter. - Though internally FileReader uses FileInputStream and FileWriter uses FileOutputStream but here the major difference is that FileReader reads two bytes at a time and FileWriter writes two bytes at a time.

What are the main problems with PrintStream?:

- the output from println() is platform dependent - PrintStream assumes the default encoding of the platform on which it's running - PrintStream eats all exceptions (PrintStream relies on an outdated and inadequate error flag) * PrintWriter still has the problems of platform dependency and minimal error reporting that plague PrintStream

Byte Streams

- used to perform input and output of 8-bit bytes - most frequently used classes are, FileInputStream and FileOutputStream.

All three read() methods return _________ to signal the end of the stream.

-1

reduction or terminal operation

-consumes the stream pipeline. -it does not produce another stream like intermediate operations. -it produces a result or a side-effect.

2. Character Streams

1. All character stream classes are descended from *Reader and Writer*. 2. character stream classes that specialize in file I/O: *FileReader and FileWriter*. The constructors of these class assume that the default character encoding and the default byte-buffer size.

For the File Input Stream, what are some commonly used constructors?

1. File Input Stream (File file) -creates a File input stream by opening a connection to a File object 2. FileInputStream(String pathname) -creates a FileInputStream by opening a connection to a file using its path

How do you create a file output stream object?

1. FileOutputStream(file1) - creates a file output stream to write data to file1 2. FileOutStream(pathname)

NOTE

1. Programs use byte streams to perform input and output of 8-bit bytes 2. All byte stream classes are descended from InputStream and OutputStream abstract classes. 3. all other stream types are built on byte streams. 4. Byte stream classes that specialize in file I/O: FileInputStream and FileOutputStream are concreate samples of Byte steam. We also have many for different purposes. 5. Its always good practice to close opened stream in finally block.

For the File Input Stream, what are some commonly used methods?

1. read() -returns an int which contains the byte value of the byte read 2. close() -all streams must be closed

*Create Buffer Streams*

1. unbuffered stream object is passed to the constructor for a buffered stream class. inp = new BufferedReader(new FileReader("x.txt")); out = new BufferedWriter(new FileWriter("c.txt"));

Three methods to fix race conditions:

1. use thread safe class concurrent.atomic 2. locking or synchronized access 3. thread confinement

Look at the following pseudocode algorithm. algorithm Test14(int x) if (x < 8) return (2 * x) else return (3 * Test14(x - 8) + 8) end Test14 What value is returned for Test14(16)?

Default buffer sizes for BufferedOutputStream / BufferedInputStream:

512 bytes for an output stream 2,048 bytes for an input stream

BufferedInputStream

A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods.

ByteArrayInputStream

A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream.

Closeable

A Closeable is a source or destination of data that can be closed.

FileInputStream

A FileInputStream obtains input bytes from a file in a file system.

FilterInputStream

A FilterInputStream contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.

Flushable

A Flushable is a destination of data that can be flushed.

Which receives characters from a Java program and converts these into bytes according to a specified encoding and writes them onto an underlying output stream? A OutputStreamWriter B OutStreamWriter C OutWriter D OutputStreamer

A OutputStreamWriter

PrintStream

A PrintStream adds functionality to another output stream, namely the ability to print representations of various data values conveniently.

PushbackInputStream

A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte.

SequenceInputStream

A SequenceInputStream represents the logical concatenation of other input streams.

StringReader

A character stream whose source is a string.

PushbackReader

A character-stream reader that allows characters to be pushed back into the stream.

DataInputStream

A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way.

DataOutputStream

A data output stream lets an application write primitive Java data types to an output stream in a portable way.

ObjectStreamField

A description of a Serializable field from a Serializable class.

FileOutputStream

A file output stream is an output stream for writing data to a File or to a FileDescriptor.

FileFilter

A filter for abstract pathnames.

Which class specifies the API by which characters are read? A java.io.Reader B java.io.Read C java.io.Writer D java.io.Write

A java.io.Reader

If a new element is added to an ArrayList whose internal array if already full,

A new, bigger internal array is created, the elements are moved to the new array, the old internal array is deleted, and then the new element is added

PipedOutputStream

A piped output stream can be connected to a piped input stream to create a communications pipe.

What is serialization?

A process of saving state of a java object to a sequence of bytes. -this sequence of bytes can be sent over a network or stored to a file.

What is a thread?

A separate process in your computer An in

Stream

A stream is a sequence of data items that are conceptually produced one at time. Streams allow manipulate collections of data in declarative way. Stream are "fancy iterators over a collection of data".

new code should use: A. PrintWriter B. PrintStream

A. PrintWriter

InputStreamReader

An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified charset.

ObjectInputStream

An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream.

File

An abstract representation of file and directory pathnames.

Buffers are not thread-safe. You must employ synchronization when you want to access a buffer from multiple threads.

Are buffers thread safe?

What is the complexity/Difficulty when dealing with threads?

Arises when multiple threads need to access the same resources.

Which is used to take text from the buffer rather than directly from the underlying input stream or other test source? A BufferReader B BufferedReader C BufferRead D BufferedRead

B BufferedReader

Which subclass of InputStream is used to read data from a file? A FileStream B FileInputStream C FileInputOutputStream D FileIOStream

B FileInputStream

functional interface for Boolean??

BooleanSupplier boolean getAsBoolean()

The flush() method

Breaks a deadlock by forcing the buffered stream to send its data even if the buffer isn't yet full. For example, suppose you've written a 300-byte request to an HTTP 1.1 server that uses HTTP Keep-Alive. You generally want to wait for a response before sending any more data. However, if the output stream has a 1,024-byte buffer, the stream may be waiting for more data to arrive before it sends the data out of its buffer. No more data will be written onto the stream until the server response arrives, but the response is never going to arrive because the request hasn't been sent yet!

Classes avaialable to wrap UnBuffered Streams

Buffer Byte Streams: 1. BufferedInputStream 2. BufferedOutputStream Buffered Char Streams: 1. BufferedReader 2. BufferedWriter

We can increase the efficiency of our OutputStreams by using the stream type ______

BufferedOutputStream

The ___________/___________ classes store written data in a buffer (a protected byte array field named buf) until the buffer is full or the stream is flushed

BufferedOutputStream / BufferedInputStream *BufferedInputStream has two constructors, as does BufferedOutputStream:

BufferedReader reads _______ of data to file

BufferedReader reads *CHUNKS* of data to file

BufferedWriter writes _______ of data to file

BufferedWriter writes *CHUNKS* of data to file

What are the two types of stream data?

Byte based/ Character based.

import java.net.URI; import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get(URI.create( "file:///C://a//File.txt")); System.out.println(p1); } } Consider the above code running on Windows. The above code will give: a) compiler error b) runtime error c) compile and print C:\a\File.txt d) none of the above

C is correct.

setFileSelectionMode

Call method specifies what the user can select from the fileChooser

ObjectInputValidation

Callback interface to allow validation of objects within a graph.

Yes

Can an inner catch re throw an expiation to an outer Catch?

What should you always do before creating a file?

Check to see if it exists. This is a good habit. try{ if(!file.exist()){ create file } }

Java has two kinds of exceptions: ______ Exceptions and Runtime Exceptions

Checked

______ require a user to surround the throwing method invocation with a try/catch block

Checked Exceptions

ObjectInputStream and ObjectOutputStream

Classes (package java.io). which respectively implement the ObjectInput and ObjectOutput interfaces, enable entire objects to be read from or written to a stream

This class provides numerous static methods that perform useful operations on collections

Collections

Sequence of elements

Collections are about data; Streams are about computations

collectors - statistics

collectors - maps (terminal operation)

Collectors.toMap(Function<T,R> keyMapper, Function<T,R> valueMapper) Collectors.toMap(Function<T,R> keyMapper, Function<T,R> valueMapper, BinaryOperator mergeFunction) Collectors.toMap(Function<T,R> keyMapper, Function<T,R> valueMapper, BinaryOperator mergeFunction, Supplier<M extends Map> mapSupplier) e.g. Map<Integer, String> personNameMap = persons.collect(Person::getId, Person::getName); Map<Integer, Person> personMap = persons.collect(Person::getId, Function.identity()); Map<Integer, Person> personTreeMap = persons.collect(Person::getId, Function.identity(), TreeMap::new);

basic collectors

Collectors.toSet() Collectors.toList() Collectors.toCollection(Supplier<T> t) Collectors.counting() e.g. Collectors.toCollection(TreeSet::new)

This is an object that can compare two other objects and determine whether one is greater than, less than, or equal to the other

Comparator

Using a for-each loop complete the code below to write out the password to the screen in boolean format. import java.io.Console; class A { public static void main(String[] args) { Console c = System. console(); char[] pw = c. readPassword( "Enter password: "); for(char curChar: _____ ) { c._____ (_____ , _____ ); } }}

Console c = System.console(); char[] pw=c.readPassword( "Enter password: "); for(char curChar: *pw*) { c.*format("%b", curChar)*; } e.g. prompt:> *Java A* prompt:> *Enter Password:* hello prompt:> truetruetruetruetrue

Using a for-each loop complete the code below to write out the password to the screen in string format. import java.io.Console; class A { public static void main(String[] args) { Console c = System.console(); char[] pw = c.readPassword( "Enter password: "); for(char curChar: pw) { c._____ (_____ , curChar); } }}

Console c = System.console(); char[] pw=c.readPassword( "Enter password: "); for(char curChar: pw) { c.*format*(*"%s"*, curChar); } e.g. c:> *Java A* c:> *Enter Password:* hello c:> hello

Console contains methods to access the _____ _____

Console contains methods to access the *PHYSICAL DEVICES* i.e. *keyboard/monitor*

ObjectStreamConstants

Constants written into the Object Serialization Stream.

FileReader

Convenience class for reading character files.

FileWriter

Convenience class for writing character files.

persistent data

Data maintained in files exists beyond the duration of program execution

The ____________/____________ classes provide methods for reading and writing Java's primitive data types and strings in a binary format

DataInputStream and DataOutputStream

readLine()

DataInputStream provides the popular readLine() method that reads a line of text as delimited by a line terminator and returns a string:

What should you know for the test?

Example of deadlock Example of race condition

All exceptions inherit from the ______ class

Exception

What is the difference between printwriter and FileOutputStream?

F.O.S writes to a file as a streams of bytes P.W writes to a file using characters

T/F: Streams are asynchronous

False Streams are synchronous; that is, when a program (really a thread) asks a stream to read or write a piece of data, it waits for the data to be read or written before it does anything else

BufferedWriter is less efficient than FileWriter true or false

False. *BufferedWriter* is *more efficient* than FileWriter As FileWriter writes *single chars* at a time whereas *BufferedWriter* writes *chunks of data to file*

Type out the code used to create a file in Java

File file = new File("fileName"); Creates a file in the directory it was run from

File makes a new _____ file but not the data.

File makes a new *EMPTY* file.

Example

FileInputStream in = new FileInputStream("xanadu.txt"); FileOutputStream out = new FileOutputStream("outagain.txt"); int c; while ((c = in.read()) != -1) { out.write(c);

What class am I? I read characters (single or whole) stream of chars from a file.

FileReader class

FileReader class _____ characters ( _____ or whole) in a _____ of chars from a file.

FileReader class *READ* characters (*SINGLE* or whole) in a *STREAM* of chars from a file.

example of FileReader and FileWriter. *This will read character by character and write it.*

FileReader inputStream = new FileReader("xanadu.txt"); FileWriter outputStream = new FileWriter("characteroutput.txt"); int c; while ((c = inputStream.read()) != -1) { outputStream.write(c)

FileReader reads _______ chars from a _____at a time

FileReader reads *SINGLE* chars from a *FILE* at a time

What class am I? write characters (single or whole) in a stream of chars to a file.

FileWriter class

What is a stream (generally speaking)?

Flow of data Sequence of data and bytes or uni-code characters in some sort of sequential queue.

What does flush() do?

Flushes all the data written to the output stream to the destination. Bytes written to output stream may not have been fully written to storage yet. There is a chance data might be stored in memory somewhere. Calling flush guarantees any buffer data is flushed a.k.a written to the file

The constructor for a Socket takes two parameters, one is the port and the other is the ______

IP Address

We can read data from a file by using a/an ______

InputStream

3 types of Stream Primitive

IntStream LongStream DoubleStream

can you convert from one primitive stream to another

IntStream - asDoubleStream(), asLongStream() LongStream = asDoubleStream() DoubleStream - none mapToInt(XtoYFunction f) mapToLong(XtoYFunction f) mapToDouble(XtoYFunction f)

tagging interface

It does not contain methods

An ArrayList is so called because

It is implemented as a class that uses an internal array to hold the elements of the list

Why you should flush all streams immediately before you close them?

It's important to flush your streams whether you think you need to or not. Depending on how you got hold of a reference to the stream, you may or may not know whether it's buffered. (For instance, System.out is buffered whether you want it to be or not.) Failing to flush when you need to can lead to unpredictable, unrepeatable program hangs that are extremely hard to diagnose if you don't have a good idea of what the problem is in the first place.

What improvement does PrintWriter have over the PrintStream class?

It's internationalizable: PrintWriter offers four write() methods, which write characters rather than bytes; also, if the underlying writer properly handles character set conversion, so do all the methods of the PrintWriter.

FILES_AND_DIRECTORIES

JFileChooser static constant that indicate that files and directories can be selected

This class is a good choice to use when your application will be storing a large amount of data in a list, and a lot of insertions and/or deletions are likely to take place

LinkedList

This list class stores its elements in a data structure that is made of a series of connected nodes

LinkedList

The concrete classes that implement the List interface are

LinkedList, ArrayList, and Vector

NOTE

Most of the classes covered in the I/O Streams section are in the java.io package 1. Byte Streams 2. Character Streams 3. Buffered Streams. 4. Data Streams. 5. Object Streams.

The Java notation MyClass<Student> means that

MyClass is a generic class

If the stack method push is called on an empty stack

None of the above

A Node class for a linked list that can hold elements of type Object can be declared to have fields

Object element; Node next;

The most important concrete subclass of Writer

OutputStreamWriter

Draw an Output stream diagram

PROGRAM ---> OUTPUT STREAM ---> DESTINATION (Dest. could be File, Storage unit) In the output stream there is data that is waiting to be produced into something

PipedReader

Piped character-input streams.

PipedWriter

Piped character-output streams.

Which of the following generic type notations uses a wldcard?

Point<?>

PrintWriter contains extra ______ for _________. Makes it more _____ and ________ than Writer

PrintWriter contains extra *METHODS* for *FORMATTING*. Makes it more *FLEXIBLE* and *POWERFUL* than Writer

PrintWriter

Prints formatted representations of objects to a text-output stream.

This sorting algorithm recursively divides an array into sublists.

Quiksort

What are the two basic functions you can do with a stream?

Read or write.

character based IO

Reader and writer are at the top of the ________class hierarchies.

Java has two kinds of exceptions: Checked Exceptions and ______ Exceptions

Runtime

hasNext

Scanner method determines whether the end-of-file key combination has been entered.

Selection sort

Serializable

Serializability of a class is enabled by the class implementing the java.io.Serializable interface.

A/An ______ is used to connect to a remote resource such as a server

Socket

ServerSocket.accept() returns a/an ______

Socket

Class "Outputstream" provides these methods:

Subclasses of OutputStream use these methods to write data onto particular media:

optional methods for producing alternative

T orElse(T other) T orElseGet(Supplier<? extends T> other) <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X extends Throwable

overloaded of reduce()

T reduce(T identity, BinaryOperator<T> accumulator) T reduce(T identity, BinaryOperator<T> accumulator) U reduce( U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator combiner) e.g. int result = words.reduce(0, (total, word) -> total + word.length(), (total1, total2) -> total1 + total2);

DataInput

The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types.

DataOutput

The DataOutput interface provides for converting data from any of the Java primitive types to a series of bytes and writing these bytes to a binary stream.

InPutStream

The InputStream is used to read data from a source.

Which of the following is true?

The ListIterator interface is a subinterface of the Iterator interface

OutPutStream

The OutputStream is used for writing data to a destination.

StreamTokenizer

The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time.

*NOTE*

The above two I/o are less efficient as each read or write request is handled directly by the underlying OS. This can make a program much less efficient, since each such request often triggers disk access, network activity. To Overcome this Buffer I/O is implemented in Java.

BufferedOutputStream

The class implements a buffered output stream.

What does the close() method do?

The close() method releases any resources associated with the stream, such as file handles or ports. If the stream derives from a network connection, then closing the stream terminates the connection

A new element is added to an ArrayList object at index k. Assuming the list has size s and does not have to be resized,

The elements at current positions k..s-1 must be moved toward the end of the array

What is de-serialization?

The process of building object state back after reading a sequence of bytes from over a network or from a stored file.

Which of the following is true?

The remove() method of an iterator can only be called after next() has been called

Method to to skip over data without reading it.

The skip() method

writeBytes()

The writeBytes() method iterates through the String argument but writes only the least significant byte of each character. Thus, information will be lost for any string with characters from outside the Latin-1 character set.

writeChars()

The writeChars() method simply iterates through the String argument, writing each character in turn as a two-byte, big-endian Unicode character (a UTF-16 code point, to be absolutely precise).

List one method from FileReader class

There are *no methods* in *FileReader*. However *methods inherited* from: java.lang.*Object* java.io.*InputStreamReader* java.io.*Reader* From java.io.*Reader*: read() - Reads a *single character*

File Navigation and I/O

There are several other classes that we would be going through to get to know the basics of File Navigation and I/O. File Class FileReader Class FileWriter Class

Bridge streams

There are two general-purpose byte-to-character "bridge" streams: *InputStreamReader* and *OutputStreamWriter*. The charset that it uses may be specified by name or may be given explicitly.

ByteArrayOutputStream

This class implements an output stream in which the data is written into a byte array.

LineNumberInputStream Deprecated

This class incorrectly assumes that bytes adequately represent characters.

FilePermission

This class represents access to a file or directory.

Standard Streams : Standard Input

This is used to feed the data to user's program and usually a keyboard is used as standard input stream and represented as System.in.

Why does the Java Collections Framework define a List as an interface rather than a class?

To allow different types of concrete classes, with different performance characteristics to implement the interface

In File class close() method frees up expensive operating system resources

True.

Compilers less than Java 7 uses instance methods on File to create files and directories. True or false

True. e.g. File f = new File("C:\\a\\b\\Log.txt"); f.*createNewFile()*;

15.7.1 Q1: Which of the following statements is false? a. InputStream and OutputStream are abstract classes for performing byte-based I/O. b. Tubes are synchronized communication channels between threads. c. A filter stream provides additional functionality, such as aggregating data bytes into meaningful primitive-type units. FilterInputStream and FilterOutputStream are typically extended, so some of their filtering capabilities are provided by their concrete subclasses. d. A PrintStream performs text output. System.out and System.err are PrintStreams.

Tubes are synchronized communication channels between threads. Actually, pipes are synchronized communication channels between threads.

What is multi-threading?

Two or more tasks executing in a program. Many threads can run concurrently in a program.

If we want to read line by line then.

Use BufferedReader and PrintWriter which can wrap Filereader and Filewriter and has operations Readline and Println.

What code do you need to use if any code is being access by multiple threads?

Use synchronize.

The boolean contains(E element) method searches a ArrayList for a given element. A correct and efficient implementation of this method

Uses sequential search to locate the element

In an application that allows multiple threads to access a list, which concrete list class would you use?

Vector

JDK 1.4 implemented NIO in terms of the following APIs: - Buffers - Channels - Selectors - Regular expressions - Charsets The regular expression and charset APIs were provided to simplify common I/O-related tasks.

What APIs does NIO include?

ByteBuffers (and other primitive-type buffers) created via allocate() or wrap() are nondirect byte buffers. Nondirect byte buffers have backing arrays, and you can access these backing arrays via the array() method (which happens to be declared as byte[] array() in the ByteArray class) as long as hasArray() returns true. (When hasArray() returns true, you'll need to call arrayOffset() to obtain the location of the first data item in the array.)

What are nondirect byte buffers?

Reductions are terminal operations. They reduce the stream to a non-stream value that can be used in your program.

What are reductions?

- available() - mark() - markSupported() - read() - reset() - skip()

What are some methods of InputStream class?

throw an exception

What do try/catch blocks do for a program?

BufferedWriter writes text to a character-output stream (a Writer instance), buffering characters so as to provide for the efficient writing of single characters, arrays, and strings. Invoke either of the following constructors to construct a buffered writer: BufferedWriter(Writer out) BufferedWriter(Writer out, int size) The buffer size may be specified, or the default size (8,192 bytes) may be accepted. The default is large enough for most purposes. BufferedWriter includes a handy void newLine() method for writing a line-separator string, which effectively terminates the current line. BufferedReader reads text from a character-input stream (a Reader instance), buffering characters so as to provide for the efficient reading of characters, arrays, and lines. Invoke either of the following constructors to construct a buffered reader: BufferedReader(Reader in) BufferedReader(Reader in, int size) The buffer size may be specified, or the default size (8,192 bytes) may be used. The default is large enough for most purposes. BufferedReader includes a handy String readLine() method for reading a line of text, not including any line-termination characters.

What does BufferedWriter and BufferedReader do?

FileOutputStream and FileInputStream are useful for writing and reading bytes and arrays of bytes. However, they provide no support for writing and reading primitive-type values (such as integers) and strings. For this reason, Java provides the concrete DataOutputStream and DataInputStream filter stream classes. Each class overcomes this limitation by providing methods to write or read primitive-type values and strings in an operating system-independent way: - Integer values are written and read in big-endian format (the most significant byte comes first) - Floating-point and double precision floating-point values are written and read according to the IEEE 754 standard, which specifies four bytes per floating-point value and eight bytes per double precision floating-point value. - Strings are written and read according to a modified version of UTF-8, a variable-length encoding standard for efficiently storing two-byte Unicode characters.

What does DataOutputStream and DataInputStream do?

Files are common stream destinations and sources. The concrete FileOutputStream class lets you write a stream of bytes to a file; the concrete FileInputStream class lets you read a stream of bytes from a file. FileOutputStream and FileInputStream are useful in a file-copying context.

What does FileOutputStream and FileInputStream do?

FileWriter is a convenience class for writing characters to files. It subclasses OutputStreamWriter, and its constructors, such as FileWriter(String path), call OutputStreamWriter(OutputStream). FileReader is a convenience class for reading characters from files. It subclasses InputStreamReader, and its constructors, such as FileReader(String path), call InputStreamReader(InputStream).

What does FileWriter and FileReader do?

File declares the File[] listRoots() class method to return the root directories (roots) of available file systems as an array of File objects. File[] roots = File.listRoots(); for (File root: roots) System.out.println(root);

What does File[] listRoots() method of the File class do?

Channel is also extended by the java.nio.channels.InterruptibleChannel interface. InterruptibleChannel describes a channel that can be asynchronously closed and interrupted. This interface overrides its Channel superinterface's close() method header, presenting the following additional stipulation to Channel's contract for this method: Any thread currently blocked in an I/O operation on this channel will receive AsynchronousCloseException (an IOException descendent). A channel that implements this interface is asynchronously closeable: When a thread is blocked in an I/O operation on an interruptible channel, another thread may invoke the channel's close() method. This causes the blocked thread to receive a thrown AsynchronousCloseException instance. A channel that implements this interface is also interruptible: When a thread is blocked in an I/O operation on an interruptible channel, another thread may invoke the blocked thread's interrupt() method. Doing this causes the channel to be closed, the blocked thread to receive a thrown ClosedByInterruptException instance, and the blocked thread to have its interrupt status set. (When a thread's interrupt status is already set and it invokes a blocking I/O operation on a channel, the channel is closed and the thread will immediately receive a thrown ClosedByInterruptException instance; its interrupt status will remain set.)

What does InterruptibleChannel interface do?

Threads must often communicate. One approach involves using shared variables. Another approach involves using piped streams via the PipedOutputStream and PipedInputStream classes. The PipedOutputStream class lets a sending thread write a stream of bytes to an instance of the PipedInputStream class, which a receiving thread uses to subsequently read those bytes. Attempting to use a PipedOutputStream object and a PipedInputStream object from a single thread is not recommended because it might deadlock the thread.

What does PipedOutputStream and PipedInputStream do?

Java provides the Writer and Reader classes for performing character I/O. Writer is the superclass of all writer subclasses.

What does Writer and Reader classes do?

InputStream is the superclass of all input stream subclasses.

What does abstract class InputStream do?

OutputStream is the superclass of all output stream subclasses.

What does abstract class OutputStream do?

The count method returns the number of elements of a stream.

What does count method do?

The distinct method returns a stream that yields elements from the original stream, in the same order, except that duplicates are suppressed. Stream<String> uniqueWords = Stream.of("merrily", "merrily", "merrily", "gently").distinct();

What does distinct method do?

Return the absolute form of this File object's abstract path. This method is equivalent to new File(this.getAbsolutePath()).

What does getAbsoluteFile() method of the File class do?

Return the absolute path string of this File object's abstract path. When it's already absolute, the path string is returned as if by calling getPath(). When it's the empty abstract path, the path string of the current user directory (identified via user.dir) is returned. Otherwise, the abstract path is resolved in an operating system-dependent manner. On Unix/Linux operating systems, a relative path is made absolute by resolving it against the current user directory. On Windows operating systems, the path is made absolute by resolving it against the current directory of the drive named by the path, or the current user directory when there is no drive.

What does getAbsolutePath() method of the File class do?

Return the canonical (simplest possible, absolute and unique) form of this File object's abstract path. This method throws java.io.IOException when an I/O error occurs (creating the canonical path may require file system queries); it equates to new File(this.getCanonicalPath()).

What does getCanonicalFile() method of the File class do?

Return the canonical path string of this File object's abstract path. This method first converts this path to the absolute form when necessary, as if by invoking getAbsolutePath(), and then maps it to its unique form in an operating system-dependent way. Doing so typically involves removing redundant names such as "." and ".." from the path, resolving symbolic links (on Unix/Linux operating systems), and converting drive letters to a standard case (on Windows operating systems). This method throws IOException when an I/O error occurs (creating the canonical path may require file system queries).

What does getCanonicalPath() method of the File class do?

returns the number of unallocated bytes in the partition identified by this File object's abstract path; it returns zero when the abstract path doesn't name a partition.

What does getFreeSpace() method of the File class do?

Return the file name or directory name denoted by this File object's abstract path. This name is the last in a path's name sequence. The empty string is returned when the path's name sequence is empty.

What does getName() method of the File class do?

Return the parent path string of this File object's path, or return null when this path doesn't name a parent directory.

What does getParent() method of the File class do?

Convert this File object's abstract path into a path string where the names in the sequence are separated by the character stored in File's separator field. Return the resulting path string.

What does getPath() method of the File class do?

returns the size (in bytes) of the partition identified by this File object's abstract path; it returns zero when the abstract path doesn't name a partition.

What does getTotalSpace() method of the File class do?

returns the number of bytes available to the current JVM on the partition identified by this File object's abstract path; it returns zero when the abstract path doesn't name a partition.

What does getUsableSpace() method of the File class do?

It supports bulk access to file attributes, provides a change notification facility, offers the ability to escape to file system-specific APIs, and has a service provider interface for pluggable file system implementations.

What does improved filesystem interface support?

Return true when this File object's abstract path is absolute; otherwise, return false when it's relative. The definition of absolute path is system dependent. For Unix/Linux operating systems, a path is absolute when its prefix is "/". For Windows operating systems, a path is absolute when its prefix is a drive specifier followed by "\" or when its prefix is "\\".

What does isAbsolute() method of the File class do?

Return true when this File object's abstract path refers to an existing directory.

What does isDirectory() method of the File class do?

Return true when this File object's abstract path refers to an existing normal file. A file is normal when it's not a directory and satisfies other operating system-dependent criteria. It's not a symbolic link or a named pipe, for example. Any nondirectory file created by a Java application is guaranteed to be a normal file.

What does isFile() method of the File class do?

Return true when the file denoted by this File object's abstract path is hidden. The exact definition of hidden is operating system dependent. On Unix/Linux operating systems, a file is hidden when its name begins with a period character. On Windows operating systems, a file is hidden when it has been marked as such in the file system.

What does isHidden() method of the File class do?

Return the time that the file denoted by this File object's abstract path was last modified, or 0 when the file doesn't exist or an I/O error occurred during this method call. The returned value is measured in milliseconds since the Unix epoch (00:00:00 GMT, January 1, 1970).

What does lastModified() method of the File class do?

A convenience method for calling list(), converting its array of Strings to an array of Files, and returning the Files array.

What does listFiles() method of the File class do?

The reduce method is a general mechanism for computing a value from a stream. The simplest form takes a binary function and keeps applying it, starting with the first two elements. List<Integer> values = . . .; Optional<Integer> sum = values.stream().reduce((x, y) -> x + y); In this case, the reduce method computes v0 + v1 + v2 + . . . , where the vi are the stream elements. The method returns an Optional because there is no valid result if the stream is empty. Often, there is an identity value e such that e op x = x, and you can use that element as the start of the computation. For example, 0 is the identity value for addition. Then call the second form of reduce List<Integer> values = . . .; Integer sum = values.stream().reduce(0, (x, y) -> x + y); The identity value is returned if the stream is empty, and you no longer need to deal with the Optional class.

What does reduce method do?

You can concatenate two streams with the static concat method of the Stream class.

What does stream.concat() do?

The call stream.limit(n) returns a new stream that ends after n elements (or when the original stream ends, if it is shorter). This method is particularly useful for cutting infinite streams down to size. Stream<Double> randoms = Stream.generate(Math::random).limit(100);

What does stream.limit(n) do?

the JVM default exception handler terminates execution and displays a stack trace and error message.

What happens if an exception is not caught?

The operating system monitors a collection of streams and returns an indication to the thread of which streams are ready to perform I/O. As a result, a single thread can multiplex many active streams via common code and makes it possible, in a web server context, to manage a huge number of network connections.

What is "readiness selection"?

An instance of the File class contains an abstract representation of a file or directory path (a compact map that locates and identifies a file system object).

What is a File class?

A buffer is an object that stores a fixed amount of data to be sent to or received from an I/O service (an operating system component for performing input/output). It sits between an application and a channel that writes the buffered data to the service or reads the data from the service and deposits it into the buffer.

What is a buffer?

A channel is an object that represents an open connection to a hardware device, a file, a network socket, an application component, or another entity that's capable of performing writes, reads, and other I/O operations. Channels efficiently transfer data between byte buffers and operating system-based I/O service sources or destinations.

What is a channel?

Forcing a CPU to perform I/O tasks and wait for I/O completions (such a CPU is said to be I/O bound) is wasteful of this resource. Performance can be improved by offloading these tasks to DMA controllers so that the processor can get on with other work. A channel serves as a conduit for communicating (via the operating system) with a DMA controller to efficiently drain byte buffers to or fill byte buffers from a disk.

What is a channel?

A stream is an ordered sequence of bytes of arbitrary length.

What is a stream?

Absolute path is a path that starts with the root directory symbol; no other information is required to locate the file/directory that it denotes.

What is an absolute path?

Java provides the DataOutputStream and DataInputStream classes to stream primitive-type values and String objects. However, you cannot use these classes to stream non-String objects. Instead, you must use object serialization and deserialization to stream objects of arbitrary types. Object serialization is a Java virtual machine (JVM) mechanism for serializing object state into a stream of bytes. Its deserialization counterpart is a JVM mechanism for deserializing this state from a byte stream. Note An object's state consists of instance fields that store primitive-type values and/or references to other objects. When an object is serialized, the objects that are part of this state are also serialized (unless you prevent them from being serialized). Furthermore, the objects that are part of those objects' states are serialized (unless you prevent this), and so on. Java supports default serialization and deserialization, custom serialization and deserialization, and externalization.

What is object serialization and deserialization?

What is the output of this program? class output { public static void main(String args[]) { StringBuffer c = new StringBuffer("Hello"); System.out.println(c.length()); } } a) 4 b) 5 c) 6 d) 7

InputStream subclasses such as ByteArrayInputStream support marking the current read position in the input stream via the mark() method and later return to that position via the reset() method.

What subclass of InputStream does support mark() and reset() methods?

ByteArrayOutputStream and ByteArrayInputStream are useful when you need to convert an image to an array of bytes, process these bytes in some manner, and convert the bytes back to the image.

When are ByteArrayOutputStream and ByteArrayInputStream useful?

Which exception is thrown by read() method? a) IOException b) InterruptedException c) SystemException d) SystemInputException

byte streams are useful for binary IO and character streams are optimized for Unicode.

Why does java define both byte and character streams?

Random access can speed up searching and sorting capabilities.

Why to use random access?

What is wrapping-chaining with an example from classes File FileWriter and PrintWriter in java.io?

Wrapping-chaining class is where one *object* is *passed* as a *parameter* to another. In the context of *Java I/O* e.g. *File f = new File("C:\\a\\myFile.txt");* FileWriter fw = new FileWriter(*f*); *PrintWriter pw = new PrintWriter(fw);* *pw*.println("c"); Where *FileWriter* is *wrapped* inside *PrintWriter*

BufferedWriter

Writes text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings.

built-in (primitive only) operation

File object

You use _________ to create directories, to list down files available in a directory.

Which exception is thrown by read() method? a) IOException b) InterruptedException c) SystemException d) SystemInputException

Which of these class is implemented by FilterInputStream class? a) InputStream b) InputOutputStream c) BufferedInputStream d) SequenceInputStream

Which of these class is used to read characters and strings in Java from console? a) BufferedReader b) StringReader c) BufferedStreamReader d) InputStreamReader

Which of these classes are used by Byte streams for input and output operation? a) InputStream b) InputOutputStream c) Reader d) All of the mentioned

Which of these method of class StringBuffer is used to reverse sequence of characters? a) reverse() b) reverseall() c) Reverse() d) reverseAll()

A directory

a File which can contain a list of other files and directories.

If the autoFlush argument is true, the stream will be flushed every time these events occur:

a byte array or linefeed is written or a println() method is invoked

end-of-file marker

a count of the total bytes in the file that is recorded in a system-maintained administrative data structure

In a typical circular doubly linked list, a node has

a field to store the element, and two references to keep track of successor and predecessor nodes

import java.nio.file.Path; import java.nio.file.Paths; class A { public static void main(String[] args) { Path p1 = Paths.get("C:\\a\\b\\File.txt"); System.out.println(p1); } } File location does not exist physically in memory. The above code will give: a) compiler error b) runtime error c) compile and print "C:\\a\\b\\File.txt" d) none of the above

a is correct. The *folders* and *subfolders do not* need to *exist* physically in order for this to combine.

import java.io.BufferedReader; import java.io.File; import java.io.FileReader; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileReader fr =new FileReader(f); BufferedReader br = new BufferedReader(fr); System.out.println(br.readLine()); br.flush(); br.close();} } Considering "hello world" is in file myFile.txt (where "hello" is on the first line and "world" on the second) The above code will give: a) compiler error b) runtime error c) compile and print "hello" d) none of the above

a is correct. *BufferedReader* class *does not* have a *flush()* method. If the *flush()* method was *removed* then it would *print "hello"* to the screen. Note: *flush()* is located in *BufferedWriter*.

import java.io.BufferedReader; import java.io.File; import java.io.FileReader; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); BufferedReader br = new BufferedReader(f); System.out.println(br.readLine()); br.close();} } Considering "hello world" is in file myFile.txt (where "hello" is on the first line and "world" on the second) The above code will give: a) compiler error b) runtime error c) compile and print "hello" d) none of the above

a is correct. import java.io.BufferedReader; import java.io.File; import java.io.FileReader; class A { public static void main(String[] args) throws Exception { *File f* = new File("C:\\a\\myFile.txt"); br* = new BufferedReader(*f*); System.out.println(br.readLine()); br.close();} } *BufferedReader* doesn't take File as a param. Solution: *File* object f needs to be *wrapped* in *FileReader* fr object which needs to be *wrapped* in *BufferedReader* br object in order to compile i.e. *File* wrapped in *FileReader* wrapped in *BufferedReader* e.g. File *f* = new File("C:\\a\\ myFile.txt"); FileReader *fr* = new FileReader(*f*); BufferedReader br = new BufferedReader(*fr*);

An AVL tree is

a kind of binary search tree

A list in which each stored element is associated with a reference to its successor is called

a linked list

If one thread tries to read the data and other thread tries to update the same data, it leads to an inconsistent state. Depending on the order in which the data were accessed, corrupted objects can result. This situation is often referred to as:

a race condition

Thread safety means that the fields of an object or class always maintain:

a valid state

2 ideal usages of optional

a) consumes the correct value b) produces an alternative

A serialized object is ________. a. an object represented as a sequence of bytes used to store the object's data in a file b. an object in memory that has been recreated from data in a file c. a standard output stream object used to convert objects in code to data in a file d. None of the above.

a. An object represented as a sequence of bytes used to store the object's data in a file.

15.7.2 Q1: The ________ abstract classes are Unicode character-based streams. a. Reader and Writer b. BufferedReader and BufferedWriter c. CharArrayReader and CharArrayWriter d. UnicodeReader and UnicodeWriter

a. Reader and Writer

The ________ abstract classes are Unicode character-based streams. a. Reader and Writer b. BufferedReader and BufferedWriter c. CharArrayReader and CharArrayWriter d. UnicodeReader and UnicodeWriter

a. Reader and Writer

15.5 Q2: A serialized object is ________. a. an object represented as a sequence of bytes used to store the object's data in a file b. an object in memory that has been recreated from data in a file c. a standard output stream object used to convert objects in code to data in a file d. None of the above.

a. an object represented as a sequence of bytes used to store the object's data in a file.

Which JFileChooser method returns the file the user selected? a. getSelectedFile. b. getFile. c. getOpenDialog. d. showOpenDialog.

a. getSelectedFile

15.6 Q2: Which JFileChooser method returns the file the user selected? a. getSelectedFile. b. getFile. c. getOpenDialog. d. showOpenDialog.

a. getSelectedFile.

Which JFileChooser method specifies what users can select in the dialog? a. setFileSelectionMode b. setSelectionMode c. showOpenDialog d. None of the above.

a. setFileSelectionMode

15.6 Q1: Which JFileChooser method specifies what users can select in the dialog? a. setFileSelectionMode b. setSelectionMode c. showOpenDialog d. None of the above

a. setFileSelectionMode.

The read() method is declared ____________ because subclasses need to change it to handle their particular medium

abstract

ServerSocket.______() is an example of a blocking call

To add a new value to a heap you should

add it as a leaf and then sift up

The stack push operation

adds a single item to the stack

In a complete binary tree

all of the above

The HeapSort method

all of the above

Pipes

are synchronized communication channels between threads

Which of these class is used to create an object whose character sequence is mutable? a) String() b) StringBuffer() c) Both of the mentioned d) None of the mentioned

Which of these classes are used by character streams for input and output operations? a) InputStream b) Writer c) ReadStream d) InputOutputStream

: Which of the following classes enable input and output of entire objects to or from a file? A. SerializedInputStream B. SerializedOutputStream C. ObjectInputStream D. ObjectOutputStream E. Scanner F. Formatter a. A and B. b. C and D. c. C, D, E, F. d. E and F.

b. C and D

Files static method ________ receives a Path and returns a boolean indicating whether that Path represents a directory on disk. a. isDiskDirectory b. isDirectory c. isFileDirectory d. isPath

b. IsDirectory

15.7.1 Q3: Which of the following statements is false? a. With a BufferedOutputStream each output operation is directed to a buffer large enough to hold the data of many output operations. Transfer to the output device is performed in one large physical output operation when the buffer fills. b. With a BufferedOutputStream, a partially filled buffer can be forced out to the device at any time by invoking the stream object's force method. c. With a BufferedInputStream, many "logical" chunks of data from a file are read as one large physical input operation into a memory buffer. d. With a BufferedInputStream, as a program requests data, it's taken from the buffer. When the buffer is empty, the next actual physical input operation is performed.

b. With a BufferedOutputStream, a partially filled buffer can be forced out to the device at any time by invoking the stream object's force method. Actually, it's the flush method

15.2 Q3: Streams that input bytes from and output bytes to files are known as ________. a. bit-based streams b. byte-based streams c. character-based streams d. Unicode-based streams

b. byte-based streams

Streams that input bytes from and output bytes to files are known as ________. a. bit-based streams b. byte-based streams c. character-based streams d. Unicode-based streams

b. byte-based streams

15.3 Q6: Files static method ________ receives a Path and returns a boolean indicating whether that Path represents a directory on disk. a. isDiskDirectory b. isDirectory c. isFileDirectory d. isPath

b. isDirectory

Which of the following statements is false? a. A Path represents the location of a file or directory. b. Path objects open files and provide file-processing capabilities. c. Class Paths is used to get a Path object representing a file or directory location. d. The static method get of class Paths converts a String representing a file's or directory's location into a Path object.

b. path objects open files and provide file-processing capabilities.

15.4.4 Q1: Records in a sequential file are not usually updated in place. Instead ________. a. the updated data is placed in a "surrogate" file b. the entire file is usually rewritten c. the file is truncated d. The above statement is false—records in sequential files are usually updated in place.

b. the entire file is usually rewritten

Records in a sequential file are not usually updated in place. Instead ________. a. the updated data is placed in a "surrogate" file b. the entire file is usually rewritten c. the file is truncated d. The above statement is false—records in sequential files are usually updated in place

b. the entire file is usually rewritten

Adding the services of one stream to another is known as ________. a. chaining b. wrapping c. adding d. sequencing

b. wrapping

15.5 Q3: Adding the services of one stream to another is known as ________. a. chaining b. wrapping c. adding d. sequencing

b. wrapping.

In a generic method, a type parameter is defined __________.

before the methods return type

in a generic method, a type parameter is defined

before the methods return type

This search algorithm repeatedly divides the portion of an array being searched in half.

binary search

This search algorithm requires that the array's contents be sorted.

binary search

ServerSocket.accept is an example of a/an ______

blocking call

boolean reduction operations

boolean allMatch(Predicate<? super T> predicate) - returns true if empty stream boolean anyMatch(Predicate<? super T> predicate) - retruns false if empty stream boolean noneMatch(Predicate<? super T> predicate) - returns true if empty stream **short-circuit terminal operations

other operations of Optional (similar to Stream)

boolean filter(Predicate<? super T> predicate) Optional map(Function<? super T, ? extends U> mapper) Optional flatMap(Function<? super T,Optional> mapper) **flatMap - for chaining multiple map optional e.g. Double result = Optional.of (-4.0).flatMap(Test::inverse).flatMap(Test::squareRoot)

optional methods for consuming values

boolean isPresent() void ifPresent(Consumer<? super T> consumer)

convert primitive stream to Stream

boxed() mapToObj(IntFunction<? extends U> mapper) mapToObj(LongFunction<? extends U> mapper) mapToObj(DoubleFunction<? extends U> mapper)

File a = new File("c:\\a"); File f = new File(a,"f.txt"); System.out.println( f.createNewFile()); System.out.println(f.exists()); The folder and file does not exist. The above code will give: a) compiler error b) runtime error c) Compile and Print "true true" d) None of the above

c is correct. f.*createNewFile() creates* "f.txt" and prints '*true*' f.*exists()* prints *true*. Note: If folder and *file exist already* then: f.*createNewFile() prints *false* and f.*exists()* prints *true*

Which of the following statements is false? a. A DirectoryStream enables a program to iterate through the contents of a directory. b. Character-based input and output can be performed with classes Scanner and Formatter. c. A relative path contains all the directories, starting with the root directory, that lead to a specific file or directory. d. Every file or directory on a disk drive has the same root directory in its path.

c. A relative path contains all the directories, starting with the root directory, that lead to a specific file or directory.

Which of the following statements is true? a. Class Scanner provides the ability to reposition to the beginning of a file with method seek. b. Class Scanner provides the ability to reposition to the beginning of a file with method reposition. c. Class Scanner does not provide the ability to reposition to the beginning of the file. d. If it is necessary to read a sequential file again, the program can simply keep reading—when the end of the file is reached, the Scanner is automatically set to point back to the beginning of the file.

c. Class scanner does not provide the ability to reposition to the beginning of the file.

15.3 Q2: Class ________ provides static methods for common file and directory manipulations, including methods for copying files; creating and deleting files and directories; getting information about files and directories; reading the contents of files; getting objects that allow you to manipulate the contents of files and directories; and more. a. File b. FileAndDirectory c. Files d. FilesAndDirectories

c. Files

Class ________ provides static methods for common file and directory manipulations, including methods for copying files; creating and deleting files and directories; getting information about files and directories; reading the contents of files; getting objects that allow you to manipulate the contents of files and directories; and more. a. File b. FileAndDirectory c. Files d. FilesAndDirectories

c. Files

15.4.2 Q1: What does the following statement do? Scanner scanner = new Scanner(Paths.get("test.txt")); a. Opens a binary file for input. b. Opens a binary file for output. c. Opens a text file for input. d. Opens a text file for output.

c. Opens a text file for input.

: What interface must a class implement to indicate that objects of the class can be output and input as a stream of bytes? a. Synchronize b. Deserializable c. Serializable d. ObjectOutput

c. Serializable

15.5.1 Q1: What interface must a class implement to indicate that objects of the class can be output and input as a stream of bytes? a. Synchronize b. Deserializable c. Serializable d. ObjectOutput

c. Serializable.

How do methods setIn, setOut and setErr affect the standard input, output and error streams? a. They output data to the standard input, output and error streams. b. They provide the only way to access the standard input, output and error streams. c. They redirect the standard input, output and error streams. d. They empty the standard input, output and error streams.

c. The redirect the standard input, output, and error streams.

15.2 Q2: How do methods setIn, setOut and setErr affect the standard input, output and error streams? a. They output data to the standard input, output and error streams. b. They provide the only way to access the standard input, output and error streams. c. They redirect the standard input, output and error streams. d. They empty the standard input, output and error streams.

c. They redirect the standard input, output and error streams.

What does the following statement do? Scanner scanner = new Scanner(Paths.get("test.txt")); a. Opens a binary file for input. b. Opens a binary file for output. c. Opens a text file for input. d. Opens a text file for output.

c. opens a text file for input.

InputStream object 's helper methods

can be used to read to stream or to do other operations on the stream. - public void close() throws IOException{} - protected void finalize()throws IOException {} - public int read(int r)throws IOException{} - public int read(byte[] r) throws IOException{} - public int available() throws IOException{}

A generic class

can extend generic and non-generic classes

In general, adding an element e in one step to a singly-linked list just before a node referenced by ref

can only be done when ref is the last node in the list

If we want to log or recover from an error in our application, we should use a/an ______

catch block

the stack empty operation

checks to see if there is at least one item on the stack

Always ______ your streams

The ______ method will automatically flush a stream

Finally, when you're done with a stream, close it by invoking this method - it releases any resources associated with the stream, such as file handles or ports.

close() method

absolute path

contains all directories, starting with the root directory, that lead to a specific file or directory.

Which of the following statements is false? a. Path method isAbsolute returns a boolean indicating whether a Path represents an absolute path to a file or directory. b. Files static method getLastModifiedTime receives a Path and returns a FileTime (package java.nio.file.attribute) indicating when the file was last modified. c. Files static method size receives a Path and returns a long representing the number of bytes in the file or directory. For directories, the value returned is platform specific. d. All of the above are true.

d. All of the above are true

When using an ObjectInputStream to read data from a file, what happens when an end-of-file marker is reached? a. Nothing occurs. b. An end-of-file character is read by the program. c. Method readObject returns the value 0. d. An EOFException is thrown.

d. An EOFException is thrown

15.5.2 Q1: When using an ObjectInputStream to read data from a file, what happens when an end-of-file marker is reached? a. Nothing occurs. b. An end-of-file character is read by the program. c. Method readObject returns the value 0. d. An EOFException is thrown.

d. An EOFException is thrown.

15.7.1 Q2: ________ is an I/O-performance-enhancement technique—it reduces the number of I/O operations by combining smaller outputs together in memory; the number of physical I/O operations is much smaller than the number of I/O requests issued by the program. a. Aggregating b. Accumulating c. Amassing d. Buffering

d. Buffering.

Which of the following statements is false? a. A LineNumberReader is a buffered character stream that tracks the number of lines read. b. Classes FileReader and FileWriter perform character-based file I/O. c. Class PipedReader and class PipedWriter implement piped-character streams for transferring data between threads. d. Class StringReader and StringWriter read characters from and write characters to Streams, respectively.

d. Class StringReader and StringWriter read characters from and write characters to Streams respectively.

Which of the following statements is false? a. Storage of data variables and arrays is temporary. b. Data is lost when a local variable "goes out of scope." c. Files are used for long-term retention of large amounts of data. d. Data maintained in files is often called transient data.

d. Data maintained in files is often called transient data

Which statement regarding Java files is false? a. Java imposes no structure on a file. b. Notions like "record" do not exist in Java files. c. The programmer must structure files to meet the requirements of applications. d. Records in a Java sequential file are stored in order by record key.

d. Records in a java file are stored in order by record key.

15.3 Q5: Path method ________ returns the String name of a file or directory without any location information. a. getStringName b. getFileOrDirectoryName c. getDirectoryName d. getFileName

d. getFileName

Path method ________ returns the String name of a file or directory without any location information. a. getStringName b. getFileOrDirectoryName c. getDirectoryName d. getFileName

d. getFileName

GZIPInputStream

decompresses data

CipherInputStream

decrypts data

DataInput

describes methods for reading primitive types from an input stream.

Class JFileChooser

displays a dialog that enables the user to easily select files or directories.

stream intermediate operation that are stateful

distinct() sorted() sorted(Comparator<? super T> comparator) **all stateful

Invoking the constructor for the File object ______ create an actual file on the file system

does not

The method run() in the generic thread class by default:

doesn't do anything

Threads can be created and deleted ______.

dynamically

Class Formatter

enables formatted data to be output to any text-based stream in a manner similar to method System.out.printf.

the process used by the Java compiler to remove generic notation and substitute an actual type for type parameters is known as

erasure

logic error

error made when using \ as a directory sparator rather than \\ in a string literal

In a binary tree that is a heap

every non root node must have a value greater than that of its parent

A thread is an:

execution stream within a process

File FileWriter FileReader BufferedReader BufferedWriter PrintWriter do not need to have be wrapped in a try/catch block or declare that method throws an Exception. true or false

false *Must* be *wrapped* in a *try/catch* block or declare that method *throws* an *Exception*.

Path is located in java.io.file.Path. True or false?

false it is located in: java.*nio*.file.Path

File FileWriter FileReader BufferedReader BufferedWriter PrintWriter are located in java.lang true or false

false located in *java.io*

Path and Paths contain only static methods. true or false?

false. *Path* is an *interface.*

A file "myFile.txt" has two lines containing the following chars on separate lines: a b When the below code executes c and d get appended to the file resulting in the following chars each on separate lines: a b c d True or false? import java.io.File; import java.io.FileWriter; import java.io.PrintWriter; class A { public static void main(String[] args) throws Exception { File f = new File("C:\\a\\myFile.txt"); FileWriter fw = new FileWriter(f); PrintWriter pw = new PrintWriter( fw); pw.println("c"); pw.println("d"); pw.flush(); pw.close(); } }

false. *a* *b* get *overwritten* with *c* and *d* therefore *output* would be: *c* *d*

Java 8 Streams

Ensembles d'études connexes

Study.com Historical Methods Ch 4

M/S Exam 1

Chapter 61: Management of Patients with Neurologic Dysfunction - ML3

Chapter 5 Short-Term and Working Memory

Gov - Test 4

Bio Exam 2

Repaso revalida física

Quiz: Hematology - Red Cells

Ch 16 small business protection: risk management and insurance

English 3B

COMM 101 exam 1 - all quizzes

AFROTC FT 21 WK

Network exam 1

ACC 201 Chp 4 LearnSmart

Hawaiian Studies

business chapter 6

Adult Health FINAL Review

Antigens

Biology 30 - the brain

Class 18 Parietal lobes