I am currently trying to recursively delete a directory... Strangely enough the shortest piece of code I was able to find is the following construct, employing an *ad-hoc inner class* and in a *visitor pattern*...


	Path rootPath = Paths.get(&quot;data/to-delete&quot;);

	try {
	  Files.walkFileTree(rootPath, new SimpleFileVisitor&lt;Path&gt;() {
		@Override
		public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
		  System.out.println(&quot;delete file: &quot; + file.toString());
		  Files.delete(file);
		  return FileVisitResult.CONTINUE;
		}

		@Override
		public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
		  Files.delete(dir);
		  System.out.println(&quot;delete dir: &quot; + dir.toString());
		  return FileVisitResult.CONTINUE;
		}
	  });
	} catch(IOException e){
	  e.printStackTrace();
	}

Source: [here][1]

This feels horribly clumsy and verbose, given that the new `nio` APIs remove so much clutter and boilerplate...

**Is there any shorter way of achieving a forced, recursive directory delete?**

I&#39;m looking for pure native Java 1.8 methods, so please don&#39;t link to external libraries...

  [1]: http://tutorials.jenkov.com/java-nio/files.html#deleting-directories-recursively

Java.nio: most concise recursive directory delete

I would like to know the internals of the tomcat NIO connector. How exactly are threads used when we create a servlet that implements CometProcessor?Is it still one thread per connection?


From what I read, the conversation goes like this

 1. Client connects to a servlet
    
 2. Servlet hangs on to the connection till there is any data available
    to the connected client
    
 3. When data is ready , the server writes to the httpResponse and
    flushes it. This actually disconnects the connection?
    
 4. Client sends another request which the server again hangs onto..

How many thread are used when this keeps happening?

What is the difference between Tomcat&#39;s BIO Connector and NIO Connector?

I try files writer as follows: 

    String content = &quot;Test File Content&quot;;

* I used as like : `Files.write(path, content.getBytes(), StandardOpenOption.CREATE);`

If file is not create, file is created and content is written. But If file available , the file content is `Test File ContentTest File Content` and if the code is run repeat, the file content is `Test File ContentTest File ContentTest File Content` ...


* I used as like : `Files.write(path, content.getBytes(), StandardOpenOption.CREATE_NEW);` , 

If file is not create, file is created and than thow an exception as follow:

&gt; java.nio.file.FileAlreadyExistsException:
&gt; /home/gyhot/Projects/indexing/ivt_new/target/test-classes/test_file
&gt; 	at
&gt; sun.nio.fs.UnixException.translateToIOException(UnixException.java:88)
&gt; 	at
&gt; ...

How to overwrite file via java new I/O?

How to overwrite file via java nio writer?

I have an application where I have a class called `PlausibilityChecker`. This class has only static methods, like `checkZipcodeFormat` or `checkMailFormat`. I use them in my GUI classes to check the input before sending it to the lower layer.

Is this good practice? I thought I&#39;d go with only static methods so that I don&#39;t have to care about passing an instance to the GUI classes or having an instance field in each gui class that doesn&#39;t reference a gui object.

I noticed that the `Files` class of `Java NIO` has only static methods so I assume this can&#39;t be that horribly wrong.

Java best practice: Class with only static methods

I have a method that takes an InputStream and reads data from it. I would like to use this method with a ByteBuffer also. Is there a way to wrap a ByteBuffer so it can be accessed as a stream?

Wrapping a ByteBuffer with an InputStream

How can I get the size of a file or directory using the new NIO in java 7?


Get file/directory size using Java 7 new IO

Rewrote question with more info

I have some code that creates a `Path` object using relative paths, like this: `Paths.get(&quot;..&quot;, &quot;folder&quot;).resolve(&quot;filename&quot;)`. Later, I want to get the path string &quot;..\folder\filename&quot; from it (I&#39;m on windows, so backslashes). When I run this code using manual compile or from Eclipse, this works fine.

However, when I run it using Maven, it doesn&#39;t work any more. The `toString()` method returns `[.., folder, filename]` instead of an actual path string. Using `path.normalize()` doesn&#39;t help. Using `path.toFile().getPath()` does return what I&#39;m looking for, but I feel there should be a solution using just the `nio.path` API.

How to get the path string from a java.nio.Path?

WatchService looks like a great technology but its been too slow to be useful on the OS X and Linux systems I&#39;ve tested on.  To add insult to injury, it doesn&#39;t seem to get notified of all events either.

This is the case both with my own code and the canonical example from Oracle. (http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/essential/io/examples/WatchDir.java)

I recognize that the OS X OpenJDK port is unsure of this functionality (see https://wikis.oracle.com/display/OpenJDK/Mac+OS+X+Port+Project+Status) 

Has anyone been using this in production with success?

Is Java 7 WatchService Slow for Anyone Else?

I used the following code to get the path             

    Path errorFilePath = FileSystems.getDefault().getPath(errorFile);

When I try to move a file using the File NIO, I get the error below:

    java.nio.file.InvalidPathException: Illegal char &lt;:&gt; at index 2: \C:\Sample\sample.txt

I also tried using [`URL.encode(errorFile)`](http://docs.oracle.com/javase/7/docs/api/java/net/URLEncoder.html#encode%28java.lang.String,java.lang.String%29) which results in the same error.


Java NIO file path issue

Java IO has [File.deleteOnExit()][1], which is a method that deletes the file it is called on during normal termination of the JVM. I&#39;ve found this to be very useful for cleaning up temporary files, especially during unit tests.

However, I don&#39;t see a method by the same name in Java NIO&#39;s [Files][2] class. I am aware that I can do `path.toFile().deleteOnExit()`, but I&#39;d like to know if there is an alternative using NIO.

Is there an alternative? If not, why is there not one?


  [1]: http://docs.oracle.com/javase/7/docs/api/java/io/File.html#deleteOnExit()
  [2]: http://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html

Alternative to File.deleteOnExit() in Java NIO?

For new applications written in Java 7, is there any reason to use a [`java.io.File`][2] object any more or can we consider it deprecated? 

I believe a [`java.nio.file.Path`][1] can do everything a [`java.io.File`][2] can do and more.


  [1]: http://download.oracle.com/javase/7/docs/api/java/nio/file/Path.html
  [2]: http://download.oracle.com/javase/7/docs/api/java/io/File.html

Java: Path vs File

I am trying to figure out if there is any difference in performance (or advantages) when we use nio `FileChannel` versus normal `FileInputStream/FileOuputStream` to read and write files to filesystem. I observed that on my machine both perform at the same level, also many times the `FileChannel` way is slower. Can I please know more details comparing these two methods. Here is the code I used, the file that I am testing with is around `350MB`. Is it a good option to use NIO based classes for File I/O, if I am not looking at random access or other such advanced features?

    package trialjavaprograms;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class JavaNIOTest {
    	public static void main(String[] args) throws Exception {
    		useNormalIO();
    		useFileChannel();
    	}
    
    	private static void useNormalIO() throws Exception {
    		File file = new File(&quot;/home/developer/test.iso&quot;);
    		File oFile = new File(&quot;/home/developer/test2&quot;);
    
    		long time1 = System.currentTimeMillis();
    		InputStream is = new FileInputStream(file);
    		FileOutputStream fos = new FileOutputStream(oFile);
    		byte[] buf = new byte[64 * 1024];
    		int len = 0;
    		while((len = is.read(buf)) != -1) {
    			fos.write(buf, 0, len);
    		}
    		fos.flush();
    		fos.close();
    		is.close();
    		long time2 = System.currentTimeMillis();
    		System.out.println(&quot;Time taken: &quot;+(time2-time1)+&quot; ms&quot;);
    	}
    
    	private static void useFileChannel() throws Exception {
    		File file = new File(&quot;/home/developer/test.iso&quot;);
    		File oFile = new File(&quot;/home/developer/test2&quot;);
    
    		long time1 = System.currentTimeMillis();
    		FileInputStream is = new FileInputStream(file);
    		FileOutputStream fos = new FileOutputStream(oFile);
    		FileChannel f = is.getChannel();
    		FileChannel f2 = fos.getChannel();
    
    		ByteBuffer buf = ByteBuffer.allocateDirect(64 * 1024);
    		long len = 0;
    		while((len = f.read(buf)) != -1) {
    			buf.flip();
    			f2.write(buf);
    			buf.clear();
    		}
    		
    		f2.close();
    		f.close();
    		
    		long time2 = System.currentTimeMillis();
    		System.out.println(&quot;Time taken: &quot;+(time2-time1)+&quot; ms&quot;);
    	}
    }

 


Java NIO FileChannel versus FileOutputstream performance / usefulness

To `allocate()` or to `allocateDirect()`, that is the question.

For some years now I&#39;ve just stuck to the thought that since `DirectByteBuffer`s are a direct memory mapping at OS level, that it would perform quicker with get/put calls than `HeapByteBuffer`s. I never was really interested in finding out the exact details regarding the situation until now. I want to know which of the two types of `ByteBuffer`s are faster and on what conditions.

ByteBuffer.allocate() vs. ByteBuffer.allocateDirect()

Is this the recommended way to get the bytes from the ByteBuffer
    
    ByteBuffer bb =..

    byte[] b = new byte[bb.remaining()]
    bb.get(b, 0, b.length);

Gets byte array from a ByteBuffer in java

For some of my Java NIO connections, when I have a `SocketChannel.write(ByteBuffer)` call, it throws an `IOException`: &quot;Broken pipe&quot;.

What causes a &quot;broken pipe&quot;, and, more importantly, is it possible to recover from that state? If it cannot be recovered, it seems this would be a good sign that an irreversible problem has occurred and that I should simply close this socket connection. Is that a reasonable assumption? Is there ever a time when this `IOException` would occur while the socket connection is still being properly connected in the first place (rather than a working connection that failed at some point)?

On a side note, is it wise to always call `SocketChannel.isConnected()` before attempting a `SocketChannel.write()`, and if so, can I also assume that the connection is &quot;broken&quot; and should be closed if both `SocketChannel.isConnected()` and `SocketChannel.isConnectionPending()` are both `false`?

Thanks!

Java NIO: What does IOException: Broken pipe mean?

I don&#39;t quite understand how different they are from each other so I have some inquiries regarding these two packages.

After looking around a bit on Google, it seems like Oracle decided to update the `NIO` package with the newer and enhanced `NIO.2` package as part of the JDK7 release.

1. How does the performance of `NIO` package compare with the `NIO.2` package?
2. What are some big changes from `NIO` to `NIO.2`? (e.g. new methods, features)
3. Why did the original `NIO` package have to be updated?
4. Is `NIO.2` just synonymous with the `NIO` package nowadays? 

It&#39;s not that I want to use the legacy package in my code, I&#39;m just really curious about this. Please tell me their differences?

Java: what exactly is the difference between NIO and NIO.2?

I am using Java NIO for my socket connections, and my protocol is text based, so I need to be able to convert Strings to ByteBuffers before writing them to the SocketChannel, and convert the incoming ByteBuffers back to Strings.  Currently, I am using this code:

    public static Charset charset = Charset.forName(&quot;UTF-8&quot;);
    public static CharsetEncoder encoder = charset.newEncoder();
    public static CharsetDecoder decoder = charset.newDecoder();
    
    public static ByteBuffer str_to_bb(String msg){
      try{
        return encoder.encode(CharBuffer.wrap(msg));
      }catch(Exception e){e.printStackTrace();}
      return null;
    }
    
    public static String bb_to_str(ByteBuffer buffer){
      String data = &quot;&quot;;
      try{
        int old_position = buffer.position();
        data = decoder.decode(buffer).toString();
        // reset buffer&#39;s position to its original so it is not altered:
        buffer.position(old_position);	
      }catch (Exception e){
        e.printStackTrace();
        return &quot;&quot;;
      }
      return data;
    }

This works most of the time, but I question if this is the preferred (or simplest) way to do each direction of this conversion, or if there is another way to try.  Occasionally, and seemingly at random, calls to `encode()` and `decode()` will throw a 
`java.lang.IllegalStateException: Current state = FLUSHED, new state = CODING_END` exception, or similar, even if I am using a new ByteBuffer object each time a conversion is done.  Do I need to synchronize these methods?  Any better way to convert between Strings and ByteBuffers?  Thanks!


Java: Converting String to and from ByteBuffer and associated problems

Does anyone know what happened to the `path.exists()` API method in the latest Java 7 API? 
I cannot find the change in the change logs, and between b123 and b130, the method has been removed from the API.I see that there is a static `Files.exists` method but I&#39;m not sure if that is the replacement or not. 

Is anyone following the Java 7 work close enough to know how this should be handled?

Thanks for any help. 


Java 7 new IO API - Paths.exists

Java 7 introduced [java.nio.file.Path][1] as a [possible replacement][2] for java.io.File.

With File, when I access a file under a specific, I would do:

    File parent = new File(&quot;c:\\tmp&quot;);
    File child = new File(parent, &quot;child&quot;); // this accesses c:\tmp\child

What&#39;s the way to do this with Path?

I supposed this will work:

    Path parent = Paths.get(&quot;c:\\tmp&quot;);
    Path child = Paths.get(parent.toString(), &quot;child&quot;);

But calling `parent.toString()` seems ugly. Is there a better way?

  [1]: http://docs.oracle.com/javase/7/docs/api/java/nio/file/Path.html
  [2]: https://stackoverflow.com/questions/6903335/java-7-path-vs-file

How to access a sub-file/folder in Java 7 java.nio.file.Path?

Directly from [this][1] Java Oracle tutorial:

&gt; Two asterisks, **, works like * but crosses directory boundaries. This
&gt; syntax is generally used for matching complete paths.

Could anybody do a real example out of it?
What do they mean with &quot;crosses directory boundary&quot;?
Crossing the directory boundary, I imagine something like checking the file from root to `getNameCount()-1`.
Again a real example explaining the difference between * and ** in *practice* would be great.

  [1]: http://docs.oracle.com/javase/tutorial/essential/io/fileOps.html#glob


When to use ** (double star) in glob syntax within JAVA

While trying to copy some files in my jar file to a temp directory with my java app, the following exception is thrown:

    java.nio.file.FileSystemNotFoundException
        at com.sun.nio.zipfs.ZipFileSystemProvider.getFileSystem(ZipFileSystemProvider.java:171)
        at com.sun.nio.zipfs.ZipFileSystemProvider.getPath(ZipFileSystemProvider.java:157)
        at java.nio.file.Paths.get(Unknown Source)
        at com.sora.util.walltoggle.pro.WebViewPresentation.setupTempFiles(WebViewPresentation.java:83)
       ....


and this is a small part of my `setupTempFiles`(with line numbers):

	81. URI uri = getClass().getResource(&quot;/webViewPresentation&quot;).toURI();
    //prints: URI-&gt;jar:file:/C:/Users/Tom/Dropbox/WallTogglePro.jar!/webViewPresentation
	82. System.out.println(&quot;URI-&gt;&quot; + uri );
	83. Path source = Paths.get(uri);

the `webViewPresentation` directory resides in the root directory of my jar:

![enter image description here][1]


This problem only exits when I package my app as  a jar, debugging in Eclipse has no problems. I suspect that this has something to do with this [bug][2] but I&#39;m not sure how to correct this problem.


Any helps appreciated


If matters:

I&#39;m on Java 8 build 1.8.0-b132

Windows 7 Ult. x64


  [1]: http://i.stack.imgur.com/Fudlg.png
  [2]: http://bugs.java.com/bugdatabase/view_bug.do?bug_id=7181278

Java access files in jar causes java.nio.file.FileSystemNotFoundException

How can I create a [`java.nio.file.Path`][1] object from a `String` object in Java 7?

I.e.

    String textPath = &quot;c:/dir1/dir2/dir3&quot;;
    Path path = ?;

where `?` is the missing code that uses `textPath`.

  [1]: http://docs.oracle.com/javase/7/docs/api/java/nio/file/Path.html

Create a Path from String in Java7

How do I recursively list all files under a directory in Java? Does the framework provide any utility?   

I saw a lot of hacky implementations. But none from the framework or [nio][1]  


  [1]: http://java.sun.com/j2se/1.4.2/docs/api/java/nio/package-summary.html

All Nio Solutions on Gang of Coders

Total of 23 Nio Solutions