标签: random-access

我正在消耗一串半随机令牌.对于每个令牌,我正在维护大量数据(包括一些子集合).

唯一令牌的数量是无限的,但实际上往往大约为100,000-300,000.

我从一个列表开始,并使用Linq查询确定要更新的相应令牌对象.

public class Model {
    public List<State> States { get; set; }
    ...
}

var match = model.States.Where(x => x.Condition == stateText).SingleOrDefault();

在第一个~30k的独特令牌中,我能够找到并更新〜1,100个令牌/秒.

性能分析表明,85%的总Cpu周期都花在了Where(...).SingleOrDefault()(这是有道理的,列表是低效的搜索方式).

所以,我将列表切换到HashSet并再次进行分析,确信HashSet能够随机搜索更快.这一次,我只处理~900令牌/秒.Linq(89%)的时间几乎相同.

所以...首先,我是否滥用了HashSet？(使用Linq是强制转换为IEnumerable然后是枚举/类似的东西？)

如果没有,那么实施自己的最佳模式是什么？我的印象是HashSet已经进行了二元搜索,所以我假设我需要构建某种树结构并且有更小的子集？

回答一些问题形式的评论...条件是唯一的(如果我得到相同的标记两次,我想更新相同的条目),HashSet是股票.Net实现(System.Collections.Generic.HashSet<T>).

更广泛的代码视图是......

        var state = new RollingList(model.StateDepth); // Tracks last n items and drops older ones. (Basically an array and an index that wraps around
        var tokens = tokeniser.Tokenise(contents); // Iterator
        foreach (var token in tokens) {
            var stateText = StateToString(ref state);
            var match = …

我正在编写一些数据访问测试实现,我需要随机访问文件内容.这是代码:

RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rwd");
final byte b[] = IOUtils.toByteArray(source);
randomAccessFile.write(b, (int) offset, size);

其中offset的类型为long.为什么RandomAccessFile没有提供方法:

public void write(byte b[], long off, int len)

？

如何覆盖此问题？

我试图获取文件的最后一行,但我的输出显示它从未找到它.我也尝试寻找所有行开头的"[",但除非跳转完美,否则程序不会跳过"[".我试图寻找 "\ r \n",System.getProperty( "line.separator"),\ r和\n.最可能是它的一个愚蠢的错误,但如果我拥有它而我找不到它,那么其他人也可能遇到它.

        RandomAccessFile raf = new RandomAccessFile(fileLocation, "r");
        //Finds the end of the file, and takes a little more
        long lastSegment = raf.length() - 5;
        //**Looks for the new line character \n?**
        //if it cant find it then take 5 more and look again.
        while(stringBuffer.lastIndexOf("\n") == -1)  {
            lastSegment = lastSegment-5;
            raf.seek(lastSegment);
            //Not sure this is the best way to do it
            String seen = raf.readLine();
            stringBuffer.append(seen);
        }
        //Trying to debug it and understand
        int location …

我想MAX_OPERATIONS从一个账户到另一个账户进行一定数量的资金转账.帐户作为refs存储在散列图调用程序中my-map(int account-id,double balance).

汇款需要从散列图"随机指数",并将它作为account-from对transfer.account-destination并且amount都应该修复.

不幸的是我不能让它发挥作用.

(defn transfer [from-account to-account amount]
  (dosync
    (if (> amount @from-account)
      (throw (Exception.  "Not enough money")))
    (alter from-account - amount)
    (alter to-account + amount)))

(defn transfer-all []
  (dotimes [MAX_OPERATIONS]
    (transfer (get mymap (rand-int[MAX_ACCOUNT]) :account-id) account-destination amount)))

据我了解，数组的元素连续存储在内存中，访问特定数组是通过将所需索引和每个元素的大小的乘积与基数组地址相加来找到该元素的地址来完成的。

由于在像 C# 这样的语言中，我可以创建一个 s 数组object[]并在其中放入我想要的任何数据类型，如果我使用不同大小的类型同时仍然允许随机，那么数组的每个元素如何以统一的长度存储（并保持）使用权？

我有一种对 a 进行操作的方法List，删除某些重复项。该算法仅对实现RandomAccess 的列表有效。为了防止误用和令人失望的性能，我想知道如何强制执行该RandomAccess限制。不幸的是，该RandomAccess接口无法扩展List，所以我需要让变量同时成为两种类型。

我可以声明该方法为 AcceptArrayList而不是List，但其他列表类型RandomAccess也可以实现（例如，Collections.synchronizedListand返回的列表Collections.checkedList），并且我不想阻止这些。

我尝试了泛型，但无法构建有效的语法：

public <T> void process(<List<T> extends RandomAccess> list) {
    ...
}

我可以做：

if (!(list instanceof RandomAccess))
    throw new UnsupportedOperationException("RandomAccess list required");

但这种限制仅在运行时强制执行，其稳健性较差。

帮助？

我有点学习数据结构,所以请原谅新手问题.问题是,我在C#中使用Stack类,我想随机访问元素.我知道我可以使用ElementAt随机访问:

Stack<int> mystack = new Stack<int>(4);
...//assume the stack is filled here
int value = mystack.ElementAt(2) // if I wanted element 2

但我只能得到价值,我无法修改它.我的意思是,在List中,我可以将随机元素修改为:

List<int> mylist = new List<int>(4);
mylist[2] = 35;

我想对Stack做同样的事情,但它没有索引器.也许这是不可能的,如果是这样,我也想知道原因.我知道当需要随机访问时,通常不会使用堆栈,但在解决问题时我仍然需要它.我最终找到了一个更好的方法,但我仍然想知道.最后,关于ElementAt(),它是O(1)还是O(N)??

根据zlib.net上的这个FAQ,可以:

在压缩流中随机访问数据

我知道Biopyton 1.60的Bio.bgzf模块,其中:

支持读写BGZF文件(Blocked GNU Zip Format),这是GZIP的一种变体,具有高效的随机访问,最常用作BAM文件格式的一部分和tabix.它在内部使用Python的zlib库,并提供一个简单的接口,如Python的gzip库.

但对于我的用例,我不想使用那种格式.基本上我想要一些东西,它模仿下面的代码:

import gzip
large_integer_new_line_start = 10**9
with gzip.open('large_file.gz','rt') as f:
    f.seek(large_integer_new_line_start)

但是本机zlib.net提供的效率可以提供对压缩流的随机访问.如何利用Python中的随机访问功能？

有没有一种方法可以使用StAX和JAX-B创建索引，然后快速访问XML文件？

我有一个很大的XML文件，需要在其中查找信息。这是在桌面应用程序中使用的，因此它应在具有少量RAM的系统上工作。

所以我的想法是这样的：创建索引，然后快速从大文件访问数据。

我不能只分割文件，因为它是我想不更改地使用的官方联邦数据库。

使用XMLStreamReader，我可以快速找到一些元素，然后使用JAXB解组该元素。

    final XMLStreamReader r = xf.createXMLStreamReader(filename, new FileInputStream(filename));
    final JAXBContext ucontext = JAXBContext.newInstance(Foo.class);
    final Unmarshaller unmarshaller = ucontext.createUnmarshaller();
    r.nextTag();

    while (r.hasNext()) {

        final int eventType = r.next();
        if (eventType == XMLStreamConstants.START_ELEMENT && r.getLocalName().equals("foo")
                && Long.parseLong(r.getAttributeValue(null, "bla")) == bla
                ) {
            // JAX-B works just fine:
            final JAXBElement<Foo> foo = unmarshaller.unmarshal(r,Foo.class);
            System.out.println(foo.getValue().getName());
            // But how do I get the offset?
            // cache.put(r.getAttributeValue(null, "id"), r.getCursor()); // ???
            break;
        }
    }

但是我无法得到补偿。我想用它来准备一个索引：
(id of element) -> (offset in file) …

我的 7z 存档中有一个 100 GB 的文本文件。我可以通过按 1 MB 块读取它来找到其中的模式'hello'（7z 将数据输出到 stdout）：

Popen("7z e -so archive.7z big100gb_file.txt", stdout=PIPE)
while True:
    block = proc.stdout.read(1024*1024)    # 1 MB block
    i += 1
    ...
    if b'hello' in block:      # omitting other details for search pattern split in consecutive blocks...
        print('pattern found in block %i' % i)
    ...

现在我们经过 5 分钟的搜索发现该模式'hello'位于第 23456 个块中，那么将来如何在 7z 文件中快速访问该块或行呢？

（如果可能，不要将此数据保存在另一个文件/索引中）

那么7z，如何在文件中间查找呢？

注意：我已经阅读了Indexing / random access to 7zip .7z archives和random search …