So, I am trying to delete a file, but it doesn't let me... here is my code:
private static final File file = new File("data.dat");
public static void recreate() {
try {
if (file.exists()) {
file.delete();
}
if (file.exists()) {
throw new RuntimeException("Huh, what now?");
}
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
As is not suspected, it throws the exception:
Exception in thread "main" java.lang.RuntimeException: Huh, what now?
Any help? What am I doing wrong (It probably is just a derp...)?
You may not have write permissions on that file. Here is how you can check write permissions on that file using File#canWrite before trying to delete that file:
if (!file.canWrite()) {
throw new RuntimeException("Sorry I don't have right permissions!");
}
// now you can try to delete it
if (file.exists()) {
file.delete();
}
EDIT: You also need read/write/execute permissions on parent directory. You can add these checks also:
if (!file.exists())
throw new RuntimeException("file doesn't exist!");
File parent = file.getParentFile();
if (!parent.canRead() || !parent.canWrite() || !parent.canExecute())
throw new RuntimeException("Sorry I don't have right permissions on dir!");
if (!file.canWrite())
throw new RuntimeException("Sorry I don't have write permission on file!");
// now you can try to delete it
if (file.delete()) // check return value
System.out.println("file deleted!!!");
else
throw new RuntimeException("Failed to delete the file");
I know it's not exactly what you asked, but since you recreate the file anyway, how about:
public static void recreate() {
try (FileOutputStream fout = new FileOutputStream(file)) {
// empty
} catch (IOException e) {
throw new RuntimeException(e);
}
}
Related
The task is to throw a FileNotFoundException() exception and handle it. You also need to check if the file exists on the computer and read data from it.
I wrote 2 methods, one searches for a file, the second one reads, but I am completely confused how to handle this exception. Can you suggest how to refactor this code to handle FileNotFoundException. And point out the errors of the code itself, since it is very terrible (I am just starting to learn Java)
public static boolean findFile(String path, String filename) throws FileNotFoundException {
File f = new File(path + "\\" + filename);
if (f.exists()) {
System.out.println("File found");
return true;
}
else {
System.out.println("File not found, please check that you entered the correct path and file name");
throw new FileNotFoundException();
}
}
public static ArrayList<String> readFromFile(String path, String filename) throws FileNotFoundException {
if(findFile(path,filename)) {
ArrayList<String> ip = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new FileReader(path + "\\" + filename))) {
String line;
ip.add(br.readLine());
while ((line = br.readLine()) != null) {
ip.add(line);
}
} catch (IOException e) {
System.out.println(e.getMessage());
System.exit(-1);
}
return ip;
}
else {
System.out.println("Failed to read the file, check the correct path and file name");
return null;
}
}
The way you've defined the findFile method, it is always going to either return true or throw an exception. So it doesn't really make any sense to test the value returned by findFile(), or for that method to even return a value. Instead, you can assume that if the method does not throw an exception, then the file was found. For the case where it wasn't, you want to catch the exception and deal with it. Here's what that all looks like:
public static void findFile(String path, String filename) throws FileNotFoundException {
File f = new File(path + "\\" + filename);
if (f.exists()) {
System.out.println("File found");
}
else {
System.out.println("File not found, please check that you entered the correct path and file name");
throw new FileNotFoundException();
}
}
public static ArrayList<String> readFromFile(String path, String filename) throws FileNotFoundException {
try {
findFile(path,filename);
// Code to read the file...
...
}
catch (FileNotFoundException ex) {
System.out.println("Failed to read the file, check the correct path and file name");
return null;
}
}
The task is to throw a FileNotFoundException() exception and handle
it.
The answer to this question depends a lot on context.
If you are running this from the command line, you will want to add a try catch for the exception and then try again if it happens
Exception e;
do {
e = null;
try {
callAMethod();
} catch(ex) {
e=ex;
}
} while (e != null);
If you are doing this from a GUI/Swing, you can re-rethrow as a RuntimeException and use Log4j or Thread.setUncaughtExceptionHandler(..) to log the error and inform the user. The user can then try again
If you are doing this as a webapp, you will want to change the response code to 404 (FileNotFound) and indicate the file that was not found
Lastly, where you throw the FileNow FoundException, you should include a message
throw new FileNotFoundException(/*incude a string with the file path*/);
I am writing a file into a directory. There might be the chance that the directory becomes unreachable.
What I want to do is..
As the code is writing to the file, if the directory becomes unreachable or a file not found exception is thrown I want it to keep checking if the directory exists and continue where I left off after the directory exists again.
After some time if the directory does not come back up then I would shut the program down.
My problem is that when a file not found exception is thrown the program just shuts down all together. Here is my code:
public class BusStopsProcessor implements Runnable
{
private BlockingQueue<Bus<buses>> busQueue;
private Bus<buses> BusObject;
public BusStopsProcessor(BlockingQueue<Bus<buses>> busQueue)
{
this.busQueue = busQueue;
}
#Override
public void run()
{
try
{
String path = "C:\\Users\\Me\\Documents\\";
File file = new File(path + "busStopsFile.txt");
FileWriter fw = new FileWriter(file, true);
CSVWriter writer = new CSVWriter(fw, '|', CSVWriter.NO_QUOTE_CHARACTER);
while(true)
{
BusObject = busQueue.take();
//each bus object should have a bus date if it does not then it is a
//poison bus object.
if(BusObject.getBusDate() != null)
{
createBusFile(BusObject, writer);
else
{
try
{
//Finished processing bus stops so close writer.
writer.close();
fw.close();
break;
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
e.printStackTrace();
}
catch (FileNotFoundException e)
{
//If a FILENOTFOUND exception is thrown here I want
//my code to be able to pick up where I left off
e.printStackTrace();
logger.warn(e.getMessage());
}
catch (IOException e)
{
e.printStackTrace();
}
}
Here is the method that I want to keep checking if the directory exists. If the file is being written into and all of a sudden the directory goes down. I dont want to repeat the same information in the file I want it to continue to write from where it left off but I just cant figure out how to do that. thank you.
private void createBusFile(Bus<buses> aBusObject, CSVWriter writer) throws InterruptedException
{
//Get bus information here
for(Bus<buses> busStop : aBusObject.getBusStops())
{
busNumber = busStop.getBusNumber();
busArrivalTime = busStop.getBusArrivalTime();
busStop = busStop.getBusStop();
String[] busFields = {busNumber, busDate, busStop};
//If a file not found exception is thrown here I want it to keep checking if the directory exists. And pick up from where I left off
writer.writeNext(busFields);
}
}
}
I am trying write to a csv file. After the execution of the code bellow the csv file is still empty.
File is in folder .../webapp/resources/.
This is my dao class:
public class UserDaoImpl implements UserDao {
private Resource cvsFile;
public void setCvsFile(Resource cvsFile) {
this.cvsFile = cvsFile;
}
#Override
public void createUser(User user) {
String userPropertiesAsString = user.getId() + "," + user.getName()
+ "," + user.getSurname() +"\n";;
System.out.println(cvsFile.getFilename());
FileWriter outputStream = null;
try {
outputStream = new FileWriter(cvsFile.getFile());
outputStream.append(userPropertiesAsString);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
#Override
public List<User> getAll() {
return null;
}
}
This is a part of beans.xml.
<bean id="userDao" class="pl.project.dao.UserDaoImpl"
p:cvsFile="/resources/users.cvs"/>
Program compiles and doesn't throw any exceptions but CSV file is empty.
If you're running your app in IDE, the /webapp/resources used for running app will differ from the /webapp/resources in your IDE. Try to log full path to file and check there.
try using outputStream.flush() as the final statement in the first of the try block.
I think you're looking at the wrong file. If you specify an absolute path /resources/users.cvs, then it probably won't be written into the a folder relative to the webapp. Instead, it will be written to /resources/users.cvs
So the first step is to always log an absolute path to make sure the file is where you expect it.
Try with this code, it will at least tell you where the problem lies (Java 7+):
// Why doesn't this method throw an IOException?
#Override
public void createUser(final User user)
{
final String s = String.format("%s,%s,%s",
Objects.requireNonNull(user).getId(),
user.getName(), user.getSurname()
);
// Note: supposes that .getFile() returns a File object
final Path path = csvFile.getFile().toPath().toAbsolutePath();
final Path csv;
// Note: this supposes that the CSV is supposed to exist!
try {
csv = path.toRealPath();
} catch (IOException e) {
throw new RuntimeException("cannot locate CSV " + path, e);
}
try (
// Note: default is to TRUNCATE the destination.
// If you want to append, add StandardOpenOption.APPEND.
// See javadoc for more details.
final BufferedWriter writer = Files.newBufferedWriter(csv,
StandardCharsets.UTF_8);
) {
writer.write(s);
writer.newLine();
writer.flush();
} catch (IOException e) {
throw new RuntimeException("write failure", e);
}
}
File oldfile = new File("C:\\NewText Document.txt");
File newfile = new File("C:\\Hello Buddy.txt");
if (oldfile.renameTo(newfile))
{
System.out.println("Rename succesful");
}
else
{
System.out.println("Rename failed");
}
I'm planning on developing it into a file normalizer, but I just want to get this done first.
I've tried using the absolute path, makes no difference. Constantly returning "Rename Failed".
Use move method of Files class. Worked for me ;)
Java doc
If you are using Java 7 then try this:
final File oldfile = new File("C:\\NewText Document.txt");
final File newfile = new File("C:\\Hello Buddy.txt");
final Path source = oldfile.toPath();
final Path dest=newfile.toPath();
try {
Files.move(source, dest);
} catch (IOException e) {
e.printStackTrace();
}
FileChooser();
File oldfile = new File(fileName);
File newfile = new File(fileName.substring(0, 21) + "hello world.txt");
if (!oldfile.exists())
{
try
{
oldfile.createNewFile();
}
catch (IOException ex)
{
System.out.println(ex);
}
}
else
{
if (oldfile.renameTo(newfile))
{
System.out.println("Rename succesful");
}
else
{
System.out.println("Rename failed");
}
}
This is my new code, it works using a file chooser,but currently it only works if i choose the file from my desktop, hence the hardcoded substring.
Okay, this is going to be a bit long. So I made a junit test class to test my program. I wanted to test if a method that uses a Scanner to read a file into the program threw and exception, if the file didn't exist like this:
#Test
public void testLoadAsTextFileNotFound()
{
File fileToDelete = new File("StoredWebPage.txt");
if(fileToDelete.delete()==false) {
System.out.println("testLoadAsTextFileNotFound - failed");
fail("Could not delete file");
}
try{
assertTrue(tester.loadAsText() == 1);
System.out.println("testLoadAsTextFileNotFound - passed");
} catch(AssertionError e) {
System.out.println("testLoadAsTextFileNotFound - failed");
fail("Did not catch Exception");
}
}
But the test fails at "could not delete file", so I did some searching. The path is correct, I have permissions to the file because the program made it in the first place. So the only other option would be, that a stream to or from the file is still running. So I checked the method, and the other method that uses the file, and as far as I can, both streams are closed inside the methods.
protected String storedSite; //an instance variable
/**
* Store the instance variable as text in a file
*/
public void storeAsText()
{
PrintStream fileOut = null;
try{
File file = new File("StoredWebPage.txt");
if (!file.exists()) {
file.createNewFile();
}
fileOut = new PrintStream("StoredWebPage.txt");
fileOut.print(storedSite);
fileOut.flush();
fileOut.close();
} catch(Exception e) {
if(e instanceof FileNotFoundException) {
System.out.println("File not found");
}
fileOut.close();
} finally {
if(fileOut != null)
fileOut.close();
}
}
/**
* Loads the file into the program
*/
public int loadAsText()
{
storedSite = ""; //cleansing storedSite before new webpage is stored
Scanner fileLoader = null;
try {
fileLoader = new Scanner(new File("StoredWebPage.txt"));
String inputLine;
while((inputLine = fileLoader.nextLine()) != null)
storedSite = storedSite+inputLine;
fileLoader.close();
} catch(Exception e) {
if(e instanceof FileNotFoundException) {
System.out.println("File not found");
return 1;
}
System.out.println("an Exception was caught");
fileLoader.close();
} finally {
if(fileLoader!=null)
fileLoader.close();
}
return 0; //return value is for testing purposes only
}
I'm out of ideas. Why can't I delete my file?
EDIT: i've edited the code, but still this give me the same problem :S
You have two problems here. The first is that if an exception is thrown during your write to the file, the output stream is not closed (same for the read):
try {
OutputStream someOutput = /* a new stream */;
/* write */
someOutput.close();
The second problem is that if there's an exception you aren't notified:
} catch (Exception e) {
if (e instanceof FileNotFoundException) {
/* do something */
}
/* else eat it */
}
So the problem is almost certainly that some other exception is being thrown and you don't know about it.
The 'correct' idiom to close a stream is the following:
OutputStream someOutput = null;
try {
someOutput = /* a new stream */;
/* write */
} catch (Exception e) {
/* and do something with ALL exceptions */
} finally {
if (someOutput != null) someOutput.close();
}
Or in Java 7 you can use try-with-resources.