blocks|key|3115904|text|不可变类型通常是一件好事：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3115905|3115906|它们在并发方面工作得更好(你不需要锁定不能改变的东西！)|unordered-list-item|3115907|它们减少了错误:可变对象很容易在你意想不到的时候被改变，这可能会引入各种奇怪的错误(“一个distance")|3115908|They的操作可以安全地共享(即对同一对象的多个引用))，这可以减少内存消耗并提高缓存利用率。|3115909|共享还使复制成为一个非常廉价的O(1)操作，如果您必须获取可变对象的防御性副本，则复制操作将是O(n)。这是一个大问题，因为复制是一个非常常见的操作(例如，每当您想要传递参数时……)|3115910|3115911|因此，使字符串不可变是一种非常合理的语言设计选择。|3115912|有些语言(特别是像Haskell和Clojure这样的函数式语言)走得更远，几乎使所有东西都是不可变的。如果你对不变性的好处感兴趣，这个enlightening+video非常值得一看。|offset|length|3115913|不可变类型有几个小缺点：|3115914|创建像连接这样的更改字符串的|3115915|操作的开销更大，因为您需要构造新对象。通常，连接两个不可变字符串的成本为O(n%2Bm)，但如果使用基于树的字符串数据结构(如Rope+)，成本可能低至O(log+(m%2Bn))。另外，如果你真的需要连接字符串efficiently.|3115916|A，你可以使用特殊的工具，比如Java的StringBuilder。在一个大字符串上的小改动可能会导致需要构造一个大字符串的全新副本，这显然会增加内存消耗。但是请注意，在垃圾收集语言中，这通常不是一个大问题，因为如果不保留对旧副本的引用，旧副本将很快被垃圾回收。|3115917|3115918|但总体而言，不变性的优点远远大于次要缺点。即使你只对性能感兴趣，复制的并发优势和廉价通常会使不变的字符串比具有锁定和防御性复制的可变字符串具有更高的性能。|3115919|entityMap|0|LINK|mutability|MUTABLE|url|http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey|1|http://en.wikipedia.org/wiki/Rope_%2528computer_science%2529|2|http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html^0|0|0|0|0|0|0|0|0|1W|I|0|0|0|0|1P|4|1|0|K|D|2|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1H|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1I|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|1J|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|1K|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1M|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1N|8|@]|9|@$Q|1O|R|1P|1|1Q]]|A|$]]|$1|S|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1S|8|@]|9|@]|A|$]]|$1|W|3|X|5|E|7|1T|8|@]|9|@$Q|1U|R|1V|1|1W]]|A|$]]|$1|Y|3|Z|5|E|7|1X|8|@]|9|@$Q|1Y|R|1Z|1|20]]|A|$]]|$1|10|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|22|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|14|$15|$5|16|17|18|A|$19|1A]]|1B|$5|16|17|18|A|$19|1C]]|1D|$5|16|17|18|A|$19|1E]]]]

Immutable types are a good thing generally:

<ul>
<li>They work better for concurrency (you don't need to lock something that can't change!)</li>
<li>They reduce errors: mutable objects are vulnerable to being changed when you don't expect it which can introduce all kinds of strange bugs ("action at a distance")</li>
<li>They can be safely shared (i.e. multiple references to the same object) which can reduce memory consumption and improve cache utilisation. </li>
<li>Sharing also makes copying a very cheap O(1) operation when it would be O(n) if you have to take a defensive copy of a mutable object. This is a big deal because copying is an incredibly common operation (e.g. whenever you want to pass parameters around....)</li>
</ul>

As a result, it's a pretty reasonable language design choice to make strings immutable.

Some languages (particularly functional languages like Haskell and Clojure) go even further and make pretty much everything immutable. This <a href="http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey">enlightening video</a> is very much worth a look if you are interested in the benefits of immutability.

There are a couple of minor downsides for immutable types:

<ul>
<li>Operations that create a changed string like concatenation are more expensive because you need to construct new objects. Typically the cost is O(n+m) for concatenating two immutable Strings, though it can go as low as O(log (m+n)) if you use a tree-based string data structure like a <a href="http://en.wikipedia.org/wiki/Rope_%28computer_science%29">Rope</a>. Plus you can always use special tools like Java's <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html">StringBuilder</a> if you really need to concatenate Strings efficiently.</li>
<li>A small change on a large string can result in the need to construct a completely new copy of the large String, which obviously increases memory consumption. Note however that this isn't usually a big issue in garbage-collected languages since the old copy will get garbage collected pretty quickly if you don't keep a reference to it.</li>
</ul>

Overall though, the advantages of immutability vastly outweigh the minor disadvantages. Even if you are only interested in performance, the concurrency advantages and cheapness of copying will in general make immutable strings much more performant than mutable ones with locking and defensive copying.

blocks|key|233844|text|它主要是为了防止编程错误。例如，字符串经常用作哈希表中的键。如果它们可以改变，哈希表就会被破坏。这只是一个例子，当你使用一段数据时改变了它会导致问题。安全性是另一个问题:如果在执行用户请求的操作之前检查是否允许用户访问位于给定路径的文件，则包含该路径的字符串最好不是可变的……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|233845|当你在做多线程的时候，它变得更加重要。不可变的数据可以在线程之间安全地传递，而可变的数据会造成无尽的麻烦。|233846|基本上，不可变数据使得处理它的代码更容易推理。这就是为什么纯函数式语言试图保持所有东西都不变的原因。|233847|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's mainly intended to prevent programming errors. For example, Strings are frequently used as keys in hashtables. If they could change, the hashtable would become corrupted. And that's just one example where having a piece of data change while you're using it causes problems. Security is another: if you checking whether a user is allowed to access a file at a given path before executing the operation they requested, the string containing the path better not be mutable...

It becomes even more important when you're doing multithreading. Immutable data can be safely passed around between threads while mutable data causes endless headaches.

Basically, immutable data makes the code that works on it easier to reason about. Which is why purely functional languages try to keep everything immutable.

blocks|key|2901892|text|在Java中，不仅String，而且所有的原始包装类(Integer、Double、Character等)都是不可变的。我不确定确切的原因，但我认为这些是所有编程方案都工作的基本数据类型。如果他们改变了，事情可能会变得很疯狂。更具体地说，我将使用一个示例:假设您打开了一个到远程主机的套接字连接。主机名将是字符串，端口将是Integer。如果在建立连接后修改了这些值，该怎么办？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2901893|就性能而言，Java从一个单独的内存区(称为字面池)为这些类分配内存，而不是从堆栈或堆分配内存。文字池被编入索引，如果您使用字符串"+string“两次，它们指向文字池中的同一对象。|2901894|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In Java not only String but all primitive Wrapper classes (Integer, Double, Character etc) are immutable. I am not sure of the exact reason but I think these are the basic data types on which all the programming schemes work. If they change, things could go wild. To be more specific, I'll use an example: Say you have opened a socket connection to a remote host. The host name would be a String and port would be Integer. What if these values are modified after the connection is established.

As far as performance is concerned, Java allocates memory to these classes from a separate memory section called Literal Pool, and not from stack or Heap. The Literal Pool is indexed and if you use a string "String" twice, they point to the same object from Literal pool.

blocks|key|239399|text|将字符串作为不可变的字符串也可以方便地引用新的字符串，因为相同/相似的字符串将很容易从先前创建的字符串池中获得。从而降低创建新对象的成本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|239400|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Having strings as immutable also allows the new string references easy, as the same/similar strings will be readily available from the pool of the Strings previously created. Thereby reducing the cost of new object creation.

<blockquote>
 Possible Duplicate: 
 <a href="https://stackoverflow.com/questions/93091/why-cant-strings-be-mutable-in-java-and-net">Why can&#39;t strings be mutable in Java and .NET?</a> 
 <a href="https://stackoverflow.com/questions/2365272/why-net-string-is-immutable">Why .NET String is immutable?</a>
</blockquote>

Several languages have chosen for this, such as C#, Java, and Python. If it is intended to save memory or gain efficiency for operations like compare, what effect does it have on concatenation and other modifying operations?

Why are strings immutable in many programming languages?

 可能重复：有几种语言可供选择，例如C#、Java和Python语言。如果它的目的是为了节省内存或提高比较等操作的效率，那么它对连接和其他修改操作有什么影响？

问为什么字符串在许多编程语言中是不可变的？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么字符串在许多编程语言中是不可变的？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么字符串在许多编程语言中是不可变的？
EN