Java instanceof Operator

In Java, the `instanceof` operator is used as the type operator. It checks if an object is an instance of a
specific class or implements a particular interface. It’s useful for verifying the type of an object before
performing operations on it, to avoid `ClassCastException`.

Syntax

java

object instanceof ClassName

`object`:The instance being checked.

`ClassName`: The class or interface being checked against.

Example

java

String text = "Hello, Java!";

if (text instanceof String) {
System.out.println("text is an instance of String");
}

In this example, `instanceof` verifies that `text` is indeed a `String` type, so the output will be:

vbnet

text is an instance of String

Notes

Polymorphism: `instanceof` is particularly useful when dealing with polymorphism, as it allows

you to check the actual class of an object referenced by a superclass or interface.
Null check: If `object` is `null`, `instanceof` returns `false`.

In Java, to check if a variable is of type `int` or `char`, you can use the `instanceof` operator for object
types and `getClass()` for boxed types like `Integer` or `Character`. However, because `int` and `char`
are primitive types, `instanceof` does not work directly with them.

Using Wrapper Classes

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/9
For primitive types, you can use wrapper classes (`Integer` for `int`, `Character` for `char`) to check the
types. Here are some approaches:

1. Checking Type Using Wrapper Classes

If you are working with boxed types, such as `Integer` and `Character`, you can use `instanceof`.

java

Object var1 = 42; // Boxed as Integer

Object var2 = 'A'; // Boxed as Character

if (var1 instanceof Integer) {

System.out.println("var1 is of type Integer");
}
if (var2 instanceof Character) {
System.out.println("var2 is of type Character");
}

2. Checking Type of Primitive Variables (Alternative Approach)

For primitive types, you may know their type at compile time because Java is strongly typed. But if you're
trying to check at runtime in a more dynamic setup, here are some approaches:

Approach using `getClass().getSimpleName()` for boxed types:

java

Object var1 = 42; // Boxed as Integer

Object var2 = 'A'; // Boxed as Character

System.out.println("var1 is of type: " + var1.getClass().getSimpleName());

System.out.println("var2 is of type: " + var2.getClass().getSimpleName());

Using `getClass().isAssignableFrom()`

This method works with boxed types as well:

java

Object var1 = 42; // Integer

Object var2 = 'A'; // Character

if (Integer.class.isAssignableFrom(var1.getClass())) {
System.out.println("var1 is of type Integer");
}
if (Character.class.isAssignableFrom(var2.getClass())) {
System.out.println("var2 is of type Character");
}

In practice, since Java is a statically-typed language, most type-checking is done at compile time, which
means you typically know the type of variables beforehand and don't often need to check the type at
runtime.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 2/9
In Java, the size of data types varies depending on whether they're primitives or objects. Here’s a quick
guide:

Primitive Data Types

The sizes of Java primitive data types are fixed, regardless of the platform.

Data Type Size (in bytes) Range

`byte` 1 -128 to 127

`short` 2 -32,768 to 32,767

`int` 4 -2,147,483

Java does not have a `sizeof` operator like in C or C++. Java is designed to abstract away hardware
details, including specific memory management. However, there are ways to estimate the memory size
of objects in Java:

1. Using the `Instrumentation` API

Java provides the `Instrumentation` API, which can be used to get the size of an object in bytes. Here’s a
rough example of how it works:

java

import java.lang.instrument.Instrumentation;

public class ObjectSizeFetcher {

private static Instrumentation instrumentation;

public static void premain(String args, Instrumentation inst) {

instrumentation = inst;
}

public static long getObjectSize(Object o) {

return instrumentation.getObjectSize(o);
}
}

For this to work:

You need to add this class as a Java agent.

Use `getObjectSize()` to get the approximate memory size of any object.

2. Using `java.lang.Runtime` (Heap Size Before and After Allocation)

If `Instrumentation` isn't available, an alternative approach is to measure the memory used by an object
indirectly by comparing the heap size before and after creating it:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 3/9
 java

public class MemoryTest {

public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();

// Get memory usage before object creation

long memoryBefore = runtime.totalMemory() - runtime.freeMemory();

// Create the object

int[] largeArray = new int[1000];

// Get memory usage after object creation

long memoryAfter = runtime.totalMemory() - runtime.freeMemory();

System.out.println("Approximate size of array: " + (memoryAfter - memoryBefore) + "

bytes");
}
}

3. Using Third-Party Libraries

Libraries like JOL (Java Object Layout) offer a detailed breakdown of object memory usage, especially
useful for complex objects.

Why There’s No `sizeof` in Java

Java’s platform independence abstracts away hardware-specific details, including direct memory size
measurement. Instead, Java focuses on automatic memory management with the garbage collector,
making such low-level operations unnecessary for most applications.

Java operators are symbols that perform specific operations on variables and values. They can be
categorized into several types:

1. Arithmetic Operators

These are used for basic mathematical operations.

Operator Description Example

`+` Addition `a + b`
`-` Subtraction `a - b`
`*` Multiplication `a * b`

`/` Division `a / b`
`%` Modulus (remainder) `a % b`

2. Unary Operators

These operate on a single operand and perform various operations.

Operator Description Example

`+` Unary plus `+a`

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 4/9
 Operator Description Example

`-` Unary minus `-a`

`++` Increment `++a` or `a++`
`--` Decrement `--a` or `a--`
`!` Logical complement (NOT) `!condition`

3. Assignment Operators

These are used to assign values to variables.

Operator Description Example

`=` Simple assignment `a = b`

`+=` Addition assignment `a += b` (same as `a = a + b`)
`-=` Subtraction assignment `a -= b` (same as `a = a - b`)
`*=` Multiplication assignment `a *= b` (same as `a = a * b`)
`/=` Division assignment `a /= b` (same as `a = a / b`)

`%=` Modulus assignment `a %= b` (same as `a = a % b`)

4. Relational Operators

These are used to compare two values and return a boolean result.

Operator Description Example

`==` Equal to `a == b`
`!=` Not equal to `a != b`

`>` Greater than `a > b`

`<` Less than `a < b`
`>=` Greater than or equal to `a >= b`
`<=` Less than or equal to `a <= b`

5. Logical Operators

These are used to perform logical operations, typically on boolean values.

Operator Description Example

`&&` Logical AND `a && b`

` `
`!` Logical NOT `!a`

6. Bitwise Operators

These operate on bits and perform bit-level operations.

Operator Description Example

`&` Bitwise AND `a & b`

` ` Bitwise OR

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 5/9
 Operator Description Example
`^` Bitwise XOR `a ^ b`
`~` Bitwise complement `~a`
`<<` Left shift `a << 2`
`>>` Right shift `a >> 2`

`>>>` Unsigned right shift `a >>> 2`

7. Ternary Operator

The ternary operator is a shorthand for `if-else` statements and is written as `? :`.

java

int result = (a > b) ? a : b;

8. Type Comparison Operator

The `instanceof` operator is used to test whether an object is an instance of a specified type (class or
subclass).

java

if (obj instanceof String) {

System.out.println("obj is a String");
}

9. Special Operators

`instanceof`:Used to check the type of an object.

Dot operator (`.`): Used to access methods and properties of objects.
Array index (`[]`): Used to access elements in an array.

Each of these operators serves a distinct purpose in Java, providing the necessary tools for manipulating
data, performing calculations, and controlling the flow of a program.

When an `int` in Java exceeds its range, it overflows or underflows, causing a phenomenon called
wrap-around. This means that if an integer goes beyond its maximum or minimum value, it "wraps
around" to the opposite end of its range.

Integer Range in Java

in Java has a range of -2,147,483,648 to 2,147,483,647 (32 bits).

`int`
When it exceeds this range, overflow or underflow occurs.

Overflow Example

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 6/9
When an `int` reaches its maximum value (`2,147,483,647`) and is incremented by 1, it wraps around to
the minimum value (`-2,147,483,648`).

java

int maxInt = Integer.MAX_VALUE; // 2,147,483,647

System.out.println("Max Int: " + maxInt);
System.out.println("Max Int + 1: " + (maxInt + 1)); // -2,147,483,648

Output:

kotlin

Max Int: 2147483647

Max Int + 1: -2147483648

Underflow Example

Similarly, if an `int` reaches its minimum value (`-2,147,483,648`) and is decremented by 1, it wraps
around to the maximum value (`2,147,483,647`).

java

int minInt = Integer.MIN_VALUE; // -2,147,483,648

System.out.println("Min Int: " + minInt);
System.out.println("Min Int - 1: " + (minInt - 1)); // 2,147,483,647

Output:

kotlin

Min Int: -2147483648

Min Int - 1: 2147483647

Handling Overflow and Underflow

Java provides the `Math` class for handling overflow more gracefully:

`Math.addExact()`:Throws an `ArithmeticException` if overflow occurs during addition.

`Math.subtractExact()`: Throws an `ArithmeticException` if overflow occurs during subtraction.
`Math.multiplyExact()`: Throws an `ArithmeticException` if overflow occurs during multiplication.

java

try {
int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 7/9
 System.out.println("Overflow occurred");
}

Using these methods can help you avoid unexpected behavior from overflow and underflow, especially
in scenarios where accuracy is critical.

Yes, in Java, bits are lost when performing a left shift operation on an `int` if they move beyond the 32-
bit boundary. Java `int` values are 32 bits in size, and when you perform a left shift, bits on the left are
discarded once they go beyond this boundary.

How Left Shift Works

The left shift operator (`<<`) shifts bits to the left and fills the rightmost bits with `0`s. However, bits
shifted out from the left side are lost and cannot be recovered.

Example of Left Shift and Bit Loss

Consider the following example, where bits are shifted left beyond the 32-bit boundary:

java

int value = 0b01111111_11111111_11111111_11111111; // 2,147,483,647 (max positive int)

int shiftedValue = value << 1; // Left shift by 1

System.out.println(Integer.toBinaryString(value)); // 01111111111111111111111111111111
System.out.println(Integer.toBinaryString(shiftedValue)); // 1111111111111111111111111111111
0

Output:

arduino

01111111111111111111111111111111 // Original value in binary

11111111111111111111111111111110 // Left-shifted value

Here’s what happens:

The leftmost `0` bit in `value` is shifted out of the boundary and is lost.
The rightmost bit position is filled with a `0`.
The result is a different number than before, which may now be negative because the sign bit
(leftmost bit) has changed.

When Left Shifting Leads to Overflow

If you left-shift an `int` enough times, the shifted bits may cause an overflow, effectively changing the
sign of the value. For example:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 8/9
 java

int x = 1; // Binary: 00000000_00000000_00000000_00000001

int shifted = x << 31; // Shifted to the left by 31 positions

System.out.println(shifted); // Output: -2147483648 (minimum int value)

System.out.println(Integer.toBinaryString(shifted)); // 10000000000000000000000000000000

Summary

Left-shifting `int` values in Java does cause bit loss if bits are shifted out of the 32-bit boundary.
Bits shifted out from the left are discarded, and `0`s fill in from the right.
Left shifts can lead to sign changes or overflow if bits are shifted into the sign bit position.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 9/9