java 異なるlistの要素を加算して新たなリストを作りたい

Question

以下の様な異なるリスト同士の要素を足し算して新たなリストを作りたいです。

List1 1,3,5,7,9
List2 2,4,6,8,10

新たなList 3,7,11,15,19

よろしくお願いします

Answer 1

import java.util.*;
import java.util.function.*;

public class Main {
    public static void main(String[] args) throws Exception {
        List<Integer> l1 = Arrays.asList(1, 3, 5, 7, 9, 11, 13, 15);
        List<Integer> l2 = Arrays.asList(0, 2, 4, 6, 8);
    
        List<Integer> result = zip(l1, l2, (a, b) -> a + b);
        System.out.println(result);
    }
    
    public static <T> List<T> zip(List<? extends T> list1, List<? extends T> list2, BinaryOperator<T> operator) {
        Iterator<? extends T> ite1 = list1.iterator();
        Iterator<? extends T> ite2 = list2.iterator();
        List<T> result = new ArrayList<T>(Math.max(list1.size(), list2.size()));
        while(ite1.hasNext() && ite2.hasNext()) {
            result.add(operator.apply(ite1.next(), ite2.next()));
        }
        ite1.forEachRemaining(result::add);
        ite2.forEachRemaining(result::add);
        return result;
    }
}

Comments

[退会済みユーザー]

forEachRemaining
(・∀・)ｲｲﾈ!!

Answer 2

zip/mapのチェーン

他の言語だとこの質問は成立しないでしょう。zipとmapのチェーンで簡単にできるから。Javaだとzipとtupleを作らなければならず退屈。省略してzipとmapを一度にやることにします。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;

public class ZipAndMap_ {

  private static <T> List<T> zippingMap(List<T> l1, List<T> l2, BinaryOperator<T> operator, List<T> acc) {
    if (l1.size() == 0 || l2.size() == 0) return acc;
    acc.add(operator.apply(l1.get(0), l2.get(0)));
    return zippingMap(l1.subList(1, l1.size()), l2.subList(1, l2.size()), operator, acc);
  }

  public static void main(String[] args) {

    List<Integer> l1 = Arrays.asList(1, 3, 5, 7, 9);
    List<Integer> l2 = Arrays.asList(2, 4, 6, 8, 10);

    List<Integer> result = zippingMap(l1, l2, (a, b) -> a + b, new ArrayList<>());
    System.out.println(result);

  }

}

Scala

Scalaで書くとこうなる。

object ZipAndMap extends App {
  val l1 = List(1,3,5,7,9)
  val l2 = List(2,4,6,8,10)
  val result = l1.zip(l2).map{case (a,b) => a + b}
}

Python

初心者の私がPythonで書くとこうなる。

l1 = [1,3,5,7,9]
l2 = [2,4,6,8,10]
map(lambda x: x[0] + x[1], zip(l1,l2))

Java

zipとtupleでやるとこうなる。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ZipAndMap {
 
  static class Tuple<T,U> {
    final T _1; final U _2;
    public Tuple(T x, U y) {this._1 = x; this._2 = y;}
  }
  
  static <T,U> List<Tuple<T,U>> zip(List<T> l1, List<U> l2, List<Tuple<T,U>> acc) {
    if (l1.size()==0 ||l2.size()==0) return acc;
    acc.add(new Tuple<>(l1.get(0),l2.get(0)));
    return zip(l1.subList(1,l1.size()),l2.subList(1,l2.size()),acc);
  }

  public static void main(String[] args) {

    List<Integer> l1 = Arrays.asList(1,3,5,7,9);
    List<Integer> l2 = Arrays.asList(2,4,6,8,10);
    
    List<Tuple<Integer,Integer>> acc = zip(l1,l2,new ArrayList<>());
    List<Integer> result = acc.stream().collect(ArrayList::new, (a,e) -> a.add(e._1 + e._2), List::addAll);
    System.out.println(result);

  }
  
}

指摘への対応

• unmodifiableListに対応できない

　やりたいことは関数型言語のListのhead/tail相当の処理なので、List#get(0)/List#subList(1,<リストのサイズ>)を使うことで効率よく同等の処理ができました。

• スタックオーバーフローにはあえて対応していません。

　末尾再帰を最適化できる言語があるからです。

Comments

[TN8001]

そうなんです。
専らC#の私はこんなのzip一発では？と思って調べたら、まだ入っていないそうで^^;

丸投げには違いありませんが軽く調べたところ、ズバリなページを見つけられなかったため、閲覧者のためもあり回答した次第です^^

[LouiS0616]

Pythonだと内包表記を使うとすっきり書けそうです。
print([e1+e2 for e1, e2 in zip(l1, l2)])

HaskellにはzipWithという関数があり、この役割はまさにzippingMapです。
print $ zipWith (+) l1 l2

[退会済みユーザー]

よくある unmodifiedList を突っ込んだらエラーになるよなこれ

[退会済みユーザー]

とりあえず要素数2万にしたら落ちたなｗ

https://paiza.io/projects/wrFjDw9KNGlA0CyOdXOjlg

[xebme]

> よくある unmodifiedList を突っ込んだらエラーになるよなこれ
なります。だから引数3つのメソッド内でArrayListをnewしています。防衛策。
関数型言語のようにunmodifiedListのhead/tailがしたいのです。イミュータブルなまま処理がしたいのですが、remove()しています。ここは課題ですね。

[xebme]

> とりあえず要素数2万にしたら落ちたなｗ
末尾再帰しない言語ですから仕方ありません。Javaの代わりに謝ります。

[xebme]

どの言語もzipは短い方に揃えるのだけれど、なぜかを説明しろと言われると、タプルに格納する型が同じとは限らないから、そもそも欠損値はNoneとして扱うしかないからなど。これは課題。

Answer 3

とりあえず大喜利 ってことで

public static List<Integer> zip(List<Integer> a, List<Integer> b) {

	Iterator<Integer> ia = a.iterator();
	Iterator<Integer> ib = b.iterator();
	
	List<Integer> result = new ArrayList();
	while(ia.hasNext() || ib.hasNext()) {
	    result.add(
	          (ia.hasNext() ? ia.next() : 0) 
	        + (ib.hasNext() ? ib.next() : 0)
	        );
	}
	return result;
}

大喜利2

public static List<Integer> zip(List<Integer> a, List<Integer> b) {

	Iterator<Integer> ia = a.iterator();
	Iterator<Integer> ib = b.iterator();

	return IntStream.range(0, Math.max(a.size(), b.size()))
		.mapToObj(index -> (Integer) //
		( (ia.hasNext() ? ia.next() : 0) 
		+ (ib.hasNext() ? ib.next() : 0)
	)).collect(Collectors.toList());
}

Answer 4

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;


public class Main {
    public static void main(String[] args) {
        {
            List<Integer> List1 = Arrays.asList(1, 3, 5, 7, 9, 11, 13, 15);
            List<Integer> List2 = Arrays.asList(2, 4, 6, 8, 10);

            List<Integer> 新たなList = IntStream
                    .range(0, Math.min(List1.size(), List2.size()))
                    .mapToObj(i -> List1.get(i) + List2.get(i))
                    .collect(Collectors.toList());

            System.out.println(新たなList); // [3, 7, 11, 15, 19]
        }
        {
            List<Integer> List1 = Arrays.asList(1, 3, 5, 7, 9, 11, 13, 15);
            List<Integer> List2 = Arrays.asList(2, 4, 6, 8, 10);

            List<Integer> 新たなList = IntStream
                    .range(0, Math.max(List1.size(), List2.size()))
                    .mapToObj(i -> (i < List1.size() ? List1.get(i) : 0) + (i < List2.size() ? List2.get(i) : 0)) // なんか冴えないね^^;
                    .collect(Collectors.toList());

            System.out.println(新たなList); // [3, 7, 11, 15, 19, 11, 13, 15]
        }
    }
}