What is == operator ?

To compare primitives and objects we use “==” equality operator in java which is a binary operator given in the java programming language

What is equals() method in java?

The Java String class equals() method compares the two given strings based on the content of the string. If any character is not matched, it returns false. If all characters are matched, it returns true.

Difference between == and equals method in java

1. == is an operator whereas equals() is a method of Object class.

2. == operator compares reference or memory location of objects in the heap, whether they point to the same location or not. Whenever we create an object using the operator new it will create a new memory location for that object. So we use the == operator to check memory location or address of two objects are the same or not.
equals() method is used to compare the state of two objects or the contents of the objects.

3. Equals method can be overridden but you can’t override behavior of “==” operator.

Below is an example which shows the use of == and equals.

public class EqualsDemo1 {

	public static void main(String[] args) {
		String str1 = new String("JAVATUTORIAL");
		String str2 = new String("JAVATUTORIAL");

		// Reference comparison
		System.out.println("Check str1 == str2 : " + (str1 == str2));

		// Content comparison
		System.out.println("Check str1.equals(str2) : " + str1.equals(str2));

		// integer-type
		System.out.println("Check Integer Type :" + (10 == 10));

		// char-type
		System.out.println("Check Char Type :" + ('a' == 'a'));
	}
}

Output
Check str1 == str2 : false
Check str1.equals(str2) : true
Check Integer Type :true
Check Char Type :true

Let us take an example where both strings have same characters and same length but in lower case.

public class EqualsDemo2 {

	public static void main(String[] args) {
		String str1 = new String("JAVATUTORIAL");
		String str2 = new String("jAVATUTORIAL");

		// Reference comparison
		System.out.println("Check str1 == str2 : " + (str1 == str2));

		// Content comparison
		System.out.println("Check str1.equals(str2) : " + str1.equals(str2));
	}
}

Output
Check str1 == str2 : false
Check str1.equals(str2) : false

Let us take an example where both Integer refer to the same object.

public class EqualsDemo3 {

	public static void main(String[] args) {

		Integer i = new Integer(10);
		Integer j = i;

		System.out.println("Check i == j : " + (i == j));
}

Output
Check i == j : true

Let us take an example where both Integer1 and Integer2 refer to the different objects.

public class EqualsDemo4 {

	public static void main(String[] args) {

		Integer i = new Integer(10);
		Integer j = new Integer(10);

		System.out.println("Check i == j : " + (i == j));
	}
}

Output
Check i == j : false

That’s it for today. Have a wonderful learning.

October 28, 2021October 28, 2021 vibssingh

Throws in Java

HOME

The throws keyword in Java is used in the signature of method to indicate that this method might throw one of the listed type of exceptions. The caller to these methods has to handle the exception using a try-catch block.

Syntax of throws

return_type method_name() throws ExceptionType1, ExceptionType2 …{  
//method code  
}

As you can see from the above syntax, we can use throws to declare multiple exceptions.

Below is an example of throws exception. Here, as you can see IOException is listed as an exception. This exception is handled by a try catch block when findFile() method is called.

public class ThrowsExample {

	public static void findFile() throws IOException {

		File file= new File("C:\\test.txt");
		FileInputStream stream = new FileInputStream(file);

	}

	public static void main(String[] args) {
		try {
			findFile();
		} catch (IOException e) {
			System.out.println(e);
		}
	}
}

Output
java.io.FileNotFoundException: C:\test.txt (The system cannot find the file specified)

When we run this program, if the file test.txt does not exist, FileInputStream throws a FileNotFoundException which extends the IOException class.

If a method does not handle exceptions, the type of exceptions that may occur within it must be specified in the throws clause so that methods further up in the call stack can handle them or specify them using throws keyword themselves.

The findFile() method specifies that an IOException can be thrown. The main() method calls this method and handles the exception if it is thrown.

In a program, if there is a chance of raising an exception then compiler always warn us about it and compulsorily we should handle that checked exception, Otherwise we will get compile time error saying unreported exception XXX must be caught or declared to be thrown. To prevent this compile time error we can handle the exception in two ways:

We have caught the exception i.e. we have handled the exception using try/catch block.
We have declared the exception i.e. specified throws keyword with the method.

Case 1 : Handle Exception Using try-catch block

In case we handle the exception, the code will be executed fine whether exception occurs during the program or not.

class Demo {
	void method() throws IOException {
		throw new IOException("IOException Occurred");
	}
}

public class TestThrowsExample2 {

	public static void main(String[] args) {
		try {
			Demo demo = new Demo();
			demo.method();
		} catch (Exception e) {
			System.out.println("Exception handled");
		}

		System.out.println("Continue the program...");
	}
}

Output
Exception handled
Continue the program...

Case 2: We declare the exception, if exception does not occur, the code will be executed fine.

class Test {
	void method() throws IOException {
		System.out.println("No Exception");
	}
}

public class TestThrowsExample3 {

	public static void main(String[] args) {
		try {
			Test test = new Test();
			test.method();
		} catch (Exception e) {
			System.out.println("Exception handled");
		}

		System.out.println("Continue the program...");
	}
}

Output
No Exception
Continue the program...

Case 3 : We declare the exception and the exception occurs, it will be thrown at runtime because throws does not handle the exception.

class TestDemo {
	void method() throws IOException {
		throw new IOException("IOException Occurred");
	}
}

public class TestThrowsExample4 {

	public static void main(String[] args) throws IOException {
		TestDemo test = new TestDemo();
		test.method();
		System.out.println("Continue the program...");

	}

}

Output
Exception in thread "main" java.io.IOException: IOException Occurred

June 21, 2021June 21, 2021 vibssingh

Iterators in Java

HOME

‘Iterator’ is an interface which belongs to collection framework. It allows us to traverse the collection, access the data element and remove the data elements of the collection.

java.util package has public interface Iterator and contains three methods:

boolean hasNext(): It returns true if Iterator has more element to iterate.
Object next(): It returns the next element in the collection until the hasNext()method return true. This method throws ‘NoSuchElementException’ if there is no next element.
void remove(): It removes from the underlying collection the last element returned by this iterator (optional operation). This method can be called only once per call to next(). The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.
forEachRemaining – Performs the given action for each remaining element until all elements have been processed or the action throws an exception. Actions are performed in the order of iteration, if that order is specified. Exceptions thrown by the action are relayed to the caller.

Below is an example of use of Iterator. The iterator() method is used to get an iterator for any collection:

public class IteratorDemo {

   public static void main(String[] args) {

		ArrayList<String> cars = new ArrayList<String>();
		cars.add("Audi");
		cars.add("BMW");
		cars.add("Ford");
		cars.add("Duster");

		// Get the iterator
		Iterator<String> it = cars.iterator();

		// Print the first item
		System.out.println("First element from list :"+it.next());

	}
}

Output
First element from list :Audi

Looping through Collection

In the below example, we are looping through the collection using hasNext() and next() methods of Iterator.

public class IteratorDemo {

	 public static void main(String[] args) {

		ArrayList<String> cars = new ArrayList<String>();
		cars.add("Audi");
		cars.add("BMW");
		cars.add("Ford");
		cars.add("Duster");

		// Get the iterator
		Iterator<String> iterator = cars.iterator();

		System.out.println("List elements : ");

		while (iterator.hasNext())
			System.out.print(iterator.next() + " ");

		System.out.println();
	}
}

Output
List elements : 
Audi BMW Ford Duster

Removing elements from Collection

Iterators are designed to easily change the collections that they loop through. The remove() method can remove items from a collection while looping. In the below example, I’m deleting the items whose reminder are not 0.

public class IteratorDemo {

	 public static void main(String[] args) {

		ArrayList<Integer> numbers = new ArrayList<Integer>();
		numbers.add(20);
		numbers.add(8);
		numbers.add(10);
		numbers.add(50);

        // Get the iterator
		Iterator<Integer> it = numbers.iterator();

		System.out.println("List of Numbers : ");
		while (it.hasNext()) {

			Integer i = it.next();

			if (i / 10 == 0) {
				it.remove();
			}
		}
		System.out.println(numbers);
	}

}

Output
List of Numbers : 
[20, 10, 50]

I hope you are cleared about Iterators now. Enjoy learning. Cheers!!

June 18, 2021September 22, 2023 vibssingh

HashMap in Java

Last Updated On

September 22, 2023

HOME

A HashMap stores items in “key/value” pairs, and you can access them by an index of another type (e.g. a String).

One object is used as a key (index) to another object (value). It can store different types: String keys and Integer values, or the same type, like String keys and String values. We need to import java.util.HashMap or its superclass in order to use the HashMap class and methods.

It is not an ordered collection, which means it does not return the keys and values in the same order in which they have been inserted into the HashMap.

Table of Contents

Create a HashMap object as shown below from:-

import java.util.HashMap;

Syntax of HashMap

HashMap<String, String> employeeDetail = new HashMap<String, String>();

HashMap<String, String> employeeDetail = new HashMap<>();

HashMap<String, Integer> employeeDetail = new HashMap<String, Integer>();