Joins the supplied list of strings after removing any empty strings from the list
509640
def join(delim, items, quotes=False):
		
		transform = lambda s: s
		if quotes == True:
			transform = lambda s: s if ' ' not in s else '"{}"'.format(s)
		
		stripped = list([transform(i) for i in items if len(i) > 0])
		if len(stripped) > 0:
			return delim.join(stripped)
		return ''
221379
def join_strings(key, value, fmt, meta):  # pylint: disable=unused-argument
    """"""
    if key in ['Para', 'Plain']:
        _join_strings(value)
    elif key == 'Image':
        _join_strings(value[-2])
    elif key == 'Table':
        _join_strings(value[-5])
209621
public static String join(Iterator strings, String sep) {
        if (!strings.hasNext())
            return "";

        String start = strings.next().toString();
        if (!strings.hasNext()) // only one, avoid builder
            return start;

        StringBuilder sb = StringUtil.borrowBuilder().append(start);
        while (strings.hasNext()) {
            sb.append(sep);
            sb.append(strings.next());
        }
        return StringUtil.releaseBuilder(sb);
    }
350987
public static String joiningWithDelimiter(CharSequence delimiter,
            List<String> stringList) {
        return joiningWith(stringList.stream(), delimiter);
    }
1042843
@Nonnull
    public static String join(@Nonnull Collection<?> strings, @Nonnull String separator) {
        StringBuilder buf = new StringBuilder();
        boolean first=true;
        for (Object s : strings) {
            if(first)   first=false;
            else        buf.append(separator);
            buf.append(s);
        }
        return buf.toString();
    }
610227
public static String join(Collection<?> objectsToJoin, String separator) {
        if ((objectsToJoin != null) && !objectsToJoin.isEmpty()) {
            StringBuilder builder = new StringBuilder();
            for (Object object : objectsToJoin) {
                builder.append(object);
                builder.append(separator);
            }
            // Remove the last separator
            return builder.substring(0, builder.length() - separator.length());
        } else {
            return EMPTY;
        }
    }
222506
public String join(List<String> list) {

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

        StringBuilder sb = new StringBuilder();
        boolean first = true;
        for (String s : list) {

            if (s == null) {
                if (convertEmptyToNull) {
                    s = "";
                } else {
                    throw new IllegalArgumentException("StringListFlattener does not support null strings in the list. Consider calling setConvertEmptyToNull(true).");
                }
            }

            if (!first) {
                sb.append(separator);
            }

            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c == escapeChar || c == separator) {
                    sb.append(escapeChar);
                }
                sb.append(c);
            }

            first = false;
        }
        return sb.toString();
    }
435122
public static String join(Collection strings, String delimiter) {
        StringBuilder builder = new StringBuilder();
        Iterator<String> iter = strings.iterator();
        while (iter.hasNext()) {
            builder.append(iter.next());
            if (!iter.hasNext()) {
                break;
            }
            builder.append(delimiter);
        }
        return builder.toString();
    }
586323
def join(strin, items):
    
    return strin.join(map(lambda item: str(item), items))
1282223
public static String join(List<?> things, String delim) {
        StringBuilder builder = new StringBuilder();
        boolean first = true;
        for (Object thing : things) {
            if (first) {
                first = false;
            } else {
                builder.append(delim);
            }
            builder.append(thing.toString());
        }
        return builder.toString();
    }
698172
def join(self, formatted_texts):
        """"""
        formatted_texts = list(formatted_texts)  # so that after the first iteration elements are not lost if generator
        for formatted_text in formatted_texts:
            assert self._is_compatible(formatted_text), "Cannot join text with different modes"
        self.text = self.text.join((formatted_text.text for formatted_text in formatted_texts))
        return self
1205177
public static String join(Collection<String> collection, String separator) {
        if (collection == null) {
            return null;
        }
        return join(collection.toArray(new String[collection.size()]), separator, 0, collection.size());
    }
265529
static <T> String join(Iterable<T> elems, String delim) {
        if (elems == null)
            return "";
        StringBuilder result = new StringBuilder();
        for (T elem : elems)
            result.append(elem).append(delim);
        if (result.length() > 0)
            result.setLength(result.length() - delim.length());
        return result.toString();
    }
990203
public static String join(String[] collection, String separator,
                              boolean trailing) {
        return join(Arrays.asList(collection), separator, trailing);
    }
118402
public static String join(String[] strings, String sep) {
        return join(Arrays.asList(strings), sep);
    }
681063
def string_join_using_or_conjunction(strings)
      ret = ""
      strings.each_with_index do |str, i|
        case i
        when 0 # 最初の要素
        when strings.size - 1 # 最後の要素
          ret << " or "
        else
          ret << ", "
        end

        ret << str
      end

      ret
    end
791596
public static void join(StringBuilder buf, Iterable<?> values, String separator) {
		for (Iterator<?> i = values.iterator(); i.hasNext();) {
			buf.append(i.next());
			if (i.hasNext()) {
				buf.append(separator);
			}
		}
	}