immutability

I have following code:- public class StaticImplementer { private static String str= "ABC"; public static void main(String args[]) { str = str + "XYZ"; } } Questions:- Here String str is static, then where this object will be stored in memory? Since String is immutable, where the object for "XYZ" will be stored? Where will be final object will be Stored? And how will garbage collection will be done? Here String str is static, then where this object will be stored in memory? String str is not an object, it's a reference to an object. "ABC" , "XYZ" & "ABCXYZ" are three distinct String objects.

According to the book Design Patterns: Elements of Reusable Object-Oriented Software,: The Builder Pattern separates the construction of a complex object from its representation so that the same construction process can create different representations. In general the Builder pattern solves the issue with large number of optional parameters and inconsistent state by providing a way to build the object step-by-step and provide a method that will actually return the final Object. With the builder pattern we go to have a build method to generate an object witch is immutable. My Question: Can I

Is there any way (utilizing Reflection I hope) that I can make an instantiated object immutable along with all of its public properties ? I have a class from someone else's codebase (no source available) that I need to utilize and I basically want an exception to be thrown if any piece of code anywhere tries to call a public setter within this class after it has been instantiated. Note: I do not want to create a wrapper object around the class in order to implement this. I am lazy. No there is not via reflection. Type definitions cannot be altered at runtime via reflection and hence it cannot

If I create an immutable class. All the fields have to be final. If I use stringbuilder in that like this final StringBuilder s = new StringBuilder("Hello "); , then the append function can append the value of the s and the class wont be immutable. Please advice. It's "shallow-immutable" in that you can't change the fields themselves, but it's not fully immutable - which means you lose pretty much all the benefits associated with immutability. Basically to achieve immutability, all the constituent parts must either be naturally immutable, or sometimes you can get away with using something

More particularly, I really want an immutable/shared linked list, and I think having immutable maps and sets would be nice too. As long as I don't have to worry about the core implementation, I can easily add extension methods/subclass/wrap it to provide a reasonably slick external interface for myself to use. Is there any reason I shouldn't do this? Performance, incompatibility, etc.? The types in the F# library (such as Set , Map and list ) were not designed to be used from C#, so I wouldn't generally recommend using them directly. It can be done and some basic operations will work well (e.g

I am learning the C programming language and am running into difficulties in understanding the minute differences between pointers, arrays and read only memory. I am working with the following example: char *myCards = "JQK"; From what I understand what this line of code accomplishes is it creates a null terminated string of characters in a read only section of memory that is accessible via the char pointer myCards . This means that I am able to compile the following but would receive an error due to the immutability of the string: *myCards = 'A'; I am trying to achieve a similar functionality