DEV Community: NRJ

Java String Management: String Pool vs String Heap Explained

NRJ — Tue, 28 May 2024 19:29:55 +0000

In Java, strings are one of the most commonly used data types. To optimize memory usage and improve performance, Java employs a concept known as the String Pool. This blog post will explain the String Pool and String Heap, using a simple code example to illustrate these concepts.

Code Example

Let's start with a basic Java program that demonstrates different ways of creating strings and compares them using the == operator and the .equals() method.

public class Main {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = new String("Hello");
        String s4 = new String("Hello");

        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // false
        System.out.println(s3 == s4); // false

        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // true
        System.out.println(s3.equals(s4)); // true
    }
}

String Pool

The String Pool, also known as the interned string pool, is a special memory region where Java stores string literals. When you create a string literal, Java first checks if the string already exists in the pool. If it does, it returns the existing reference; if not, it adds the new string to the pool. This helps save memory by avoiding the creation of multiple instances of the same string.

In the code above:

String s1 = "Hello";
String s2 = "Hello";

Both s1 and s2 point to the same string in the String Pool. Therefore, s1 == s2 returns true because both references point to the same object in memory.

String Heap

When you create a string using the new keyword, Java creates a new string object in the heap memory, even if an identical string exists in the String Pool. The heap is a larger memory area where all Java objects, including strings created with new, are stored.

In the code above:

String s3 = new String("Hello");
String s4 = new String("Hello");

Here, s3 and s4 are two different objects in the heap, each containing the string "Hello". Therefore, s3 == s4 returns false because they are distinct objects.

Comparing Strings

Java provides two ways to compare strings:

The == operator checks if two references point to the same object.
The .equals() method checks if two strings have the same value.

In the code example:

s1.equals(s2) returns true because both strings have the same value "Hello".
s1.equals(s3) returns true because both strings have the same value, despite being different objects.
s3.equals(s4) returns true for the same reason.

However, using ==:

s1 == s2 returns true because both refer to the same object in the String Pool.
s1 == s3 returns false because they refer to different objects (one in the pool, one in the heap).
s3 == s4 returns false because they are different objects in the heap.

Conclusion

Understanding the String Pool and String Heap is crucial for writing efficient Java code. The String Pool helps save memory and improve performance by reusing immutable string objects, while the String Heap provides space for dynamically created strings. Using the == operator for reference comparison and the .equals() method for value comparison allows developers to correctly handle strings based on their specific needs. By leveraging these concepts, you can write more efficient and reliable Java programs.

Dive in Spring framework - Beginner Guide

NRJ — Sat, 25 May 2024 11:28:50 +0000

Many fresher want to get SDE role in big banks like Deutsche Bank, UBS, Barclays, HSBC, etc.. But they don't know is that in every bank main tech stack is Spring.

So now let's shallow dive in Spring and Spring Boot.

Pre-requisite - Java basics with OOP's concepts.

So lets understand using basic example

Creation of object as a normal Java with new keyword

public class MyClass {
    private String message;

    public MyClass() {
        this.message = "Hello, I'm created using the new keyword!";
    }

    public String getMessage() {
        return message;
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating an instance of MyClass using the 'new' keyword
        MyClass obj = new MyClass();

        // Accessing the message
        System.out.println(obj.getMessage());
    }
}

Object Creation using Spring:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public MyClass myClass() {
        return new MyClass();
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating Spring application context
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Retrieving bean from Spring context
        MyClass obj = context.getBean(MyClass.class);

        // Accessing the message
        System.out.println(obj.getMessage());

        // Closing Spring context
        context.close();
    }
}

Let's compare the two approaches:

Using the new Keyword:

In the first code snippet:

MyClass obj = new MyClass();

Here, an instance of MyClass is created directly within the main method using the new keyword. The MyClass constructor is invoked, setting the message field to a specific value. This approach is straightforward and doesn't involve any external dependencies or frameworks.

Using Spring Dependency Injection:

In the second code snippet:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
MyClass obj = context.getBean(MyClass.class);

Here, the Spring Framework is used to manage the creation and initialization of the MyClassinstance. In the AppConfigclass, a method annotated with @Bean is defined to indicate that a bean of type MyClass should be created and managed by the Spring container. In the main method, an application context is created based on the configuration defined in AppConfig, and then the MyClassbean is retrieved from the context using context.getBean(MyClass.class). This approach allows for loose coupling, easier unit testing, and better management of dependencies, especially in large-scale applications.

Data Transfer between 2 PC's in lemon terms

NRJ — Fri, 24 May 2024 20:24:06 +0000

If you are sending some file form PC-1 to PC-2 how that files goes ?

Data Generation: Data can be anything from a simple text message to a complex file. When you create or request data on your computer, it needs to be transmitted to another computer.

Packetization: Data is broken down into smaller chunks called packets. Each packet contains a piece of the original data along with additional information such as the source and destination addresses.

Routing: Once the data is packetized, it needs to find its way to the destination computer. This is where routing comes into play. Routers are devices that forward packets between networks based on their destination addresses.

Transmission: The packets are transmitted over a physical medium, such as Ethernet cables, Wi-Fi signals, or fiber-optic cables. Each packet travels independently and can take different routes to reach the destination.

Reassembly: When the packets arrive at the destination computer, they are reassembled into the original data. This process involves checking for any missing or corrupted packets and arranging them in the correct order.

Delivery: Finally, the reassembled data is delivered to the appropriate application or service on the destination computer, where it can be processed or displayed to the user.

BFE- Backend for Front-End

NRJ — Fri, 24 May 2024 20:09:41 +0000

Let's say you are designing some web application, and your main role is develop all Backend API's. As a good backend developer your aim is to write generic API's for any other applications also like Android App, IOS App, etc. etc..

Take a example that you are building an E-commerce Web and Mobile Application. And as per the size of screen UI designer made below like pattern -
For Desktop view of specific product -

Image of product, price
Rating in terms of stars
Reviews
FAQ's

For Mobile Application view of specific product -

Image, price
Rating

FAQ's also there in mobile app but these things are in different tabs and UI/UX Developer made UI according to screen size.
So the main part is that for a different type of screen we are sending different kind of data.

To Desktop -

Product1= {
 "Image": "IMG_1",
 "Rating": "5",
 "Reviews": ["R1", "R2"],
 "FAQ": ["Q1A1", "Q2A2"]
}

To Mobile App-

Product1 = { 
 "Image": "IMG_1", 
 "Rating": "5"
}

So the problem is if you are as a Backend Developer made generic API for Product data and Different Screen Size Device need different data then how these things works ?

Answer from Noob -
As a fresher or beginner backend developer you would say that send all these data and render only those data which is needed at that time from frontend.

But as a good backend developer this is wrong. It's like user can access Reviews and FAQ's on same page where we don't want to show on that page. Yes, it is not bad for security but I think it's more of EGO of Backend Developer 😅😅. (Joking)

Actual Answer -
As I said it is not good practice for backend developer to send all data and use only required data, if developer do that then anyone can go to inspect and call that object and view all JSON of that data. (Still EGO of developer reason is at top).

To send data according to device type -

Noob Advice: Check device properties every time before sending data -
Cons of it- It will fucked up in between our Business Logic
Then BFE- Backend for Front-End came in picture to help these kind of scenarios.

BFE is basically a additional layer we add, whenever any request goes, it will first come to BFE in which BFE identifies that Device type/ Screen Size/ Desktop/ Mobile/ Tab and send request to our generalized Backend, and Backend will send our generalized request to BFE and according to Device type BFE modifies data (BFE make new object of required entities and render that object instead of Generalized response).