Returns the single String value representation for the given value list.<p>

@param valueList the value list to create the single String value for

@return the single String value representation for the given value list
352323
private String createValueFromList(List<String> valueList) {

        if (valueList == null) {
            return null;
        }
        StringBuffer result = new StringBuffer(valueList.size() * 32);
        Iterator<String> i = valueList.iterator();
        while (i.hasNext()) {
            result.append(
                replaceDelimiter(i.next().toString(), VALUE_LIST_DELIMITER, VALUE_LIST_DELIMITER_REPLACEMENT));
            if (i.hasNext()) {
                result.append(VALUE_LIST_DELIMITER);
            }
        }
        return result.toString();
    }
1140489
public static final String getSelectedValue(ListBox list) {
	int index = list.getSelectedIndex();
	return (index >= 0) ? list.getValue(index) : null;
    }
1206519
public static String formatParameterList(Collection<String> value) {
		return value == null ? null : StringUtils.collectionToDelimitedString(value, " ");
	}
86912
public <T extends ListValue> Collection<T> listTypeValues(
            Class<T> valuesClass) {
        IAssetType typeToGet = instance.getMetaModel().getAssetType(
                V1Instance.getAssetTypeToken(valuesClass));
        Query query = new Query(typeToGet);
        FilterTerm assetStateTerm = new FilterTerm(typeToGet
                .getAttributeDefinition("AssetState"));

        assetStateTerm.notEqual(AssetState.Closed);
        query.setFilter(new AndFilterTerm(
                new IFilterTerm[]{assetStateTerm}));
        return instance.queryToEntityEnum(valuesClass, query);
    }
955257
public CmsHtmlList getList() {

        if ((m_list != null) && (m_list.getMetadata() == null)) {
            m_list.setMetadata(getMetadata(getClass().getName(), m_list.getId()));
        }
        return m_list;
    }
474001
private List<Object> toList(Class<?> valueType, Object arrayObject)
   {
      List<Object> defaultValues = new ArrayList<>();
      int length = Array.getLength(arrayObject);
      boolean isClassType = (valueType == Class.class);
      for (int i = 0; i < length; i++)
      {
         Object arrayValue = Array.get(arrayObject, i);
         if (isClassType)
         {
            arrayValue = ((Class<?>) arrayValue).getName();
         }
         defaultValues.add(arrayValue);
      }
      return defaultValues;
   }
1284085
public Iterator<V> valueIterator(@SuppressWarnings("unused") K name) {
        List<V> empty = Collections.emptyList();
        return empty.iterator();
    }
1327506
public static boolean checkList(List<String> keyList, List<String> valueList) {
		// Assert.notEmpty(keyList, "参数keyList不能为空.");
		// Assert.notEmpty(valueList, "参数valueList不能为空.");
		if (keyList == null || keyList.isEmpty()) {
			throw new IllegalArgumentException("参数keyList不能为空.");
		}
		if (valueList == null || valueList.isEmpty()) {
			throw new IllegalArgumentException("参数valueList不能为空.");
		}
		if (keyList.size() != valueList.size()) {
			throw new IllegalArgumentException("参数keyList和valueList长度不一致.");
		}
		return true;
	}
1255839
public List<String> getAsStrings() {
        if (this.isEmpty()) {
            return Collections.emptyList();
        } else {
            final List<String> toStringVals = new ArrayList<>(this.size());
            for (final T i : this) {
                toStringVals.add(i == null ? "null" : i.toString());
            }
            return toStringVals;
        }
    }
581673
private List<String> createListFromValue(String value) {

        if (value == null) {
            return null;
        }
        List<String> result = CmsStringUtil.splitAsList(value, VALUE_LIST_DELIMITER);
        if (value.indexOf(VALUE_LIST_DELIMITER_REPLACEMENT) != -1) {
            List<String> tempList = new ArrayList<String>(result.size());
            Iterator<String> i = result.iterator();
            while (i.hasNext()) {
                String item = i.next();
                tempList.add(rebuildDelimiter(item, VALUE_LIST_DELIMITER, VALUE_LIST_DELIMITER_REPLACEMENT));
            }
            result = tempList;
        }

        return result;
    }
783339
@Nullable
    public static String[] nullableArrayOfStrings(@Nullable List<Object> list) {
        if (list == null || list.isEmpty()) {
            return null;
        } else {
            final String[] strings = new String[list.size()];

            //noinspection ForLoopReplaceableByForEach -> on Android it's faster
            for (int i = 0; i < list.size(); i++) {
                final Object arg = list.get(i);
                strings[i] = arg != null ? arg.toString() : "null";
            }
            return strings;
        }
    }
709580
private I_CmsStringModel getStringModel(CmsPathValue pathValue) {

        String path = pathValue.getPath();
        I_CmsStringModel model = m_models.get(path);
        if (model == null) {
            String[] tokens = path.split("/");
            String id = tokens[0];
            String propName = tokens[1];
            boolean isStructure = tokens[2].equals("S");
            model = createStringModel(new CmsUUID(id), propName, isStructure);
            m_models.put(path, model);
        }
        return model;
    }
110455
private static List<String> toList(String propertyName,
                                ValueExpression expression,
                                Object value) {

        if (value instanceof String) {

            String strValue = (String)value;

            // If the value contains no spaces, we can optimize.
            // This is worthwhile, since the execute/render lists
            // will often only contain a single value.
            if (strValue.indexOf(' ') == -1) {
                return toSingletonList(propertyName, strValue);
            }

            // We're stuck splitting up the string.
            String[] values = SPLIT_PATTERN.split(strValue);
            if ((values == null) || (values.length == 0)) {
                return null;
            }

            // Note that we could create a Set out of the values if
            // we care about removing duplicates.  However, the
            // presence of duplicates does not real harm.  They will
            // be consolidated during the partial view traversal.  So,
            // just create an list - garbage in, garbage out.
            return Collections.unmodifiableList(Arrays.asList(values));
        }

        // RELEASE_PENDING i18n ;
        throw new FacesException(expression.toString()
                                 + " : '"
                                 + propertyName
                                 + "' attribute value must be either a String or a Collection");
    }
1092209
public List<String> values(String name) {
        List<String> result = null;
        for (int i = 0, size = size(); i < size; i++) {
            if (name.equalsIgnoreCase(name(i))) {
                if (result == null) result = new ArrayList<>(2);
                result.add(value(i));
            }
        }
        return result != null
                ? Collections.unmodifiableList(result)
                : Collections.<String>emptyList();
    }
321053
private String createStringValue(CmsObject cms) {

        Attribute enabled = m_element.attribute(CmsXmlPage.ATTRIBUTE_ENABLED);

        String content = "";
        if ((enabled == null) || Boolean.valueOf(enabled.getText()).booleanValue()) {
            CmsLink link = getLink(cms);
            if (link != null) {
                content = link.getUri();
                if (cms != null) {
                    content = cms.getRequestContext().removeSiteRoot(link.getUri());
                }
            }
        }
        return content;
    }
2341
protected String getValuesString() {
        final StringBuilder builder = new StringBuilder();

        for(final String value : values) {
            builder.append(AciURLCodec.getInstance().encode(value)).append(',');
        }

        if(builder.length() > 0) {
            builder.deleteCharAt(builder.length() - 1);
        }

        return builder.toString();
    }
27344
public java.util.List<String> getValueOptions() {
        if (valueOptions == null) {
            valueOptions = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return valueOptions;
    }