Java Properties.propertyNames方法代碼示例

import java.util.Properties; //導入方法依賴的package包/類
/** Reads the given file. Searches the file for the property passed in, and stores all of those properties into a list. Randomly return one of the properties. */
private static String readNameFile(String filePath, String property) throws IOException
{
	InputStreamReader in = new InputStreamReader(NameGenerator.class.getClassLoader().getResourceAsStream("assets/lootslashconquer/names/" + filePath + ".txt"), "UTF-8");
	Properties props = new Properties();
	props.load(in);
	Enumeration<?> e = props.propertyNames();
	List<String> list = Lists.newArrayList();
	
	while(e.hasMoreElements())
	{
		String key = (String) e.nextElement();
		
		if (key != null && key.contains(property))
		{
			list.add(props.getProperty(key));
		}
	}
	
	in.close();
	
	return list.size() > 0 ? list.get((int) (Math.random() * list.size())) : "Error";
}
 

import java.util.Properties; //導入方法依賴的package包/類
private static void readTagNames() {
    try {
        File jarLocation = new File(Config.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath()).getParentFile();
        File[] configFiles = jarLocation.listFiles(f -> f.isFile() && f.getName().equals("ruuvi-names.properties"));
        if (configFiles == null || configFiles.length == 0) {
            // look for config files in the parent directory if none found in the current directory, this is useful during development when
            // RuuviCollector can be run from maven target directory directly while the config file sits in the project root
            configFiles = jarLocation.getParentFile().listFiles(f -> f.isFile() && f.getName().equals("ruuvi-names.properties"));
        }
        if (configFiles != null && configFiles.length > 0) {
            LOG.debug("Tag names: " + configFiles[0]);
            Properties props = new Properties();
            props.load(new FileInputStream(configFiles[0]));
            Enumeration<?> e = props.propertyNames();
            while (e.hasMoreElements()) {
                String key = StringUtils.trimToEmpty((String) e.nextElement()).toUpperCase();
                String value = StringUtils.trimToEmpty(props.getProperty(key));
                if (key.length() == 12 && value.length() > 0) {
                    TAG_NAMES.put(key, value);
                }
            }
        }
    } catch (URISyntaxException | IOException ex) {
        LOG.warn("Failed to read tag names", ex);
    }
}
 

import java.util.Properties; //導入方法依賴的package包/類
public synchronized void setClientInfo(java.sql.Connection conn, Properties properties) throws SQLClientInfoException {
    try {
        Enumeration<?> propNames = properties.propertyNames();

        while (propNames.hasMoreElements()) {
            String name = (String) propNames.nextElement();
            String value = properties.getProperty(name);

            setClientInfo(conn, name, value);
        }
    } catch (SQLException sqlEx) {
        SQLClientInfoException clientInfoEx = new SQLClientInfoException();
        clientInfoEx.initCause(sqlEx);

        throw clientInfoEx;
    }
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 * Replaces all the occurrences of variables in the given source object with their matching
 * values from the properties.
 *
 * @param source the source text containing the variables to substitute, null returns null
 * @param valueProperties the properties with values, may be null
 * @return the result of the replace operation
 * @since 2.6
 */
public static String replace(Object source, Properties valueProperties)
{
    if (valueProperties == null) {
        return source.toString();
    }
    Map valueMap = new HashMap();
    Enumeration propNames = valueProperties.propertyNames();
    while (propNames.hasMoreElements())
    {
        String propName = (String)propNames.nextElement();
        String propValue = valueProperties.getProperty(propName);
        valueMap.put(propName, propValue);
    }
    return StrSubstitutor.replace(source, valueMap);
}
 

import java.util.Properties; //導入方法依賴的package包/類
private static void vulElementen() {
    final Properties elementProperties = leesProperties();
    final Enumeration<?> elementNamen = elementProperties.propertyNames();
    final Map<String, String[]> metVerwijzing = new HashMap<>();
    final Map<String, String[]> zonderVerwijzing = new HashMap<>();

    while (elementNamen.hasMoreElements()) {
        final String elementNaam = (String) elementNamen.nextElement();
        final String[] elementPropertyWaarde = parsePropertyWaarde(elementProperties.getProperty(elementNaam));
        final String groepVerwijzing = elementPropertyWaarde[PROPERTY_GROEP];
        if (isLeeg(groepVerwijzing)) {
            zonderVerwijzing.put(elementNaam, elementPropertyWaarde);
        } else {
            metVerwijzing.put(elementNaam, elementPropertyWaarde);
        }
    }
    vulElementen(zonderVerwijzing);
    vulElementen(metVerwijzing);
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 *
 **/
// XXX Either generalize this facility or remove it completely.
protected void packageFromProps (Properties props) throws InvalidArgument
{
  Enumeration propsEnum = props.propertyNames ();
  while (propsEnum.hasMoreElements ())
  {
    String prop = (String)propsEnum.nextElement ();
    if (prop.startsWith ("PkgPrefix."))
    {
      String type = prop.substring (10);
      String pkg = props.getProperty (prop);
      checkPackageNameValid( pkg ) ;
      checkPackageNameValid( type ) ;
      packages.put (type, pkg);
    }
  }
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 * Helper to load parameters from a .properties file
 */
private Map<String, Object> loadParameters() throws Exception {
    Properties prop = new Properties();
    prop.load(new FileInputStream("src/main/resources/application.properties"));

    Map<String, Object> answer = new HashMap<>();
    Enumeration<?> en = prop.propertyNames();
    while (en.hasMoreElements()) {
        String key = (String) en.nextElement();
        Object value = prop.getProperty(key);
        answer.put(key, value);

    }
    return answer;
}
 

import java.util.Properties; //導入方法依賴的package包/類
protected Map<String, String> toMap(Properties properties) {
  Map<String, String> result = Maps.newHashMap();
  Enumeration<?> propertyNames = properties.propertyNames();
  while (propertyNames.hasMoreElements()) {
    String name = (String) propertyNames.nextElement();
    String value = properties.getProperty(name);
    result.put(name, value);
  }
  return result;
}
 

import java.util.Properties; //導入方法依賴的package包/類
public void addProperties(Properties props) {

        if (props == null) {
            return;
        }

        Enumeration keys = props.propertyNames();

        while (keys.hasMoreElements()) {
            String key   = (String) keys.nextElement();
            String value = props.getProperty(key);

            this.stringProps.put(key, value);
        }
    }
 

import java.util.Properties; //導入方法依賴的package包/類
public static void createCacheClient(Pool poolAttr, String regionName, Properties dsProperties,
    Boolean addControlListener, Properties javaSystemProperties) throws Exception {
  new CacheServerTestUtil().createCache(dsProperties);
  IgnoredException.addIgnoredException("java.net.ConnectException||java.net.SocketException");

  if (javaSystemProperties != null && javaSystemProperties.size() > 0) {
    Enumeration e = javaSystemProperties.propertyNames();

    while (e.hasMoreElements()) {
      String key = (String) e.nextElement();
      System.setProperty(key, javaSystemProperties.getProperty(key));
    }
  }

  PoolFactoryImpl pf = (PoolFactoryImpl) PoolManager.createFactory();
  pf.init(poolAttr);
  PoolImpl p = (PoolImpl) pf.create("CacheServerTestUtil");
  AttributesFactory factory = new AttributesFactory();
  factory.setScope(Scope.LOCAL);
  factory.setPoolName(p.getName());
  if (addControlListener.booleanValue()) {
    factory.addCacheListener(new ControlListener());
  }
  RegionAttributes attrs = factory.create();
  cache.createRegion(regionName, attrs);
  pool = p;
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 * Loads timeouts values.
 *
 * @param stream Stream to load timeouts from.
 * @see org.netbeans.jemmy.Timeouts#load(String)
 * @see org.netbeans.jemmy.Timeouts#load()
 * @exception IOException
 */
public void load(InputStream stream)
        throws IOException {
    Properties props = new Properties();
    props.load(stream);
    Enumeration<?> propNames = props.propertyNames();
    long propValue;
    String propName = null;
    while (propNames.hasMoreElements()) {
        propName = (String) propNames.nextElement();
        propValue = Long.parseLong(props.getProperty(propName));
        setTimeout(propName, propValue);
    }
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 * Internal method to create the initial set of properties. There
 * are two layers of properties: the default layer and the base layer.
 * The latter contains properties defined in the stylesheet or by
 * the user using this API.
 */
private Properties createOutputProperties(Properties outputProperties) {
    final Properties defaults = new Properties();
    setDefaults(defaults, "xml");

    // Copy propeties set in stylesheet to base
    final Properties base = new Properties(defaults);
    if (outputProperties != null) {
        final Enumeration names = outputProperties.propertyNames();
        while (names.hasMoreElements()) {
            final String name = (String) names.nextElement();
            base.setProperty(name, outputProperties.getProperty(name));
        }
    }
    else {
        base.setProperty(OutputKeys.ENCODING, _translet._encoding);
        if (_translet._method != null)
            base.setProperty(OutputKeys.METHOD, _translet._method);
    }

    // Update defaults based on output method
    final String method = base.getProperty(OutputKeys.METHOD);
    if (method != null) {
        if (method.equals("html")) {
            setDefaults(defaults,"html");
        }
        else if (method.equals("text")) {
            setDefaults(defaults,"text");
        }
    }

    return base;
}
 

import java.util.Properties; //導入方法依賴的package包/類
private void init() {
    // GET APPLETVIEWER USER-SPECIFIC PROPERTIES
    Properties avProps = getAVProps();

    // ADD OTHER RANDOM PROPERTIES
    // XXX 5/18 need to revisit why these are here, is there some
    // standard for what is available?

    // Standard browser properties
    avProps.put("browser", "sun.applet.AppletViewer");
    avProps.put("browser.version", "1.06");
    avProps.put("browser.vendor", "Oracle Corporation");
    avProps.put("http.agent", "Java(tm) 2 SDK, Standard Edition v" + theVersion);

    // Define which packages can be extended by applets
    // XXX 5/19 probably not needed, not checked in AppletSecurity
    avProps.put("package.restrict.definition.java", "true");
    avProps.put("package.restrict.definition.sun", "true");

    // Define which properties can be read by applets.
    // A property named by "key" can be read only when its twin
    // property "key.applet" is true.  The following ten properties
    // are open by default.  Any other property can be explicitly
    // opened up by the browser user by calling appletviewer with
    // -J-Dkey.applet=true
    avProps.put("java.version.applet", "true");
    avProps.put("java.vendor.applet", "true");
    avProps.put("java.vendor.url.applet", "true");
    avProps.put("java.class.version.applet", "true");
    avProps.put("os.name.applet", "true");
    avProps.put("os.version.applet", "true");
    avProps.put("os.arch.applet", "true");
    avProps.put("file.separator.applet", "true");
    avProps.put("path.separator.applet", "true");
    avProps.put("line.separator.applet", "true");

    // Read in the System properties.  If something is going to be
    // over-written, warn about it.
    Properties sysProps = System.getProperties();
    for (Enumeration e = sysProps.propertyNames(); e.hasMoreElements(); ) {
        String key = (String) e.nextElement();
        String val = (String) sysProps.getProperty(key);
        String oldVal;
        if ((oldVal = (String) avProps.setProperty(key, val)) != null)
            System.err.println(lookup("main.warn.prop.overwrite", key,
                                      oldVal, val));
    }

    // INSTALL THE PROPERTY LIST
    System.setProperties(avProps);

    // Create and install the security manager
    if (!noSecurityFlag) {
        System.setSecurityManager(new AppletSecurity());
    } else {
        System.err.println(lookup("main.nosecmgr"));
    }

    // REMIND: Create and install a socket factory!
}
 

import java.util.Properties; //導入方法依賴的package包/類
private String[] activationArgs(ActivationGroupDesc desc) {
    ActivationGroupDesc.CommandEnvironment cmdenv;
    cmdenv = desc.getCommandEnvironment();

    // argv is the literal command to exec
    List<String> argv = new ArrayList<>();

    // Command name/path
    argv.add((cmdenv != null && cmdenv.getCommandPath() != null)
                ? cmdenv.getCommandPath()
                : command[0]);

    // Group-specific command options
    if (cmdenv != null && cmdenv.getCommandOptions() != null) {
        argv.addAll(Arrays.asList(cmdenv.getCommandOptions()));
    }

    // Properties become -D parameters
    Properties props = desc.getPropertyOverrides();
    if (props != null) {
        for (Enumeration<?> p = props.propertyNames();
             p.hasMoreElements();)
        {
            String name = (String) p.nextElement();
            /* Note on quoting: it would be wrong
             * here, since argv will be passed to
             * Runtime.exec, which should not parse
             * arguments or split on whitespace.
             */
            argv.add("-D" + name + "=" + props.getProperty(name));
        }
    }

    /* Finally, rmid-global command options (e.g. -C options)
     * and the classname
     */
    for (int i = 1; i < command.length; i++) {
        argv.add(command[i]);
    }

    String[] realArgv = new String[argv.size()];
    System.arraycopy(argv.toArray(), 0, realArgv, 0, realArgv.length);

    return realArgv;
}
 

import java.util.Properties; //導入方法依賴的package包/類
/**
 * Sets the values of Options using the values in <code>properties</code>.
 *
 * @param properties The modifier properties to be processed.
 * @throws ParseException if there are any problems encountered
 *                        while processing the properties.
 */
protected void processProperties(Properties properties) throws ParseException
{
    if (properties == null)
    {
        return;
    }

    for (Enumeration<?> e = properties.propertyNames(); e.hasMoreElements();)
    {
        String option = e.nextElement().toString();

        Option opt = options.getOption(option);
        if (opt == null)
        {
            throw new UnrecognizedOptionException("Default option wasn't defined", option);
        }

        // if the option is part of a group, check if another option of the group has been selected
        OptionGroup group = options.getOptionGroup(opt);
        boolean selected = group != null && group.getSelected() != null;

        if (!cmd.hasOption(option) && !selected)
        {
            // get the modifier from the properties instance
            String value = properties.getProperty(option);

            if (opt.hasArg())
            {
                if (opt.getValues() == null || opt.getValues().length == 0)
                {
                    try
                    {
                        opt.addValueForProcessing(value);
                    }
                    catch (RuntimeException exp) //NOPMD
                    {
                        // if we cannot add the modifier don't worry about it
                    }
                }
            }
            else if (!("yes".equalsIgnoreCase(value)
                    || "true".equalsIgnoreCase(value)
                    || "1".equalsIgnoreCase(value)))
            {
                // if the modifier is not yes, true or 1 then don't add the
                // option to the CommandLine
                continue;
            }

            cmd.addOption(opt);
            updateRequiredOptions(opt);
        }
    }
}