Final:

• Any variable declare along with final modifier then those variables treated as final variable.
•  if we declare final variables along with static will became constants.
• public final String name = "foo"; //never change this value
• If you declare method as final that method also known as final methods.Final methods are not overridden.means we can't overridden that method in anyway.
• public final void add(){
   }
   public class A{
   void add(){
   //Can't override
   }
  
   }
• If you declare class is final that class is also known as final classes.Final classes are not extended.means we can't extens that calss in anyway.
• public final class indhu{
   }
   public class classNotAllowed extends indhu {...} //not allowed

Finally:

• Finally blocks are followed by try or catch.finally blocks are complasary executable blocks.But finally is useful for more than just exception handling.
•  it allows the programmer to avoid having cleanup code accidentally bypassed by a return,
   continue, or break,Closing streams, network connection, database connection. Putting cleanup  code in a finally block is always a good practice even when no exceptions are anticipated
•  where finally doesn't execute e.g. returning value from finally block, calling System.exit from try block etc
• finally block always execute, except in case of JVM dies i.e. calling System.exit() .
  
   lock.lock();
  try {
    //do stuff
  } catch (SomeException se) {
    //handle se
  } finally {
    lock.unlock(); //always executed, even if Exception or Error or se
    //here close the database connection and any return statements like that we have to write
  }

Finalize():

• finalize() is a method which is present in Java.lang.Object class.
•  Before an object is garbage collected, the garbage collector calls this finalize() of object.Any unreferncebefore destorying if that object having any connections with databse or anything..It will remove  the connections and it will call finalize() of object.It will destroy the object.
• If you want to Explicitly call this garbage collector you can use System.gc() or Runtime.gc() objects are there from a long time the garbage collector will destroy that objects.
• public void finalize() {
    //free resources (e.g. unallocate memory)
    super.finalize();
  }

Java provides different types of Map implementations, two of the most commonly used being HashMap and Hashtable. Both of these classes implement the Map< interface and store key-value pairs, but they differ significantly in terms of synchronization, performance, and usage. In this article, we will explore the differences in detail.

Introduction

A Map in Java is a collection of key-value pairs where each key is unique. Both HashMap and Hashtable use a hashing mechanism to store and retrieve data efficiently. However, they have different characteristics that make them suitable for different use cases.

Key Differences Between HashMap and Hashtable

The table below provides a summary of the key differences between HashMap and Hashtable:

Here is example of a C program that uses a for loop to calculate the sum of 'n' numbers:

String:

• Series of characters is known as string.
• String is final class in java.
  public final class String
  extends Object
  implements Serializable, Comparable<String>, CharSequence.
• We can create a String object in two ways.
• 1. By using new operator
      String str= new String("Java");
  2.By using String literal.
     String str= "Java".

Difference between string object and string literal  :

 
• Whenever you call new() in JAVA it create an object in heap.
• String literals will go into String Constant Pool.
• For objects JVM used String constant pool which is for efficient memory management in java. Unlike other Java Objects, instead of managing String object on heap area, they introduced String constant pool. One of important characteristic of String constant pool is that it does not create same String object if there is already String constant in the pool.

Example program:

String is immutable. What exactly is the meaning??

• String is immutable means that you cannot change the object itself, but you can change the reference to the object. 
•  String a="a";
         a = "str";
• When you called a = "str", you are actually changing the reference of a to a new object created by the String literal "str". 
• Changing an object means to use its methods to change one of its fields (or the fields are public and not final, so that they can be updated from outside without accessing them via methods)
• String str="smiley";
  str=str+"bird";
  here new String object will be created.

String class constructors:

8.charAt(int index);

• To find character at given index

9.indexOf(char ch):

• Returns first occurrence of  given character

• LinkedHashSet allows only unique elements.
• LinkedHashSet allows Insertion order.
• LinkedHashSet allows only one null value.

• TreeSet Allows only Unique elements.
• Treeset having sorted order
• TreeSet doesn't allow  any null value.

• in Set interface if you want to add elements you can use add() method.
• If you want to remove you can use remove() method.

• Serializable means transferable
• The concept of transferring object of a class from one location to another location is known as Serialization.
• All the java classes can be devided into two. 

• The classes whose objects can be transferable .  Objects of all classes  that are implementing serializable  interface can be transferable
• The classes whose objects can't be transferable .  Objects of all classes  which are not implementing serializable  interface cant be transferable .
• To transfer the object need to convert to byte stream :  serializing 
• To receive Object need to convert from byte stream to Object : deserializing
• Classes ObjectInputStream and ObjectOutputStream are high-level streams that contain the methods for serializing and deserializing an object.
 

public class Student implements java.io.Serializable
{
   public String name;
   public int number ;
   
}

import java.io.*;

public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "harsha";
       
     e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/student.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
} 

 Deserialization

import java.io.*;
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Student e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Student ) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("student class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized student...");
      System.out.println("Name: " + e.name);

      System.out.println("Number: " + e.number);

    }
} 

Transient Keyword: 

• The keyword transient in Java used to indicate that the variable should not be serialized
• By default all the variables in the object is converted to persistent state. In some cases, you may want to avoid persisting some variables because you don’t have the necessity to transfer across the network. So, you can declare those variables as transient.
• If the variable is declared as transient, then it will not be persisted. It is the main purpose of the transient keyword.