All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.hudi.common.util.CollectionUtils Maven / Gradle / Ivy

There is a newer version: 1.0.0-beta2
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.hudi.common.util;

import org.apache.hudi.common.util.collection.Pair;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import static org.apache.hudi.common.util.ValidationUtils.checkArgument;

/**
 * Utils for Java Collection.
 */
public class CollectionUtils {

  private static final Properties EMPTY_PROPERTIES = new Properties();

  /**
   * Returns an empty {@code Properties} instance. The props instance is a singleton,
   * it should not be modified in any case.
   */
  public static Properties emptyProps() {
    return EMPTY_PROPERTIES;
  }

  public static boolean isNullOrEmpty(Collection c) {
    return Objects.isNull(c) || c.isEmpty();
  }

  public static boolean isNullOrEmpty(Map m) {
    return Objects.isNull(m) || m.isEmpty();
  }

  public static boolean nonEmpty(Collection c) {
    return !isNullOrEmpty(c);
  }

  /**
   * Reduces provided {@link Collection} using provided {@code reducer} applied to
   * every element of the collection like following
   *
   * {@code reduce(reduce(reduce(identity, e1), e2), ...)}
   *
   * @param c target collection to be reduced
   * @param identity element for reducing to start from
   * @param reducer actual reducing operator
   *
   * @return result of the reduction of the collection using reducing operator
   */
  public static  U reduce(Collection c, U identity, BiFunction reducer) {
    return c.stream()
        .sequential()
        .reduce(identity, reducer, (a, b) -> {
          throw new UnsupportedOperationException();
        });
  }

  /**
   * Makes a copy of provided {@link Properties} object
   */
  public static Properties copy(Properties props) {
    Properties copy = new Properties();
    copy.putAll(props);
    return copy;
  }

  /**
   * Returns last element of the array of {@code T}
   */
  public static  T tail(T[] ts) {
    checkArgument(ts.length > 0);
    return ts[ts.length - 1];
  }

  /**
   * Collects provided {@link Iterator} to a {@link Stream}
   */
  public static  Stream toStream(Iterator iterator) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED),
        false
    );
  }

  /**
   * Combines provided arrays into one
   */
  @SuppressWarnings("unchecked")
  public static  T[] combine(T[] one, T[] another) {
    T[] combined = (T[]) Array.newInstance(one.getClass().getComponentType(), one.length + another.length);
    System.arraycopy(one, 0, combined, 0, one.length);
    System.arraycopy(another, 0, combined, one.length, another.length);
    return combined;
  }

  /**
   * Combines provided array and an element into a new array
   */
  @SuppressWarnings("unchecked")
  public static  T[] append(T[] array, T elem) {
    T[] combined = (T[]) Array.newInstance(array.getClass().getComponentType(), array.length + 1);
    System.arraycopy(array, 0, combined, 0, array.length);
    combined[array.length] = elem;
    return combined;
  }

  /**
   * Combines provided {@link List}s into one, returning new instance of {@link ArrayList}
   */
  public static  List combine(List one, List another) {
    ArrayList combined = new ArrayList<>(one.size() + another.size());
    combined.addAll(one);
    combined.addAll(another);
    return combined;
  }

  /**
   * Combines provided {@link Map}s into one, returning new instance of {@link HashMap}.
   *
   * NOTE: That values associated with overlapping keys from the second map, will override
   *       values from the first one
   */
  public static  HashMap combine(Map one, Map another) {
    HashMap combined = new HashMap<>(one.size() + another.size());
    combined.putAll(one);
    combined.putAll(another);
    return combined;
  }

  /**
   * Combines provided {@link Map}s into one, returning new instance of {@link HashMap}.
   *
   * NOTE: That values associated with overlapping keys from the second map, will override
   *       values from the first one
   */
  public static  HashMap combine(Map one, Map another, BiFunction merge) {
    HashMap combined = new HashMap<>(one.size() + another.size());
    combined.putAll(one);
    another.forEach((k, v) -> combined.merge(k, v, merge));
    return combined;
  }

  /**
   * Zip two lists into a Map. Will throw Exception if the size is different between these two lists.
   */
  public static  Map zipToMap(List keys, List values) {
    checkArgument(keys.size() == values.size(),
        "keys' size must be equal with the values' size");
    return IntStream.range(0, keys.size()).boxed().collect(Collectors.toMap(keys::get, values::get));
  }

  /**
   * Returns difference b/w {@code one} {@link Collection} of elements and {@code another}
   * The elements in collection {@code one} are also duplicated and returned as a {@link Set}.
   */
  public static  Set diffSet(Collection one, Set another) {
    Set diff = new HashSet<>(one);
    diff.removeAll(another);
    return diff;
  }

  /**
   * Returns difference b/w {@code one} {@link List} of elements and {@code another}
   *
   * NOTE: This is less optimal counterpart to {@link #diff(Collection, Collection)}, accepting {@link List}
   *       as a holding collection to support duplicate elements use-cases
   */
  public static  List diff(Collection one, Collection another) {
    List diff = new ArrayList<>(one);
    diff.removeAll(another);
    return diff;
  }

  public static  Stream> batchesAsStream(List list, int batchSize) {
    checkArgument(batchSize > 0, "batch size must be positive.");
    int total = list.size();
    if (total <= 0) {
      return Stream.empty();
    }
    int numFullBatches = (total - 1) / batchSize;
    return IntStream.range(0, numFullBatches + 1).mapToObj(
        n -> list.subList(n * batchSize, n == numFullBatches ? total : (n + 1) * batchSize));
  }

  public static  List> batches(List list, int batchSize) {
    return batchesAsStream(list, batchSize).collect(Collectors.toList());
  }

  /**
   * Determines whether two iterators contain equal elements in the same order. More specifically,
   * this method returns {@code true} if {@code iterator1} and {@code iterator2} contain the same
   * number of elements and every element of {@code iterator1} is equal to the corresponding element
   * of {@code iterator2}.
   *
   * 

Note that this will modify the supplied iterators, since they will have been advanced some * number of elements forward. */ public static boolean elementsEqual(Iterator iterator1, Iterator iterator2) { while (iterator1.hasNext()) { if (!iterator2.hasNext()) { return false; } Object o1 = iterator1.next(); Object o2 = iterator2.next(); if (!Objects.equals(o1, o2)) { return false; } } return !iterator2.hasNext(); } @SafeVarargs public static List createImmutableList(final T... elements) { return Collections.unmodifiableList(Stream.of(elements).collect(Collectors.toList())); } public static List createImmutableList(final List list) { return Collections.unmodifiableList(list); } @SafeVarargs public static Map createImmutableMap(final Pair... elements) { Map map = new HashMap<>(); for (Pair pair : elements) { map.put(pair.getLeft(), pair.getRight()); } return Collections.unmodifiableMap(map); } public static Map createImmutableMap(final Map map) { return Collections.unmodifiableMap(map); } @SafeVarargs public static Set createSet(final T... elements) { return Stream.of(elements).collect(Collectors.toSet()); } @SafeVarargs public static Set createImmutableSet(final T... elements) { return Collections.unmodifiableSet(createSet(elements)); } public static Set createImmutableSet(final Set set) { return Collections.unmodifiableSet(set); } private static Object[] checkElementsNotNull(Object... array) { return checkElementsNotNull(array, array.length); } private static Object[] checkElementsNotNull(Object[] array, int length) { for (int i = 0; i < length; i++) { checkElementNotNull(array[i], i); } return array; } private static Object checkElementNotNull(Object element, int index) { return Objects.requireNonNull(element, "Element is null at index " + index); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy