Gets the value for the given key as a list.

@param key the key to get the value for
@param delimiter the delimiter to split the values
@return the list of values for the given key
184890
public static List<String> getList(PropertyKey key, String delimiter) {
    return sConf.getList(key, delimiter);
  }
1066864
public static List<String> readUniqueColumnValuesFromDelimitedFile(String filename, 
      int columnNumber, String delimiter) {
    Set<String> values = Sets.newHashSet(
        readColumnFromDelimitedFile(filename, columnNumber, delimiter));
    return Lists.newArrayList(values);
  }
1151785
public List<Integer> getIntegers(String name, String delimiter) {
        List<String> strings = getStrings(name, delimiter);

        List<Integer> ints = new ArrayList<>(strings.size());
        for (String value : strings) {
            try {
                int i = Integer.parseInt(value);
                ints.add(i);
            } catch (NumberFormatException e) {
            }
        }

        return Collections.unmodifiableList(ints);
    }
955236
public static List<String> splitAsList(String text, String delimiter) {
        List<String> answer = new ArrayList<String>();
        if (text != null && text.length() > 0) {
            answer.addAll(Arrays.asList(text.split(delimiter)));
        }
        return answer;
    }
18732
@SuppressWarnings("unchecked")
	@Override
	public List<String> getStringList(String key) {
		return getData(key, List.class);
	}
801250
private static List<String> parseList(String input, String delim) {
        List<String> result = new ArrayList<>();

        StringTokenizer st = new StringTokenizer(input, delim);
        while (st.hasMoreTokens()) {
            String token = st.nextToken().trim();
            if (token.length() > 0) {
                result.add(token);
            }
        }

        return result;
    }
218062
@Override
    public List<String> getStringList( final String             key,
                                       final List<String>       defaultValue )
    {
        return getStringList( key, DEFAULT_LIST_DELIMITER, defaultValue );
    }
229215
public static Array listToArray(String list, char delimiter) {
	if (list.length() == 0) return new ArrayImpl();
	int len = list.length();
	int last = 0;

	Array array = new ArrayImpl();
	try {
	    for (int i = 0; i < len; i++) {
		if (list.charAt(i) == delimiter) {
		    array.append(list.substring(last, i));
		    last = i + 1;
		}
	    }
	    if (last <= len) array.append(list.substring(last));
	}
	catch (PageException e) {}
	return array;
    }
674080
public List<String> get(String key)
    {
        if(key == null)
            throw new IllegalArgumentException("Null keys not allowed.");

        return map.get(key);
    }
1311176
public Iterator<String> getValues(String inputKey) {
        String key = Normalizer.normalize(inputKey, Normalizer.NORMALIZE_LOWER);
        List<String> vals = this.values.get(key);
        if (null != vals) {
            return vals.iterator();
        }
        return new LinkedList<String>().iterator();
    }
469334
public static String[] words(final String value, final String delimiter) {
        validate(value, NULL_STRING_PREDICATE, NULL_STRING_MSG_SUPPLIER);
        return value.split(delimiter);
    }
934357
public static List<String> split(char delim, String toSplit) {
    checkNotNull(toSplit, "toSplit");
    if (toSplit.indexOf(delim) == -1) {
      return Arrays.asList(toSplit); // sortable in JRE 7 and 8
    }
    List<String> out = new LinkedList<String>();
    StringBuilder currentString = new StringBuilder();
    for (char c : toSplit.toCharArray()) {
      if (c == delim) {
        out.add(emptyToNull(currentString.toString()));
        currentString.setLength(0);
      } else {
        currentString.append(c);
      }
    }
    out.add(emptyToNull(currentString.toString()));
    return out;
  }
47211
public static String getKeyList(Iterator<Key> it, String delimiter) {
	StringBuilder sb = new StringBuilder(it.next().getString());
	if (delimiter.length() == 1) {
	    char c = delimiter.charAt(0);
	    while (it.hasNext()) {
		sb.append(c);
		sb.append(it.next().getString());
	    }
	}
	else {
	    while (it.hasNext()) {
		sb.append(delimiter);
		sb.append(it.next().getString());
	    }
	}
	return sb.toString();
    }
858820
public List getAll(Object key) {
        Object value = mMap.get(key);
        if (value instanceof List) {
            return ((List)value);
        }
        else {
            List list = new ArrayList();
            if (value != null || mMap.containsKey(key)) {
                list.add(value);
            }
            mMap.put(key, list);
            return list;
        }
    }
1236549
public List<Long> getLongs(String name, String delimiter) {
        List<String> strings = getStrings(name, delimiter);

        List<Long> longs = new ArrayList<>(strings.size());
        for (String value : strings) {
            try {
                long i = Long.parseLong(value);
                longs.add(i);
            } catch (NumberFormatException e) {
            }
        }

        return Collections.unmodifiableList(longs);
    }
1035421
public List<V> getAll(Object key) {
        List<V> res = map.get(key);
        if (res == null) {
            res = Collections.emptyList();
        }
        return res;
    }
1097391
public static StringBinding join(final ObservableList<?> items, final ObservableValue<String> delimiter) {
        return Bindings.createStringBinding(() -> items.stream().map(String::valueOf).collect(Collectors.joining(delimiter.getValue())), items, delimiter);
    }