[试验证迹]1000000条数据 用集合和数组 对于实际内存的影响

最新推荐文章于 2019-08-25 14:56:16 发布
原创 最新推荐文章于 2019-08-25 14:56:16 发布 · 689 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#内存 #服务器

本文通过实验对比了使用数组和不同类型的集合（如MAP）装载一百万个引用对象时，在服务器启动时的内存实际用量。结果显示，数组比集合在内存使用上更为节省。

分别用集合和数组装一百万个引用对象 在服务器启动时加载 通过对比进程看内存的实际用量

结果如下 ↓↓↓


无

27746 root      20   0 9389m 130m  11m S  0.3  0.8   0:05.15 java   
28039 root      20   0 8089m 123m  11m S  2.0  0.8   0:03.64 java
28296 root      20   0 8024m 122m  11m S  0.0  0.8   0:03.76 java 


局部变量 用数组
29411 root      20   0 8024m 188m  11m S  0.7  1.2   0:04.25 java
29711 root      20   0 8024m 186m  11m S  2.0  1.2   0:04.42 java
30004 root      20   0 8024m 186m  11m S  0.0  1.2   0:04.50 java


局部变量 用MAP集合
30283 root      20   0 8089m 187m  11m S  0.7  1.2   0:04.78 java
30538 root      20   0 8024m 188m  11m S  0.0  1.2   0:04.43 java 
31069 root      20   0 8089m 186m  11m S  0.0  1.2   0:04.53 java 


全局变量 用数组
32635 root      20   0 8089m 193m  11m S  0.0  1.2   0:04.77 java
421 root      20   0 8089m 195m  11m S  0.7  1.2   0:04.57 java
712 root      20   0 8024m 191m  11m S  0.0  1.2   0:04.50 java
967 root      20   0 8024m 192m  11m S  0.0  1.2   0:04.77 java
1259 root      20   0 8089m 197m  11m S  0.0  1.2   0:04.87 java


全局变量 用MAP集合
31448 root      20   0 8089m 273m  11m S  0.7  1.7   0:21.89 java
31702 root      20   0 8024m 271m  11m S  0.3  1.7   0:21.83 java
32293 root      20   0 8024m 189m  11m S  0.7  1.2   0:04.78 java
1557 root      20   0 8024m 188m  11m S  2.0  1.2   0:04.67 java
1818 root      20   0 8089m 188m  11m S  0.0  1.2   0:04.81 java
2093 root      20   0 8089m 189m  11m S  0.3  1.2   0:04.85 java
2349 root      20   0 8089m 188m  11m S  0.3  1.2   0:04.68 java
2627 root      20   0 7959m 188m  11m S  0.3  1.2   0:04.61 java


全局变量 MAP集合+数组
2925 root      20   0 8024m 195m  11m S  0.3  1.2   0:04.47 java
3180 root      20   0 7959m 192m  11m S  1.0  1.2   0:04.75 java
3436 root      20   0 8024m 188m  11m S  0.0  1.2   0:04.66 java
孙墨潇
关注
从100亿条记录的文本文件中取出重复数最多的前10条
qq_26498709的博客
11-03 1万+
场景哈希分治法 这是一个 ip 地址 127.0.0.1 假设有100亿个这样的 ip 地址存在文件中 这个文件大小大约是 100GB 问题：要统计出100亿个 ip 中，重复出现次数最多的前10个分析100GB 几乎不可能一次加载进内存进行操作，所以必须要拆分 那么可以利用分治的思想，把规模大的问题化小，然后解决各个小的问题，最后得出结果。实现思路 ipv4 地址是一个 32 位的整数，
数据量很大时，JavaScript 数组操作的一些优化记录
xiaoxiaoxiaoyang218的博客
01-17 3536
这里写自定义目录标题数据量很大时，JavaScript 数组操作的一些优化记录创建已知数量的数组从数组中删除一部分数据数组扁平化 数据量很大时，JavaScript 数组操作的一些优化记录 持续更新。。。 创建已知数量的数组 使用赋值代替push操作 示例：创建100w长度值等于索引的数组 // Bad 23.94091796875ms var n = 1000000, arr = [] ...
List内存分配
Sinolife0605的博客
12-06 326
当采用默认构造函数List<int> value = new List<int>();实例化一个List<T>对象时，.Net Framework只是在内存中申请了一块内存来存放List<T>对象本身（不包含List当中的Items元素）。当为List<T>对象添加第一个Item元素时，List<T>对象会申请能存储...
JAVA 区分集合和数组
08-19
JAVA 区分集合和数组 Java 中的集合和数组是两个不同的概念，它们之间有着明显的区别。了解它们之间的区别对于编程实践非常重要。 数组 数组是 Java 语言内置的数据类型，它是一个线性的序列，所有元素可以快速...
Java集合和数组的区别
08-31
Java编程语言中，集合和数组是两种常见的数据结构，它们在存储和管理数据时有着显著的区别。理解这些差异对于编写高效、灵活的代码至关重要。 **数组（Array）**： 1. **固定大小**：数组在创建时必须指定长度，...
精选资源
数据结构--栈和数组--思维导图.pdf
08-29
"数据结构--栈和数组--思维导图.pdf" 数据结构是计算机科学中的一个重要概念，栈和数组是数据结构中两个非常重要的概念。本文将对栈和数组进行详细的解释，并提供相关的思维导图。 栈是一个只允许在一端进行插入和...
java8新特性 stream流的方式遍历集合和数组操作
08-18
Java 8 新特性 Stream 流的方式遍历集合和数组操作 Java 8 中引入了 Stream 流的概念，旨在提供一种更加优雅的方式来遍历集合和数组。Stream 流可以看作是一种 lazy 的数据结构，它可以对集合和数组进行遍历、过滤...
浅谈java中集合的由来,以及集合和数组的区别详解
09-01
在Java编程语言中，集合和数组是两种不同的数据结构，它们各自有其特定的用途和优缺点。本文将深入探讨Java集合的起源及其与数组之间的关键差异。 首先，让我们了解集合的由来。在Java早期版本中，程序员主要依赖...
还原真像:ArrayList性能几乎完美，100万数据测试
baidu_32472003的博客
07-18 8158
还原真像:ArrayList性能几乎完美，100万数据测试 程序汪汪 2018-07-17 22:17:21 背景 程序员面试题中经常遇到ArrayList与LinkedList区别，现实的测试情况肯定没多少人清楚。   理论是这样，现实测试情况很打脸啊。 学习目标 搞清楚JDK1.8种ArrayList与LinkedList的性能情况 代码例子 环境准备：java jdk1....
C中如何定义长度为1000000的整型数组
休矣1998的博客
12-11 1万+
int n[1000000];这样肯定是不行的，因为这样定义的数组用的是栈内存，系统默认值为最大1Mb，一个int型占4字节这样最大可以申请1024*1024/4=264144个，如果考虑到系统自身的占用最大值约为25000个。int *p=(int )malloc(1000000sizeof(int));，这样用的是堆内存，只要你内存有那么多的连续空间就可以；例子如下： #include&lt;...
100万条数据占用多少空间
热门推荐
jing_xin的专栏
02-26 4万+
比如你数据库某一张表有三个字段：一个long型，一个varchar（100） 型，一个date型。 long型占用8个字节（一个字节8位），data占用8字节。 那么一行占用：8+100+8=116Byte。 那么100万行，大约有110M。这是三列。如果你是10列，你就可以粗略估计出来了...
聊聊JVM（三）两种计算Java对象大小的方法
ITer_ZC的专栏
12-09 3万+
这篇说说如何计算Java对象大小的方法。之前在聊聊高并发（四）Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型。 普通对象的结构如下，按64位机器的长度计算 1. 对象头(_mark)， 8个字节 2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节 3. 数据区 4.Padding(内存对齐)，按照8的倍数
C++如何定义一个长度超过一百万的整型数组
小小白成长之路
08-25 7372
C++如何定义一个长度超过一百万的整型数组 今天在解决一道题的时候，在函数内部定义数组突然脑子抽风多打了几个零（一百万），一运行 ——嗯，爆了orz 于是，我翻开了书，但并没有发现哪里有说数组大小限制。 后来找到度娘帮忙 首先明确，数组申明在函数内部，即属于局部变量，是存放在栈上的 其次，栈的默认内存空间为 1 M左右 一百万长度的数组占用的内存大小：1000000=1000 *100...
C# 集合和数组相同和异同点 对于内存存储方式有何不同
最新发布
08-30
<think> 我们正在讨论C#中集合（例如List<T>）和数组（Array）的相同点、不同点以及内存存储方式的差异。 根据引用[1]和引用[3]以及之前的知识，我们可以总结如下： 相同点： 1. 两者都是用来存储多个相同类型元素的数据结构。 2. 都支持通过索引（从0开始）来访问元素。 不同点： 1. 数组是固定长度的，一旦创建，长度不能改变（除非重新创建）。而集合（如List<T>）是动态的，可以动态添加或删除元素，长度可变。 2. 数组可以是一维、多维或交错数组（数组的数组），而集合通常是一维的，但可以通过嵌套实现多维效果。 3. 数组是语言内置的类型，在System命名空间下，而集合是.NET框架提供的类，位于System.Collections.Generic等命名空间下。 4. 数组在声明时需要指定长度（或通过初始化器推断），而集合在创建时可以不指定容量（但有默认容量），并且可以随着元素的增加自动扩容。 5. 集合提供了更多的方法来操作元素，如Add, Remove, Insert等，而数组本身的方法较少（主要靠Array类的静态方法和LINQ扩展方法）。 内存存储方式： 1. 数组：在内存中是一段连续的内存块。数组变量是一个引用，指向数组对象的第一个元素。数组元素在堆上连续存储（无论值类型还是引用类型，对于引用类型，存储的是引用，实际对象在堆的其他位置）。 2. 集合（以List<T>为例）：内部使用一个数组来存储元素。因此，List<T>在内存中也是连续存储元素。但是，List<T>是一个包装类，它除了包含存储元素的数组外，还有其他的字段（如容量、元素计数等）。当添加元素超过当前容量时，List<T>会创建一个新的更大的数组（通常是原容量的2倍），并将原数组的元素复制过去，原数组将被丢弃（等待垃圾回收）。 另外，根据引用[2]：对于引用类型，==操作符默认比较的是引用（内存地址）是否相同。这一点对于数组和集合都是适用的，因为它们都是引用类型。 验证内存存储方式： 对于数组：int[] arr = new int[10]; // 在堆上分配连续40字节（假设int为4字节）的内存块。 对于List<int>：List<int> list = new List<int>(); // 初始化时内部数组可能为0或一个小数组（如4个元素）。当添加元素时，内部数组会动态扩容。 总结： 数组是静态的连续内存块，而集合则是动态的（内部使用数组，但自动管理容量）。 下面用表格形式总结： | 特性 | 数组 (Array) | 集合 (例如 List<T>) | |--------------|--------------------------------------------|---------------------------------------------| | 长度 | 固定长度 | 动态长度 | | 内存分配 | 连续内存块 | 内部使用数组，也是连续内存块 | | 扩容 | 无法直接扩容，需创建新数组并复制 | 自动扩容（通常加倍） | | 多维支持 | 直接支持多维数组 | 仅一维，但可通过List<List<T>>模拟多维 | | 方法 | 方法较少（主要靠静态方法和LINQ） | 提供丰富方法（Add, Remove, Find等） | | 类型安全性 | 支持泛型（如int[]） | 支持泛型（List<T>） | | 存储方式 | 值类型元素直接存储，引用类型存储引用 | 同数组（因为内部使用数组） | | 性能 | 访问元素速度快（连续内存，直接索引） | 同数组（因为内部是数组），但扩容时有开销 | 注意：集合有很多种（如LinkedList<T>，HashSet<T>等），这里我们主要比较的是数组和List<T>，因为List<T>是最常用且内部基于数组的集合。 相关问题： 1. 在C#中，数组和List<T>分别在什么场景下使用更合适？ 2. List<T>在动态扩容时有哪些性能开销？如何优化？ 3. 多维数组（如int[,]）和交错数组（int[][]）在内存布局上有何不同？ 4. 如何避免List<T>频繁扩容带来的性能损失？ 5. 对于值类型和引用类型，数组和List<T>在内存分配上有何差异？ </think> ### C# 数组与集合的对比分析 #### **一、相同点** 1. **存储目的** 均用于存储**相同数据类型**的多个元素（值类型或引用类型）[^1]。 2. **索引访问** 均支持通过 `索引` 访问元素（如 `arr[0]` 或 `list[0]`）。 3. **内存位置** 对象本身（数组对象/集合对象）均存储在**托管堆**中（引用类型特性）。 --- #### **二、不同点** | **特性** | **数组** | **集合（如 `List<T>`）** | |------------------|--------------------------------------------|---------------------------------------------| | **长度** | 固定长度（创建后不可变） | 动态长度（支持 `Add()`/`Remove()` 等操作） | | **内存连续性** | 元素连续存储（物理连续内存块） | 内部数组连续存储，但集合对象包含额外元数据 | | **扩容机制** | 需手动创建新数组并复制数据 | 自动扩容（触发时创建新数组并复制）[^1] | | **多维支持** | 原生支持多维数组（`int[,]`） | 需嵌套集合（如 `List<List<int>>`）模拟多维 | | **方法功能** | 基础操作（`Length`, `Clone()`） | 丰富方法（`Add()`, `Contains()`, `Remove()`） | | **比较行为** | `==` 比较引用地址[^2] | 可重载 `Equals()` 实现值比较 | | **初始化语法** | `int[] arr = {1, 2, 3};` | `List<int> list = new() {1, 2, 3};` | --- #### **三、内存存储方式差异** 1. **数组的内存布局** ```csharp int[] arr = new int[3]; // 堆中分配连续12字节（假设int=4字节） ``` - 内存结构：`[int0][int1][int2]`（严格连续） - 元数据：仅存储数组长度和类型信息 2. **集合的内存布局**（以 `List<T>` 为例） ```csharp List<int> list = new List<int>(3); // 包含额外控制字段 ``` - 内存结构： ```mermaid graph LR A[List对象] --> B[_items数组引用] A --> C[_size计数] A --> D[_version版本号] B --> E[[int0][int1][int2]] // 实际数据存储 ``` - 关键特征： - 实际数据存储在内部数组 `_items` 中（连续内存块） - 集合对象包含额外字段（`_size`, `_version` 等），增加约 16-24 字节开销 - 扩容时创建新数组并复制数据（原数组等待 GC 回收） --- #### **四、性能与使用场景** | **场景** | **推荐选择** | **原因** | |------------------------|-------------|---------------------------------------------| | 固定长度数据 | 数组 | 无额外开销，访问速度最快 $O(1)$ | | 频繁增删元素 | 集合 | 自动扩容简化操作 | | 内存敏感场景 | 数组 | 无集合的元数据开销 | | 需要复杂数据操作 | 集合 | 内置方法（排序/查找）减少代码量 | | 大对象（>85KB） | 谨慎选择 | 两者均进入大对象堆（LOH），易引发碎片[^3] | > 💡 **关键结论**：数组是轻量级连续存储结构，集合是封装了动态数组的高级抽象。优先选择集合提升开发效率，在性能关键路径（如高频循环）考虑数组优化。 --- ### 相关问题 1. 如何检测 `List<T>` 自动扩容造成的性能开销？ 2. 多维数组（`int[,]`）和交错数组（`int[][]`）在内存布局上有何区别？ 3. 使用 `ArrayPool<T>` 能否避免集合扩容时的内存分配开销？ 4. 值类型元素（如 `struct`）在数组和集合中的内存分配差异是什么？ 5. 如何通过 `Span<T>` 减少数组/集合操作的内存复制？
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值