There is no reliable way to detect if a class is immutable. This is because there are so many ways a property of a class might be altered and you can’t detect all of them via reflection. The only way to get close to this is: Only allow final properties of types that are immutable … Read more
Case 1: String str = “Good”; str = str + ” Morning”; In the above code you create 3 String Objects. “Good” it goes into the String Pool. ” Morning” it goes into the String Pool as well. “Good Morning” created by concatenating “Good” and ” Morning”. This guy goes on the Heap. Note: Strings … Read more
On my computer, there’s a file /etc/dictionaries-common/words containing a large collection of English words: >>> with open(“/etc/dictionaries-common/words”) as f: … words = [line.strip() for line in f] … >>> “python” in words True >>> “BDFL” in words False Let’s create a dictionary storing the lengths of all those words: >>> word_lengths = {w: len(w) for … Read more
Strings don’t have any methods on them that allow a change to the value of the string. In other words: strings are immutable. When you call str.replace a new string is built and returned. >>> s1 = ‘Rohit’ >>> s2 = s1.replace(‘R’, ‘M’) >>> >>> s1 ‘Rohit’ >>> s2 ‘Mohit’ As you can see s1 … Read more
5 is immutable, too. When you have an immutable data structure, a += b is equivalent to a = a + b, so a new number, tuple or whatever is created. When doing this with mutable structures, the structure is changed. Example: >>> tup = (1, 2, 3) >>> id(tup) 140153476307856 >>> tup += (4, … Read more
You won’t find a mandatory reason why java.lang wrappers must be immutable. Simply because it’s a design decision. They could have decided otherwise. The language designers had to choose between mutable and immutable. And they chose immutable. That’s it. There are some compelling (IMO) reasons though to make them immutable: It’s consistent with String. The … Read more
Vals are initialized in the order they are declared (well, precisely, non-lazy vals are), so properties is getting initialized before loadedProps. Or in other words, loadedProps is still null when propertiesis getting initialized. The simplest solution here is to define loadedProps before properties: class Config { private val loadedProps = { val p = new … Read more
It’s perfectly safe to use across platforms. The behavior is specified in §15.4.2 of the Java Language Specification (emphasis added): The result of the postfix expression must be a variable of a type that is convertible (§5.1.8) to a numeric type, or a compile-time error occurs. The type of the postfix increment expression is the … Read more
After compilation some strings may refer to the one instance, so, you will edit more than you want and never know what else are you editing. public static void main(String args[]) throws Exception { String s1 = “Hello”; // I want to edit it String s2 = “Hello”; // It may be anywhere and must … Read more
Python doesn’t test for mutable objects, it tests for hashable objects. Custom class instances are by default hashable. That’s fine because the default __eq__ implementation for such classes only tests for instance identity and the hash is based of the same information. In other words, it doesn’t matter that you alter the state of your … Read more