相关疑难解决方法(0)

我想创建一个新的对象数组,将两个较小的数组放在一起.

它们不能为空,但大小可能为0.

我无法在这两种方式之间进行选择:它们是等效还是更高效(例如system.arraycopy()复制整个块)？

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
System.arraycopy(publicThings, 0, things, 0, publicThings.length);
System.arraycopy(privateThings, 0, things,  publicThings.length, privateThings.length);

要么

MyObject[] things = new MyObject[publicThings.length+privateThings.length];
for (int i = 0; i < things.length; i++) {
    if (i<publicThings.length){
        things[i] = publicThings[i]
    } else {
        things[i] = privateThings[i-publicThings.length]        
    }
}

唯一的区别是代码的外观？

编辑:感谢链接的问题,但他们似乎有一个未解决的讨论:

如果it is not for native types:byte [],Object [],char [] 真的更快吗？在所有其他情况下,执行类型检查,这将是我的情况,因此将是等效的......不是吗？

在另一个相关问题上,他们说the size matters a lot,对于size> 24,system.arraycopy()获胜,小于10,手动for循环更好......

现在我真的很困惑.

Java System.arraycopy()对于小型数组是否有效,或者它是一种本机方法使得它可能比简单的循环和函数调用效率低得多？

本机方法是否会因跨越某种Java系统桥而产生额外的性能开销？

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 是一种本地方法.

这种方法的时间复杂度是多少？

可能重复:
是什么让JNI调用变慢？

首先让我说,这些问题的出现更多是出于好奇而不是真正的必然.

我很想知道从Java执行JNI调用的开销是多少,比如System.arraycopy分配数组并使用for循环复制元素.

如果开销很大,那么可能有一个粗略的"神奇数字"元素,它补偿简单地使用for循环,而不是使用系统调用.而且,系统调用中究竟涉及到什么导致这种开销？我猜测必须将堆栈推送到调用的上下文,这可能需要一段时间,但我无法找到整个过程的良好解释.

让我澄清一下我的问题:

我知道使用arraycopy是用Java复制数组的最快方法.

话虽如此,让我说我用它来复制一个只有一个元素的数组.由于我调用底层OS这样做,有有将在此调用的开销.我很想知道这个开销是什么以及在调用过程中会发生什么.

如果使用arraycopy误解了我的问题,我很抱歉.我很想知道JNI调用的开销,以及实际调用中涉及的内容.

我正在研究一个项目,但我不能使用任何现有的java数据结构(即ArraysList,树等)

我只能使用数组.因此,我需要使用新内存动态更新数组.

我正在读取文本文件,并为阵列内存预先分配100:

   String [] wordList;
   int wordCount = 0;
   int occurrence = 1;
   int arraySize = 100;
   wordList = new String[arraySize];
   while ((strLine = br.readLine()) != null)   {
         // Store the content into an array
         Scanner s = new Scanner(strLine);
         while(s.hasNext()) {
           wordList[wordCount] = s.next();
           wordCount++;
         } 
   }

现在这适用于100个以下列表项.br.readline是遍历文本文件每一行的缓冲读取器.我有它然后将每个单词存储到列表中,然后递增我的索引(wordCount).

但是,一旦我有一个包含超过100个项目的文本文件,我就会收到分配错误.

如何动态更新此阵列(从而重新发明轮子)？

谢谢!

简单的问题,在Java中复制双精度数组的最快方法是什么.我目前这样做......

public static double[] clone_doubles(double[] from)
{
    double[] to = new double[from.length];
    for (int i = 0; i < from.length; i++) to[i] = from[i];
    return to;
}

它也进行分配以避免溢出,但如果有更快的方法我将分配与副本分开.

我看过了Arrays.copyOf(),System.arraycopy()但我想知道是否有人有任何巧妙的技巧.

编辑: 如何复制double[][]？

对于 addAll 操作，是否有复杂度为 O(1) 而不是 O(n) 的 Java 集合，还是必须实现我自己的集合？使用有效的链表，Collection1.addAll(Collection2) 操作应该将第二个集合附加到第一个集合，将 collection2 的第一个节点添加到集合 1 的最后一个节点，然后其他的。但这并不是我阅读了似乎使用迭代器的文档，所以我猜复杂度是 O(collection2.size)。

那正确吗 ？

我的问题是关于：Public String（char [] value）。有人可以帮我吗：它是否在内部为每个值[i]循环。特别，

Public String（char [] value）的含义是：

for each char[i]
returnedSTRING = returnedSTRING + char[i] 

或不 ？

例

short size = 1234;
    byte[] payload = {12,43, 55,123, 11, 55};

byte [] shortSize = ByteBuffer.allocate(2).putShort(size).array();
byte[] entirePayload = new byte[shortSize.length+payload.length];   

System.arraycopy(shortSize, 0, entirePayload, 0, 2);
System.arraycopy(payload, 0, entirePayload, 2, payload.length);

这是Java System调用的根本原因吗？