Java Properties Load from File loadStrictly(File file)

Description

Loads a Map from a File assuming strings as keys and values.

License

Open Source License

Parameter

Parameter	Description
file	the File containing a Properties -like layout of keys and values.

Return

the read data as a .

Declaration

public static Map<String, String> loadStrictly(File file) 

Method Source Code

//package com.java2s;
/**//from   ww  w .  jav a  2  s .  c o m
 * Copyright (c) 2002-2014 "Neo Technology,"
 * Network Engine for Objects in Lund AB [http://neotechnology.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;

import java.io.IOException;
import java.io.InputStream;

import java.io.Reader;

import java.util.HashMap;

import java.util.Map;
import java.util.Properties;

public class Main {
    /**
     * Loads a {@link Map} from a {@link Reader} assuming strings as keys
     * and values. Any {@link IOException} is wrapped and thrown as a
     * {@link RuntimeException} instead.
     *
     * @param reader the {@link Reader} containing a {@link Properties}-like
     * layout of keys and values.
     * @return the read data as a {@link Map}.
     */
    public static Map<String, String> loadStrictly(Reader reader) {
        try {
            return load(reader);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Loads a {@link Map} from an {@link InputStream} assuming strings as keys
     * and values. Any {@link IOException} is wrapped and thrown as a
     * {@link RuntimeException} instead.
     *
     * @param stream the {@link InputStream} containing a
     * {@link Properties}-like layout of keys and values.
     * @return the read data as a {@link Map}.
     */
    public static Map<String, String> loadStrictly(InputStream stream) {
        try {
            return load(stream);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Loads a {@link Map} from a {@link File} assuming strings as keys
     * and values. Any {@link IOException} is wrapped and thrown as a
     * {@link RuntimeException} instead.
     *
     * @param file the {@link File} containing a {@link Properties}-like
     * layout of keys and values.
     * @return the read data as a {@link Map}.
     */
    public static Map<String, String> loadStrictly(File file) {
        try {
            return load(file);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Loads a {@link Map} from a {@link Reader} assuming strings as keys
     * and values.
     *
     * @param reader the {@link Reader} containing a {@link Properties}-like
     * layout of keys and values.
     * @return the read data as a {@link Map}.
     * @throws IOException if the {@code reader} throws {@link IOException}.
     */
    public static Map<String, String> load(Reader reader) throws IOException {
        Properties props = new Properties();
        props.load(reader);
        return new HashMap<String, String>((Map) props);
    }

    /**
     * Loads a {@link Map} from an {@link InputStream} assuming strings as keys
     * and values.
     *
     * @param stream the {@link InputStream} containing a
     * {@link Properties}-like layout of keys and values.
     * @return the read data as a {@link Map}.
     * @throws IOException if the {@code stream} throws {@link IOException}.
     */
    public static Map<String, String> load(InputStream stream) throws IOException {
        Properties props = new Properties();
        props.load(stream);
        return new HashMap<String, String>((Map) props);
    }

    /**
     * Loads a {@link Map} from a {@link File} assuming strings as keys
     * and values.
     *
     * @param file the {@link File} containing a {@link Properties}-like
     * layout of keys and values.
     * @return the read data as a {@link Map}.
     * @throws IOException if the file reader throws {@link IOException}.
     */
    public static Map<String, String> load(File file) throws IOException {
        FileInputStream stream = null;
        try {
            stream = new FileInputStream(file);
            return load(stream);
        } finally {
            closeIfNotNull(stream);
        }
    }

    private static void closeIfNotNull(Closeable closeable) throws IOException {
        if (closeable != null)
            closeable.close();
    }
}

Related

1. loadReader(Reader stream)
2. loadRecursively(String propertiesFilename)
3. loadRQGProperties()
4. loadSetting(InputStream in, String key)
5. loadSettings(String propertiesFileName)
6. loadSystemProperty(String evn, String fileName)
7. loadTestProperties(String filename)
8. loadToStringFromFile(String fullFileName)
9. loadTrimedProperties(String filename)