Understanding Flyweight Design Pattern in Java

-

The Flyweight Design Pattern is a powerful structural design pattern in Java used to reduce memory usage when dealing with a large number of similar objects. Instead of creating a new object every time, this pattern reuses shared objects, improving performance, memory efficiency, and scalability.

If you work with applications like editors, games, data visualization tools, or map rendering, understanding the Flyweight Pattern is extremely useful.

What is the Flyweight Pattern?

The Flyweight Pattern allows an application to support a large number of fine-grained objects by sharing common data. It splits object state into:

  • Intrinsic State – shared, reusable, constant
  • Extrinsic State – specific to each object and supplied externally

This allows the system to hold fewer objects in memory.

Real-Time Use Cases of Flyweight Pattern

  • Text editors storing repeated characters
  • Game engines rendering millions of objects
  • Map applications with repeated markers
  • Caching system objects
  • Image icon reuse in UI applications

Flyweight Pattern – UML Explanation

  • Flyweight – interface for shared objects
  • ConcreteFlyweight – actual reusable object
  • FlyweightFactory – returns shared objects
  • Client – supplies extrinsic state

Flyweight Pattern – Real-Time Java Example (Drawing Circles)

Imagine a graphics application where you draw thousands of circles. Most circles share the same color, so creating new objects each time wastes memory. Flyweight helps reuse these objects.

Step 1: Flyweight Interface

public interface Shape {
    void draw(int x, int y);
}

Step 2: ConcreteFlyweight (Shared Object)

public class Circle implements Shape {

    private String color;  // intrinsic state

    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("Drawing " + color + " circle at (" + x + "," + y + ")");
    }
}

Step 3: Flyweight Factory

import java.util.HashMap;
import java.util.Map;

public class ShapeFactory {

    private static final Map<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Shape circle = circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
        }
        return circle;
    }
}

Step 4: Client Code

public class FlyweightDemo {

    public static void main(String[] args) {

        for (int i = 0; i < 5; i++) {
            Shape circle = ShapeFactory.getCircle("Red");
            circle.draw(i, i * 10);
        }

        for (int i = 0; i < 3; i++) {
            Shape circle = ShapeFactory.getCircle("Blue");
            circle.draw(i * 5, i * 5);
        }
    }
}

Expected Output

Drawing Red circle at (0,0)
Drawing Red circle at (1,10)
Drawing Red circle at (2,20)
Drawing Red circle at (3,30)
Drawing Red circle at (4,40)
Drawing Blue circle at (0,0)
Drawing Blue circle at (5,5)
Drawing Blue circle at (10,10)

Notice that only two circle objects (Red and Blue) are created and reused multiple times.

Why Use Flyweight Pattern?

  • Drastically reduces memory usage
  • Improves application performance
  • Ideal for handling millions of similar objects

When Should You Use It?

  • When your application has a large number of similar objects
  • When memory is a concern
  • When object properties can be split into shared and non-shared states

Advantages

  • Reduced memory footprint
  • Better performance
  • Reusable objects improve consistency

Disadvantages

  • Code becomes more complex
  • Extrinsic state must be handled carefully by the client

Conclusion

The Flyweight Design Pattern in Java is essential when working with memory-heavy applications such as games, maps, editors, and UI frameworks. It helps reuse shared objects, boost performance, and reduce memory usage. If you are preparing for interviews or building large-scale applications, mastering this pattern is highly beneficial.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more