Java 什么'；向int[]的所有元素添加常量值的最短方法是什么？矩阵加法怎么样？

我有一个int的数组。我需要为每个元素添加1。向每个元素添加给定常量的最短、最通用的方法是什么，即不使用显式循环？我一直在网上寻找，不断得到关于在数组中添加元素（即连接）的页面

难道没有比循环遍历每个元素并添加常量更优雅的东西吗？是否有某种标准的库方法

---

在这个问题上，如果没有显式循环，如何将两个数组相加（即矩阵相加）？

如果不可修改的结果是可以的，并且您没有坚持使用数组，您可以使用一个可爱的技巧将相加延迟到最后一刻。但是，一旦需要访问整个结果数组，任何性能优势都将丢失，代码将变得比需要的更复杂

public class OffsetArrayList extends AbstractList< Integer > {
    private final List< Integer > liUnderlying;
    private final int iOffset;
    public OffsetArrayList( int iOffset, liUnderlying ) {
        this.iOffset = iOffset;
        this.liUnderlying = liUnderlying;
    }
    @Override
    public Integer get( int iIndex ) {
        return liUnderlying.get( iIndex ) + iOffset;
    }
    @Override
    public Integer set( int iIndex, Integer iNewValue ) {
        return liUnderlying.set( iIndex, iNewValue - iOffset ) + iOffset;
    }
    // etc.
}

// create new array
int[] aiInput = new int[] { 23, 98, -45 };
// two object allocations, but no new array created and no additions performed
OffsetArrayList alPlusOne = new OffsetArrayList( 1, Arrays.asList( aiInput ) );
// one addition performed; constant time
assert( alPlusOne.get( 0 ) == 24 );

// benefit murky, as we are adding to the same element repeatedly
for ( int i = 0; i < 1000000; ++i )
    assert( alPlusOne.get( 2 ) == -44 );

// benefit lost, input destroyed
int[] aiOutput = alPlusOne.toArray( aiInput );

公共类OffsetaryList扩展了AbstractList{
私有最终列表liunderlaying；
私人最终国际补偿；
公共偏移量列表（内部偏移量、内部偏移量）{
this.iOffset=iOffset；
this.liunderlieng=liunderlieng；
}
@凌驾
公共整数get（整数索引）{
返回liunderlaying.get（iIndex）+iOffset；
}
@凌驾
公共整数集（int iIndex，Integer iNewValue）{
返回liUnderlieng.set（iIndex，iNewValue-iOffset）+iOffset；
}
//等等。
}
//创建新阵列
int[]aiInput=newint[]{23,98，-45}；
//两个对象分配，但未创建新数组，也未执行任何添加
offsetaraylist alPlusOne=新的offsetaraylist（1，Arrays.asList（aiInput））；
//进行一次添加；恒定时间
断言（alPlusOne.get（0）==24）；
//利益不明，因为我们正在重复添加相同的元素
对于（int i=0；i<1000000；++i）
断言（alPlusOne.get（2）=-44）；
//利益损失，投入破坏
int[]aiOutput=alPlusOne.toArray（aiInput）；

以下是如何使用编写上述两个案例的方法

---

1。向每个元素添加1:

transform(yourArray, Integers.add.f(1));

它是一个函数编程库，因此不提供变异操作。但是您可以自己轻松地添加它们

public static <A> void transform(Array<A> xs, F<A, A> f) {
  for(int i = 0; i < xs.length(); i++) {
    xs.set(i, f.f(xs.get(i)));
  }
}

---

2。添加两个矩阵：

transform(yourArray, Integers.add.f(1));

---

让

xss

和

yss

成为两个矩阵，这两种类型的

Array使这种技术更容易实现。
Java语言中没有内置任何东西。您可能会发现一个处理类似这样的数组操作的库，但在它的封面下，它将使用迭代。也可能有一些库使用JNI来调用向量操作，使用硬件指令或GPU来并行化代码？你写的代码？还是速度？您的阵列可以有多大？为什么不允许循环？@RangiLin，1。显然，shortest将引用他编写的代码。“短”和“长”不是测量速度的方式。2.数组长度应该是无关紧要的。3.这不是被允许的问题。他正在寻找一种简洁、更优雅的方式来写同样的东西。@RangiLin，我的意思是短，正如missingfaktor所说，但快速也会引起兴趣。也许我只是被IDL的过去使用惯坏了，但在我看来，必须有一些简洁的方法来处理向量——一种不需要为（应该是什么）一个基本操作拖入一个全新的库，或者编写各种各样的迷你方法来处理常见的矩阵/向量操作的方法。相信我，@JohnK，对于Java集合框架API，您甚至还没有触及令人失望的表面。你可以看看Guava（它有一个
列表.transform
，它能够以一种通用的方式将我和@missingfaktor的答案结合起来）。这不完全是我想要的，但是学习函数式Java很酷。谢谢@约翰，你知道斯卡拉吗？它是一种在JVM上运行的函数式语言，可以与Java库完全互操作。在其中，您的两个示例将分别编写为：
xs.transform（1+）
和
（xss，yss）.zip.map{case（xs，ys）=>（xs，ys）.zip.map（+u）}
。