* @return the environment variable value, or the default value if not found
     */
    public static String getEnv(String key, String defaultValue) {
        return System.getenv().getOrDefault(key, defaultValue);
    }

    /**
     * Returns the current time in milliseconds.
     *
     * @return the current time in milliseconds
     */
    public static long currentTimeMillis() {

     * @return List of keywords for the default field, or empty list if none.
     */
    public List<String> getDefaultKeyword() {
        if (fieldLogMap != null) {
            return fieldLogMap.getOrDefault(Constants.DEFAULT_FIELD, Collections.emptyList());
        }
        return Collections.emptyList();
    }

    /**
     * Adds a query term to the highlighted query set.

        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getSystemProperty(final String key, final String defaultValue) {
                return systemPropMap.getOrDefault(key, defaultValue);
            }
        };
        ComponentUtil.setFessConfig(fessConfig);
        SystemHelper systemHelper = new SystemHelper() {
            @Override

        }
      }
      return 0;
    }

    @Override
    public int add(E element, int occurrences) {
      checkArgument(occurrences >= 0);
      Integer frequency = backingMap.getOrDefault(element, 0);
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);

     *
     * - a `getFooOrDefault(@Nullable Foo defaultValue)` method that returns
     *   `map.getOrDefault(FOO_KEY, defaultValue)`
     *
     * - a call that consults a chain of maps, as in `mapA.getOrDefault(key, mapB.getOrDefault(key,
     *   ...))`
     *
     * So it makes sense for the parameter (and thus the return type) to be @Nullable.
     *

   *
   * <p>Prefer to write the lambda expression {@code k -> map.getOrDefault(k, defaultValue)}
   * instead. Note that it is not serializable unless you explicitly make it {@link Serializable},
   * typically by writing {@code (Function<K, V> & Serializable) k -> map.getOrDefault(k,
   * defaultValue)}.
   *
   * @param map source map that determines the function behavior

            throw new IllegalStateException("Unable to retrieve current key for rotation");
        }

        try {
            // Generate new key version
            int currentVersion = keyVersions.getOrDefault(sessionId, 0);
            int newVersion = currentVersion + 1;

            // Derive new key from current key
            String rotationLabel = String.format("KeyRotation-v%d", newVersion);

     *
     * @param handle notification handle
     * @return number of consecutive failures
     */
    private int getFailureCount(ChangeNotificationHandle handle) {
        return failureCounts.getOrDefault(handle.getDirectoryPath(), 0);
    }

    /**
     * Increment failure count for a handle
     *
     * @param handle notification handle
     */

      mediaType.parsedCharset = this.parsedCharset;
    }
    // Return one of the constants if the media type is a known type.
    @SuppressWarnings("GetOrDefaultNotNull") // getOrDefault requires API Level 24
    MediaType result = firstNonNull(knownTypes.get(mediaType), mediaType);
    return result;
  }

  /**

    return result;
  }

  /**
   * Returns the value associated with {@code key}, or zero if there is no value associated with
   * {@code key}.
   */
  public long get(K key) {
    return map.getOrDefault(key, 0L);
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the new value.
   */
  @CanIgnoreReturnValue
  public long incrementAndGet(K key) {