immutability

I know this is probably very stupid, but a lot of places claim that the Integer class in Java is immutable, yet the following code: Integer a=3; Integer b=3; a+=b; System.out.println(a); Executes without any trouble giving the (expected) result 6. So effectively the value of a has changed. Doesn't that mean Integer is mutable? Secondary question and a little offtopic: "Immutable classes do not need copy constructors". Anyone care to explain why? Travis Webb Immutable does not mean that a can never equal another value. For example, String is immutable too, but I can still do this: String str =

I already know the definition of immutable classes but I need a few examples. Paŭlo Ebermann Some famous immutable classes in the Standard API: java.lang.String (already mentioned) The wrapper classes for the primitive types: java.lang.Integer, java.lang.Byte, java.lang.Character, java.lang.Short, java.lang.Boolean, java.lang.Long, java.lang.Double, java.lang.Float java.lang.StackTraceElement (used in building exception stacktraces) Most enum classes are immutable, but this in fact depends on the concrete case. (Don't implement mutable enums, this will screw you up somewhen.) I think that at

From Java 1.6 Collection Framework documentation : Collections that do not support any modification operations (such as add , remove and clear ) are referred to as unmodifiable . [...] Collections that additionally guarantee that no change in the Collection object will ever be visible are referred to as immutable . The second criteria confuses me a bit. Given the first collection is unmodifiable, and assuming that the original collection reference has been disposed away, what are the changes that are referred to in the second line? Is it referring to the changes in the elements held in the

My goal is to make a Java object immutable. I have a class Student . I coded it in the following way to achieve immutability: public final class Student { private String name; private String age; public Student(String name, String age) { this.name = name; this.age = age; } public String getName() { return name; } public String getAge() { return age; } } My question is, what is the best way to achieve immutability for the Student class? assylias Your class is not immutable strictly speaking, it is only effectively immutable. To make it immutable, you need to use final : private final String

From a recent SO question (see Create a dictionary in python which is indexed by lists ) I realized I probably had a wrong conception of the meaning of hashable and immutable objects in python. What does hashable mean in practice? What is the relation between hashable and immmutable? Are there mutable objects that are hashable or immutable objects that are not hashable? Hashing is the process of converting some large amount of data into a much smaller amount (typically a single integer) in a repeatable way so that it can be looked up in a table in constant-time ( O(1) ), which is important for

A few times, I've run into the scenario where an accessor method is needed for both mutable and immutable references. For ~3 lines it isn't a problem to duplicate the logic, but when the logic gets more complex, it's not nice to copy-paste large blocks of code. I'd like to be able to re-use the code for both. Does Rust provide some way handle this better then copy-pasting code, or using unsafe casts? e.g.: impl MyStruct { pub fn get_foo(&self) -> &Bar { // ~20 lines of code // --- snip --- return bar; } pub fn get_foo_mut(&mut self) -> &mut Bar { // ~20 lines of code // (exactly matching