Java:具有数百万项的 HashMap 性能与 if-else 搜索数值范围-6ren

Java:具有数百万项的 HashMap 性能与 if-else 搜索数值范围

转载作者：行者123 更新时间：2023-11-29 06:52:38

如果可以的话，我正在寻找一些建议。我的 PlayStation 模拟器中有一个方法(基于 Java 的大学论文已经完成)。它采用一个整数内存地址，然后返回该地址处的字节 - 根据地址将读取重定向到 RAM、BIOS ROM、给定的 I/O 端口等。目前，这是使用大量 if-else 案例实现的，这些案例检查地址范围并相应地从正确的位置读取，返回字节。

这对我的整体运行时间造成了大约 9% 的性能影响。我想我可以使用调度表来改进这一点——本质上是一个 HashMap，它带有代表内存地址的自动装箱的 Integer 键和一个 lambda 值来根据地址处理字节的返回。现在请记住，考虑到 PS1 的内存映射，大约有 260 万个不同的可能地址，这会使用更多的内存 - 没关系。

令我困惑的是，这比 if-else 语句包的性能稍差——大约占总运行时间的 12%。有没有更好的方法来做我正在做的事情？我不能使用数组解决方案(地址作为原始 int 索引和存储在该索引处的 lambda)，因为地址空间中存在间隙，如果没有一个数量级的过多内存使用，这将无法处理。

我很欣赏任何其他可能使这个数字下降一点的想法 - 我意识到 Java 不是一种很好的仿真语言，但我论文的一部分是证明它可以工作(确实如此)。非常感谢。

问候，菲尔

编辑:

下面是 readByte 方法的完整代码(地址被转换为 long 以允许将较低地址与较高地址进行比较，对于普通 int 而言，该值被认为是负值):

/**
 * This reads from the correct area depending on the address.
 * @param address
 * @return 
 */
public byte readByte(int address) {

    long tempAddress = address & 0xFFFFFFFFL;
    byte retVal = 0;      

    if (tempAddress >= 0L && tempAddress < 0x200000L) { // RAM
        retVal = ram[(int)tempAddress];
    } else if (tempAddress >= 0x1F000000L && tempAddress < 0x1F800000L) { // Expansion Region 1
        // do nothing for now
        ;
    } else if (tempAddress >= 0x1F800000L && tempAddress < 0x1F800400L) { // Scratchpad
        // read from data cache scratchpad if enabled
        if (scratchpadEnabled()) {
            tempAddress -= 0x1F800000L;
            retVal = scratchpad[(int)tempAddress];
        }
    } else if (tempAddress >= 0x1F801000L && tempAddress < 0x1F802000L) { // I/O Ports
        if (tempAddress >= 0x1F801000L && tempAddress < 0x1F801004L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(expansion1BaseAddress >>> 24);
                    break;
                case 1:
                    retVal = (byte)(expansion1BaseAddress >>> 16);
                    break;
                case 2:
                    retVal = (byte)(expansion1BaseAddress >>> 8);
                    break;
                case 3:
                    retVal = (byte)expansion1BaseAddress;
                    break;
            }
        }
        else if (tempAddress >= 0x1F801004L && tempAddress < 0x1F801008L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(expansion2BaseAddress >>> 24);
                    break;
                case 1:
                    retVal = (byte)(expansion2BaseAddress >>> 16);
                    break;
                case 2:
                    retVal = (byte)(expansion2BaseAddress >>> 8);
                    break;
                case 3:
                    retVal = (byte)expansion2BaseAddress;
                    break;
            }
        } else if (tempAddress >= 0x1F801008L && tempAddress < 0x1F80100CL) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(expansion1DelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(expansion1DelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(expansion1DelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)expansion1DelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F80100CL && tempAddress < 0x1F801010L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(expansion3DelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(expansion3DelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(expansion3DelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)expansion3DelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F801010L && tempAddress < 0x1F801014L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(biosRomDelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(biosRomDelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(biosRomDelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)biosRomDelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F801014L && tempAddress < 0x1F801018L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(spuDelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(spuDelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(spuDelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)spuDelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F801018L && tempAddress < 0x1F80101CL) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(cdromDelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(cdromDelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(cdromDelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)cdromDelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F80101CL && tempAddress < 0x1F801020L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(expansion2DelaySize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(expansion2DelaySize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(expansion2DelaySize >>> 8);
                    break;
                case 3:
                    retVal = (byte)expansion2DelaySize;
                    break;
            }
        } else if (tempAddress >= 0x1F801020L && tempAddress < 0x1F801024L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(commonDelay >>> 24);
                    break;
                case 1:
                    retVal = (byte)(commonDelay >>> 16);
                    break;
                case 2:
                    retVal = (byte)(commonDelay >>> 8);
                    break;
                case 3:
                    retVal = (byte)commonDelay;
                    break;
            }
        } else if (tempAddress >= 0x1F801040L && tempAddress < 0x1F801050L) {
            // read from ControllerIO object
            retVal = cio.readByte((int)tempAddress);
        } else if (tempAddress >= 0x1F801060L && tempAddress < 0x1F801064L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(ramSize >>> 24);
                    break;
                case 1:
                    retVal = (byte)(ramSize >>> 16);
                    break;
                case 2:
                    retVal = (byte)(ramSize >>> 8);
                    break;
                case 3:
                    retVal = (byte)ramSize;
                    break;
            }
        }
        else if (tempAddress >= 0x1F801070L && tempAddress < 0x1F801074L) { // Interrupt Status Register
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(interruptStatusReg >>> 24);
                    break;
                case 1:
                    retVal = (byte)(interruptStatusReg >>> 16);
                    break;
                case 2:
                    retVal = (byte)(interruptStatusReg >>> 8);
                    break;
                case 3:
                    retVal = (byte)interruptStatusReg;
                    break;    
            }
        }
        else if (tempAddress >= 0x1F801074L && tempAddress < 0x1F801078L) { // Interrupt Mask Register
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(interruptMaskReg >>> 24);
                    break;
                case 1:
                    retVal = (byte)(interruptMaskReg >>> 16);
                    break;
                case 2:
                    retVal = (byte)(interruptMaskReg >>> 8);
                    break;
                case 3:
                    retVal = (byte)interruptMaskReg;
                    break;    
            }
        }
        else if (tempAddress >= 0x1F801080L && tempAddress < 0x1F801100L) {
            retVal = dma.readByte(address);
        }
        else if (tempAddress >= 0x1F801100L && tempAddress < 0x1F801104L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer0.counterValueRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer0.counterValueRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer0.counterValueRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer0.counterValueRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801104L && tempAddress < 0x1F801108L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer0.counterModeRead(false) >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer0.counterModeRead(false) >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer0.counterModeRead(false) >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer0.counterModeRead(false);
                    break;
            }
        }
        else if (tempAddress >= 0x1F801108L && tempAddress < 0x1F80110CL) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer0.counterTargetRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer0.counterTargetRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer0.counterTargetRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer0.counterTargetRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801110L && tempAddress < 0x1F801114L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer1.counterValueRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer1.counterValueRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer1.counterValueRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer1.counterValueRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801114L && tempAddress < 0x1F801118L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer1.counterModeRead(false) >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer1.counterModeRead(false) >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer1.counterModeRead(false) >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer1.counterModeRead(false);
                    break;
            }
        }
        else if (tempAddress >= 0x1F801118L && tempAddress < 0x1F80111CL) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer1.counterTargetRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer1.counterTargetRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer1.counterTargetRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer1.counterTargetRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801120L && tempAddress < 0x1F801124L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer2.counterValueRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer2.counterValueRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer2.counterValueRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer2.counterValueRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801124L && tempAddress < 0x1F801128L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer2.counterModeRead(false) >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer2.counterModeRead(false) >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer2.counterModeRead(false) >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer2.counterModeRead(false);
                    break;
            }
        }
        else if (tempAddress >= 0x1F801128L && tempAddress < 0x1F80112CL) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(timer2.counterTargetRead() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(timer2.counterTargetRead() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(timer2.counterTargetRead() >>> 8);
                    break;
                case 3:
                    retVal = (byte)timer2.counterTargetRead();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801810L && tempAddress < 0x1F801814L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(gpu.readResponse() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(gpu.readResponse() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(gpu.readResponse() >>> 8);
                    break;
                case 3:
                    retVal = (byte)gpu.readResponse();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801814L && tempAddress < 0x1F801818L) {
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(gpu.readStatus() >>> 24);
                    break;
                case 1:
                    retVal = (byte)(gpu.readStatus() >>> 16);
                    break;
                case 2:
                    retVal = (byte)(gpu.readStatus() >>> 8);
                    break;
                case 3:
                    retVal = (byte)gpu.readStatus();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801800L && tempAddress < 0x1F801804L) { // CDROM
            switch ((int)tempAddress & 0xF) {
                case 0:
                    retVal = cdrom.read1800();
                    break;
                case 1:
                    retVal = cdrom.read1801();
                    break;
                case 2:
                    retVal = cdrom.read1802();
                    break;
                case 3:
                    retVal = cdrom.read1803();
                    break;
            }
        }
        else if (tempAddress >= 0x1F801C00L && tempAddress < 0x1F802000L) {
            // fake SPU read
            retVal = spu.readByte(address);
        }
    } else if (tempAddress >= 0x1F802000L && tempAddress < 0x1F803000L) { // Expansion Region 2 (I/O Ports)
        // read from BIOS post register
        if (tempAddress == 0x1F802041L) {
            retVal = biosPost;
        }
    } else if (tempAddress >= 0x1FA00000L && tempAddress < 0x1FC00000L) { // Expansion Region 3 (Multipurpose)
        // do nothing for now
        ;
    } else if (tempAddress >= 0x1FC00000L && tempAddress < 0x1FC80000L) { // BIOS ROM
        // read from memory mapped BIOS file
        tempAddress -= 0x1FC00000L;
        retVal = biosBuffer.get((int)tempAddress);
    } else if (tempAddress >= 0xFFFE0000L && tempAddress < 0xFFFE0200L) { // I/O Ports (Cache Control)
        if (tempAddress >= 0xFFFE0130L && tempAddress < 0xFFFE0134L) { // Cache Control Register
            int shift = (int)(tempAddress & 0x3L);
            switch (shift) {
                case 0:
                    retVal = (byte)(cacheControlReg >>> 24);
                    break;
                case 1:
                    retVal = (byte)(cacheControlReg >>> 16);
                    break;
                case 2:
                    retVal = (byte)(cacheControlReg >>> 8);
                    break;
                case 3:
                    retVal = (byte)cacheControlReg;
                    break;    
            }
        }            
    }

    return retVal;
}

最佳答案

最佳方法取决于您在幕后的实现。我看到 PSX 的地址空间是 32 位的，但与许多控制台一样，区域是镜像的。现在没有看到您的实际实现，这只是猜测，但这里有一些注意事项。

我会开始考虑这张 table

 KUSEG     KSEG0     KSEG1
  00000000h 80000000h A0000000h  2048K  Main RAM (first 64K reserved for BIOS)
  1F000000h 9F000000h BF000000h  8192K  Expansion Region 1 (ROM/RAM)
  1F800000h 9F800000h    --      1K     Scratchpad (D-Cache used as Fast RAM)
  1F801000h 9F801000h BF801000h  8K     I/O Ports
  1F802000h 9F802000h BF802000h  8K     Expansion Region 2 (I/O Ports)
  1FA00000h 9FA00000h BFA00000h  2048K  Expansion Region 3 (whatever purpose)
  1FC00000h 9FC00000h BFC00000h  512K   BIOS ROM (Kernel) (4096K max)
        FFFE0000h (KSEG2)        0.5K   I/O Ports (Cache Control)

因此，对于 I/O 端口，您无能为力，因为它们是分开的，必须专门处理，我们可以尝试研究如何改进其他一切的寻址。

我们可以看到镜像区域与 4 个最相关的位不同。这意味着我们可以执行 address &= 0x0FFFFFFF 以便我们忽略该区域并仅考虑地址的有效部分。

所以现在我们有 3 种地址:

从0x0000000开始，映射到主RAM
从 0xF000000 开始到 0xFC00000 结束的组(+ bios rom)
0xFFFF0000 的 I/O 端口

这可能会导致您同时使用 if/else 和缓存的混合方法，例如:

byte readMemory(int address) 
{
  if ((address & 0xFF000000) == 0xFF000000)
    return ioPorts.read(address);

  // remove most significative nibble, we don't need it
  address &= 0x0FFFFFFF;

  // 0xF000000 zone
  // according to bios rom size you could need a different kind of comparison since it may wrap over 0xFFFFFFF
  if ((address & 0xF000000) == 0xF000000)
  {
    // now your address space is just from 0xF000000 to 0xFC00000 + size of BIOS ROM (4mb max?)
  }
  else
  {
    // we don't know if you map bios together with ram or separately
    return mainRam.readMemory(address);
  }
}

现在我们在 0xF000000 和 0xFC000000 之间有地址空间，必须将其分成多个部分。正如您从内存映射中看到的那样:

F000000h
F800000h
F801000h
F802000h
FA00000h
FC00000h

如果您注意到，您会发现前 4 位始终是 0xF，而后 12 位始终是 0，因此我们不需要他们了解在哪里发送调用。这意味着地址中有趣的部分具有以下掩码 0x0FFF000，因此我们可以转换地址:

address = (address >>> 12) & 0xFFF;

现在这些只有 4096 个可能的值可以适合一个紧凑的 LUT 表。

关于Java:具有数百万项的 HashMap 性能与 if-else 搜索数值范围，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42475957/

文章推荐： php - 单击特定单选按钮后验证文本区域框

文章推荐： MYSQL:如何在不查询整个表的情况下获取过去X小时内插入的行

文章推荐： java - 单元测试中的@Autowire 似乎不起作用

javascript - 字母正则表达式 + 数值
我正在开发一个 Java 脚本，为此我需要正则表达式来检查文本框中输入的文本是否应该是字母和数值的组合。我尝试了 Java 脚本的 NaN 函数，但字符串的最小长度和最大长度应为 4，并以字母作为第
algorithm - (数值)计算两个长方体的相交体积
我给出了两个长方体，其中只有一个轴对齐(另外两个不需要对齐)和顶点坐标(在全局坐标系中)，我知道它们相交。我正在寻找一种可以计算路口体积的算法。为了检查交点，我使用了分离轴定理。最佳答案可以通过
MySQL json_search 数值
我有一个类似这样的对象的 json 列表 [{ "something": "bla", "id": 2 }, { "something": "yes", "id": 1
vba - 字典不显示特定键(数值)的项目
这是一篇很长的文章，但请留在我身边... 我有一个字典，它将“PO”保存为Key，将“SO”保存为项目(在某些情况下，某个“PO”可能有多个“SO”) . 工作表中的我的 Excel 数据，字典在其中
elasticsearch - 术语包括 Elasticsearch 数值
我的问题是是否有办法使用 terms include在 numeric field在 elasticsearch aggregation . 我在 Elasticsearch 中对多个字段使用通用查询
json - 编码不带引号的 json 数值
我有一个 perl 代码片段 use JSON::XS; $a = {"john" => "123", "mary" => "456"}; print encode_json($a),"\n"; 输出
python - python的不等式/数值+条件语句？
我想对 python 进行一个条件测试，以检查给定输入数字的值是否等于或小于 9，并且大于或等于 0。 number =input( "Please enter a number! :" ) Plea
javascript - 获取对象中的 "next"数值
我有一个这样的对象: var rock = { 5: 0.5, 0: 0.8, 10: 0.3, 2: 1.0, } 我有一个像 4.3 这样的数字，我需要前后数字的索引和值。在这个例子中我会
iOS - 字符串中各个字符的 Unicode 数值
对于 iOS 中的 Objective-C: 如果我有一个字符串，如何读取单个字符的 unicode 数值？例如，如果我的字符串是:“Δ”，unicode 字符是 U+0394，那么我如何读取该字符
java - 数值 Java 库
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。要求我们推荐或查找工具、库或最喜欢的场外资源的问题对于 Stack Overflow 来说是偏离主题的，
javascript - 检查数组是否包含(仅)数值
我有这样的数组 var arrayVal_Int = ["21", "53", "92", "79"]; var arrayVal_Alpha = ["John", "Christine", "L
php - 递增 alpha 数值
就像标题暗示我需要做这样的事情...... $i++;//we all know this. $value = 'a'; increment($value);// i need this functi
python - 生成具有给定(数值)分布的随机数
我有一个文件，其中包含一些不同值的概率，例如: 1 0.1 2 0.05 3 0.05 4 0.2 5 0.4 6 0.2 我想使用此分布生成随机数。是否存在处理此问题的现有模块？自己编写代码相当简单
c++ - Rcpp 数值 vector 输出只返回一个值
因此，我在从使用 RCPP 创建的函数返回值时遇到了一些问题。它只返回 NumericVector 的第一个值。问题是当我在自身内部调用函数并将 NumericVector 传递回 out 变量时。任
c++ - 数值 vector 运算符重载+右值引用参数
我有下面的数字 vector 模板类(用于数值计算的 vector )。我正在尝试使编写 D=A+B+C 成为可能，其中所有变量都是 Vector 对象。 A、B 和 C 不应修改。我的想法是使用 V
mysql常用函数实例总结【聚集函数、字符串、数值、时间日期处理等】
本文实例讲述了mysql常用函数。分享给大家供大家参考，具体如下：本文内容： mysql函数的介绍聚集函数 avg count max
python - 如何从 Object dtype 中提取特定的单词/数值？
我正在尝试使用 python(无关)为我的公司自动化一些事情，这就是我的问题。首先，我正在从邮箱中的特定文件夹创建数据框。(到这里没问题)” RangeIndex: 36 entries, 0 to
javascript - Angular ng-if 数值 bool 值
我在让 Angular ng-if 工作时遇到了一些麻烦。我希望我的 DOM 元素之一在 $scope.week = 1 时消失。在我的 Controller 中我设置了 $scope.week =
Solr 数值 Trie 与传统 trie(前缀树)
我正在阅读 Ingersoll、Morton 和 Farris 撰写的 Taming Text，但我不明白 solr 的数字 trie 实现如何帮助搜索文本？我对 solr.TrieField fie
javascript - 在 PHP 计算中使用 JavaScript 数值
这个问题已经有答案了: What is the difference between client-side and server-side programming? (3 个回答) 已关闭 9 年前

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Java:具有数百万项的 HashMap 性能与 if-else 搜索数值范围