DEV Community: Nirmit Gupta

File Operations In JAVA

Nirmit Gupta — Wed, 19 Feb 2025 21:41:25 +0000

File handling is one of the most important aspects in world of coding.
In JAVA we can perform the following by JAVA I/O API.

File handling enables one to perform various operations related to create, read, delete, update a file.

Before jumping into file handling lets understand the concept of Streams in JAVA.

Streams

Streams are a sequence of character.
There are two types of streams in JAVA.
1.) Input Stream — The input stream is used to read data from a file.
It is an abstract class which provides common definition to be used by subclasses. We have various subclasses of InputStream such as —
.)AudioInputStream — It is used to read or manipulate audio data.

.)ByteArrayInputStream — Used to read byte array data as stream.

.)FileInputStream — This input stream subclass is used to read and manipulate data from files.

.)FilterInputStream — Provide additional functionality like buffering or data transformation.

.)StringBufferInputStream — Stream to read data from a string buffer.

.)ObjectInputStream — Used to read and deserialize objects from an input stream.

2.)Output Stream — The output stream is used to write data to various output devices such as monitor,file and many more.It is also an abstract class with various subclasses.

.)ByteArrayOutputStream
.)FileOutputStream
.)StringBufferOutputStream
.)ObjectOutputStream
.)DataOutputStream
.)PrintStream

Based on data we have two types of streams.

.)Byte Stream- This stream is used to read/write byte data.

.)Character Stream- This stream is used to read/write character data.

Since one has got idea on Streams and various stuff around it, lets comeback to File Handling in JAVA.

Lets see a few methods related to file handling which will give idea of what all we can do in file handling.

.)canRead() — This method returns a boolean value which tells whether a file is readable or not.

.)createNewFile() — This method returns a boolean value and creates a new file.

.)delete() — This method returns a boolean value and deletes a file.

.)getName() — This method returns a string value which is the name of the file.

.)getAbsolutePath() — This method returns a string value which is the absolute path of the file.

.)length() — This method returns a long value which is the size of the file.

.)list() — This method returns a string array which contains names of all files present in the directory.

.)mkdir() — This method returns a boolean value and create a new directory.

.)canWrite() —This method returns a boolean value and checks whether we can write data into a file or not.

.)exists() — This method return a boolean value and checks whether a file exists or not.

With files one can do CRUD operations which are -
.)Create a file

import java.io.File;
import java.io.IOException;

public class CreateFile {
    public static void main(String args[]) {
        try {
            // Create an object of a file
            File file = new File("Example.txt");
            //Check whether file exists or not
            if (file.createNewFile()) {
                System.out.println("File " + file.getName() + " got created successfully.");
            } else {
                System.out.println("File already exists in the directory.");
            }
        } catch (IOException exception) {
            System.out.println("Unexpected error is occurred.");
        }
    }
}

Output

File Example.txt got created successfully.

.)Read a file

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadAFile {
    public static void main(String[] args) {
        File file = new File("Example.txt");
        try {
            Scanner sc = new Scanner(file);

            //Reading the file
            while (sc.hasNextLine()) {
                String data = sc.nextLine();
                System.out.println(data);
            }
            sc.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

Output

Hello World

.)Write/Update a file

import java.io.FileWriter;

public class WriteAFile {
    public static void main(String[] args) {
        try {
            FileWriter file = new FileWriter("Example.txt");
            file.write("Hello World");

            //Close the stream
            file.close();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

.)Delete a file

import java.io.File;

public class DeleteAFile {
    public static void main(String[] args) {
        File file = new File("Example.txt");
        try {
            if(file.delete()){
                System.out.println("File deleted successfully");
            }
            else{
                System.out.println("Exception occurred while deleting the file");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Output

File deleted successfully

This marks the end of the tutorial.

In summary JAVA provides a robust mechanism to handle file operations in JAVA which makes development easy.My suggestion would be to explore more in this topic and play with more methods for better grasp of the topic.
I hope the above tutorial provides some value to the reader and if you find this tutorial useful, do leave a comment and share it with fellow developers.
!!Happy Learning.Happy Coding!!

Annotations in JAVA

Nirmit Gupta — Tue, 18 Feb 2025 18:05:16 +0000

JAVA Annotations are nothing but metadata for for programs.
Annotations provide additional data for classes, interfaces, methods, fields which is used by JVM and compiler.

Syntax :-

@AnnotationName
public class MyClass{...}

Predefined Java Annotations :-
JAVA provides us with several built-in annotations.
Lets explore them one by one.
a) @override
This annotations ensures that the method is been overriden from its superclass.
In below example display method Child class is overriden from parent class. So it ensures that we inherit the correct method intended to be inherited. If we make some spelling mistake with method name and use override annotation, it will throw error.
Error message will be as follows - "Method does not override method from its superclass"

class Parent {
    void display(){
        System.out.println("Hello from parent class");   
    }
}

class Child extends Parent{
    @Override
    void display(){
        System.out.println("Hello from child class");
    }
}

b) @deprecated
It provides information that following method or class is deprecated . Provides user that it may be removed in future versions.
In below example it shows that method named "calcSum" will be deprecated.

class Sum {

    @Deprecated
    int calcSum(int a,int b){
        return a+b; 
    }
}

c) @SuppressWarnings
Suppresses warnings issued by compilers. Helps to keep code clean by removing unnecessary warnings.
Syntax-

@SuppressWarnings("warning_type")
class Sum {

    @Deprecated
    int calcSum(int a,int b){
        return a+b;
    }
}

public class Main {
    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        Sum sum=new Sum();
        int sumValue=sum.calcSum(1,2);
        System.out.println("Sum is="+sumValue);
    }
}

In above example without annotation, we would get warning that calcSum is deprecated.

Lets discuss about built-in annotations in JAVA which are used in custom annotations.
a)@Target
Tells which type of element where annotation is to be applied like TYPE (class,enums,interface),FIELD,METHOD,CONSTRUCTOR,LOCAL_VARIABLE,ANNOTATION_TYPE,PARAMETER
@Target(ElementType.TYPE)
b)@Retention
Specifies at which level annotation will be available.
Ex-
.)SOURCE - It tells that annotation is available at source code and ignored during compilation.
.)CLASS - It tells that annotation is available to compiler and not JVM.
.)RUNTIME - It tells that annotation is available to compiler and JVM.
c)@Inherited
Tells that annotation is inherited by subclasses.
d)@Documented
Ensueres annotation is documented in JavaDoc .

Types of Annotations
a)Marker Annotations
Annotations without methods are marker annotations
Ex - @override ,@deprecated
@interface MyAnnotations{}
b)Single-Value Annotations
Annotations with one method.

@interface MyAnnotations{
  int num();
}

//Apply
@MyAnnotations(num=1)

c)Multi-Value Annotations
Annotations with more than one method.

@interface MyAnnotations{
  int num1();
  int num2();
}

//Apply
@MyAnnotations(num1=1,num2=1)

Custom Annotations

Lets try creating custom annotation which will provide much deeper understanding of the topic.
a.)To define custom annotation we use the @interface keyword :

@Retention(RetentionPolicy.RUNTIME)  // Available at runtime
@Target(ElementType.METHOD)          // Can be applied to methods only
@interface Review {
    String reviewerName() default "Unknown";
}

Over here we define annotation with name "Review" using @interface keyword .
b.)Next step is to apply the annotation.

public class CodeReview {
    @Review(reviewerName = "John")
    public void ReviewMethod1() {
        System.out.println("I need review");
    }
    @Review(reviewerName = "Mike")
    public void ReviewMethod2() {
        System.out.println("I also need review");
    }
}

Both methods "ReviewMethod1" and "ReviewMethod2" have annotation "Review" which tells the name of the reviewer of those methods.
c.) Now lets read and display these Annotations

public class MainExample {
    public static void main(String[] args) {
        Class<CodeReview> obj=CodeReview.class;
        for(Method method:obj.getDeclaredMethods()){
            if(method.isAnnotationPresent(Review.class)){
                Review annotation=method.getAnnotation(Review.class);
                System.out.println("Method:" +method.getName()+ "| Reviewer: "+annotation.reviewerName());
            }
        }
    }
}

d.)Output

Method:ReviewMethod1 | Reviewer: John
Method:ReviewMethod2 | Reviewer: Mike

Now if you go through the code in "c" you will see have used JAVA Reflections API. It is a powerful feature to read and manipulate structure and behaviour of classes, methods and fields at runtime.

This marks the end of tutorial.
We explored annotations, their syntax, types and how to write custom annotations.
My suggestion would be to explore more in this topic and play with more annotations for better grasp of the topic.
I hope the above tutorial provides some value to the reader and if you find this tutorial useful, do leave a comment and share it with fellow developers.
!!Happy Learning.Happy Coding!!