ArrayList<String> conditions = new ArrayList<String>();
conditions.add("condition1");
conditions.add("condition2");
conditions.add("condition3");

private String buildCondition(ArrayList<String> conditions) {
    StringBuilder sb = new StringBuilder();
    for (String condition : conditions) {
        sb.append(condition);
        sb.append(" or ");
    }
    int index = sb.lastIndexOf(" or ");
    return index > 0 ? sb.substring(0, index) : sb.toString();
}  // condition1 or condition2 or condition3

Joiner.on(" or ").join(conditions);

StringBuilder sb = new StringBuilder("result:");
Joiner.on("＃").appendTo(sb, 1, 2, 3);
System.out.println(sb);     //result:1＃2＃3

Joiner.on("#").join(1, null, 3)

Joiner.on("#").skipNulls().join(1, null, 3);      //1#3
Joiner.on("#").useForNull("").join(1, null, 3);   //1##3

 Map<Integer, Integer> test = new HashMap<Integer, Integer>();
 test.put(1, 2);
 test.put(3, 4);
 Joiner.on("#").withKeyValueSeparator("=").join(test); //1=2#3=4

Joiner.on("#").withKeyValueSeparator("=").join(ImmutableMap.of(1, 2, 3, 4));  //1=2#3=4

/**
* Returns a joiner which automatically places {@code separator} between consecutive elements.
*/
public static Joiner on(String separator) {
	return new Joiner(separator);
}
/**
* Returns a joiner which automatically places {@code separator} between consecutive elements.
*/
public static Joiner on(char separator) {
	return new Joiner(String.valueOf(separator));
}

/**
   * Appends the string representation of each of {@code parts}, using the previously configured
   * separator between each, to {@code appendable}.
   *
   * @since 11.0
   */
  public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
    checkNotNull(appendable);
    if (parts.hasNext()) {
      appendable.append(toString(parts.next()));
      while (parts.hasNext()) {
        appendable.append(separator);
        appendable.append(toString(parts.next()));
      }
    }
    return appendable;
  }

public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
    try {
        this.appendTo((Appendable)builder, (Iterator)parts);
        return builder;
    } catch (IOException var4) {
        throw new AssertionError(var4);
    }
}

public final <A extends Appendable> A appendTo(A appendable, @Nullable Object first, @Nullable Object second, Object... rest) throws IOException {
    return this.appendTo((Appendable)appendable, (Iterable)iterable(first, second, rest));
}

private static Iterable<Object> iterable(final Object first, final Object second, final Object[] rest) {
    Preconditions.checkNotNull(rest);
    return new AbstractList() {
        public int size() {
            return rest.length + 2;
        }
        public Object get(int index) {
            switch(index) {
            case 0:
                return first;
            case 1:
                return second;
            default:
                return rest[index - 2];
            }
        }
    };
}

public boolean hasNext() {
        return cursor != size();
}
public E next() {
        checkForComodification();
    try {
    E next = get(cursor);
    lastRet = cursor++;
    return next;
    } catch (IndexOutOfBoundsException e) {
    checkForComodification();
    throw new NoSuchElementException();
    }
}