creating a line editor program in java? [closed]
This is the original problem: Your program will be a line editor. A line editor is an editor where all operations are performed by entering commands at the command line. Commands include displaying lines, inserting text, editing lines, cutting and pasting text, loading and saving files. For example, a session where the user enters three lines of text and saves them as a new file may appear as:
Menu: m Delete line: dl
Load file: l Delete range: dr
Show all: sa Copy range: cr
Show line: sl Paste lines: pl
Show range: sr Write to file: w
New line: nl Quit: q
Edit line: el Write and quit: wq
-> nl
type line? (y/n): y
1: this is the first line
type line? (y/n): y
2: and a second line
type line? (y/n): y
3: and this is the third line
type line? (y/n): n
-> w
write to file: test.txt
-> sa
1: this is the first line
2: and a second line
3: and this is the third line
-> q
The file created is:
this is the first line
and a second line
and this is the third line
The editor will first display a menu after which it will prompt for commands with "-> ". The commands which can be entered can be seen in the menu appearing in the example.
This web page was written with the line editor described here. The Commands
If you run the program with no command line arguments it will begin with an empty document. If you give the name of an existing file as a command line argument it will open and load the contents of that file. You can exit the program with either the quit, q, or write and quit, wq, command. Displaying the menu
The menu is displayed when the program starts. It can be displayed with the command m. Reading and writing files
The load file command l will ask the user for a file name, open the file for reading, read the file contents into the editor and close the file. If there is already text in the editor it is discarded. The write file command w will write the contents of the editor to a file. If a file has previously been opened with the read file command that same file is used for writing. Otherwise, the program will prompt the user for a file name. For either the read or write file commands if the requested file cannot be opened an appropriate error message is displayed. Displaying text
Text can be displayed with three commands: show all (sa), show range (sr), and show line (sl). All three commands display text with line numbers. Show all displays the entire document. Show range will ask the user a range of lines ("from" and "to") and will display the lines in that range. If the "to" line number is greater than the number of lines in the document lines up to the end of the document will be displayed. Show line will ask the user for a line number and display that line. Entering new lines of text
New lines of text are entered using the new line command nl. Before entering a new line the program will ask type line? (y/n). If the user chooses yes the line will be accepted after the line number is displayed. If the document is empty the new line will be the first line (line 1) of the document. If the document is not empty the program will prompt the user to enter the line after which the new line will be placed. If the line number is out of range the program will not accept a new line. A new first line can be added by asking to add a line after (the non-existent) line 0. After the user has entered a line the program will continue asking for new lines until the user answers no. As the new lines are being entered they are added sequentially to the document. As the user begins to enter lines at the new line command the line after which the new line is being added is first displayed (unless the user is entering lines at the beginning of the document). Examples:
-> sa
1: this is the first line
2: and a second line
3: and this is the third line
-> nl
insert after line number: 1
inserting after:
this is the first line
type line? (y/n): y
2: one and a half
type line? (y/n): y
3: one and three quarters
type line? (y/n): n
-> sa
1: this is the first line
2: one and a half
3: one and three quarters
4: and a second line
5: and this is the third line
->
The buffers
There are two buffers, the line buffer and the string buffer, used for moving blocks of text. The line buffer holds ranges of entire lines and the string buffer holds substrings of individual lines. Whenever a new 开发者_Python百科range of lines is copied to the line buffer or a string is copied to the string buffer the previous contents of that buffer are deleted (but the other buffer is unaffected). Moving ranges of lines
Blocks of lines can be moved using copy range, cr, and paste lines, pl. Copy range will ask the user for a range of line numbers ("from" and "to") and will copy the lines to the line buffer - the lines remain unchanged in the document. Paste lines will ask the user to enter the number of the line after which the lines from the line buffer will be pasted. The lines are then copied into the document - the line buffer is left unchanged. Ranges of lines are deleted with delete range, dr. Again, the user is asked for the range of line numbers to delete. The lines are then deleted (the line buffer is unchanged). Editing a line of text
The edit line command, el will ask for the number of a line to edit then display the line preceded by a scale which allows the user to identify positions in the line by number (beginning with 0). Then the line menu is displayed and the program prompts for input.
-> el
line number: 3
0 5 10 15 20
|----+----|----+----|-
one and three quarters
Show line: s
Copy to string buffer: c
Cut: t
Paste from string buffer: p
Enter new substring: e
Delete substring: d
Quit line: q
->
The scale is at least as long as the line displayed. Operations chosen from the line menu will then operate on this chosen line until quit line, q.
Show line will display the line (again) with the scale. Quit returns to the main editor menu. The remaining commands edit the chosen line.
Copy to string buffer and Paste from string buffer work like copy range and paste lines but they work with the string buffer rather than the line buffer. Also, Paste from string buffer will insert the substring so that it begins at the specified position. (Thus it does an "insert before" where paste lines does an "insert after.")
-> c
0 5 10 15 20
|----+----|----+----|-
one and three quarters
from position: 4
to position: 7
copied:
0 5 10 15 20
|----+----|----+----|-
one and three quarters
^^^^
Show line: s
Copy to string buffer: c
Cut: t
Paste from string buffer: p
Enter new substring: e
Delete substring: d
Quit line: q
-> p
0 5 10 15 20
|----+----|----+----|-
one and three quarters
insert at position: 14
0 5 10 15 20 25
|----+----|----+----|----+
one and three and quarters
Show line: s
Copy to string buffer: c
Cut: t
Paste from string buffer: p
Enter new substring: e
Delete substring: d
Quit line: q
->
Delete substring, t, will prompt for a range of characters to delete, will display the string with the substring underlined, ask the user if the range is ok, and then delete the substring.
-> el
line number: 1
0 5 10 15 20
|----+----|----+----|-
this is the first line
Show line: s
Copy to string buffer: c
Cut: t
Paste from string buffer: p
Enter new substring: e
Delete substring: d
Quit line: q
-> d
0 5 10 15 20
|----+----|----+----|-
this is the first line
from position: 12
to position: 18
delete:
0 5 10 15 20
|----+----|----+----|-
this is the first line
^^^^^^^
y/n: y
0 5 10 15
|----+----|----+
this is the ine
Cut, t, combines copy to string buffer and delete substring. It copies the substring to the string buffer and removes it from the line.
Enter new substring, e, will allow the user to type new text into an existing line.
line number: 1
0 5 10 15 20
|----+----|----+----|-
this is the first line
Show line: s
Copy to string buffer: c
Cut: t
Paste from string buffer: p
Enter new substring: e
Delete substring: d
Quit line: q
-> e
0 5 10 15 20
|----+----|----+----|-
this is the first line
insert at position: 12
text: very very
0 5 10 15 20 25 30
|----+----|----+----|----+----|-
this is the very very first line
Internals
You will define (among others) two classes: a Line class and a Document class. The Line class will hold the text of a line from the document in a field of type String and provide basic operations on a line. Some of these operations are insert a string into the line at a specified position, delete a substring, copy a substring, etc. The Line class will also have a field with the number of characters stored in the line. The Document class will hold an entire document (each line in one String) and provide basic operations such as inserting lines, deleting, copying, and pasting ranges of lines. It will also have a field with the number of lines currently in the document. Elsewhere in your program you will provide code for the operations (chosen by the user from the menu) which will then call the member functions of the Line and Document classes.
The document will be a doubly linked list of lines (Strings) with a header node. I.e., if there are 100 lines in the document there will be 101 nodes in the linked list - 100 holding text and one header node. This will make insertions and deletions much easier by eliminating special boundary conditions. Line numbers will not be stored with lines. Instead, every time a line number is needed (e.g. for display in show range and show all, finding positions for new line, etc.) it will be found by traversing the list and counting.
All strings will be Java Strings. Lines of text can be manipulated with concatenation and the substring methods:
String substring(int beginIndex) // Returns a new string that is a
// substring of this string.
String substring(int beginIndex, int endIndex) // Returns a new string
// that is a substring of
// this string.
To accept a new line of user input you must use nextLine since reading with next stops accepting input at the first white space and text lines may contain white space. You must use nextLine for all keyboard input: nextLine does not mix well with next, nextInt, etc., so to read integer input you will first read a String and then convert it to an integer using Integer.parseInt.
You will do appropriate input validation. When choosing operations (in response to the "->" prompt) your program will only accept input as stated in the menu. When accepting integer input (line numbers, character positions in a line) your program will check for valid numbers and ranges.
=========================== The only things I've basically figured out are the scale and the menu...
A reasonable methodology when you are a little lost is XP. Here is what I'd suggest:
Take each step and make it as small as you possibly can. Write it down on a separate card or line item in a to-do list.
Once you have all the steps, pick one that doesn't seem to depend on any others and do it. This might be as simple as "Display the menu".
I suggest you also write a test to ensure it works--it takes a little time in the beginning, but in the long run you'll be a much happier person if you have tests. Writing the tests first is even better.
The most important thing is breaking down the list of steps from what you were provided into something that can be implemented--seriously, the smallest steps possible. You may come up with 50-100 items from that problem description.
It's also important to "Get started". Your program should ALWAYS run.
Another theory that might help with testing is "Do the simplest thing that could possibly work". This means write a test first to test a very small piece of functionality, then write the code to make it work. For instance if the test is "assert(5,add(3,2))" the simplest thing that could possibly work is to have "add" return the number 5 and run the test--hey, it passes. Then when you add your next test, you may have to re-write add to be more flexible and actually do work.
(Sorry for the edits, but wanted to try to help you as much as possible before the question closed. I hope it helps.)
加载中,请稍侯......
精彩评论