blocks|key|806208|text|通过MappedByteBuffer将其写出来。创建一个足够大的文件，映射它，获取一个asIntBuffer()，输入您的数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|806209|然后，您可以稍后映射它，并通过IntBuffer.get(明显的索引上的数学)访问它。|806210|这大大加快了序列化的速度。|806211|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|$]]

Write it out via MappedByteBuffer. Create a big enough file, map it, get an asIntBuffer(), put in your numbers.

Then you can map it later and access it via IntBuffer.get(obvious-math-on-indices).

This is much faster the serialization.

blocks|key|58765|text|如果数组的计算开销太大，您可能要做的就是序列化它。这基本上是将数据的二进制副本放到您可以非常快速加载的存储介质(例如硬盘)上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|58766|序列化非常简单。下面是专门解决序列化数组问题的a+tutorial。|offset|length|58767|由于这些值可能只会在评估扑克牌牌的算法发生变化时才会发生变化，因此只提供序列化的文件应该没什么问题。如果存储在每个数组元素中的数据不是太大(例如，如果是16位整数，则文件大小约为1MB+)，则文件大小应该是合理的。|58768|entityMap|0|LINK|mutability|MUTABLE|url|http://www.java-tips.org/blog/java-se/serializing-arrays.html^0|0|N|A|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

What you probably want to do, if the computation of the array is too expensive, is serialize it. That basically places a binary copy of the data onto a storage medium (e.g. your hard disk) that you can very quickly load.

Serialization is pretty straightforward. Here's <a href="http://www.java-tips.org/blog/java-se/serializing-arrays.html" rel="nofollow noreferrer">a tutorial</a> that specifically addresses serializing arrays.

Since these values will presumably only change if your algorithm for evaluating a poker hand changes, it should be fine to just ship the serialized file. The file size should be reasonable if the data you are storing in each array element is not too large (if it's a 16-bit integer for example, the file will be around 1MB in size).

blocks|key|806294|text|以下是一些事情：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|806295|如果这是扑克牌手牌，你不能只存储2-14。您还需要存储西装以及。这实际上意味着你需要存储0-51。否则你无法知道array[2][3][4][5][6]是同花顺还是同花顺。|offset|length|style|CODE|806296|如果你实际上不需要为你的应用程序存储套装，并且你真的想在一个数组中存储它，那么使用0-12的索引，而不是2-14。这将允许您使用13×13×13×13×13+(371,293成员)阵列，而不是15×15×15×15×15+(759,375成员)阵列。每当访问数组时，只需从每个索引中减去2即可。(我不确定你的525,720个数字是从哪里来的……)|806297|entityMap^0|0|1K|K|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

A few things:

If this is for poker hands, you can't just store 2-14. You also need to store the suit as well. This really means you need to store 0-51. Otherwise you have no way of knowing if <code>array[2][3][4][5][6]</code> is a straight or a straight flush.

If you don't actually need to store the suits for your application, and you really want to do it in an array, use indexes of 0-12, not 2-14. This would allow you to use a 13×13×13×13×13 (371,293 member) array, instead of a 15×15×15×15×15 (759,375 member) array. Whenever you access the array, you'd just need to subtract 2 from each index. (I'm not sure where you got your 525,720 count...)

blocks|key|58139|text|我将首先折叠您的维度以进行索引：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|58140|假设您有一组索引(在第一个示例中，允许值为2到14)：|58141|+i1+=+2
+i2+=+3
+i3+=+5
+i4+=+6
+i5+=+7|code-block|syntax|javascript|58142|创建了你的数组|58143|+short+array[]+=+new+short[13+*+13+*+13+*+13+*+13];
+...|58144|那么访问每个元素就变成了|58145|+array[(i1+-+2)+*+13+*+13+*+13+*+13+%2B+(i2+-+2)+*+13+*+13+*+13+%2B+(i3+-+2)
+++++*+13+*+13+%2B+(i4+-+2)+*+13+%2B+(i5+-+2)]|58146|这个数组占用的内存要少得多，因为您不需要在每个维度上创建额外的对象层，而且您可以轻松地将整个内容存储在一个文件中，并将其加载到一个列表中。|58147|遍历此数组也会更快，因为您将执行1/5的数组查找。|58148|此外，收紧每个维度中的元素数量将节省大量内存。|58149|为了保持代码的整洁，这个数组应该隐藏在一个带有get和set方法的对象中，该方法接受5个索引。|58150|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$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|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I would start by collapsing your dimensions for indexing:

assuming you have a set of indexes (from your first example, allowed values are 2 to 14):

<pre><code> i1 = 2
 i2 = 3
 i3 = 5
 i4 = 6
 i5 = 7
</code></pre>

and created your array with

<pre><code> short array[] = new short[13 * 13 * 13 * 13 * 13];
 ...
</code></pre>

then accessing each element becomes

<pre><code> array[(i1 - 2) * 13 * 13 * 13 * 13 + (i2 - 2) * 13 * 13 * 13 + (i3 - 2)
 * 13 * 13 + (i4 - 2) * 13 + (i5 - 2)]
</code></pre>

This array will take much less memory since you don't need to create an additional layer of objects along each dimension, and you can easily store the entire contents in a file and load it in one list.

It will also be faster to traverse this array because you will be doing 1/5 the array lookups.

Also the tightening up of the number of elements in each dimension will save significant memory.

To keep your code clean this array should be hidden inside an object with a get and set method which takes the five indexes.

blocks|key|1078434|text|首先，感谢您的热情！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1078435|因此，直截了当的方法似乎只是序列化它。我想我会先试一试，测试一下性能，看看是否足够。(我想是的)。|1078436|关于MappedByteBuffer..。是否正确理解，这使得加载序列化数组的一小部分成为可能？所以我在运行时加载所需的值，而不是在启动时加载整个数组？|1078437|@Jennie西装存储在不同的数组中。我不确定这是不是最好的方法，因为关于这个特定的问题有很多东西需要考虑。同花顺基本上是一张高牌牌，具有不同的值...因此，我没有真正的理由将相同的排列(高牌)存储两次，但这是目前的方法。我认为方法是哈希函数，所以我可以很容易地将高卡值转换为同花值，但我没有考虑这么多。|1078438|关于索引，你当然是对的。这只是暂时的。对我来说，测试"2+3+4+5+6“的值更容易，现在只需输入卡片值……稍后，我将对数组进行裁剪！|1078439|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

First of all, thanks for your enthusiasm!

So the straight forward approach seems to just serialize it. I think I'll try this at first, to test the performance, and see if its sufficient. (Which I guess it is). 

About the MappedByteBuffer... Is it correctly understood, that this makes it possible to load a fraction of the serialized array? So I load the values I need at run-time, instead of loading the whole array at startup?

@Jennie
The suits are stored in a different array. I'm not sure this is the best way to go, since there's lots of stuff to consider about this particular problem. A flush is basically a high-card hand, with a different value... So There's no real reason for me to store the same permutations (high cards) twice, but this is the way to do it for now. I think the way to go is a hash-function, so I can convert high-card values to flush-values easily, but I have not given this many thoughts.

About the indicies, you're of course right. This is just for now. It's easier for me to test the value for "2 3 4 5 6", by just putting in the card-values for now... Later, I'll cut of the array!

blocks|key|805543|text|不能直接回答你最初的问题，但是...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|805544|如果您正在尝试进行快速扑克手评估，则需要确保通过The+Great+Poker+Hand+Evaluator+Roundup进行阅读。|offset|length|805545|特别是：Cactus+Kev's+Poker+Hand+Evaluator。|805546|我参与了关于运行最快的5手和7手扑克评估的长期讨论，其中大部分内容都来自于此。坦率地说，除非你能在一个查询表中保存所有的C(52,5)或2,598,960个HAND值，否则我不认为这些计算会更快。|805547|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codingthewheel.com/archives/poker-hand-evaluator-roundup|1|http://www.suffecool.net/poker/evaluator.html^0|0|O|12|0|0|4|X|1|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

Not a direct answer to your original question, but...

If you are trying to do fast poker-hand evaluations, you want to make sure you read through <a href="http://www.codingthewheel.com/archives/poker-hand-evaluator-roundup" rel="nofollow noreferrer">The Great Poker Hand Evaluator Roundup</a>. 

Particularly: <a href="http://www.suffecool.net/poker/evaluator.html" rel="nofollow noreferrer">Cactus Kev's Poker Hand Evaluator</a>.

I was involved in long-running discussion about running the fastest possible 5- and 7-hand poker evaluations where most of this stuff comes from. Frankly, I don't see how these evaluations are going to any faster until you can hold all C(52,5) or 2,598,960 hand values in a look-up table.

I have a 5 dimensional array, where all indicies range from 2-14. It contains all the possible permutations of a 5 number sequence.
This array holds 525720 permutations, which takes quite a while to compute. (5-7 seconds on my Macbook pro). It should be used as a lookup table, to access a value in constant time, or more specific, the value of a certain poker-hand:

<pre><code>array[2][3][4][5][7] // 1
array[5][5][5][5][14] // 2000
</code></pre>

Is there a faster way to create this array? I was thinking about persisting the array in some way, and then load it each time my program starts - but is there any efficient ways to do this?

I'm not very familiar with persistence. I dont really know if it's worth it for me, to load it from disk, instead of create it each time. I know about Hibernate, but this seems like a bit of a overkill, just to persist a single array?

Persisting large array for faster access

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个5维数组，其中所有的索引都在2-14之间。它包含一个5位数序列的所有可能的排列。这个数组包含525720个排列，这需要相当长的时间来计算。(在我的Macbook pro上5-7秒)。它应该用作查找表，以访问固定时间内的值，或者更具体地说，访问某个扑克手的值：array[2][3][4][5][7] // 1ar...

问持久化大型数组以加快访问速度
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问持久化大型数组以加快访问速度EN