| CPSC 225 | Intermediate Programming | Spring 2025 |
This lab deals with Java's stream classes.
Labs are due at the start of lab on the date listed. It's fine to hand in your lab right at the start of lab, but the lab period is for starting on the new lab, not finishing the previous one.
To be eligible for revise-and-resubmit, you must turn in something by the due date. Late work and extensions are generally not accepted/granted; see the posted late policy for more information.
You may work with a partner if you wish. Both partners must actively contribute to the solution! You only need one handin for the group — be sure to put both teammates' names in every file.
Otherwise you may get help but you may not use other resources (friends, neighbors, websites, ChatGPT, etc) to produce answers. See the posted policy on academic integrity for more information.
To hand in your work:
Make sure that your name (along with your partner's name if you are working with a partner) is at the beginning of each file (use the @author tag in Java files) and that all your Java files have been auto-formatted and saved.
Copy the entire lab6 project directory from your workspace ~/cs225/workspace to your handin directory in /classes/cs225/handin.
Check that everything got handed in correctly — navigate to your handin directory and make sure it contains a subdirectory src containing your Java files.
Recall from class that there are four steps to working with streams:
Review the slides from Monday's class (posted on the schedule page) for an overview of the common stream classes and their primary methods and see the posted StreamsDemo example for an example of usage. For more information on specific streams classes and methods, such as to find out what happens when end-of-stream is reached, google
java 17 classnameto find the API documentation for the class classname. (Use the actual class name you are interested in, not the word "classname".)
Always remember to flush() an output stream or writer after you write to it — this writes out anything that might have been buffered. You don't need to flush() after every individual thing that is written, but flush() after writing a batch of things if you aren't going to write again for a while.
Both of the programs you'll write take their input from commandline arguments rather than reading input from the user. Within the program, access commandline arguments using the args array passed to main — don't prompt the user for anything.
When a program is run from the command line, the values for the commandline arguments are specifed as part of the command:
java Grep the -
would run the Java program Grep with the commandline arguments the -.
To specify the commandline arguments to use when you run a program within Eclipse:
Right-click on the file with the main program in the Package Explorer, then choose Run As -> Run Configurations. If you don't see "Run Configurations" offered as a choice on the Run As menu, run the program once and then try this step again.
Make sure the selected run configuration on the left is for the desired main program, then click on the Arguments tab.
Enter the commandline arguments in the "Program arguments" box. For example, for a commandline of
java Grep the -
enter the - for the program arguments.
Click Run or Close, depending on whether or not you want to run the program at this time or just set it up for running later.
Repeat the process to change the values, otherwise the program will be run with the same arguments every time.
Note: Do not use Scanner for any of these exercises. The goal is to work directly with streams!
Create a new Java project called lab6 in Eclipse.
grep is a commandline Unix tool for searching files for a particular string or pattern; it prints the lines of the file matching the search pattern. Write a program named Grep which works like a simple version of the Unix grep:
Create a new class Grep for your main program.
Write a static helper method grep which takes a string pattern, an input stream, and an output stream as parameters, reads one line of text at a time from the input stream, and prints each line that contains the pattern on the output stream. Stop reading when the end of the stream is reached. (To choose types for the input and output stream parameters: is reading text a byte stream or a character stream? What class provides the ability to read a line of text at a time?)
Write a main program which takes the pattern and the source as commandline parameters, and uses the grep helper method to print the lines matching the pattern. The source can be one of three things: -, which means to read from standard input (System.in); a string that starts with http, which means to read from the specified URL; and anything else, which means to read from a file with that name. Output should be printed to the console (System.out).
For example, running
java Grep the -
should print all the lines containing "the" that the user types in. (Press ctrl-D when you have finished entering input.)
The following would look for lines containing "the" on the math homepage (note that what is retrieved is the HTML source of the page):
java Grep the http://math.hws.edu
To test the program with a file, you can use your Grep.java file (you'll need to use src/Grep.java for the filename to reflect the fact that it is in the src subdirectory of your project) or you can create a new text file in Eclipse to use (put any such files at the top level of your project directory, not in src).
Write a program Copy which copies from the input (which can be standard input, a URL, or a file) to the output (which can be standard output or a file). Specifically:
Create a new class Copy with a main program.
Write a static helper method copy which takes an input stream and an output stream as parameters, then reads bytes one at a time from the input stream and writes them to the output stream. End when the end of the stream is reached. (To choose types for the input and output stream parameters: is reading bytes a byte stream or a character stream? What class provides the ability to read one byte at a time?)
Write a main program which takes the source and destination as commandline parameters, and uses the copy helper method to copy the source to the destination. As with #1, the source can be one of three things: -, which means to read from standard input (System.in); a string that starts with http, which means to read from the specified URL; and anything else, which means to read from a file with that name. The destination can be - (write to standard output) or a filename. (Writing to a URL is not supported.)
Hint: you can streamline the code in main and avoid unnecessary repetition by declaring variables for the input and output streams (what types?) and initializing them separately based on the commandline parameters. Once both are properly initialized, call copy to do the copy.
(This section is optional — you are encouraged to work on it during lab if you finish the other exercises or for additional practice after lab. It isn't a required part of the lab.)
Try out DataInputStream and DataOutputStream: first write a short main program which reads in two integers and a line of text from the user, then writes them to one file using a DataOutputStream and a second file using an appropriate character stream. (It's fine to hardcode the filenames.) Next, write a short main program which reads in each of the files and prints the two numbers and the line of text on the screen. Also open the files that you wrote with a text editor — what do you see?
Check out the File class (see the Java API), then modify your Grep program so that if the source is a directory instead of a file, it recursively searches all of the files in the directory and any subdirectory of the directory, printing the lines that match the pattern. For each matched line, print both the filename and the line itself.
The Unix grep makes use of regular expressions to allow for more powerful and flexible searching. Java implements the idea of regular expressions in the Pattern classes. Treat the string provided to your grep function as a regular expression rather than as a literal, and print out the matching lines accordingly.