blocks|key|3741112|text|在Oracle的JDK中，字符串有四个实例级字段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3741113|3741114|A+character+array|unordered-list-item|3741115|a|3741116|+offset|3741117|An+integral+character+count|3741118|An+integral+hash+value|3741119|3741120|这意味着每个字符串都引入了一个额外的对象引用(字符串本身)，以及除了字符数组本身之外的三个整数。(偏移量和字符数允许在通过String#substring()方法生成的字符串实例之间共享字符数组，这是其他一些Java库实现者所避免的设计选择。)除了额外的存储开销之外，还有更多的间接访问级别，更不用说字符串保护其字符数组的边界检查了。|3741121|字符串是不可变的。这意味着一旦你创建了字符串，如果另一个进程可以转储内存，你就没有办法(除了反射)在GC开始之前删除数据，这意味着内存的浪费。|3741122|使用数组，您可以在处理完数据后显式地擦除数据:您可以用您喜欢的任何东西覆盖数组。|3741123|因此，就我所能得出的结论是，对于您的情况，char[]在内存方面更好。|3741124|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

In Oracle's JDK a String has four instance-level fields:

<ul>
<li>A character array</li>
<li>An integral offset</li>
<li>An integral character count</li>
<li>An integral hash value</li>
</ul>

That means that each String introduces an extra object reference (the String itself), and three integers in addition to the character array itself. (The offset and character count are there to allow sharing of the character array among String instances produced through the String#substring() methods, a design choice that some other Java library implementers have eschewed.) Beyond the extra storage cost, there's also one more level of access indirection, not to mention the bounds checking with which the String guards its character array.

Strings are immutable. That means once you have created the string, if another process can dump memory, there's no way (aside from reflection) you can get rid of the data before GC kicks in which means waste of memory.

With an array, you can explicitly wipe the data after you're done with it: you can overwrite the array with anything you like.

So as far as I can conclude is char[] is better in terms of memory for your case.

blocks|key|3796032|text|String是java中的类，它包装char数组，如您在代码中所见|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3796033|private+final+char+value[];|code-block|syntax|javascript|3796034|因此，每次创建String对象时，它都是由char数组支持的。同样，String类有三个不同的字段，因为它比char数组占用更多的内存。|3796035|但是如果你看到用法，那么String比char数组更好，因为它是不可变的。你不需要对字符串进行任何内存管理。性能明智的char+array[]对于较少的操作更快(如果您是在大数据上执行)。|3796036|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

String is class In java and it wraps char array as you can see in code

<pre><code>private final char value[];
</code></pre>

so every time you create a String object it is backed by char array.
and also String class is having three different fields because of that it is taking more memory than char array. 

but if you see usage then String is better than char array because its immutable. you don't have to do any memory management for String. Performance wise char array[] is faster for few operations (if you are performing on huge data).

blocks|key|3741310|text|除了字符(或宽字符)数组之外，CString还包含字符串大小、分配的缓冲区大小和引用计数器(另外用作锁定标志)。包含字符数组的缓冲区可能比它包含的字符串大得多--它允许减少耗时的分配调用的数量。此外，当CString设置为零大小时，它仍然包含两个wchar字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3741311|当然，当您将CString的大小与相应的C样式数组的大小进行比较时，数组会更小。但是，如果您希望尽可能广泛地操作CString允许的字符串，您最终将为字符串大小、缓冲区大小定义自己的变量，有时还会定义refcounter和/或防护标志。实际上，您需要存储字符串大小，以避免每次需要时都调用strlen。如果允许缓冲区大于字符串长度，则需要单独存储缓冲区大小，并避免每次在字符串中添加或减去时调用reallocs。以此类推--您可以牺牲一些小尺寸的增加来换取速度、安全性和功能性的显著提高。|3741312|所以，答案取决于你要对字符串做什么。假设您想要一个字符串来存储用于日志记录的类名--有一个C样式的字符串(const和static)就可以了。如果需要字符串来操作和广泛使用它与MFC或ATL相关的类，请使用CString系列类型。|3741313|P.S比较C%2B%2B和char[]的字符串|3741314|Source|offset|length|3741315|entityMap|0|LINK|mutability|MUTABLE|url|http://gotoanswer.stanford.edu/?q=CString%2520or%2520char%2520array%2520which%2520one%2520is%2520better%2520in%2520terms%2520of%2520memory^0|0|0|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$J|Y|K|Z|1|10]]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

CString in addition to array of chars (or wide chars) contains string size, allocated buffer size, and reference counter (serving additionally as a lock flag). The buffer containing the array of chars may be significantly larger than the string it contains -- it allows to reduce the number of time-costly allocation calls. In addition, when the CString is set to be zero-sized, it still contains two wchar characters.

Naturally, when you compare the size of CString with the size of corresponding C-style array, the array will be smaller. However, if you want to manipulate your string as extensively as CString allows, you will eventually define your own variables for string size, buffer size and sometimes refcounter and/or guard flags. Indeed, you need to store your string size to avoid calling strlen each time you need it. You need to store separately your buffer size if you allow your buffer to be larger than the string length, and avoid calling reallocs each time you add to or subtract from the string. And so on -- you trade some small size increase for significant increases in speed, safety and functionality. 

So, the answer depends on what you are going to do with the string. Suppose you want a string to store the name of your class for logging -- there a C-style string (const and static) will do fine. If you need a string to manipulate and use it extensively with MFC or ATL-related classes, use CString family types. If you need to manipulate string in the "engine" parts of your application that are isolated from its interface, and may be converted to other platforms, use std::string or write your own string type to suit your particular needs (this can be really useful when you write the "glue" code to place between the interface and the engine, otherwise std::string is preferable).

P.S Comparing String of C++ with char[]

<a href="http://gotoanswer.stanford.edu/?q=CString%20or%20char%20array%20which%20one%20is%20better%20in%20terms%20of%20memory" rel="nofollow">Source</a>

I am developing an Android application. The primary requirement of the application is that it should be efficient in terms of memory. So, which of these should I proceed with?

<pre><code>String batterylevel;
batterylevel = Float.toString(batteryPct);
</code></pre>

or 

<pre><code>char batterylevel[];
batterylevel = Float.toString(batteryPct).toCharArray();
</code></pre>

Which is efficient in terms of memory: char[] or String?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在开发一个Android应用程序。应用程序的主要要求是在内存方面应该是高效的。那么，我应该继续其中的哪一个呢？String batterylevel;batterylevel = Float.toString(batteryPct);或char batterylevel[];batterylevel = Float...

问就内存而言，哪个更有效: char[]还是String？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问就内存而言，哪个更有效: char[]还是String？EN