Question

假设一个对象数组：Element T []，每个对象包含两个整数变量（x，y）。

T = (1,1) (2,2) (3,3) (4,4)

每次以更快的方式将新元素添加到数组时，我想增加对象变量 x 的值。新元素可以添加到任何位置，我们会在插入位置（位置+1）后递增所有 x 元素

在添加（6,6）之前：

T = (1,1) (2,2) (3,3) (4,4)

在不同位置添加（6,6）之后：

1）T = （6,6）（ 2 ，1）（ 3 ，2）（ 4 ，3）（ 5 ，4）

或

2）T =（1,1）（2,2）（6,6）（ 4 ，3）（ 5 ，4）

或

3）T =（1,1）（2,2）（3,3）（6,6）（ 5 ，4）

我使用 arraycopy 方法添加新元素，并使用循环增加每个元素的变量 x ，如下所示：

使用

x

Ta[0] = (6,6)
araycopy(T, 0, Ta, 1, T.size-1 );

因为它比

While (i< T.length){

  T[i] = T[i+1]

  T[i].x ++;

   i++;
}

我需要添加新元素并以更快的时间增加数组的其他对象。

// -------------------

public class elemt {

public int x;
public int y;

public elemt(int a, int b){
    this.x= a;
    this.y= b;
}


public void inc(){
 x++;
}

int getX(){
    return x;
}

int getY(){
    return y;
}

}

// ----------------

公共类TAD {

public static ArrayList＆lt; elemt＆gt; T = new ArrayList＆lt; elemt＆gt; （）;

public static ArrayList＆lt; elemt＆gt; T1 =新的ArrayList＆lt; elemt＆gt; （）;

 public static void main(String[] args){



    for(int i=0; i<10000000; i++){
       T1.add(new elemt(i, i));
      }


     long t0 = System.currentTimeMillis();

      T1.add(0, new elemt(1, 1));

     long t1= System.currentTimeMillis()- t0;

     System.out.println("Time without Incrementation : "+t1);


 //--------------

     for(int i=0; i<10000000; i++){
       T.add(new elemt(i, i));
      }


    long t2 = System.currentTimeMillis();

       T.add(0, new elemt(1, 1));

        for(int i=1; i<T.size(); i++){
          T.get(i).inc();
        }

    long t3= System.currentTimeMillis()- t2;

  System.out.println("Time with Incrementation: "+t3);



 }

// -------结果：

没有增量的时间：15毫秒

增量时间：156毫秒

我的目标是尽可能减少增量过程的时间

（增量时间＆lt;没有增量的时间* 2）

因为实际上

增量时间（156 ms）=无增量时间（15 ms）* 10

我注意到我可以在任何位置添加一个新元素，但我选择了最坏的情况（在第一个位置添加一个元素，需要增加arraylist的所有 x 元素）< / p>

Answer 1

请勿使用数组，请使用Deque，可能是LinkedList。这是在正面插入O(1)。

public void addAndIncrement(Deque<Point> deque, Point new) {
  for(Point p : deque) {
    p.x++;
  }

  deque.addFirst(new);
}

或其他什么。

Answer 2

如果经常插入，我建议您使用List（例如LinkedList）。

它允许您轻松地在任何位置插入元素。也可以轻松地遍历List以对每个元素进行一些工作。

如果您想尝试第三方lib，例如番石榴，你可以试试番石榴：

Lists.transform（列表，功能） http://docs.guava-libraries.googlecode.com/git-history/release/javadoc/com/google/common/collect/Lists.html#transform(java.util.List，com.google.common.base.Function）

它执行map(list, function)之类的功能。所以你不必自己进行迭代，只需知道transform方法，你想对每个元素做什么。然后它为你做到了。

P.S。当链接包含brackets？

时，如何使用标签写下markdown http链接

Answer 3

只是一个建议（一些“开箱即用”的想法）：

如果您没有其他要求并且只能通过数组访问T个对象，那么您实际上不必增加该对的第一个元素。

今天你这样做（你正在增加第一个值）......

given T[i] = (firstElement, secondElement);
x = firstElement;
y = secondElement;
// work with x and y now...

...你可以这样做（而且不需要增加firstElement）：

given T[i] = (firstElement, secondElement);
x = firstElement + i; // add the index!
y = secondElement;
// work with x and y now...

这会将您插入的O（n）复杂度转换为O（1）。但是，当然，这在很大程度上取决于您的场景以及您如何使用T个对象的值。

通过arraycopy添加和增加数组元素

3 个答案: