InstanceOfJava

What are the oops concepts in java?

Posted by: Unknown Posted date: 12:14 PM / comment : 0 Core java Interview Questions , Java SE

Oops concepts are the rules which are supposed to be satisfied by a programming language in order to call that programming language as an Object Oriented Programming Language
The three oops concepts are
        i.Encapsulation
        ii. Polymorphism
        iii.Inheritance
Encapsulation:
The process of binding the data with corresponding functions.
Polymorphism:
Defining multiple methods with same name.
Inheritance:
Getting the properties from one class object to another class object

What happens When System.out.println(null)?

Posted by: Unknown Posted date: 12:06 PM / comment : 5 Core java Interview Questions

Compilation Error -This is because you can pass an Object or a String or char[]. Since null can fit in both, the compiler doesn't know which method to use, leading to compile error.

Method Overloading:
    1.public void prinltln(String str) { }
    2.public void prinltln(char[] ch){ }
    3.public void prinltln(Object ch){
It seems the call System.out.print(null) is ambiguous to compiler because print(null) here will find the two best specific matches i.e. print(String) and print(char[]) . So compiler is unable to determine which method to call here .
Compilation Error:
System.out.println(null)

Program #1: what will happen when we print System.out.println(null)

Compile Fine:
     System.out.println((String)null);//null
     System.out.println((char[])null);
     System.out.println((Object)null);//null
It's the compiler type-checking the parameters of the method call.
But here we need to know one more thing System.out.println((char[])null); will compile fine but at run time will throw runtime exception.

Program #2: what will happen when we print System.out.println(null) by type casting

package com.systemoutprintn;
public class Test {
/**
* @Website: www.instanceofjava.com
* @category: System.out.println(null)
*/
public static void main(String[] args) {
System.out.println((String)null);//null
System.out.println((Object)null);//null
System.out.println((char[])null);
}
}

Output:

null
null
Exception in thread "main" java.lang.NullPointerException
at java.io.Writer.write(Unknown Source)
at java.io.PrintStream.write(Unknown Source)
at java.io.PrintStream.print(Unknown Source)
at java.io.PrintStream.println(Unknown Source)
at com.systemoutprintn.Test.main(Test.java:13)

Explain System.out.println()?

Posted by: saidesh Posted date: 12:02 PM / comment : 0 Core java Interview Questions , Java SE

System is a class Which is present in java.lang package.
Out is a static final field (variable) of Printstream class
Println(): method of Printstream Class
Class System{
public static final Printstream Out;
}
Class Printstream{
public void println(){}}

Final ,finally and finalize()?

Posted by: Instanceofjava Posted date: 6:15 PM / comment : 0 Core java Interview Questions , Java SE

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();
}

Differences between HashMap and Hash-table

Posted by: saidesh Posted date: 12:05 PM / comment : 2 Core java Interview Questions , Java SE

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:

Feature	HashMap	Hashtable
Synchronization	Not synchronized (not thread-safe)	Synchronized (thread-safe)
Performance	Faster (no overhead of synchronization)	Slower (due to synchronization)
Null Keys/Values	Allows one null key and multiple null values	Does not allow null keys or values
Iteration	Uses Iterator (fail-fast)	Uses Enumerator (legacy, not fail-safe)
Inheritance	Extends AbstractMap	Extends Dictionary (legacy class)
Thread Safety	Requires external synchronization for multi-threading	Thread-safe, but may impact performance
Use Case	Best for non-threaded applications	Suitable for multi-threaded environments

Differences between HashMap and Hash-table

Synchronization or Thread Safe : One of the major differences between HashMap and Hashtable is that HashMap is non-synchronized whereas Hashtable is synchronized, which means Hashtable is thread-safe and can be shared between multiple threads but HashMap cannot be shared between multiple threads without proper synchronization. Java 5 introduced ConcurrentHashMap which is an alternative of Hashtable and provides better scalability than Hashtable in Java.Synchronized means only one thread can modify a hash table at one point of time. Basically, it means that any thread before performing an update on a hashtable will have to acquire a lock on the object while others will wait for lock to be released.

Null keys and null values : The HashMap class is roughly equivalent to Hashtable, except that it permits nulls. (HashMap permits one null key and multiple null values.
Hashtable doesn't permit any sort of nulls (key or values).).

Iterating the values: The third significant difference between HashMap vs Hashtable is that Iterator in the HashMap is a fail-fast iterator while the enumerator for the Hashtable is not and throw ConcurrentModificationException if any other Thread modifies the map structurally by adding or removing any element except Iterator’s own remove() method. But this is not a guaranteed behavior and will be done by JVM on best effort. This is also an important difference between Enumeration and Iterator in Java.

Default Capacity:
Hashmap: static final int DEFAULT_INITIAL_CAPACITY =16 static final float DEFAULT_LOAD_FACTOR = 0.75f;
Hashtable: static final int DEFAULT_INITIAL_CAPACITY = 11; static final float DEFAULT_LOAD_FACTOR = 0.75f;

HashMap does not guarantee that the order of the map will remain constant over time.

HashMap can be synchronized by using Collections.synchronizedMap() method

Map m = Collections.synchronizedMap(hashMap);

Example:

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

import java.util.HashMap;
import java.util.Hashtable;
public class HashMapHashtableExample {
public static void main(String[] args) {
Hashtable<String,String> hashtableobj = new Hashtable<String, String>();
hashtableobj.put("name", "ramu");
hashtableobj.put("petname", "ram");
System.out.println("Hashtable object output :"+ hashtableobj);
HashMap hashmapobj = new HashMap();
hashmapobj.put("name", "ramu");
hashmapobj.put("pertname", "ram");
System.out.println("HashMap object output :"+hashmapobj);
}
}

HashMap in Java

What is HashMap?

HashMap<K, V> is a part of the java.util package and implements the Map<K, V> interface. It stores key-value pairs using a hashing mechanism, which allows efficient insertion, deletion, and retrieval operations.

Characteristics of HashMap

Not synchronized: Multiple threads can access a HashMap concurrently, but this can lead to inconsistent data if modifications occur.
Allows null values and a single null key.
Unordered: Does not guarantee any specific order of keys.
Performance: Fast for most operations since there is no synchronization overhead.

Hashtable in Java

What is Hashtable?

Hashtable<K, V> is a legacy class from Java 1.0 that implements the Map<K, V> interface and extends the Dictionary<K, V> class. It stores key-value pairs using hashing and provides built-in synchronization, making it thread-safe.

Characteristics of Hashtable

Synchronized: All methods are thread-safe but can lead to performance bottlenecks.
Does not allow null keys or values.
Unordered: Similar to HashMap, it does not guarantee the order of keys.
Uses Enumerator instead of Iterator (legacy mechanism, should be avoided).

Java String

Posted by: saidesh Posted date: 12:00 PM / comment : 1 Java SE

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:

public class StringCreationDemo {
public static void main (String args[]) {
String str1 = "Hello";
String str2 = "Hello";
System.out.println("str1 and str2 : literal");
System.out.println("str1 == str2 is " + (str1 == str2));
String str3 = new String("Hello");
String str4 = new String("Hello");
System.out.println("str3 and str4 : new operator");
System.out.println(" str3 == str4 is " + (str3 == str4));
String str5 = "Hel"+ "lo";
String str6 = "He" + "llo";
System.out.println("str5 and str6 : expression.");
System.out.println(" str5 == str6 is " + (str5 == str6));
}
}

Output:

str1 and str2 : literal
str1 == str2 is true.
str3 and str4 : new operator str3 == str4 is false.
str5 and str6 : expression
str5 == str6 is true.

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.

Why Strings are immutable in java?

Security: Parameters are typically represented as String in network connections, database connection urls, usernames/passwords etc. If it were mutable, these parameters could be easily changed.
Synchronization and concurrency: making String immutable automatically makes them thread safe thereby solving the synchronization issues.
Caching: when compiler optimizes your String objects, it sees that if two objects have same value (a="test", and b="test") and thus you need only one string object (for both a and b, these two will point to the same object).
Class loading: String is used as arguments for class loading. If mutable, it could result in wrong class being loaded (because mutable objects change their state).

How to prove Strings are immutable?

package com.instanceofjava;
public class StringImmutableDemo {
public static void main(String[] args) {
String s1="Java";
String s2 = "Rocks!";
System.out.println("The hascode of s1 = " + s1.hashCode());
System.out.println("The hascode of s2 = " + s2.hashCode());
s1=s1 + s2;
System.out.println("The hascode [AFTER] s1 is changed = " + s1.hashCode());
}

Output:

The hascode of s1 = 2301506
The hascode of s2 = -1841810349
The hascode [AFTER] s1 is changed = 1248336149

String class constructors:

String class has 8 important constructors.

1.String():

Creates empty string object.

2.String(String value):

Creates String objects with the string value

3.String(StringBuffer sb):

Creates String object with the given StringBuffer object.

4. String(StringBuilder sb):

Creates String object with the given StringBuilder object.

5.String(char[] ch):

Creates String object with the given array values.

6.String(char ch, int offset, int count):

Creates String object with the given array values start with offset by including with the given count of characters.

7.String(byte[] b):

Creates String object with the given byte array values.

8.String(byte[] b, int offset, int count):

Creates String object with the given byte array values starts with offset by including with the given count of bytes

String methods:

1.isEmpty():

This method used to check whether String is empty or not

2.length():

To find the length of given string.

package com.instanceofjavaforus;
public Class StringMethodsDemo{
public static void main (String args[]) {
String str="";
System.out.println(str.isEmpty()) ;
System.out.println(str.length());
}
}
Output:
true
0

3.equals();

To compare two strings

4.compareTo():

To Compare two string objects lexicographically, means after comparison method should return difference between string content

5.compareToIgnoreCase():

To Compare two string objects lexicographically, means after comparison method should return difference between string content ignores case.

package com.instanceofjavaforus;
public Class StringMethodsDemo{
public static void main (String args[]) {
String str1="abc";
String str2= new String("abc")
System.out.println(str1.equals(str2)) ;
String str3="a";
String str4="A";
System.out.println(str3.compareTo(str4)) ;
String str5="a";
String str6="A";
System.ot.println(str3.compareToIgnoreCase(str4)) ;
}
}
Output:
true
32
0

6.7. startsWith(), endsWith():

To check whether the string starts with specified string or ends with specified string

package com.instanceofjavaforus;
public Class StringMethodsDemo{
public static void main (String args[]) {
String str1="Java programming language";
System.out.println(str1.startsWith("Java"));
System.out.println(str1.endsWith("java"));
}
}
Output:
true
false

8.charAt(int index);

To find character at given index

package com.instanceofjavaforus;
public Class StringMethodsDemo{
public static void main (String args[]) {
String str1="Java";
System.out.println(str1.charAt(1));
System.out.println(str1.charAt(3));
}
}
Output:
a
a

9.indexOf(char ch):

Returns first occurrence of given character

package com.instanceofjavaforus;
public Class StringMethodsDemo{
public static void main (String args[]) {
String str1="Java";
System.out.println(str1.indexOf("J"));
System.out.println(str1.indexOf("B"));
}
}
Output:
0
-1

Subscribe to: Posts ( Atom )