Java 类java.util.StringJoiner 实例源码

/**
 * Creates a resolved classifier reference. This means a classifier with a valid uri of its declaration.
 *
 * @param qualifiedName
 *            QualifiedName of the classifier
 * @param uri
 *            Platform uri of the classifier declaration
 */
public ClassifierReference(QualifiedName qualifiedName, URI uri) {
    this.classifierName = qualifiedName.getLastSegment();
    List<String> frontSegments = qualifiedName.getSegments();
    if (frontSegments.size() > 0) {
        StringJoiner joiner = new StringJoiner(N4JSQualifiedNameConverter.DELIMITER);
        for (String segment : frontSegments.subList(0, frontSegments.size() - 1)) {
            joiner.add(segment);
        }
        this.classifierModuleSpecifier = joiner.toString();
    } else {
        this.classifierModuleSpecifier = "";
    }
    this.uri = uri;

}

private static void collectData(DataSeries parentSeries, StackNode parentNode, float baseHeight, float baseWidth,
        StringJoiner sj, IndentLevel indent) {

    if (parentSeries.hasNoChildren())
        return;

    indent.increase();

    Long siblingSum = parentSeries.getChildren().map(s -> s.sum).max(Long::compare).get();
    parentSeries.getChildren().forEach(series -> {
        sj.add(indent.get() + SimpleTimeFormat.convert(series.sum) + " - " + series.name);
        float parentScale = (float) series.sum / parentSeries.sum;
        float siblingScale = (float) series.sum / siblingSum;
        StackNode node = new StackNode(series.name,
                series.name + " took " + SimpleTimeFormat.convert(series.sum),
                parentNode.width * parentScale, baseHeight, parentScale, siblingScale);

        parentNode.addChild(node);
        collectData(series, node, baseHeight, baseWidth, sj, indent);
    });

    indent.decrease();
}

@WithCommand
public void run(CommandSender sender, @WithName("plugin") @WithOptional Plugin plugin) {
    Collection<String> scriptNames;
    if (plugin != null) {
        ScriptRegistry reg = (ScriptRegistry) scripts().get(plugin);
        scriptNames = reg.getEntries().keySet();
    } else
        scriptNames = scripts().getEntries().keySet();
    StringJoiner str = new StringJoiner(GRAY + ", ");
    for (String name : scriptNames)
        str.add(AQUA + name);
    if (scriptNames.size() > 0)
        sender.sendMessage(GOLD + "Showing " + scriptNames.size() + " scripts: " + str.toString());
    else
        sender.sendMessage(RED + "No script found.");
}

public void addAlladdAll() {
    StringJoiner sj = new StringJoiner(DASH, "{", "}");
    ArrayList<String> firstOne = new ArrayList<>();
    firstOne.add(ONE);
    firstOne.add(TWO);
    firstOne.add(THREE);
    firstOne.stream().forEachOrdered(sj::add);

    ArrayList<String> nextOne = new ArrayList<>();
    nextOne.add(FOUR);
    nextOne.add(FIVE);
    nextOne.stream().forEachOrdered(sj::add);

    String expected = "{"+ONE+DASH+TWO+DASH+THREE+DASH+FOUR+DASH+FIVE+"}";
    assertEquals(sj.toString(), expected);
}

/**
 * extractDir parses the input path for wild card characters.
 *
 * @param path String folder path to search
 * @return String up to the wild card character
 */
static String extractDir(String path) {
    String[] parts = path.split(DIR_EXTRACTION);

    StringJoiner dirPath = new StringJoiner(fileSystem.getSeparator());
    for (String part : parts) {
        // append until a wild card
        if (part.contains("*")) { // append until a wild card
            break;
        }
        dirPath.add(part);
    }
    if (dirPath.length() == 0) { // if no path then use the current dir
        return ".";
    }

    return dirPath.toString();
}

private String generateString() {
    Long pid = fPid;
    Long tid = fTid;

    StringBuilder sb = new StringBuilder();
    if (fName != null) {
        sb.append(fName);
    }

    if (pid != null || tid != null) {
        sb.append(' ');
        StringJoiner sj = new StringJoiner(", ", "(", ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        if (pid != null) {
            sj.add("pid=" + pid.toString()); //$NON-NLS-1$
        }
        if (tid != null) {
            sj.add("tid=" + tid.toString()); //$NON-NLS-1$
        }
        sb.append(sj.toString());
    }

    return sb.toString();
}

private void refreshPdeFileImportPreview() {
    if (! getParameters().importablePdeFiles.isEmpty()) {
        filesDetectedLabel.setForeground(JBColor.BLACK);
        filesDetectedLabel.setText(getParameters().importablePdeFiles.size() + " PDE files");

        StringJoiner importablePdeFilePaths = new StringJoiner("\n");

        for (VirtualFile importablePdeFile : getParameters().importablePdeFiles) {
            importablePdeFilePaths.add(importablePdeFile.getPath());
        }

        importableClassesListTextArea.setText(importablePdeFilePaths.toString());
    } else {
        importableClassesListTextArea.setText("No sketch classes were found at this root directory.");
        filesDetectedLabel.setText("0 PDE files");
        filesDetectedLabel.setForeground(JBColor.RED);
    }
}

public WebServer(URI endpoint) throws IOException {
  this.server = GrizzlyServerFactory.createHttpServer(endpoint, new HttpHandler() {

    @Override
    public void service(Request rqst, Response rspns) throws Exception {
      rspns.setStatus(HttpStatus.NOT_FOUND_404.getStatusCode(), "Not found");
      rspns.getWriter().write("404: not found");
    }
  });

  WebappContext context = new WebappContext("WebappContext", BASE_PATH);
  ServletRegistration registration = context.addServlet("ServletContainer", ServletContainer.class);
  registration.setInitParameter(ServletContainer.RESOURCE_CONFIG_CLASS,
      PackagesResourceConfig.class.getName());

  StringJoiner sj = new StringJoiner(",");
  for (String s : PACKAGES) {
    sj.add(s);
  }

  registration.setInitParameter(PackagesResourceConfig.PROPERTY_PACKAGES, sj.toString());
  registration.addMapping(BASE_PATH);
  context.deploy(server);
}

private String[] unnumbered(String actual[])
{
    for (int i = actual.length-1; i >= 0; i--)
    {
        StringJoiner sj = new StringJoiner("\n");
        String[] bits = actual[i].split("\n");
        for (String bit: bits)
        {
            Pattern p = Pattern.compile("^[0-9.]*");
            Matcher m = p.matcher(bit);
            bit = m.replaceFirst("0");
            sj.add(bit);
        }
        actual[i] = sj.toString();
    }
    return actual;
}

public static void print(Map<String,Method> methods) throws Exception {
    methods.forEach((n,m)->{

        Class<?> returnType = m.getReturnType();
        Class<?>[] params = m.getParameterTypes();
        System.out.printf("%-40s ", m.getName());

        // Only string, boolean, long, int double
        //if ( returnType )

        System.out.print(returnType.getSimpleName());

        System.out.print(" <- ");
        StringJoiner sj = new StringJoiner(" ,", "(",")");
        for (Class<?>p : params ) {
            sj.add(p.getSimpleName());
        }
        System.out.print(sj.toString());
        System.out.println();
    });
}

private String getConstructorLine() {
    StringBuilder resultBuilder = new StringBuilder();
    resultBuilder
            .append("public ")
            .append(sourceClass.getName())
            .append("(");
    StringJoiner constructorParams = new StringJoiner(", ");
    variables.stream().forEach(variable -> {
        String name = variable.getName().getValue();
        constructorParams.add(determinClassName(variable) + " " + name);
    });
    resultBuilder.append(constructorParams.toString());
    resultBuilder.append(
            ") {");
    return resultBuilder.toString();
}

/**
 * Returns a text containing all robots currently located in the given node.
 */
@Override
public String nodeToString(final ITreeNode node) {
    ITreeNode nodeToStringify = node;
    // Use an alias if set
    if (this.mOriginalToAlias != null) {
        final ITreeNode alias = this.mOriginalToAlias.get(node);
        if (alias != null) {
            nodeToStringify = alias;
        }
    }

    final StringJoiner joiner = new StringJoiner(", ", "{", "}");
    final SortedSet<Robot> robotsAtNode = this.mNodeToRobots.get(nodeToStringify);
    if (robotsAtNode != null) {
        for (final Robot robot : robotsAtNode) {
            joiner.add(Integer.toString(robot.getId()));
        }
    }
    return joiner.toString();
}

@Override
public void setBeanName(ScanAtom bean) {
    StringJoiner name = new StringJoiner(" ");
    name.add("Scan of");

    ScanRequest<?> scanReq = bean.getScanReq();
    StringJoiner paths = new StringJoiner(", ");
    for (Object pathModel : scanReq.getCompoundModel().getModels()) {
        for (String pathName : pathAssemblerRegister.keySet()) {
            if (pathModel.getClass().getSimpleName().toLowerCase().startsWith(pathName)) {
                paths.add(pathAssemblerRegister.get(pathName).getString(pathModel));
            }
        }
    }
    name.add(paths.toString());
    name.add("collecting data with");
    name.add(scanReq.getDetectors().keySet().stream().map(detName -> "'"+detName+"'").collect(Collectors.joining(", ")));
    name.add("detector(s)");

    bean.setName(name.toString());
}

/**
 * Sets headers so that the response is never cached.
 * @param response the response on which to set the headers.
 * @throws NullPointerException if the argument is {@code null}. 
 */
public static void doNotCache(HttpServletResponse response) {
    requireNonNull(response, "response");

    response.setHeader(CacheControl, new StringJoiner(", ")
                                    .add(NoStore)
                                    .add(NoCache)
                                    .add(MustRevalidate)
                                    .toString());
    response.setHeader(Pragma, NoCache);
    response.setIntHeader(Expires, 0);
}

/**
 * Calculates the server classpath, which is a colon-delimited string of directories and .jar files.
 * @param baseLibDir    The base directory of server libs and classes
 * @return The classpath
 */
private static String calculateServerClasspath(String baseLibDir) {
    try {
        Path baseLibPath = Paths.get(baseLibDir).toAbsolutePath().normalize();
        Stream<Path> jars = Files.find(baseLibPath, 1, (path, attrs) -> path.toString().endsWith(".jar"));
        StringJoiner joiner = new StringJoiner(":");

        // server libs directory (containing the server Java classes)
        joiner.add(baseLibPath.toString());

        // all .jar files in the same directory
        jars.forEach((path) -> joiner.add(path.toString()));

        return joiner.toString();

    } catch (IOException ex) {
        String message = "Error resolving server base lib dir: " + ex.getMessage();
        logger.error(message, ex);
        throw new IllegalArgumentException(message, ex);
    }
}

private static String displayStringForValue(Object value) {
  if (value == null) {
    return "";
  }
  if (value instanceof double[]) {
    return Arrays.toString((double[]) value);
  }
  if (value instanceof String[]) {
    return Arrays.toString((String[]) value);
  }
  if (value instanceof boolean[]) {
    return Arrays.toString((boolean[]) value);
  }
  if (value instanceof byte[]) {
    StringJoiner joiner = new StringJoiner(", ", "[", "]");
    for (byte raw : (byte[]) value) {
      // Display as unsigned hexadecimal strings, eg 15 -> 0x0F
      joiner.add(String.format("0x%02X", 0xFF & raw));
    }
    return joiner.toString();
  }
  return value.toString();
}

public void testEmptyBoth() {
    fixesStream().forEach(fixes -> {
        StringJoiner sj = new StringJoiner(",", fixes.pre0, fixes.suf0);
        StringJoiner other = new StringJoiner(":", fixes.pre1, fixes.suf1);

        sj.merge(other);
        assertEquals(sj.toString(), fixes.pre0 + fixes.suf0);

        other.setEmptyValue("NOTHING");
        sj.merge(other);
        assertEquals(sj.toString(), fixes.pre0 + fixes.suf0);

        sj = new StringJoiner(",", fixes.pre0, fixes.suf0).setEmptyValue("EMPTY");
        assertEquals(sj.toString(), "EMPTY");
        sj.merge(other);
        assertEquals(sj.toString(), "EMPTY");
    });
}

String toConsulRegistrationJson() {
    final StringBuilder builder = new StringBuilder();
    builder.append("{");
    append(builder, "ID", id);
    builder.append(",");
    append(builder, "Name", name);
    builder.append(",");
    if (!tags.isEmpty()) {
        builder.append("\"Tags\":[");
        StringJoiner joiner = new StringJoiner(",");
        tags.stream().map(t -> "\"" + t + "\"").forEach(joiner::add);
        builder.append(joiner.toString());
        builder.append("],");
    }
    if (address != null) {
        append(builder, "Address", address);
        builder.append(",");
    }
    append(builder, "Port", port);
    builder.append(",");
    builder.append("\"Check\":{");
    append(builder, "Interval", interval);
    builder.append("}");
    builder.append("}");
    return builder.toString();
}

/**
 * @param activeChar
 * @param characterName
 * @throws IllegalArgumentException
 */
private void findCharactersPerAccount(L2PcInstance activeChar, String characterName) throws IllegalArgumentException
{
    final L2PcInstance player = L2World.getInstance().getPlayer(characterName);
    if (player == null)
    {
        throw new IllegalArgumentException("Player doesn't exist");
    }

    final Map<Integer, String> chars = player.getAccountChars();
    final StringJoiner replyMSG = new StringJoiner("<br1>");
    chars.values().stream().forEachOrdered(replyMSG::add);

    final NpcHtmlMessage adminReply = new NpcHtmlMessage(0, 1);
    adminReply.setFile(activeChar.getHtmlPrefix(), "data/html/admin/accountinfo.htm");
    adminReply.replace("%account%", player.getAccountName());
    adminReply.replace("%player%", characterName);
    adminReply.replace("%characters%", replyMSG.toString());
    activeChar.sendPacket(adminReply);
}

/**
 * Returns the "canonical string representation" of the actions in the
 * specified mask.
 * Always returns present actions in the following order:
 * connect, listen, accept, resolve.
 *
 * @param mask a specific integer action mask to translate into a string
 * @return the canonical string representation of the actions
 */
private static String getActions(int mask) {
    StringJoiner sj = new StringJoiner(",");
    if ((mask & CONNECT) == CONNECT) {
        sj.add("connect");
    }
    if ((mask & LISTEN) == LISTEN) {
        sj.add("listen");
    }
    if ((mask & ACCEPT) == ACCEPT) {
        sj.add("accept");
    }
    if ((mask & RESOLVE) == RESOLVE) {
        sj.add("resolve");
    }
    return sj.toString();
}

/**
 * 設定ファイルを元に NaEF Restful API の DtoChanges 取得 API の URL を生成する
 * <p>
 * http://{naef-addr}:{naef-rest-api-port}/api/{naef-rest-api-version}/dto-changes?version={tx}&time={time}
 *
 * @param tx   ターゲットとなるトランザクション ID
 * @param time ターゲットとなる時間
 * @return NaEF Restful API DtoChanges URL
 */
public static URL getDtoChangesUri(TransactionId.W tx, DateTime time) throws IOException {
    NotifierConfig conf = NotifierConfig.instance();
    String urlStr = new Formatter().format(
            "http://%s:%s/api/%s/dto-changes",
            conf.naefAddr(),
            conf.naefRestApiPort(),
            conf.naefRestApiVersion())
            .toString();

    StringJoiner queries = new StringJoiner("&");
    if (tx != null) {
        queries.add("version=" + tx.toString());
    }
    if (time != null) {
        queries.add("time=" + time.getValue());
    }

    if (queries.length() > 0) {
        urlStr += "?" + queries.toString();
    }

    return new URL(urlStr);
}

/**
 * classファイルから対象パッケージ以下のEnumクラスを取得
 *
 * @param packageName ルートパッケージ名
 * @param dir 対象ディレクトリ
 * @return クラスリスト
 * @throws ClassNotFoundException エラー
 * @throws IOException
 */
private static Set<Class<?>> findEnumClassesWithFile(final String packageName, final Path dir) {
    Set<Class<?>> classes = new HashSet<>();
    try (Stream<Path> stream = Files.walk(dir)) {
        stream.filter(entry -> entry.getFileName().toString().endsWith(".class")).forEach(file -> {
            StringJoiner joiner = new StringJoiner(".", packageName + ".", "");
            dir.relativize(file).forEach(p -> joiner.add(p.toString()));
            String className = joiner.toString().replaceAll(".class$", "");
            loadEnum(className).ifPresent(classes::add);
        });
    } catch (IOException e) {
        LOG.error(e.getMessage(), e);
    }

    return classes;
}

private String formatRecipients(String[] recipients) {

        if (recipients == null){
            return null;
        }

        if (recipients.length == 1) {
            return recipients[0];
        }

        StringJoiner joiner = new StringJoiner(",");
        for (CharSequence cs: recipients) {
            joiner.add(cs);
        }
        return joiner.toString();
    }

/**
 * @return true if the line addition succeeded
 */
private boolean addNewEntry(String line)
{
    if (entries.size() >= maxEntries) {
        if (keepFirst) {
            return false;
        }
        else if (maxEntries == 0) {
            return true;
        }
        entries.removeFirst();
    }
    StringJoiner joiner = new StringJoiner(lineSeparator);
    joiner.add(line);
    entries.addLast(joiner);
    return true;
}

@Override
public String toString()
{
    StringJoiner joiner = new StringJoiner(",", "{", "}");
    if (data != null)
    {
        for (Object o : (Object[]) data)
        {
            joiner.add(o.toString());
        }
    }
    return joiner.toString();
}

/**
 * Dumps available runners to a stream
 *
 * @param out
 *            stream to print to
 */
private void printAvailableRunners(PrintStream out) {
    if (testerRegistry.getDescriptors().isEmpty())
        out.println("No runners found.");
    else {
        StringJoiner sj = new StringJoiner("\n\t");
        sj.add("Available runners are:");
        testerRegistry.getDescriptors().values().forEach(td -> sj.add(td.getId()));
        out.println(sj);
    }
}

/**
 * Dumps available testers to a stream
 *
 * @param out
 *            stream to print to
 */
private void printAvailableTesters(PrintStream out) {
    if (testerRegistry.getDescriptors().isEmpty())
        out.println("No testers found.");
    else {
        StringJoiner sj = new StringJoiner("\n\t");
        sj.add("Available testers are:");
        testerRegistry.getDescriptors().values().forEach(td -> sj.add(td.getId()));
        out.println(sj);
    }
}

/**
 * Helper method to get the method name from arguments.
 */
private String methodToString(String name, Class<?>[] argTypes) {
    StringJoiner sj = new StringJoiner(", ", getName() + "." + name + "(", ")");
    if (argTypes != null) {
        for (int i = 0; i < argTypes.length; i++) {
            Class<?> c = argTypes[i];
            sj.add((c == null) ? "null" : c.getName());
        }
    }
    return sj.toString();
}

@Override
String toShortString() {
    StringBuilder sb = new StringBuilder("constructor ");
    sb.append(getDeclaringClass().getTypeName());
    sb.append('(');
    StringJoiner sj = new StringJoiner(",");
    for (Class<?> parameterType : getParameterTypes()) {
        sj.add(parameterType.getTypeName());
    }
    sb.append(sj);
    sb.append(')');
    return sb.toString();
}

public String toRFC1779String(Map<String, String> oidMap) {
    if (assertion.length == 1) {
        return assertion[0].toRFC1779String(oidMap);
    }

    StringJoiner sj = new StringJoiner(" + ");
    for (int i = 0; i < assertion.length; i++) {
        sj.add(assertion[i].toRFC1779String(oidMap));
    }
    return sj.toString();
}

private String getErrorMessage(String initMsg) {
    List<String> locators = Lists.reverse(getLocators());
    if (locators.size() > 0) {
        initMsg += ": ";
        StringJoiner joiner = new StringJoiner(", ");
        for (String loc : locators) {
            joiner.add(loc);
        }
        initMsg += joiner.toString();
    }
    initMsg += " " + configError;
    return initMsg;
}

/**
 * Returns a filtered version of the given headers value.
 *
 * Note: The implementation currently only filters out HttpOnly cookies
 *       from Set-Cookie and Set-Cookie2 headers.
 */
private String filterHeaderField(String name, String value) {
    if (value == null)
        return null;

    if (SET_COOKIE.equalsIgnoreCase(name) ||
        SET_COOKIE2.equalsIgnoreCase(name)) {

        // Filtering only if there is a cookie handler. [Assumption: the
        // cookie handler will store/retrieve the HttpOnly cookies]
        if (cookieHandler == null || value.length() == 0)
            return value;

        JavaNetHttpCookieAccess access =
                SharedSecrets.getJavaNetHttpCookieAccess();
        StringJoiner retValue = new StringJoiner(",");  // RFC 2965, comma separated
        List<HttpCookie> cookies = access.parse(value);
        for (HttpCookie cookie : cookies) {
            // skip HttpOnly cookies
            if (!cookie.isHttpOnly())
                retValue.add(access.header(cookie));
        }
        return retValue.toString();
    }

    return value;
}

@Override
public String toString() {
    StringJoiner joiner = new StringJoiner(", ");
    joiner.add("permission: " + permission);
    joiner.add("noPermissionError: " + noPermissionError);
    joiner.add("noPermissionSound: " + noPermissionSound);
    joiner.add("cost: " + cost);
    joiner.add("noMoneyError: " + noMoneyError);
    joiner.add("noMoneySound: " + noMoneySound);
    return '{' + joiner.toString() + '}';
}

private <E extends Enum<E>> void selectorToString(StringBuilder sb, Set<E> c, E[] values) {
    if (!c.containsAll(Arrays.asList(values))) {
        sb.append(c.stream()
                .sorted((x, y) -> x.ordinal() - y.ordinal())
                .map(v -> v.name().toLowerCase(Locale.US))
                .collect(new Collector<CharSequence, StringJoiner, String>() {
                    @Override
                    public BiConsumer<StringJoiner, CharSequence> accumulator() {
                        return StringJoiner::add;
                    }

                    @Override
                    public Supplier<StringJoiner> supplier() {
                        return () -> new StringJoiner(",", (sb.length() == 0)? "" : "-", "")
                                .setEmptyValue("");
                    }

                    @Override
                    public BinaryOperator<StringJoiner> combiner() {
                        return StringJoiner::merge;
                    }

                    @Override
                    public Function<StringJoiner, String> finisher() {
                        return StringJoiner::toString;
                    }

                    @Override
                    public Set<Characteristics> characteristics() {
                        return Collections.emptySet();
                    }
                }));
    }
}

@Transient
public void setSelectedExchangeCurrencyPairs(Set<SelectedExchangeCurrencyPair> selectedExchangeCurrencyPairs) {
    this.selectedExchangeCurrencyPairs = selectedExchangeCurrencyPairs;
    for (SelectedExchangeCurrencyPair selectedExchangeCurrencyPair : selectedExchangeCurrencyPairs) {
        StringJoiner stringJoiner = new StringJoiner(",");
        for (CurrencyPair currencyPair : selectedExchangeCurrencyPair.getCurrencyPairList()) {
            stringJoiner.add(currencyPair.toString());
        }
        if (StringUtils.isNotBlank(stringJoiner.toString())) {
            currencyPairByExchangeMap.put(selectedExchangeCurrencyPair.getExchangeName(), stringJoiner.toString());
        }
    }
}

private static String getId(final String prefix, final Integer hierarchy, final Integer length) {
    final String id = randomUUID().toString();
    final String nodash = id.replaceAll("-", "");
    final StringJoiner joiner = new StringJoiner("/");
    rangeClosed(0, hierarchy - 1).forEach(x -> joiner.add(nodash.substring(x * length, (x + 1) * length)));
    joiner.add(id);

    return prefix + joiner;
}

@Override
protected Function<String, String> createFunction(Object resolved) {
    return s -> {
        if (s == null) {
            return null;
        } else if (resolved instanceof Iterable) {
            StringJoiner joiner = new StringJoiner(delimiter);
            for (Object o : (Iterable) resolved) {
                joiner.add(oh.stringify(o));
            }
            return joiner.toString();
        }
        return s;
    };
}

private <E extends Enum<E>> void selectorToString(StringBuilder sb, Set<E> c, E[] values) {
    if (!c.containsAll(Arrays.asList(values))) {
        sb.append(c.stream()
                .sorted((x, y) -> x.ordinal() - y.ordinal())
                .map(v -> v.name().toLowerCase(Locale.US))
                .collect(new Collector<CharSequence, StringJoiner, String>() {
                    @Override
                    public BiConsumer<StringJoiner, CharSequence> accumulator() {
                        return StringJoiner::add;
                    }

                    @Override
                    public Supplier<StringJoiner> supplier() {
                        return () -> new StringJoiner(",", (sb.length() == 0)? "" : "-", "")
                                .setEmptyValue("");
                    }

                    @Override
                    public BinaryOperator<StringJoiner> combiner() {
                        return StringJoiner::merge;
                    }

                    @Override
                    public Function<StringJoiner, String> finisher() {
                        return StringJoiner::toString;
                    }

                    @Override
                    public Set<Characteristics> characteristics() {
                        return Collections.emptySet();
                    }
                }));
    }
}

private String literalize(List<String> v, int type){
    StringJoiner sj = new StringJoiner(",", "(",")");
    if(type == Types.NUMERIC || type == Types.BIGINT || type == Types.BIT || type == Types.DECIMAL
            || type == Types.DOUBLE || type == Types.FLOAT || type == Types.INTEGER || type == Types.REAL || type == Types.ROWID
            || type == Types.SMALLINT || type == Types.TINYINT){


        v.forEach(s -> sj.add(s) );
    }else{
        v.forEach(s -> sj.add("'" + s + "'") );
    }
    return sj.toString();
}

public void testSimple() {
    fixesStream().forEach(fixes -> {
        StringJoiner sj = new StringJoiner(",", fixes.pre0, fixes.suf0);
        StringJoiner other = new StringJoiner(",", fixes.pre1, fixes.suf1);
        Stream.of("a", "b", "c").forEachOrdered(sj::add);
        Stream.of("d", "e", "f").forEachOrdered(other::add);

        sj.merge(other);
        assertEquals(sj.toString(), fixes.pre0 + "a,b,c,d,e,f" + fixes.suf0);
    });
}