Merge Properties Into Map : Properties « Collections « Java Tutorial

Home
Java Tutorial
1.Language
2.Data Type
3.Operators
4.Statement Control
5.Class Definition
6.Development
7.Reflection
8.Regular Expressions
9.Collections
10.Thread
11.File
12.Generics
13.I18N
14.Swing
15.Swing Event
16.2D Graphics
17.SWT
18.SWT 2D Graphics
19.Network
20.Database
21.Hibernate
22.JPA
23.JSP
24.JSTL
25.Servlet
26.Web Services SOA
27.EJB3
28.Spring
29.PDF
30.Email
31.J2ME
32.J2EE Application
33.XML
34.Design Pattern
35.Log
36.Security
37.Apache Common
38.Ant
39.JUnit
Java Tutorial » Collections » Properties 
9.34.29.Merge Properties Into MapPrevious/Next
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


/**
 * Miscellaneous collection utility methods.
 * Mainly for internal use within the framework.
 *
 @author Juergen Hoeller
 @author Rob Harrop
 @since 1.1.3
 */
abstract class CollectionUtils {

  /**
   * Merge the given Properties instance into the given Map,
   * copying all properties (key-value pairs) over.
   * Uses <code>Properties.propertyNames()</code> to even catch
   * default properties linked into the original Properties instance.
   @param props the Properties instance to merge (may be <code>null</code>)
   @param map the target Map to merge the properties into
   */
  public static void mergePropertiesIntoMap(Properties props, Map map) {
    if (map == null) {
      throw new IllegalArgumentException("Map must not be null");
    }
    if (props != null) {
      for (Enumeration en = props.propertyNames(); en.hasMoreElements();) {
        String key = (Stringen.nextElement();
        map.put(key, props.getProperty(key));
      }
    }
  }

  /**
   * Return <code>true</code> if the supplied Collection is <code>null</code>
   * or empty. Otherwise, return <code>false</code>.
   @param collection the Collection to check
   @return whether the given Collection is empty
   */
  public static boolean isEmpty(Collection collection) {
    return (collection == null || collection.isEmpty());
  }

  /**
   * Return <code>true</code> if the supplied Map is <code>null</code>
   * or empty. Otherwise, return <code>false</code>.
   @param map the Map to check
   @return whether the given Map is empty
   */
  public static boolean isEmpty(Map map) {
    return (map == null || map.isEmpty());
  }




  /**
   * Check whether the given Collection contains the given element instance.
   * Enforces the given instance to be present, rather than returning
   * <code>true</code> for an equal element as well.
   @param collection the Collection to check
   @param element the element to look for
   @return <code>true</code> if found, <code>false</code> else
   */
  public static boolean containsInstance(Collection collection, Object element) {
    if (collection != null) {
      for (Iterator it = collection.iterator(); it.hasNext();) {
        Object candidate = it.next();
        if (candidate == element) {
          return true;
        }
      }
    }
    return false;
  }

  /**
   * Return <code>true</code> if any element in '<code>candidates</code>' is
   * contained in '<code>source</code>'; otherwise returns <code>false</code>.
   @param source the source Collection
   @param candidates the candidates to search for
   @return whether any of the candidates has been found
   */
  public static boolean containsAny(Collection source, Collection candidates) {
    if (isEmpty(source|| isEmpty(candidates)) {
      return false;
    }
    for (Iterator it = candidates.iterator(); it.hasNext();) {
      if (source.contains(it.next())) {
        return true;
      }
    }
    return false;
  }

  /**
   * Return the first element in '<code>candidates</code>' that is contained in
   * '<code>source</code>'. If no element in '<code>candidates</code>' is present in
   * '<code>source</code>' returns <code>null</code>. Iteration order is
   {@link Collection} implementation specific.
   @param source the source Collection
   @param candidates the candidates to search for
   @return the first present object, or <code>null</code> if not found
   */
  public static Object findFirstMatch(Collection source, Collection candidates) {
    if (isEmpty(source|| isEmpty(candidates)) {
      return null;
    }
    for (Iterator it = candidates.iterator(); it.hasNext();) {
      Object candidate = it.next();
      if (source.contains(candidate)) {
        return candidate;
      }
    }
    return null;
  }

  /**
   * Find a value of the given type in the given Collection.
   @param collection the Collection to search
   @param type the type to look for
   @return a value of the given type found, or <code>null</code> if none
   @throws IllegalArgumentException if more than one value of the given type found
   */
  public static Object findValueOfType(Collection collection, Class typethrows IllegalArgumentException {
    if (isEmpty(collection)) {
      return null;
    }
    Class typeToUse = (type != null ? type : Object.class);
    Object value = null;
    for (Iterator it = collection.iterator(); it.hasNext();) {
      Object obj = it.next();
      if (typeToUse.isInstance(obj)) {
        if (value != null) {
          throw new IllegalArgumentException("More than one value of type [" + typeToUse.getName() "] found");
        }
        value = obj;
      }
    }
    return value;
  }

  /**
   * Determine whether the given Collection only contains a single unique object.
   @param collection the Collection to check
   @return <code>true</code> if the collection contains a single reference or
   * multiple references to the same instance, <code>false</code> else
   */
  public static boolean hasUniqueObject(Collection collection) {
    if (isEmpty(collection)) {
      return false;
    }
    boolean hasCandidate = false;
    Object candidate = null;
    for (Iterator it = collection.iterator(); it.hasNext();) {
      Object elem = it.next();
      if (!hasCandidate) {
        hasCandidate = true;
        candidate = elem;
      }
      else if (candidate != elem) {
        return false;
      }
    }
    return true;
  }

}
9.34.Properties
9.34.1.Setting and Getting Elements
9.34.2.using properties
9.34.3.Getting property by String key value
9.34.4.Getting a key List from Properties
9.34.5.Loading and Saving properties
9.34.6.Use store() to save the properties
9.34.7.List Properties to a print stream or print writer
9.34.8.Using Enumeration to loop through Properties
9.34.9.Put value to a Property list.
9.34.10.Sort Properties when saving
9.34.11.Sorts a property list and turns the sorted list into a string.
9.34.12.Sorts property list and print out each key=value pair prepended with specific indentation.
9.34.13.Load a properties file in the classpath
9.34.14.A Properties file stored in a JAR can be loaded this way
9.34.15.Load a properties file in the startup directory
9.34.16.Have a multi-line value in a properties file
9.34.17.Use XML with Properties
9.34.18.Store properties as XML file
9.34.19.Getting and Setting Properties
9.34.20.Convert a Properties list into a map.
9.34.21.To read a Properties file via an Applet
9.34.22.Read system property as an integer
9.34.23.Read a set of properties from the received input stream, strip off any excess white space that exists in those property values,
9.34.24.Property access utility methods
9.34.25.An utility class to ease up using property-file resource bundles.
9.34.26.Copy a set of properties from one Property to another.
9.34.27.Create Properties from String array
9.34.28.Gets strong-type-value property from a standard Properties
9.34.29.Merge Properties Into Map
9.34.30.Property Loader
9.34.31.Returns a Properties object matching the given node
9.34.32.The properties iterator iterates over a set of enumerated properties.
9.34.33.Use a default property list.
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.