Describe the Composite design pattern and provide an example of its usage in a hierarchical structure.

The Composite design pattern is a structural design pattern that allows you to compose objects into tree-like structures to represent part-whole hierarchies. It lets clients treat individual objects and compositions of objects uniformly.

The main idea behind the Composite pattern is to have a common interface for both individual objects and composite objects. This interface typically includes operations for adding, removing, and accessing child components, as well as operations that can be performed on both individual and composite objects.

One example of the Composite pattern is a hierarchical structure of a file system. In this example, a file system can be represented as a tree-like structure, where directories can contain both files and subdirectories. Each file and directory in the file system can be treated as a component, and the file system itself can be treated as a composite.

Let's consider a simplified implementation of the Composite pattern for a file system:

```java
// Component interface
public interface FileSystemComponent {
void display();
}

// Leaf class representing a file
public class File implements FileSystemComponent {
private String name;

public File(String name) {
this.name = name;
}

public void display() {
System.out.println("File: " + name);
}
}

// Composite class representing a directory
public class Directory implements FileSystemComponent {
private String name;
private List components;

public Directory(String name) {
this.name = name;
this.components = new ArrayList<>();
}

public void addComponent(FileSystemComponent component) {
components.add(component);
}

public void removeComponent(FileSystemComponent component) {
components.remove(component);
}

public void display() {
System.out.println("Directory: " + name);
for (FileSystemComponent component : components) {
component.display();
}
}
}

// Usage example
public class Main {
public static void main(String[] args) {
// Create files
FileSystemComponent file1 = new File("file1.txt");
FileSystemComponent file2 = new File("file2.txt");
FileSystemComponent file3 = new File("file3.txt");

// Create directories
FileSystemComponent dir1 = new Directory("dir1");
FileSystemComponent dir2 = new Directory("dir2");

// Add files to directory 1
((Directory) dir1).addComponent(file1);
((Directory) dir1).addComponent(file2);

// Add files to directory 2
((Directory) dir2).addComponent(file3);

// Add directories to directory 1
((Directory) dir1).addComponent(dir2);

// Display the file system structure
dir1.display();
}
}
```

In this example, we have a file system structure consisting of files and directories. The `File` class represents a file, while the `Directory` class represents a directory. Both classes implement the `FileSystemComponent` interface, which defines the common operations for both files and directories.

The `Directory` class maintains a list of `FileSystemComponent` objects, which can be files or subdirectories. It provides methods to add and remove components from the list. The `display` method is implemented to recursively display the file system structure, including all files and subdirectories.

In the `Main` class, we create files and directories and add them to the file system structure. Finally, we call the `display` method on the root directory to display the entire file system structure.

By using the Composite pattern, we can treat individual files and directories as well as the entire file system uniformly. This allows us to perform operations on the file system structure without having to differentiate between files and directories.