</tr>
                                        <tr>
                                            <th><la:message key="labels.user_street"/></th>
                                            <td>${f:h(attributes.street)}<la:hidden property="attributes.street"/></td>
                                        </tr>
                                        <tr>

    }

    public static class StreamOf<T> {

        private final Supplier<Stream<T>> supplier;

        public StreamOf(final Supplier<Stream<T>> supplier) {
            this.supplier = supplier;
        }

        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);

                            }
                        });
                        final List<String> newGroupList = stream(user.getGroupNames()).get(stream -> stream.collect(Collectors.toList()));
                        stream(user.getGroupNames()).of(stream -> stream.forEach(name -> {
                            if (oldGroupList.contains(name)) {
                                oldGroupList.remove(name);

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.labeltype;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

            }
        }
        form.fields.entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> {
            final String key = LaFunctions.u(e.getKey());
            stream(e.getValue()).of(stream -> stream.filter(StringUtil::isNotBlank)
                    .forEach(s -> pagingQueryList.add("fields." + key + "=" + LaFunctions.u(s))));
        });
        form.as.entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> {

        body.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                .filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
        body.virtualHosts = stream(entity.getVirtualHosts())
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).collect(Collectors.joining("\n")));

        byte[] content;
        try ( ASN1InputStream stream = new ASN1InputStream(token) ) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        }catch ( IOException e ) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

        try ( ASN1InputStream stream = new ASN1InputStream(content) ) {

        if (values == null || values.length == 0) {
            return true;
        }
        return stream(values).get(stream -> stream.allMatch(StringUtil::isBlank));
    }

    protected static String[] simplifyArray(final String[] values) {
        return stream(values).get(stream -> stream.filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;

        }
        final float importantContantLangBoost = fessConfig.getQueryBoostImportantContentLangAsDecimal().floatValue();
        getQueryLanguages().ifPresent(langs -> stream(langs).of(stream -> stream.forEach(lang -> {
            boolQuery.should(
                    builder.apply(fessConfig.getIndexFieldTitle() + "_" + lang, fessConfig.getQueryBoostTitleLangAsDecimal().floatValue()));