You can use the overload of Collectors.joining that takes prefix and suffix parameters.

 String values = list.stream()
    .collect(Collectors.joining("','", "'", "'"));

This will place single-quotes around all your values correctly, assuming that all of your values are strings that need single quotes for the syntax.

But, as is the case with all problems involving constructing a query by concatenating values, it leaves your vulnerable to SQL injection. A more secure and versatile solution involves using a PreparedStatement. Value placeholders are ? characters, and you can use various setXyz methods to set the values safely. It protects against SQL injection and allows for any data types to be used, not just string types.

You asked for a Java 8 solution, but it's not necessary to use any Java 8 features for this. Here's how I'd do it:

static String prefixLines(String prefix, String input) {
    return input.replaceAll(".*\\R|.+\\z", Matcher.quoteReplacement(prefix) + "$0");
}

I think matching entire lines (including a partial last line) makes things a bit easier than matching just line separators, as in Peter Lawrey's answer. Still, +1 for that. Also, kudos to Holger for mentioning quoteReplacement, which is very easy to forget.

Note that I've used \\R which matches any Unicode line break. However, this doesn't match the behavior of BufferedReader.readLine() in case that's important.

Your implementation looks ok, but if you want something different, try this:

public static List<String> getData(final TypeFlow flow) {
    return new AbstractList<String>() {
        @Override
        public String get(int index) {
            return flow.value()+DATA_TYPE.get(index).value();
        }

        @Override
        public int size() {
            return DATA_TYPE.size();
        }
    };
}

This way you create a "virtual list" which does not actually contains data, but computes it on the fly.

There is already an accepted answer and I upvoted it too.

Still I would like to offer potentially another solution. Potentially because it has one requirement:
The stream.spliterator() of Stream<String> stream needs to be Spliterator.SIZED.

If that applies to your case, you could use also this solution:

  public String format(Stream<String> stream) {
    Spliterator<String> spliterator = stream.spliterator();
    StringJoiner sj = spliterator.getExactSizeIfKnown() == 1 ?
      new StringJoiner("") :
      new StringJoiner(",", "[", "]");
    spliterator.forEachRemaining(sj::add);

    return sj.toString();
  }

According to the JavaDoc Spliterator.getExactSizeIfKnown() "returns estimateSize() if this Spliterator is SIZED, else -1." If a Spliterator is SIZED then "estimateSize() prior to traversal or splitting represents a finite size that, in the absence of structural source modification, represents an exact count of the number of elements that would be encountered by a complete traversal."

Since "most Spliterators for Collections, that cover all elements of a Collection report this characteristic" (API Note in JavaDoc of SIZED) this could be the desired directer way.

EDIT:
If the Stream is empty we can return an empty String at once. If the Stream has only one String there is no need to create a StringJoiner and to copy the String to it. We return the single String directly.

  public String format(Stream<String> stream) {
    Spliterator<String> spliterator = stream.spliterator();

    if (spliterator.getExactSizeIfKnown() == 0) {
      return "";
    }

    if (spliterator.getExactSizeIfKnown() == 1) {
      AtomicReference<String> result = new AtomicReference<String>();
      spliterator.tryAdvance(result::set);
      return result.get();
    }

    StringJoiner result = new StringJoiner(",", "[", "]");
    spliterator.forEachRemaining(result::add);
    return result.toString();
  }