Re: Help Help, I am intermediate in Java...need help in follow case
ElementX wrote:
RedGrittyBrick wrote:
ElementX wrote:
RedGrittyBrick wrote:
ElementX wrote:
RedGrittyBrick wrote:
ElementX wrote:
first create a plain class which accepts two java.io.File object in
constructor as input and output and a method which performs
replacement.
- the replacement must take into account the file ending of the input
file:
+ for .java, .cpp, .c and .css remove the FIRST occurrence of "/
* ... */"
+ for .xml, .xhtml, .html and .xsl remove the FIRST occurrence of
"<!-- ...
-->"
has any body have an example class to do it?
I'd start with the requirement "first create a plain class which accepts
two java.io.File object in constructor as input [and output]" From this
I'd write
class ReplaceFirstComment {
ReplaceFirstComment(File input, File output) {
// TODO
}
}
Then I'd compile it and test it. I'd not move on until I was entirely
happy with the test results and had eliminated any compiler warnings.
Then I'd think about the next tiny change that I could make that I could
compile and test.
At first thanks a lot...for your help...
so I create some code...what do yu think...what is the next step...?
Now, I can replace // comments from a text file...how I need a
solution for follow problem...
+ for .java, .cpp, .c and .css remove the FIRST occurrence of "/* ...
*/"
+ for .xml, .xhtml, .html and .xsl remove the FIRST occurrence of
"<!-- ...
I create flowing code....
public class RemoveHeader {
private File toDir;
private List<FileSet> filesets = new ArrayList<FileSet>();
private List<String> includes = new ArrayList<String>();
private List<String> excludes = new ArrayList<String>();
Hmm, your original specification makes no mention of lists of files to
include, lists to exclude and FileSets. Is this something you omitted
from the statement of what you are trying to achieve?
@SuppressWarnings("unused")
private String charset;
Why Suppress warnings about unused variables? I find it better to remove
them.
public RemoveHeader() {
// TODO Auto-generated constructor stub
}
/**
* @param charset
* @param excludes
* @param filesets
* @param includes
* @param mappingFile
* @param mappings
* @param toDir
*/
// File input, File output
public RemoveHeader(String charset, List<String> excludes,
List<FileSet> filesets, List<String> includes, File Input) {
Neither of these constructors match the signature you mentioned in your
first post. Why is that?
super();
this.charset = charset;
this.setExcludes(excludes);
this.setFilesets(filesets);
this.setToDir(Input);
}
public static void main(String[] args) {
// String charset = "UTF-8";
// String[] exclude = {"*.java","*.c","*.cpp"};
// String[] include = {"*.xml","*.xhtml"};
// List<String> includesa = new ArrayList<String>();
// List<String> excludesa = new ArrayList<String>();
// includesa.addAll(includesa);
// excludesa.addAll(exclude);
// FileSet fs = new FileSet();
// List<FileSet> lfs = new ArrayList<FileSet>();
// File in = new File ("");
// RemoveHeader rh = new
RemoveHeader(charset,excludesa,lfs,includesa,in);
// DirectoryScanner ds = new DirectoryScanner();
// ds.addExcludes(exclude);
// ds.setIncludes(include);
// ds.scan();
// rh.removeCommentFromFile("test.txt", "/*");
I'd cut that out entirely - When I need to keep old versions of code
around I use a Version Control System of some sort.
RemoveHeader rh = new RemoveHeader();
rh.removeCommentFromFile("test.txt", "//");
}
OK, but it doesn't really match the spec.
I'd be awfully tempted to shorten those two lines to
new RemoveHeader().removeCommentFromFile("text.txt", "//");
/**
* Defines the directory where to save the replaced files.
* This is a mandatory parameter.
*
* @param toDir the directory where to save files
*/
public void setTodir(File toDir) {
this.setToDir(toDir);
}
/**
* Defines the character encoding used for reading and
* writing files.
*
* @param charset a valid character encoding for the
* current Java platform
*/
public void setCharset(String charset) {
this.charset = charset;
}
None of the above do anything at present. They are clutter. I'd remove
them until I got the core of the program working.
public void removeCommentFromFile(String file, String comment) {
That is insufficient to specify the types of comments you want to
remove. I think instead of "String comment" you need "String
commentStart, String commentEnd".
try {
File inFile = new File(file);
if (!inFile.isFile()) {
System.out.println("Parameter is not an existing
file");
return;
}
//Construct the new file that will later be renamed to the
original filename.
Your original spec suggested that the class would be constructed passing
the name of an input file and the name of an output file, now you seem
to be doing an in-place edit (using a temporary file and rename,
delete). Why doesn't your code match the requirements description?
File tempFile = new File(inFile.getAbsolutePath() +
".tmp");
BufferedReader br = new BufferedReader(new
FileReader(file));
PrintWriter pw = new PrintWriter(new
FileWriter(tempFile));
// String lineToRemove = line;
//Read from the original file and write to the new
//unless content matches data to be removed.
String line = null;
Why initialise it to null?
while ((line = br.readLine())!=null) {
if (!line.trim().startsWith(comment)) {
pw.println(line);
pw.flush();
}
}
pw.close();
br.close();
The above is the core of the processing. Now you need to keep track of
the start and end of comments, including those that span multiple lines.
You need to plan how you will deal with nested comments.
I'd construct some test data and use that to think about suitable
control structures. Many people would consider this a language-parsing
problem rather than the simple line-editing problem that your code supposes.
Some example test data I'd think about:
------------testfile1-----------------
Lorem ipsum dolor sit amet, consectetur
/*
adipisicing elit, sed do eiusmod tempor
*/
incididunt ut labore et dolore magna aliqua.
------------testfile2-----------------
Lorem ipsum dolor sit amet, consectetur
adipisicing /* elit, */ sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua.
------------testfile3-----------------
Lorem ipsum dolor sit amet, consectetur
adipisicing /* elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua.
Ut enim ad */ minim veniam, quis nostrud
exercitation ullamco laboris nisi ut
------------testfile4-----------------
Lorem ipsum dolor sit amet, consectetur
adipisicing /* elit, sed do eiusmod tempor
incididunt /* ut labore et dolore magna aliqua.
Ut enim ad minim*/ veniam*/, quis nostrud
exercitation ullamco laboris nisi ut
------------testfile5-----------------
Lorem ipsum dolor sit amet, consectetur
adipisicing /* elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam, quis nostrud
------------testfile6-----------------
Lorem ipsum dolor sit amet, consectetur
adipisicing /** elit, sed do eiusmod tempor
* incididunt ut labore et dolore magna aliqua.
Ut enim */ ad minim veniam, quis nostrud
Maybe you need a variable that keeps track of comment/noncomment state
at each point in the file?
Maybe you need to read the whole file as a single string and search for
the positions of the start and end comment markers?
Maybe you do need to deal with nested comments the same way Java, c, etc
compilers do? Perhaps they have different rules?
[remaining code omitted]
I think your 180 lines can be boiled down to this:
-----------------------------------8<------------------------------------
import java.io.*;
public class ReplaceFirstComment {
public static void main(String[] args) {
File inFile = new File("test.txt");
File outFile = new File("out.txt");
new ReplaceFirstComment(inFile, outFile).doit();
}
private File inFile, outFile;
ReplaceFirstComment(File inFile, File outFile) {
this.inFile = inFile;
this.outFile = outFile;
}
private void doit() {
try {
if (!inFile.isFile()) {
System.out.println("Parameter is not an existing file");
return;
}
BufferedReader br = new BufferedReader(
new FileReader(inFile));
PrintWriter pw = new PrintWriter(
new FileWriter(outFile));
String comment = chooseCommentMarker(inFile);
String line;
while ((line = br.readLine()) != null) {
if (!line.trim().startsWith(comment)) {
pw.println(line);
pw.flush();
}
}
pw.close();
br.close();
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
private String chooseCommentMarker(File file) {
return "//";
}
}
-----------------------------------8<------------------------------------
Untested.
I've removed comments but I would keep (some of) them in real life.
I've also rearranged the constructor signature to match what you
originally stated.
Personally, I find the above a lot more readable. YMMV.
--
RGB