* <p>
     * Usage example:
     * </p>
     *
     * <pre>
     * StringUtil.defaultString(null, "NULL")  = "NULL"
     * StringUtil.defaultString("", "NULL")    = ""
     * StringUtil.defaultString("aaa", "NULL") = "aaa"
     * StringUtil.defaultString("aaa", null)   = "aaa"
     * StringUtil.defaultString(null, null)    = null
     * </pre>
     *
     * @param str

 * Contains helper methods for string operations, including backported JDK functionality
 * for compatibility with older Java versions.
 */
public final class StringUtil {

    /**
     *
     */
    private StringUtil() {
    }

    /**
     * Implementation of {@link java.lang.String#join} backported for JDK7.
     *
     * @param delimiter the separator to use between elements

            if (StringUtil.isBlank(value)) {
                map = Collections.emptyMap();
            } else {
                final Set<String> keySet = new HashSet<>();
                map = split(value, "\n").get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> {
                    final String[] pair = s.split("=");
                    if (pair.length == 1) {
                        return new Pair<>(StringUtil.EMPTY, pair[0].trim());

import org.junit.jupiter.params.provider.ValueSource;

/**
 * Test class for StringUtil utility methods
 */
class StringUtilTest {

    @Test
    @DisplayName("Should join single element without delimiter")
    void testJoinSingleElement() {
        String result = StringUtil.join(",", "hello");
        assertEquals("hello", result);
    }

    @Test

                .ifPresent(s -> entry.put(new BasicAttribute(fessConfig.getLdapAttrTelephoneNumber(), s)));
        OptionalUtil.ofNullable(user.getHomePhone())
                .filter(StringUtil::isNotBlank)
                .ifPresent(s -> entry.put(new BasicAttribute(fessConfig.getLdapAttrHomePhone(), s)));
        OptionalUtil.ofNullable(user.getHomePostalAddress())
                .filter(StringUtil::isNotBlank)

            credentials = new NTCredentials(username, password == null ? StringUtil.EMPTY : password,
                    workstation == null ? StringUtil.EMPTY : workstation, domain == null ? StringUtil.EMPTY : domain);
        } else {
            credentials = new UsernamePasswordCredentials(username, password == null ? StringUtil.EMPTY : password);
        }
        return credentials;
    }

                return pagingQueryList.stream()
                        .filter(s -> prefix == null || !s.startsWith(prefix))
                        .collect(Collectors.joining("&", "&", StringUtil.EMPTY));
            }
            return null;
        }).orElse(StringUtil.EMPTY);
    }

    /**
     * Generates URL query parameters for facet filtering.
     *
     * @return URL-encoded query string containing facet parameters

     */
    public static String decodePath(final String id) {
        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getPath()) && StringUtil.isEmpty(pi.getName())) {
            return StringUtil.EMPTY;
        }
        if (StringUtil.isEmpty(pi.getPath())) {
            return pi.getName();
        }
        return pi.getPath() + "/" + pi.getName();
    }

    /**

        final StringBuilder queryBuf = new StringBuilder(255);

        final String query = buildBaseQuery();
        if (StringUtil.isNotBlank(query)) {
            queryBuf.append(escapeQuery(query));
        }

        stream(params.getExtraQueries())
                .of(stream -> stream.filter(q -> StringUtil.isNotBlank(q) && q.length() <= maxQueryLength).forEach(q -> {
                    appendQuery(queryBuf, q);
                }));

                            .filter(StringUtil::isNotBlank)
                            .distinct()
                            .collect(Collectors.joining("\n")));
                    form.virtualHosts = stream(entity.getVirtualHosts())
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining("\n")));