How is data stored in Java?.

Data in Java is stored in memory in various ways:

Primitive types: Values are stored directly in allocated memory locations (e.g., stack). These include byte, short, int, long, float, double, boolean, char.
```
// int - primitive type, value stored directly
int age = 30;
```

Reference types: A reference (address) is stored in memory, pointing to the location of the object itself (in the heap). These include classes, interfaces, arrays.

// String - reference type, data holds a reference to the "Hello" object in the heap
String data = "Hello";
// CustomObject instance is created in the heap, obj holds a reference to it
CustomObject obj = new CustomObject();

Arrays: Objects in the heap containing a set of elements (either primitive values or references to other objects). The array variable holds a reference to this object.

// Array of ints, nums holds a reference to the array object in the heap
int[] numbers = new int[10];
// Array of Strings, names holds a reference to the array object
String[] names = {"Alice", "Bob"};

Objects: Created in the heap. The variable holds a reference to the object. Inside the object, there can be primitive fields or references to other objects.

// Person class with fields
class Person {
    String name; // Reference to String object
    int age; // Primitive value
}

// Creating a Person object in the heap, person holds a reference
Person person = new Person();
person.name = "Charlie";
person.age = 25;

Strings: String objects are stored in the heap. Strings are immutable. Their values are often cached in the String Pool for optimization when created as literals.
```
// String literal, can be created in String Pool
String str1 = "Java";
// Creating a new String object in the heap
String str2 = new String("Java");
```

Collections (List, Set, Map, etc.): Objects stored in the heap. They contain references to other objects.

// ArrayList stores references to added String objects
List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

Stack: Used for storing local variables (primitive types), references to objects, and call stack information. The data lifecycle in the stack is tied to the called method.
Heap: Used for storing all objects. Memory cleanup in the heap is performed by the garbage collector.

Thus, data in Java is distributed between the stack (for primitives and references) and the heap (for objects).