Java8的這些集合騷操做，你掌握了嘛？

時間  2020-12-20
標籤 html java 面試 編程 app 函數式編程 函數 學習 測試 欄目 Java 简体版
原文   原文鏈接

Java8時Lambda表達式的出現，將行爲做爲參數傳遞進函數的函數式編程，大大簡化了以前冗雜的寫法。html

對於集合一類，咱們來整理一下發生的變化吧。java

Java8的這些集合騷操做，你掌握了嘛？

 

Iterable的forEach

Iterable接口就是全部可迭代類型的父接口，咱們熟知的Collection接口就是繼承自它。Java8接口默認方法以及Lambda表達式的出現，讓咱們在遍歷元素時對元素進行操做變得格外簡單。面試

下面的forEach方法就是Java8新增的，它接受一個Consumer對象，是一個消費者類型的函數式接口。編程

default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

下面這段代碼遍歷輸出每一個元素。app

public void testForEach(){
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        list.forEach(System.out::println);
    }

Iterator的forEachRemaining

java.util.Iterator是用於遍歷集合的迭代器，接口定義以下：函數式編程

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

default方法是Java8接口中新增的，forEachRemaining方法接收一個Consumer，咱們能夠經過該方法簡化咱們的遍歷操做：函數

/** * Java8 爲Iterator新增了 forEachRemaining(Consumer action) 方法 */
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        Iterator<Integer> iterator = list.iterator();
        iterator.forEachRemaining(System.out::println);
    }

Collection的removeIf

Java8爲Collection增長了默認的removeIf方法，接收一個Predicate判斷，test方法結果爲true，就移除對應的元素。學習

default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            // 判斷元素是否須要被移除
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

下面這段代碼移除列表中的偶數元素。測試

public void testRemoveIf() {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        list.removeIf(x -> x % 2 == 0);
        list.forEach(System.out::println);
    }

Stream操做

具體使用能夠參照ui

public void testStream(){
        IntStream stream = IntStream.builder().add(1).add(2).add(3).build();
        int max = stream.max().getAsInt();
        System.out.println(max);
    }

List的replaceAll

Java8爲List接口增長了默認的replaceAll方法，須要UnaryOperator來替換全部集合元素，UnaryOperator是一個函數式接口。

default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

下面這個示例爲每一個元素加上3。

public void testReplaceAll(){
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        list.replaceAll(x -> x + 3);
        list.forEach(System.out::println);
    }

List的sort

Java8爲List接口增長了默認的sort方法，須要Comparator對象來控制元素排，咱們能夠傳入Lambda表達式。

default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

下面這個例子將list逆序。

public void testSort() {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        list.sort((x, y) -> y - x);
        System.out.println(list);
    }

Map的ForEach

Map接口在Java8一樣也新增了用於遍歷的方法：

default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

該方法接收一個二元的參數，分別對應key和value：

private void print(Map<Integer,String> map){
        map.forEach((x , y )-> {
            System.out.println("x -> " + x + ", y -> " + y);
        });
    }

爲了接下來測試方便，數據先準備一下：

Map<Integer, String> map = new HashMap<>();

    {
        map.put(1, "hello");
        map.put(2, "summer");
        map.put(3, "day");
        map.put(4, "tqbx");
    }

Map的remove

Java8新增了一個remove(Object key, Object value)方法。

default boolean remove(Object key, Object value) {
        // key存在且key對應的value確實是傳入的value才移除
        Object curValue = get(key);
        if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }

移除key爲3且value爲day的元素。

@Test public void testRemove(){
        map.remove(3,"day");
        print(map);
    }

Map的compute相關方法

Object compute(Object key, BiFunction remappingFunction)：該方法使用remappingFunction根據key-value對計算一個新value，狀況以下：

  • 只要新value不爲null，就使用新value覆蓋原value。
  • 若是原value不爲null，但新value爲null，則刪除原key-value對。
  • 若是原value、新value同時爲null那麼該方法不改變任何key-value對，直接返回null。

Object computeIfAbsent(Object key, Function mappingFunction)：

  • 若是傳給該方法的key參數在Map中對應的value爲null，則使用mappingFunction根據key計算個新的結果。
  • 若是計算結果不爲null，則用計算結果覆蓋原有的value。
  • 若是原Map原來不包括該key，那麼該方法可能會添加一組key-value對。

Object computeIfPresent(Object key, BiFunction remappingFunction)：

  • 若是傳給該方法的key參數Map中對應的value不爲null，該方法將使用remappingFunction根據原key、value計算一個新的結果。
  • 若是計算結果不爲null，則使用該結果覆蓋原來的value。
  • 若是計算結果爲null，則刪除原key-value對。
@Test
    public void testCompute() {
        //key==2 對應的value存在時，使用計算的結果做爲新value
        map.computeIfPresent(2, (k, v) -> v.toUpperCase());
        print(map);

        //key==6 對應的value爲null (或不存在)時，使用計算的結果做爲新value
        map.computeIfAbsent(6, (k) -> k + "haha");
        print(map);
    }

Map的getOrDefault

default V getOrDefault(Object key, V defaultValue) {
        V v;
        // key存在或 value存在，則返回對應的value，不然返回defaultValue
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }
@Test public void testGetOrDefault(){
        // 獲取指定key的value，若是該key不存在，則返回default
        String value = map.getOrDefault(5, "若是沒有key==5的value,就返回這條信息");
        System.out.println(value);
    }

Map的merge

default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        // 先獲取原值
        V oldValue = get(key);
        // 原值爲null，新值則爲傳入的value，不爲null，則使用function計算，獲得新值
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        // 新值若是爲null，則移除原key-value對
        if(newValue == null) {
            remove(key);
        } else {
            // 不爲null，則替換之
            put(key, newValue);
        }
        // 返回新值
        return newValue;
    }
@Test public void testMerge(){
        // key爲2 的值 加上 +add
        map.merge(2," + add",(oldval, newVal) -> oldval + newVal);
        print(map);
    }

Map的putIfAbsent

default V putIfAbsent(K key, V value) {
        // 獲得原值
        V v = get(key);
        // 原值爲null，則替換新值
        if (v == null) {
            v = put(key, value);
        }
		// 返回原值
        return v;
    }
@Test
    public void testPutIfAbsent(){
        // key = 10 對應的value不存在， 則用101010 覆蓋
        String s1 = map.putIfAbsent(10, "101010");
        System.out.println(s1);
        print(map);
        System.out.println("============================");
        // key = 2 對應的value存在且爲summer，返回summer
        String s2 = map.putIfAbsent(2, "2222");
        System.out.println(s2);
        print(map);
    }

輸出結果

null
x -> 1, y -> hello
x -> 2, y -> summer
x -> 3, y -> day
x -> 4, y -> tqbx
x -> 10, y -> 101010
============================
summer
x -> 1, y -> hello
x -> 2, y -> summer
x -> 3, y -> day
x -> 4, y -> tqbx
x -> 10, y -> 101010

Map的replace相關方法

@Test
    public void testReplace(){
        //boolean 將指定的 1 -> hello 鍵值對的value替換爲hi
        map.replace(1,"hello","hi");
        print(map);
        System.out.println("============================");
        //V 指定key對應的value替換成新value
        map.replace(2,"天喬巴夏");
        print(map);
        System.out.println("============================");
        //void 對全部的key和value 進行計算，填入value中
        map.replaceAll((k,v)-> k + "-" + v.toUpperCase());
        print(map);
    }

輸出結果：

 

x -> 1, y -> hi
x -> 2, y -> summer
x -> 3, y -> day
x -> 4, y -> tqbx
============================
x -> 1, y -> hi
x -> 2, y -> 天喬巴夏
x -> 3, y -> day
x -> 4, y -> tqbx
============================
x -> 1, y -> 1-HI
x -> 2, y -> 2-天喬巴夏
x -> 3, y -> 3-DAY
x -> 4, y -> 4-TQBX

原文：https://www.cnblogs.com/summerday152/p/14129448.html

若是以爲本文對你有幫助，能夠關注一下我公衆號，回覆關鍵字【面試】便可獲得一份Java核心知識點整理與一份面試大禮包！另有更多技術乾貨文章以及相關資料共享，你們一塊兒學習進步！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程