Posts Tagged ‘file’

Files and directories in Java: the NIO.2 Approach

In the previous post I told you about the old fashioned way to handle files in java.
In this article we will focus on the new API.
The File class is no longer used. We will use the “Path” class instead.
Files is a utility class to create either files or directories, that takes a path in the constructor:

	Path filePath=Paths.get("/home/laura/demo.txt");
	Path dirPath=Paths.get("/home/laura/newdir");
	Path nestedDirPath=Paths.get("/home/laura/newdir3/newdir4");

The “createDirectories” method created the whole file system structure (the nested directories).

With NIO.2 copying or deleting a file or directory have become a matter of one line of code, thanks to the very straightforward methods “copy”, “delete”, etc.

Many things can be achieved with the utility classes Files and Paths.

Java IO: Handling characters files efficiently

Let´s take a look a the classic IO file handling in java.
First let´s start with the “File” class.
The File class is not used to read or write data. It´s used to create or delete files and directories, for searching and working with paths.
So it´s not used for the files or directories content.

The File class constructor does not create anything on the hard drive. As you can see in the following snippet, you need to use the createNewFile method for it:

		File file = new File("/home/laura/demo.txt");
		System.out.println("Does the file exists?"+file.exists());
		boolean created = file.createNewFile();
		System.out.println("File created?"+created);
		System.out.println("Does the file exists?"+file.exists());

The createNewFile method returns “false” if the file already exists.

If the goal is handling text files, you don´t need to use any Stream class. All you need is a writer one. The basic option is to use the naked “FileReader” and “FileWriter” classes:

		FileWriter fileWriter= new FileWriter(file);
		fileWriter.write("hello world. this is a text file.");
		FileReader fileReader= new FileReader(file);
		char[] in = new char[100];		
		int size =;
		System.out.println("File size:"+size);
		for(char c: in){

The FileReader method “read” delivers the amount of character read.

Notice that after writing the text into the file, you need to call the method “flush”. It´s necessary to call it to make sure that the whole data flows into the file before closing the writer.

So far so good. But this simple way shown above is not the most elegant solution out there, because we have been using an array (that has a fixed size)!

A much better approach is wrapping it up using the classes BufferedReader and BufferedWriter:

		FileWriter fileWriter= new FileWriter(file);
		BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
		bufferedWriter.write("hello world. this is a text file.");
		bufferedWriter.write("You are using the buffered reader now!");			
		FileReader fileReader= new FileReader(file);
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		String data;			

Notice that buffered reader also has a method called “readLine”, that you wouldn´t get with a simple File reader.
Once you close a writer it cannot be reopened again. You get an exception if you use it after closing it!

Linux file system

filesystem: the files and directories (or folders), the method used to store data on the hard drive (such as the ext3 filesystem.

– Windows keeps all the important system files in a single directory C:\
– Linux follows the lead of its UNIX
– Windows and Linux setups are both logical

✓ Linux uses a forward slash (/) between directories, not the backslash (\) that Windows uses. So, the file yum.conf in the directory etc is

✓ Files and directories can have names up to 256 characters long, and these names can contain underscores (_), dashes (-), and dots (.) any-
where within. So my.big.file or my.big_file or my-big-file are all valid filenames.

✓ Upper- and lowercase matter. They have to match exactly. The files yum.conf and Yum.conf are not the same as far as Linux is concerned.
Linux is case-sensitive — it pays attention to the case of each character. Windows, on the other hand, is case-insensitive.

✓ The same filesystem can span multiple partitions, hard drives, and media (such as CD-ROM drives). You just keep going down through
subdirectories, not having to care whether something is on disk A, B, or whatever.

Everything in the Linux filesystem is relative to the root directory — not to be confused with the system Administrator, who is the root user. The root directory is referred to as /, and it is the filesystem’s home base — a doorway into all your files. As such, it contains a relatively predictable set of subdirectories. Each distribution varies slightly in terms of what it puts in the root directory. More or less you can find the following directories.

/bin   : Essential commands that everyone needs to use at any time.*
/boot  : The information that boots the machine, including your kernel.*
/dev :  The device drivers for all the hardware that your system needs to  interface with.*
/etc  : The configuration files for your system.*
/home  : The home directories for each of your users.
/lib  : The libraries, or the code that many programs (and the kernel) use.*
/media  : A spot where you add temporary media, such as floppy disks and  CD-ROMs; not all distributions have this directory.
/mnt  :  A spot where you add extra filesystem components such as networked drives and items you aren’t permanently adding to your filesystem but that aren’t as temporary as CD-ROMs and floppies.
/opt   : The location that some people decide to use (and some programs want to use) for installing new software packages, such as word
processors and office suites.
/proc   : Current settings for your kernel (operating system).*
/root   : The superuser’s (root user’s) home directory.
/sbin   : The commands the system Administrator needs access to.*
/srv   : Data for your system’s services (the programs that run in thebackground).*
/sys   : Kernel information about your hardware.*
/tmp   : The place where everyone and everything stores temporary files.
/usr   : A complex hierarchy of additional programs and files.
/var   : The data that changes frequently, such as log files and your mail.