最近很多小伙伴都在问Python何时为相同的字符串分配新的内存？和python字符串相同这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展2个相同的字符串“不相等”[Python]、

最近很多小伙伴都在问Python何时为相同的字符串分配新的内存？和python 字符串相同这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展2个相同的字符串“不相等” [Python]、Java ArrayList相同的字符串分组并获得最频繁的字符串、Java字符串不变性和使用相同的字符串值创建新的字符串、PHP将两个不同的字符串表示为相同等相关知识，下面开始了哦！

• Python何时为相同的字符串分配新的内存？（python 字符串相同）
• 2个相同的字符串“不相等” [Python]
• Java ArrayList相同的字符串分组并获得最频繁的字符串
• Java字符串不变性和使用相同的字符串值创建新的字符串
• PHP将两个不同的字符串表示为相同

Python何时为相同的字符串分配新的内存？（python 字符串相同）

两个具有相同字符a == b的Python字符串可能共享内存id（a）== id（b），或者可能在内存中两次，id（a）！= id（b）。尝试

ab = "ab"print id( ab ), id( "a"+"b" )

Python在这里认识到新创建的“ a” +“ b”与内存中已经存在的“ ab”相同-不错。

现在考虑一个由N个长的州名组成的列表[“ Arizona”，“ Alaska”，“ Alaska”，“ California” …]（在我的情况下为N〜500000）。
我看到50个不同的id（）s⇒每个字符串“ Arizona” …仅存储一次，很好。
但是将列表写入磁盘，然后再次读回：“相同”列表现在具有N个不同的id（），增加了内存，请参见下文。

怎么了-有人能解释Python字符串内存分配吗？

""" when does Python allocate new memory for identical strings ?    ab = "ab"    print id( ab ), id( "a"+"b" )  # same !    list of N names from 50 states: 50 ids, mem ~ 4N + 50S, each string once    but list > file > mem again: N ids, mem ~ N * (4 + S)"""from __future__ import divisionfrom collections import defaultdictfrom copy import copyimport cPickleimport randomimport sysstates = dict(AL = "Alabama",AK = "Alaska",AZ = "Arizona",AR = "Arkansas",CA = "California",CO = "Colorado",CT = "Connecticut",DE = "Delaware",FL = "Florida",GA = "Georgia",)def nid(alist):    """ nr distinct ids """    return "%d ids  %d pickle len" % (        len( set( map( id, alist ))),        len( cPickle.dumps( alist, 0 )))  # rough est ?# cf http://stackoverflow.com/questions/2117255/python-deep-getsizeof-list-with-contentsN = 10000exec( "\n".join( sys.argv[1:] ))  # var=val ...random.seed(1)    # big list of random names of states --names = []for j in xrange(N):    name = copy( random.choice( states.values() ))    names.append(name)print "%d strings in mem:  %s" % (N, nid(names) )  # 10 ids, even with copy()    # list to a file, back again -- each string is allocated anewjoinsplit = "\n".join(names).split()  # same as > file > mem againassert joinsplit == namesprint "%d strings from a file:  %s" % (N, nid(joinsplit) )# 10000 strings in mem:  10 ids  42149 pickle len  # 10000 strings from a file:  10000 ids  188080 pickle len# Python 2.6.4 mac ppc

新增25jan：
Python内存（或任何程序的）中有两种字符串：

• 唯一字符串的Ucache中的Ustring：节省内存，并且如果两个都在Ucache中，则可以使a == b快速
• Ostrings，其他的，可以存储多次。

intern(astring)将字符串放入Ucache（Alex +1）；除此之外，我们对Python如何将Ostrings移到Ucache一无所知-在“ ab”之后，“ a” +“ b”是如何进入的？（“文件中的字符串”是没有意义的-无法知道。）
简而言之，Ucache（可能有多个）仍然模糊。

历史脚注： SPITBOL 统一所有字符串ca。1970年。

答案1

在分配不可变对象（例如字符串）时，Python语言的每种实现都可以自由地做出自己的取舍-制作一个新对象，或者找到一个相等的对象，并使用一个以上的引用，从该语言的角度来看都很好观点看法。当然，在实践中，现实世界中的实现会做出合理的折衷：在定位这样的对象时，再引用一个合适的现有对象既便宜又容易，如果要找到合适的现有对象（可能会可能不存在），看起来可能需要很长时间才能搜索到。

因此，例如，在一个函数中多次出现相同字符串文字（在我所知道的所有实现中）将使用“对同一对象的新引用”策略，因为在构建该函数的常量池时，它非常容易快捷避免重复；但是跨单独的功能执行此操作可能是一项非常耗时的任务，因此，现实世界中的实现要么根本不执行此操作，要么仅在某些启发式确定的情况子集中执行此操作，而这些子集可以希望我们合理地权衡编译时间（通过搜索相同的现有常量而降低）与内存消耗（如果不断制作新的常量副本会增加内存消耗）。

我不知道Python的任何实现（或与此有关的其他具有常量字符串的语言，例如Java）在从文件中读取数据时会麻烦识别可能的重复项（以通过多个引用重用单个对象）的麻烦- -这似乎不是一个有希望的折衷办法（这里您要付出运行时的费用，而不是编译时的费用，所以这种折衷的吸引力就更小了）。当然，如果你知道（得益于应用层面的考虑），这样的不可变对象是大，非常容易出现很多重复，你可以很容易地实现自己的“常量池”战略（实习生可以帮助您为字符串做，但不难为自己而生，例如具有不可变项的元组，巨大的长整数，

2个相同的字符串“不相等” [Python]

f_nmr,f_Question,f_1,f_2,f_3,f_answer = file.readline().split('-')
print(f_2)
print(f_answer)
if f_2 == f_answer:
    print("Yes")
elif f_2 != f_answer:
    print("No")

Java ArrayList相同的字符串分组并获得最频繁的字符串

我认为您正在寻找：

Optional<Map.Entry<String,Long>> maxEntryByValue = count.entrySet()
        .stream()
        .max(Comparator.comparing(Map.Entry::getValue));

或者，如果您不想使用Optional，则可以使用：

Map.Entry<String,Long> maxEntryByValue = count.entrySet()
        .stream()
        .max(Comparator.comparing(Map.Entry::getValue))
        .orElse(null); // or any default value,or you can use orElseThrow(..)

您可以遍历条目，如果 value 与您的 targetValue 相匹配，则将该密钥存储在Set<K> keys中。这将包含具有特定 targetValue

    for (Map.Entry<String,Object> entry : map.entrySet()) {
      String key = entry.getKey();
      Object value = entry.getValue();
      if (value.equals(targetValue)) {
        keys.add(entry.getKey());//add the keys to the set<K> keys
      }
    }
    return keys; //all the keys having the same targetValue will be in this set

Java字符串不变性和使用相同的字符串值创建新的字符串

我知道问题的标题不是很清楚，对此感到抱歉，不知道如何提出。我有一个非常基本的Java实现问题，我想着重于应用程序性能，但是它也涉及Java中的String创建模式。

我了解Java中字符串的不变性概念。我不确定的是，我在某处读到以下内容不会创建两个不同的String对象：

String name = "Sambhav";String myName= "Sambhav";

我想知道Java是怎么做到的？它实际上是否在程序存储器中寻找一个String值并检查其是否存在，如果不存在则创建一个新的String对象？在那种情况下，显然可以节省内存，但存在性能问题。

还可以说我有这样的代码：

  public void some_method(){        String name = "Sambhav";        System.out.println(name); //  or any random stufff  }

现在，在每次调用此函数时，是否正在创建一个新的String并将其添加到内存中，或者我是否使用相同的String对象？我只是想知道所有事情的真相？

如果我们这样说

String name = "Sambhav";String myName= "Sambhav";

不会因为引用而创建新对象，那

String name = new String("Sambhav");String myName= new String("Sambhav");

Java是否仍然可以捕捉到该字符串相同，只是将myName指向与上一条语句中创建的对象相同的对象？

答案1

字符串是内部char数组，具有一些与基础char数组一起使用的固有功能。例如。subString（int），split（String）方法。

字符串是不可变的，这意味着更改字符串引用所做的任何努力都会创建一个新的字符串并为此分配内存。如下

line 1. String a = new String("SomeString");line 2. a = "SomeStringChanged";

第1行使用变量a引用的“ SomeString”分配内存，并将“ SomeString ” 添加到 字符串池

第2行在 字符串池中 使用“ SomeStringChanged” 分配内存，并被aie a引用，现在不指向“ SomeString”，并且“
SomeString”占用的内存现在可用于 gc 。

这里没有重复使用

line 3. String  b =  "SomeStringChanged";

现在，文字“ SomeStringChanged* ”被变量 a 和 b 重用 。也就是说，它们指的是 相同的内存位置
，实际上是指称为“ 字符串池 ”的位置。 ***

line 4. a = new String("SomeStringChanged");

现在，新的分配完成包含“ SomeStringChanged ”，并引用 一个

有 没有再使用 ，现在发生的事情。（字符数组 SomeStringChanged的 字符串池中已经存在。因此，没有字符串池分配发生）

line 5. a = new String("SomeStringChanged").intern();

现在，在第4行中创建的分配将被丢弃，变量 a 和 b 指向包含“
SomeStringChanged”的字符串池中的相同位置。这里重复使用相同的char数组。功劳归于 intern（） 方法

line 6. String x = new String("SomeX");line 7. String y = "SomeX";

第6 行将 在堆和字符串池中为 SomeX 创建一个分配。char数组已重复。

第7行不会为 SomeX 分配任何内存，因为它已经在字符串池中了

Line 8 String s = new String(someStringVariable);

第8行将仅在堆中分配单个内存位置，而不在字符串池中分配单个内存位置。

总之，只有在将String引用声明为文字或将String对象插入的情况下，才可以重用字符串的char数组，即只有这两个可以使用String池（这实际上是char数组重用的思想）。

PHP将两个不同的字符串表示为相同

"608E-4234" == "272E-3063"

今天关于Python何时为相同的字符串分配新的内存？和python 字符串相同的介绍到此结束，谢谢您的阅读，有关2个相同的字符串“不相等” [Python]、Java ArrayList相同的字符串分组并获得最频繁的字符串、Java字符串不变性和使用相同的字符串值创建新的字符串、PHP将两个不同的字符串表示为相同等更多相关知识的信息可以在本站进行查询。