Java9で追加されたメソッド一覧とその使い方

OracleのJDK9-eaの[JavaDoc](http://download.java.net/java/jdk9/docs/api/) を参照して **since:9** の表記があるクラスの**一部**について記載しています。
JDK9は未リリースであり、実際のリリースではこの記事とは異なる可能性があります。

# Package [java.lang](http://download.java.net/java/jdk9/docs/api/java/lang/package-summary.html) 編

## [Integer](http://download.java.net/java/jdk9/docs/api/java/lang/Integer.html) の章
### **parseInt**
```java
public static int parseInt(CharSequence s,
                           int beginIndex,
                           int endIndex,
                           int radix)
                    throws NumberFormatException
```
> 文字列の一部を切り取ってIntegerにパースするメソッド
> #### Java8
> ```java
> // 16進数で表記したカラーコード
> String cssColor = "#4dba16";
> int red   = Integer.parseInt(cssColor.substring(1, 3), 16);
> int green = Integer.parseInt(cssColor.substring(3, 5), 16);
> int blue  = Integer.parseInt(cssColor.substring(5, 7), 16);
> 
> // 何かのお金
> String payStr = "2000メタ";
> int pay = Integer.parseInt(payStr.substring(0, payStr.length() - 2), 10);
> 
> ```
> #### Java9
> ```java
> String cssColor = "#4dba16";
> int red   = Integer.parseInt(cssColor, 1, 3, 16);
> int green = Integer.parseInt(cssColor, 3, 5, 16);
> int blue  = Integer.parseInt(cssColor, 5, 7, 16);
> 
> String payStr = "2000メタ";
> int pay = Integer.parseInt(payStr, 0, payStr.length() - 2, 10);
> ```

### **parseUnsignedInt**
```java
public static int parseUnsignedInt(CharSequence s,
                                   int beginIndex,
                                   int endIndex,
                                   int radix)
                            throws NumberFormatException
```
> 文字列の一部を切り取って符号なしでIntegerにパースするメソッド
> #### Java8
> ```java
> // Integer.MAX_VALUE is 2147483647
> String maxPlusOne    = "2147483648はIntegerの最大値を超えている";
> // 次の行は NumberFormatException が発生する
> int parseInt         = Integer.parseInt(maxPlusOne.substring(0, 10));
> // 次の変数には -2147483648 が入る
> int parseUnsignedInt = Integer.parseUnsignedInt(maxPlusOne.substring(0, 10));
> ```
> #### Java9
> ```java
> // Integer.MAX_VALUE is 2147483647
> String maxPlusOne    = "2147483648はIntegerの最大値を超えている";
> // 次の行は NumberFormatException が発生する
> int parseInt         = Integer.parseInt(maxPlusOne, 0, 10, 10);
> // 次の変数には -2147483648 が入る
> int parseUnsignedInt = Integer.parseUnsignedInt(maxPlusOne, 0, 10, 10);
> ```

## [Long](http://download.java.net/java/jdk9/docs/api/java/lang/Long.html) の章
### **parseLong**
```java
public static long parseLong(CharSequence s,
                             int beginIndex,
                             int endIndex,
                             int radix)
                      throws NumberFormatException
```
> 文字列の一部を切り取ってLongにパースするメソッド
> #### Java8 & Java9
> Integerと同様なので省略


### **parseUnsignedLong**
```java
public static long parseUnsignedLong(CharSequence s,
                                     int beginIndex,
                                     int endIndex,
                                     int radix)
                              throws NumberFormatException
```
> 文字列の一部を切り取って符号なしでLongにパースするメソッド
> #### Java8 & Java9
> Integerと同様なので省略

## [Byte](http://download.java.net/java/jdk9/docs/api/java/lang/Byte.html) の章
### **compareUnsigned**
```java
public static int compareUnsigned(byte x,
                                  byte y)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

## [Character](http://download.java.net/java/jdk9/docs/api/java/lang/Character.html) の章
### **定数**
> 追加された以下の4つの定数は Unicode 6.3 で新たに追加されたものらしいですが、
> アラビア語やヘブライ語などを使う機会がなければ気にする必要はないようです
> 
> |定数|Code Point|略記|
> |:--:|:---------|:--|
> |DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE  |U+2066|LRI|
> |DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE  |U+2067|RLI|
> |DIRECTIONALITY_FIRST_STRONG_ISOLATE   |U+2068|FSI|
> |DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE|U+2069|PDI|

### **codePointOf**
```java
public static int codePointOf(String name)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

## [Character.UnicodeBlock](http://download.java.net/java/jdk9/docs/api/java/lang/Character.UnicodeBlock.html) の章
### **定数**
> たくさん

## [String](http://download.java.net/java/jdk9/docs/api/java/lang/String.html) の章
1.8時点では以下の2つのメソッドは親クラス([CharSequence](http://cr.openjdk.java.net/~mr/jigsaw/spec/api/java/lang/CharSequence.html))のデフォルト実装でした。
9からはおそらくこれ→ [[JEP 254: Compact Strings](http://openjdk.java.net/jeps/254)] の影響で各クラスでOverrideする形に変わったと推測。
そのため使い方に変化はありません。
### **chars**
```java
public IntStream chars()
```
> 単純に文字コード値のストリームを生成する
> #### Java8 & Java9
> ```java
> String characters = "defABC";
> characters.chars()
>         .mapToObj(c -> String.valueOf(Character.toChars(c)) + " is " + c)
>         .sorted()
>         .forEach(System.out::println);
> ```

### **codePoints**
```java
public IntStream codePoints()
```
> サロゲートペアを考慮した文字コード値のストリームを生成する
> #### Java8 & Java9
> ```java
> String characters = "𠮷野家の新メニュー 𩸽の開き定食 780円(嘘)";
> characters.codePoints()
>         .mapToObj(c -> String.valueOf(Character.toChars(c)))
>         .filter(s -> s.length() > 1)
>         .forEach(s -> System.out.println(s + " はサロゲートペア"));
> ```

## [StringBuffer](http://download.java.net/java/jdk9/docs/api/java/lang/StringBuffer.html) の章
### **chars**
> Stringと同様なので省略

### **codePoints**
> Stringと同様なので省略

## [StringBuilder](http://download.java.net/java/jdk9/docs/api/java/lang/StringBuilder.html) の章
### **chars**
> Stringと同様なので省略

### **codePoints**
> Stringと同様なので省略

## [Class\<T\>](http://download.java.net/java/jdk9/docs/api/java/lang/Class.html) の章
### **forName**
```java
public static Class<?> forName(Module module,
                               String name)
```
> #### Java9
> ```java
> // TODO:後で書く
> ```

### **getModule**
```java
public Module getModule()
```
> Java9で新たに追加された[Module](http://download.java.net/java/jdk9/docs/api/java/lang/reflect/Module.html)クラスを取得するメソッド
> #### Java9
> ```java
> // TODO:後で書く
> ```

### **getPackageName**
```java
public String getPackageName()
```
> 完全修飾パッケージ名を取得できます
> #### Java8
> ```java
> String packageName = String.class.getPackage().getName();
> ```
> #### Java9
> ```java
> String packageName = String.class.getPackageName();
> ```

## [ClassLoader](http://download.java.net/java/jdk9/docs/api/java/lang/ClassLoader.html) の章

### **findClass**
```java
protected Class<?> findClass(String moduleName,
                             String name)
```
### **findResource**
### **getUnnamedModule**
### **getPlatformClassLoader**
### **getDefinedPackage**
### **getDefinedPackages**

## [StrictMath](http://download.java.net/java/jdk9/docs/api/java/lang/StrictMath.html) の章
### **multiplyExact**
### **multiplyFull**
### **multiplyHigh**
### **floorDiv**
### **floorMod**

# Package [java.math](http://download.java.net/java/jdk9/docs/api/java/math/package-summary.html) 編

## [BigInteger](http://download.java.net/java/jdk9/docs/api/java/math/BigInteger.html) の章
### **定数**
> #### `BigInteger.TWO`
>0,1,10は前からあったが2が追加された

### **BigInteger**
```java
public BigInteger(byte[] val,
                  int off,
                  int len)
```

### **sqrt**
```java
public BigInteger sqrt()
```
> 平方根を求めるメソッドが追加された
> #### Java8
> ※処理は[ここ](https://gist.github.com/JochemKuijpers/cd1ad9ec23d6d90959c549de5892d6cb)を参考に作成しました
> 
> ```java
> BigInteger number = BigInteger.valueOf(227529L);
> BigInteger a = BigInteger.ONE;
> BigInteger b = number.shiftRight(5).add(BigInteger.valueOf(8));
> while (b.compareTo(a) >= 0) {
>     BigInteger mid = a.add(b).shiftRight(1);
>     if (mid.multiply(mid).compareTo(n) > 0) {
>         b = mid.subtract(BigInteger.ONE);
>     } else {
>         a = mid.add(BigInteger.ONE);
>     }
> }
> BigInteger sqrtNumber = a.subtract(BigInteger.ONE);
> ```
>
> #### Java9
> ```java
> BigInteger number = BigInteger.valueOf(227529L);
> BigInteger sqrtNumber = number.sqrt();
> ```

### **sqrtAndRemainder**
```java
public BigInteger sqrtAndRemainder()
```
> 平方根とその余りを求めるメソッドが追加された
> #### Java8
> ```java
> BigInteger number = BigInteger.valueOf(228483L);
> BigInteger a = BigInteger.ONE;
> BigInteger b = number.shiftRight(5).add(BigInteger.valueOf(8));
> while (b.compareTo(a) >= 0) {
>     BigInteger mid = a.add(b).shiftRight(1);
>     if (mid.multiply(mid).compareTo(n) > 0) {
>         b = mid.subtract(BigInteger.ONE);
>     } else {
>         a = mid.add(BigInteger.ONE);
>     }
> }
> BigInteger sqrtNumber = a.subtract(BigInteger.ONE);
> BigInteger remainderNumber = number.subtract(sqrtNumber.multiply(sqrtNumber));
> ```
>
> #### Java9
> ```java
> BigInteger number = BigInteger.valueOf(228483L);
> BigInteger[] sqrtAndRemainderNumber = number.sqrtAndRemainder();
> BigInteger sqrtNumber = sqrtAndRemainderNumber[0];
> BigInteger remainderNumber = sqrtAndRemainderNumber[1];
> ```

## [BigDecimal](http://download.java.net/java/jdk9/docs/api/java/math/BigDecimal.html) の章
### **定数**
> #### `BigInteger.TWO` は追加されたが `BigDecimal.TWO` は追加されてない。
> 
> #### 丸めモードの定数が非推奨になった
> 以下の定数全てが[@Deprecated](http://download.java.net/java/jdk9/docs/api/java/lang/Deprecated.html)(since=“9”)となった。
> 
> |丸めモード|説明|
> |:-------|:--|
> |ROUND_CEILING    |**正**の無限大へ近づける|
> |ROUND_FLOOR      |**負**の無限大へ近づける|
> |ROUND_HALF_DOWN  |五捨六入|
> |ROUND_HALF_UP    |四捨五入|
> |ROUND_DOWN       |切り捨て|
> |ROUND_UP         |切り上げ|
> |ROUND_HALF_EVEN  |末尾を偶数にする|
> |ROUND_UNNECESSARY|丸めない|
> 上記に伴い上記を使用するdivideやsetScaleも非推奨となってます
> ~~([丸めモードのEnumは1.5から](http://docs.oracle.com/javase/1.5.0/docs/api/java/math/RoundingMode.html)存在するのだから早く削除すればいいのに……)~~

### **sqrt**
```java
public BigDecimal sqrt(MathContext mc)
```
> 平方根を求めるメソッドが追加された
> 
> #### Java8
> ※元の処理は[ここ](http://d.hatena.ne.jp/nowokay/20081122/1227328290)を参考に作成しました
> 
> ```java
> BigDecimal number = new BigDecimal(2);
> int scale = 34;
> 
> BigDecimal a = new BigDecimal(Math.sqrt(number.doubleValue()), MathContext.DECIMAL128);
> BigDecimal b = new BigDecimal(2);
> for(int tempScale = 16; tempScale < scale; tempScale *= 2) {
>     a = x.subtract(
>             a.multiply(a).subtract(number).divide(
>             a.multiply(b), scale, RoundingMode.HALF_EVEN));
> }
> sqrtNumber = a;
> ```
> #### Java9
> ```java
> BigDecimal number = new BigDecimal(2);
> BigDecimal sqrtNumber = number.sqrt();
> ```

# Package [java.time](http://download.java.net/java/jdk9/docs/api/java/time/package-summary.html) 編
Java8で追加されため、まだ浸透していない感じのするパッケージ
ところどころ [Joda-Time](http://www.joda.org/joda-time/) に似てる？

## [Clock](http://download.java.net/java/jdk9/docs/api/java/util/time/Clock.html) の章
### **tickMillis**
```java
public static Clock tickMillis(ZoneId zone)
```
> 1分ごとに変わる時計　tickMinutes(ZoneId zone) や
> 1秒ごとに変わる時計　tickSeconds(ZoneId zone) は以前から存在したが、
> 1ミリ秒ごとに変わる時計を作るメソッドが新たに追加された。
> #### Java8
> ```java
> Clock baseClock = Clock.system(ZoneId.of("Asia/Tokyo"));
> Clock millisClock = Clock.tick(baseClock, Duration.ofMillis(1));
> ```
> #### Java9
> ```java
> Clock millisClock = Clock.tickMillis(ZoneId.of("Asia/Tokyo"));
> ```

## [Duration](http://download.java.net/java/jdk9/docs/api/java/util/time/Duration.html) の章
### **dividedBy**
### **toSeconds**
### **toDaysPart**
### **toHoursPart**
### **toMinutesPart**
### **toSecondsPart**
### **toMillisPart**
### **toNanosPart**

## [LocalDate](http://download.java.net/java/jdk9/docs/api/java/util/time/LocalDate.html) の章
### **ofInstant**
### **datesUntil**
### **datesUntil**
### **toEpochSecond**

## [LocalTime](http://download.java.net/java/jdk9/docs/api/java/util/time/LocalTime.html) の章
### **ofInstant**
### **toEpochSecond**

## [OffsetTime](http://download.java.net/java/jdk9/docs/api/java/util/time/OffsetTime.html) の章
### **toEpochSecond**


# Package [java.util](http://download.java.net/java/jdk9/docs/api/java/util/package-summary.html) 編

## [Optional\<T\>](http://download.java.net/java/jdk9/docs/api/java/util/Optional.html) の章
### **ifPresentOrElse**
```java
public void ifPresentOrElse(Consumer<? super T> action,
                            Runnable emptyAction)
```
> isPresent()のTrue,False両方で処理を行いたい場合に便利になりました
> Java8でこのメソッドのようなことをしようと試行錯誤している記事で下記を見つけました。
[で、結局 Optional のインスタンスに対して ifNotPresent 的なことをやりたいときはどうしたらいいんですか？](http://qiita.com/mdstoy/items/e62eda1efad7d122f431) by @mdstoy さん
> #### Java8
> ```java
> public void hoge(Optional<String> optStr) {
>     if (optStr.isPresent()) {
>         Log.debug("Data is " + optStr.get());
>     } else {
>         Log.error("error");
>     }
> }
> ```
> #### Java9
> ```java
> public void hoge(Optional<String> optStr) {
>     optStr.ifPresentOrElse(
>             s  -> Log.debug("Data is " + s),
>             () -> Log.error("error"));
> }
> ```

### **stream**
```java
public Stream<T> stream()
```
> Optionalで包まれているコレクションからnullでないものだけを簡単に取り出せるようになった
> #### Java8
> ```java
> List<Optional<String>> list = new ArrayList<>();
> list.add(Optional.of("文字もじ"));
> list.add(Optional.empty());
> 
> List<String> nonNullList = list.stream()
>         .filter(s -> s.isPresent())
>         .map(s -> s.get())
>         .collect(Collectors.toList());
> ```
> #### Java9
> ```java
> List<Optional<String>> list = new ArrayList<>();
> list.add(Optional.of("文字もじ"));
> list.add(Optional.empty());
> 
> List<String> nonNullList = list.stream()
>         .flatMap(Optional::stream)
>         .collect(Collectors.toList());
> ```

### **or**
```java
public Optional<T> or(Supplier<Optional<T>> supplier)
```
> Optionalから取り出さずに処理を続けたい場合の処理が楽に書けるようになった
> #### Java8
> ```java
> Optional<String> base = Optional.of(null);
> Optional optStr;
> if (base.isPresent()) {
>     optStr = base;
> } else {
>     optStr = Optional.of("Empty");
> }
> ```
> #### Java9
> ```java
> Optional<String> base = Optional.of(null);
> Optional optStr = base.or(() -> Optional.of("Empty"));
> ```

## [Arrays](http://download.java.net/java/jdk9/docs/api/java/util/Arrays.html) の章
### **equals**
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

### **mismatch**
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

## [List\<E\>](http://download.java.net/java/jdk9/docs/api/java/util/List.html) の章
### **of**
```java
static <E> List<E> of()
static <E> List<E> of(E e1)
static <E> List<E> of(E e1, E e2)
...
static <E> List<E> of(E e1, E e2, E e4, E e5, E e6, E e7, E e8, E e9)
static <E> List<E> of(E e1, E e2, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
static <E> List<E> of(E... elements)
```
> イミュータブルなリストが簡単に作れる
> このメソッド既視感が・・・・・・ そうだ[Guava](https://github.com/google/guava)だ！
> #### Java8
> ```java
> // TODO:Listのelementのネタを考える
> public static final List<String> HOGE_LIST = Collections.unmodifiableList(
>         new ArrayList<String>() {
>             {
>                 add("hoge");
>                 add("fuga");
>                 add("piyo");
>             }
>         }
> );
> ```
> #### Java9
> ```java
> // TODO:Listのelementのネタを考える
> public static final List<String> HERO_COLOR = List.of("hoge", "fuga", "piyo");
> ```

## [Set\<E\>](http://download.java.net/java/jdk9/docs/api/java/util/Set.html) の章
### **of**
```java
static <E> Set<E> of()
static <E> Set<E> of(E e1)
static <E> Set<E> of(E e1, E e2)
...
static <E> Set<E> of(E e1, E e2, E e4, E e5, E e6, E e7, E e8, E e9)
static <E> Set<E> of(E e1, E e2, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
static <E> Set<E> of(E... elements)
```
> イミュータブルなセットが簡単に作れる
> #### Java8
> ```java
> public static final Set<String> HERO_COLOR = Collections.unmodifiableSet(
>         new HashSet<String>() {
>             {
>                 add("RED");
>                 add("BLUE");
>                 add("GREEN");
>                 add("YELLOW");
>                 add("PINK");
>             }
>         }
> );
> ```
> #### Java9
> ```java
> public static final Set<String> HERO_COLOR = Set.of("RED", "BLUE", "GREEN", "YELLOW", "PINK");
> ```

## [Map\<K,V\>](http://download.java.net/java/jdk9/docs/api/java/util/Map.html) の章
### **of**
```java
static <K,V> Map<K,V> of()
static <K,V> Map<K,V> of(K k1, V v1)
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2)
...
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5,  V v5,
                         K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5,  V v5,
                         K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
```
> イミュータブルなマップが簡単に作れる
> #### Java8
> ```java
> // TODO:Key-Valueのネタを考える
> public static final List<String> HERO_COLOR = 
> public static final Map<Integer, String> HOGE_MAP = Collections.unmodifiableMap(
>     new HashMap<Integer, String>() {
>         {
>             put(0, "hoge");
>             put(1, "fuga");
>             put(2, "piyo");
>         }
>     }
> );
> ```
> #### Java9
> ```java
> // TODO:Key-Valueのネタを考える
> Map<Integer, String> map = Map.of(
>         0, "hoge",
>         1, "fuga",
>         2, "piyo"
> );
> ```

### **ofEntries**
```java
static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

### **entry**
```java
static <K,V> Map.Entry<K,V> entry(K k,
                                  V v)
```
> #### Java8
> ```java
> Map.Entry<String, Integer> entry = new TreeMap<String, Integer>() {
>     {
>         put("A", 1000);
>     }
> }.firstEntry();
> ```
> #### Java9
> ```java
> Map.Entry<String, Integer> entry = Map.entry("A", 1000);
> ```

## [Objects](http://download.java.net/java/jdk9/docs/api/java/util/Objects.html) の章
### **requireNonNullElse**
### **requireNonNullElseGet**
### **requireNonNull**
### **checkIndex**
### **checkFromToIndex**
### **checkFromIndexSize**

## [Enumeration](http://download.java.net/java/jdk9/docs/api/java/util/Enumeration.html) の章
### **asIterator**


# Package [java.util.jar](http://download.java.net/java/jdk9/docs/api/java/util/package-summary.html) 編

## [JarFile](http://download.java.net/java/jdk9/docs/api/java/util/jar/JarFile.html) の章
### **JarFile**
### **getVersion**
### **isMultiRelease**


# Package [java.util.stream](http://download.java.net/java/jdk9/docs/api/java/stream/package-summary.html) 編

## [Stream\<T\>](http://download.java.net/java/jdk9/docs/api/java/util/stream/Stream.html) の章
以下の3つのメソッドについての投稿はすでにQiitaで投稿があったので詳しくは下記を参照ください。
[Java 9 Streamに追加された3つの新機能](http://qiita.com/k--kato/items/64967d2555f39aace608) by @k--katoさん
### **takeWhile**
```java
default Stream<T> takeWhile(Predicate<? super T> predicate)
```
> 先頭から指定された条件に一致している間のストリームを取得できるメソッド
> #### Java8
> ```java
> // TODO:動かないので後で直す
> List<String> list = Arrays.asList("ね", "こ", "か", "い", "た", "い", "ね");
> 
> boolean isTakeWhile = true;
> for (int str : list) {
>     isTakeWhile = isTakeWhile && !str.equals("か");
>     if (isTakeWhile) {
>         System.out.print(str);
>     }
> }
> ```
> #### Java9
> ```java
> List<String> list = Arrays.asList("ね", "こ", "か", "い", "た", "い", "ね");
> list.stream()
>         .takeWhile(s -> !s.equals("か"))
>         .forEach(System.out::print);
> ```

### **dropWhile**
```java
default Stream<T> dropWhile(Predicate<? super T> predicate)
```
> 先頭から指定された条件に一致している間のストリームを取り除いたストリームを取得できるメソッド
> #### Java8
> ```java
> List<String> list = Arrays.asList("ね", "こ", "か", "い", "た", "い", "ね");
>
> boolean isDropWhile = true;
> for (String str : list) {
>     isDropWhile = isDropWhile && !s.equals("か");
>     if (!isDropWhile) {
>         System.out.print(str);
>     }
> }
> ```
> #### Java9
> ```java
> List<String> list = Arrays.asList("ね", "こ", "か", "い", "た", "い", "ね");
> list.stream()
>         .dropWhile(s -> !s.equals("か"))
>         .forEach(System.out::print);
> ```

### **ofNullable**
```java
static <T> Stream<T> ofNullable(T t)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

## [Collectors](http://download.java.net/java/jdk9/docs/api/java/util/stream/Collectors.html) の章
### **flatMapping**
```java
static <T,U,A,R> Collector<T,?,R> flatMapping(Function<? super T,? extends Stream<? extends U>> mapper,
                                              Collector<? super U,A,R> downstream)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```

### **filtering**
```java
static <T,A,R> Collector<T,?,R> filtering(Predicate<? super T> predicate,
                                          Collector<? super T,A,R> downstream)
```
> #### Java8
> ```java
> // TODO:後で書く
> ```
> #### Java9
> ```java
> // TODO:後で書く
> ```