JavaのStream操作

はじめに

Javaの実装で利用したStream操作をまとめてみました。

特定のデータのみ抽出したい

NULLデータを取り除く(List版)

リストからNULLデータを取り除く方法です。

package com.app;

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

public class Main {

    public static void main(String[] args) {
        System.out.println("---NULLあり---");
        List<Integer> isNullList = Arrays.asList(1, 2, null, 3);
        isNullList.forEach(System.out::println);

        System.out.println("---NULLなし---");
        List<Integer> nonNullList = isNullList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        nonNullList.forEach(System.out::println);
    }

}

実行結果

---NULLあり---
1
2
null
3
---NULLなし---
1
2
3

NULLデータを取り除く(配列版)

配列からNULLデータを取り除く方法です。

package com.app;

import java.util.Arrays;
import java.util.Objects;

public class Main {

    public static void main(String[] args) {
        System.out.println("---NULLあり---");
        Integer[] isNullArray = { 1, 2, null, 3 };
        Arrays.stream(isNullArray).forEach(System.out::println);

        System.out.println("---NULLなし---");
        Integer[] nonNullArray = Arrays.stream(isNullArray)
                .filter(Objects::nonNull)
                .toArray(Integer[]::new);

        Arrays.stream(nonNullArray).forEach(System.out::println);
    }

}

実行結果

---NULLあり---
1
2
null
3
---NULLなし---
1
2
3

NULLデータを取り除く(Map版)

リストからMapデータを取り除く方法です。

package com.app;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        System.out.println("---NULLあり---");
        Map<String, Integer> isNullMap = new HashMap<String, Integer>(){
            {
                put("key1",1);
                put("key2",2);
                put("keyNull",null);
                put("key3",3);
            }
        };
        isNullMap.entrySet().stream().forEach(System.out::println);

        System.out.println("---NULLなし---");
        Map<String, Integer> nonNullMap = isNullMap.entrySet().stream()
                .filter(e-> Objects.nonNull(e.getValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        nonNullMap.entrySet().stream().forEach(System.out::println);

    }

}

実行結果

---NULLあり---
key1=1
key2=2
keyNull=null
key3=3
---NULLなし---
key1=1
key2=2
key3=3

データ変換

Listを配列に変換する

Listを配列に変換する方法です。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("apple", "banana", "cherry");
        System.out.println("---Listデータ---");
        list.forEach(System.out::println);

        System.out.println("---配列データ---");
        String[] array = list.stream().toArray(String[]::new);
         Arrays.stream(array).forEach(System.out::println);

    }

}

実行結果

---リストデータ---
apple
banana
cherry
---配列データ---
apple
banana
cherry

ListをMapに変換する(KeyはListのインデックス)

リストをMapに変換する方法です。Mapのキーはリストのインデックスを指定します。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        System.out.println("---リストデータ---");
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.forEach(System.out::println);

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = IntStream.range(0, list.size())
                .boxed()
                .collect(Collectors.toMap(i -> i, list::get));
        map.entrySet().stream().forEach(System.out::println);

    }

}

実行結果

---リストデータ---
apple
banana
cherry
---Mapデータ---
0=apple
1=banana
2=cherry

配列をListに変換する

配列をListに変換する方法です。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        System.out.println("---配列データ---");
        String[] array = { "apple", "banana", "cherry" };
        Arrays.stream(array).forEach(System.out::println);

        System.out.println("---リストデータ---");
        List<String> list = Arrays.stream(array).collect(Collectors.toList());
        list.forEach(System.out::println);

    }

}

実行結果

---配列データ---
apple
banana
cherry
---リストデータ---
apple
banana
cherry

配列をMapに変換する(Keyは配列のインデックス)

配列をMapに変換する方法です。Mapのキーは配列のインデックスを指定します。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        System.out.println("---配列データ---");
        String[] array = { "apple", "banana", "cherry" };
        Arrays.stream(array).forEach(System.out::println);

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = IntStream.range(0, array.length)
                .boxed()
                .collect(Collectors.toMap(i -> i, i -> array[i]));
        map.entrySet().stream().forEach(System.out::println);

    }

}

実行結果

---配列データ---
apple
banana
cherry
---Mapデータ---
0=apple
1=banana
2=cherry

MapをListに変換する(Mapのキーのみリストにする)

MapのKeyをListに変換する方法です。

package com.app;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---Listデータ---");
        List<Integer> keyList = map.keySet().stream().collect(Collectors.toList());
        keyList.forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---Listデータ---
1
2
3

MapをListに変換する(MapのValueのみListにする)

MapのValueをListに変換する方法です。

package com.app;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---Listデータ---");
        List<String> valueList = map.values().stream().collect(Collectors.toList());
        valueList.forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---Listデータ---
apple
banana
cherry

MapをListに変換する(MapのEntry(KeyとValue)を配列にする)

MapのEntry(KeyとValue)を配列に変換する方法です。

package com.app;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---リストデータ---");
        List<Map.Entry<Integer, String>> entryList = map.entrySet().stream().collect(Collectors.toList());
        entryList.forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---配列データ---
1=apple
2=banana
3=cherry

Mapを配列に変換する(MapのKeyのみ配列にする)

MapのKeyを配列に変換する方法です。

package com.app;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---配列データ---");
        Integer[] keyArray = map.keySet().stream().toArray(Integer[]::new);
        Arrays.stream(keyArray).forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---配列データ---
1
2
3

Mapを配列に変換する(MapのValueのみ配列にする)

MapのValueを配列に変換する方法です。

package com.app;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---配列データ---");
        String[] valueArray = map.values().stream().toArray(String[]::new);
        Arrays.stream(valueArray).forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---配列データ---
apple
banana
cherry

Mapを配列に変換する(MapのEntry(KeyとValue)をListにする)

MapのEntry(KeyとValue)を配列に変換する方法です。

package com.app;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class Main {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        System.out.println("---Mapデータ---");
        Map<Integer, String> map = new HashMap<Integer, String>() {
            {
                put(1, "apple");
                put(2, "banana");
                put(3, "cherry");
            }
        };
        map.entrySet().stream().forEach(System.out::println);

        System.out.println("---配列データ---");
        Entry<Integer, String>[] entryArray = map.entrySet().stream().toArray(Entry[]::new);
        Arrays.stream(entryArray).forEach(System.out::println);

    }

}

実行結果

---Mapデータ---
1=apple
2=banana
3=cherry
---配列データ---
1=apple
2=banana
3=cherry

データの合計

Listデータの合計

シンプルなListデータの合計を計算します。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        System.out.println("---Intger,int型の合計---");
        List<Integer> listInt = Arrays.asList(1, 2, 3, 4);
        int sumInt = listInt.stream().mapToInt(Integer::intValue).sum();
        System.out.println(sumInt);

        System.out.println("---Long,long型の合計---");
        List<Long> listLong = Arrays.asList(1L, 2L, 3L, 4L);
        long sumLong = listLong.stream().mapToLong(Long::intValue).sum();
        System.out.println(sumLong);

        System.out.println("---Double,double型の合計---");
        List<Double> listDouble = Arrays.asList(0.1, 0.2, 0.3, 0.4);
        double sumDouble = listDouble.stream().mapToDouble(Double::doubleValue).sum();
        System.out.println(sumDouble);

    }

}

実行結果

--Intger,int型の合計---
10
--Long,long型の合計---
10
--Double,double型の合計---
1.0

配列データの合計

シンプルな配列データの合計を計算します。

package com.app;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Intger,int型の合計---");
        Integer[] arrayInt = {1, 2, 3, 4};
        int sumInt =  Arrays.stream(arrayInt).mapToInt(Integer::intValue).sum();
        System.out.println(sumInt);

        System.out.println("---Long,long型の合計---");
        Long[] arrayLong = {1L, 2L, 3L, 4L};
        long sumLong =  Arrays.stream(arrayLong).mapToLong(Long::intValue).sum();
        System.out.println(sumLong);

        System.out.println("---Double,double型の合計---");
        Double[] arrayDouble = {0.1, 0.2, 0.3, 0.4};
        double sumDouble =  Arrays.stream(arrayDouble).mapToDouble(Double::doubleValue).sum();
        System.out.println(sumDouble);

    }

}

データの最大値・最小値

Listデータの最大値・最小値

Listデータの最大値・最小値を求めます。

package com.app;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Listの最大値---");
        List<Integer> listMax = Arrays.asList(1, 2, 3, 4);
        Optional<Integer> maxOpt = listMax.stream().max(Integer::compare);
        int max = maxOpt.orElse(0);
        System.out.println(max);

        System.out.println("---Listの最小値---");
        List<Integer> listMin = Arrays.asList(1, 2, 3, 4);
        Optional<Integer> minOpt = listMin.stream().min(Integer::compare);
        int min = minOpt.orElse(0);
        System.out.println(min);

    }

}

実行結果

---Listの最大値---
4
---Listの最小値---
1

配列データの最大値・最小値

配列データの最大値・最小値を求めます。

package com.app;

import java.util.Arrays;
import java.util.Optional;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Listの最大値---");
        Integer[] arrayMax = {1, 2, 3, 4};
        Optional<Integer> maxOpt = Arrays.stream(arrayMax).max(Integer::compare);
        int max = maxOpt.orElse(0);
        System.out.println(max);

        System.out.println("---Listの最小値---");
        Integer[] arrayMin = {1, 2, 3, 4};
        Optional<Integer> minOpt = Arrays.stream(arrayMin).min(Integer::compare);
        int min = minOpt.orElse(0);
        System.out.println(min);

    }

}

実行結果

---Listの最大値---
4
---Listの最小値---
1

特定のデータの個数

Listデータの特定の個数

Listデータの特定のデータの個数を計算します。

package com.app;

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

public class Main {

    public static void main(String[] args) {

        System.out.println("---Listの2より大きい個数---");
        List<Integer> listCount = Arrays.asList(1, 2, 3, 4);
        long count = listCount.stream().filter(val -> 2 < val).count();
        System.out.println(count);

    }

}

実行結果

---Listの2より大きい個数---
2

配列データの特定の個数

配列データの特定のデータの個数を計算します。

package com.app;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        System.out.println("---配列の2より大きい個数---");
        Integer[] arrayCount = { 1, 2, 3, 4 };
        long count = Arrays.stream(arrayCount).filter(val -> 2 < val).count();
        System.out.println(count);

    }

}

実行結果

---配列の2より大きい個数---
2

データの平均

Listデータの平均

Listデータの平均を計算します。

package com.app;

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;

public class Main {

    public static void main(String[] args) {

        System.out.println("---Listの平均-Integer,int型---");
        List<Integer> listIntCount = Arrays.asList(1, 2, 3, 4, 5);
        OptionalDouble averageIntOpt = listIntCount.stream().mapToDouble(Integer::intValue).average();
        double averageInt = averageIntOpt.orElse(0.0);
        System.out.println(averageInt);

        System.out.println("---Listの平均-Long,long型---");
        List<Long> listLongCount = Arrays.asList(6L, 7L, 8L, 9L, 10L);
        OptionalDouble averageLongOpt = listLongCount.stream().mapToDouble(Long::longValue).average();
        double averageLong = averageLongOpt.orElse(0.0);
        System.out.println(averageLong);

        System.out.println("---Listの平均-Double,double型---");
        List<Double> listDoubleCount = Arrays.asList(11.0, 12.0, 13.0, 14.0, 15.0);
        OptionalDouble averageDoubleOpt = listDoubleCount.stream().mapToDouble(Double::doubleValue).average();
        double averageDouble = averageDoubleOpt.orElse(0.0);
        System.out.println(averageDouble);

    }

}

実行結果

---Listの平均-Integer,int型---
3.0
---Listの平均-Long,long型---
8.0
---Listの平均-Double,double型---
13.0

配列データの平均

配列データの平均を計算します。

package com.app;

import java.util.Arrays;
import java.util.OptionalDouble;

public class Main {

    public static void main(String[] args) {

        System.out.println("---配列の平均-Integer,int型---");
        Integer[] arrayIntCount = { 1, 2, 3, 4, 5 };
        OptionalDouble averageIntOpt = Arrays.stream(arrayIntCount).mapToDouble(Integer::intValue).average();
        double averageInt = averageIntOpt.orElse(0.0);
        System.out.println(averageInt);

        System.out.println("---配列の平均-Long,long型---");
        Long[] arrayLongCount = { 6L, 7L, 8L, 9L, 10L };
        OptionalDouble averageLongOpt = Arrays.stream(arrayLongCount).mapToDouble(Long::longValue).average();
        double averageLong = averageLongOpt.orElse(0.0);
        System.out.println(averageLong);

        System.out.println("---配列の平均-Double,double型---");
        Double[] arrayDoubleCount = { 11.0, 12.0, 13.0, 14.0, 15.0 };
        OptionalDouble averageDoubleOpt = Arrays.stream(arrayDoubleCount).mapToDouble(Double::doubleValue).average();
        double averageDouble = averageDoubleOpt.orElse(0.0);
        System.out.println(averageDouble);

    }

}

実行結果

---配列の平均-Integer,int型---
3.0
---配列の平均-Long,long型---
8.0
---配列の平均-Double,double型---
13.0