Crates new {@link Predicate} with trailing wildcard for each entry

@param values
@return
@throws InvalidDataAccessApiUsageException for strings with whitespace
762052
public Criteria startsWith(Iterable<String> values) {
		Assert.notNull(values, "Collection must not be null");
		for (String value : values) {
			startsWith(value);
		}
		return this;
	}
1342747
public static Query withStringsIgnoreCase(String field, String[] values) {
        return Query.withStrings(field, values, true);
    }
1193658
protected String randomValue(List<String> values) {
		if (values == null || values.isEmpty()) {
			throw new InvalidFunctionUsageException("No values to choose from");
		}
		
		final int idx = random.nextInt(values.size());
		
		return values.get(idx);
	}
294986
public static boolean areNotEmpty(String... values) {
		boolean result = true;
		if (values == null || values.length == 0) {
			result = false;
		} else {
			for (String value : values) {
				result &= !isEmpty(value);
			}
		}
		return result;
	}
1276359
public static <T extends Enum<T>> String[] enumNameToStringArray(T[] values) {

        int i = 0;
        String[] result = new String[values.length];
        for (T value : values) {
            result[i++] = value.name();
        }
        return result;
    }
1020512
public FilterValues<S> with(char value) {
        PropertyFilterList<S> current = currentProperty();
        Object obj;
        try {
            obj = current.getPropertyFilter().adaptValue(value);
        } catch (IllegalArgumentException e) {
            throw mismatch(e);
        }
        return with(current, obj);
    }
491464
public void setParamTabExFileEntries(String value) {

        try {
            m_userSettings.setExplorerFileEntries(Integer.parseInt(value));
        } catch (Throwable t) {
            // should usually never happen
        }
    }
91621
public void extractValues(HashMap<String, String> values) {
        for (MultipleSyntaxElements l : childContainers) {
            l.extractValues(values);
        }
    }
756496
protected void doSetAllValues( Map<? extends String, ?> values ) {
        if (values != null) {
            document.putAll(Utility.unwrapValues(values));
        }
    }
1199450
private static String filterValue(String value) 
            throws IOException {
        InternalStringBuilder result = new InternalStringBuilder(value.length());
        
        for (int i = 0; i < value.length(); ++i) {
            char c = value.charAt(i);
            switch (c) {
                case '<':
                    result.append("&lt;");
                    break;
                case '>':
                    result.append("&gt;");
                    break;
                case '&':
                    result.append("&amp;");
                    break;
                default:
                    result.append(c);
            }
        }
        
        return result.toString();
    }
44406
private static List<String> resolveValues(final Iterable<? extends String> values) {
        final List<String> valuesList = new ArrayList<String>();

        for(final String value : values) {
            Validate.notNull(value, "One of the specified values was null");
            valuesList.add(value);
        }

        return valuesList;
    }
242202
public static String[] removeEmpties(final String... values) {
		if (values == null || values.length == 0){
			return new String[0];
		}
		List<String> validValues = new ArrayList<String>();
		for (String value : values){
			if (value != null && value.length() > 0){
				validValues.add(value);
			}
		}
		return validValues.toArray(new String[validValues.size()]);
	}
866033
private static function MaybeThrowIfValueDoesNotMatchMultiTypedArrayValueArray(
        bool $autoTrimStrings,
        bool $throwIfNotUnique,
        array $value,
        string ...$types
    ) : array {
        $value = static::MaybeThrowIfNotArrayIntKeys($value);
        $value = static::MaybeThrowIfValueArrayDoesNotMatchTypes($value, ...$types);

        /**
        * @var (scalar|array|object|null)[]
        */
        $value = static::MaybeRemapStringsToTrimmedStrings($value, $autoTrimStrings, ...$types);

        $initialCount = count($value);

        /**
        * @var array<int, scalar|array|object|null>
        */
        $out = [];

        foreach ($value as $maybe) {
            if ( ! in_array($maybe, $out, true)) {
                $out[] = $maybe;
            }
        }

        if ($throwIfNotUnique && count($out) !== $initialCount) {
            throw new InvalidArgumentException(
                'Argument 3 passed to ' .
                __METHOD__ .
                ' contained non-unique values!'
            );
        }

        return $out;
    }
207285
public void addItems(String values) throws Exception {
        for (String line : values.split("[\\r\\n]")) {
            String[] pcs = line.split("\\=", 2);

            if (pcs.length == 2) {
                setItem(pcs[0], pcs[1]);
            }
        }
    }
449002
public static Set<String> parseParameterList(String values) {
		Set<String> result = new TreeSet<String>();
		if (values != null && values.trim().length() > 0) {
			// the spec says the scope is separated by spaces
			String[] tokens = values.split("[\\s+]");
			result.addAll(Arrays.asList(tokens));
		}
		return result;
	}
648569
@SafeVarargs
    public static <T> Set<T> newSets(T... values) {
        if(null == values || values.length == 0){
            Assert.notNull(values, "values not is null.");
        }
        return new HashSet<>(Arrays.asList(values));
    }
323293
public AnnotationValueBuilder<T> values(@Nullable String... strings) {
        return member(AnnotationMetadata.VALUE_MEMBER, strings);
    }