求java完整的读取ini的所有section及key及删除section或key等

如题!

现在网上的java读取ini都是只读取某个section下的key的value

哪个高人能实现如下功能!

读取某个section下的key的value

读取ini的所有section及key

删除section及其下面的key

只删除某个section下的一个key

修改section

我觉得这样算比较完整了..希望大家帮忙!

14 个解决方案

#1

拜托楼主先把自己的问题整理一下
你的问题有矛盾阿

现在网上的java读取ini都是只读取某个section下的key的value 
读取某个section下的key的value 

#2

还有，貌似楼主对ini文件的理解出现偏差

1.ini文件中的key是唯一的
所以，不存在
读取某个section下的key的value

检索ini文件的时候，肯定是全文检索key，怎莫能定位到section呢
除非你把ini文件当普通的文本文件来处理 

2.所谓section
只不过用注释来区分段落，以便ini文件具有更好的可读性
实际上不起任何作用

#3

就是有两种嘛
一种是带section一种是没有的

我就是需要有section的嘛..key可能是检索全文的..但是他读取的还是某个section下的key的value呀

#4

引用 3 楼 bemperor 的回复:

就是有两种嘛
一种是带section一种是没有的

我就是需要有section的嘛..key可能是检索全文的..但是他读取的还是某个section下的key的value呀

我都说了，section只不过是注释，可以自己加，也可以删掉

不然，楼主自己贴一个你理解的带section的ini文件上来

#5

section不是注释，以前的ini中不同section中的key是可以重复的，而且读取时也需要指定section才可以读取出来

[mysqld]
basedir=D:/MySQL/
datadir=D:/MySQL/data
default-character-set=gbk
[client]
default-character-set=gbk


java中默认没有对这样的ini支持。如果你需要，自己写咯，一行行的读取发现是"["开头就是section开头，然后读取到一行就找"="，前面是key后面是value就行了

#6

我也是想用一行一行读..但就是想找找看有没有更好的方法!

#7

所以偶说，除非不把它当ini文件看
一行行读，和读一般文本文件有何区别呢

#8

所以我发贴就是想问能不能不把他当文本文件读..有没有更好的办法!

#9

你就单独写一个类来处理这种ini文件啊，这个并不复杂啊。（实现当然还是一行行的读，Properties文件也一样是这种处理方式啊）

#10

呵呵，楼主这些功能windows api里倒都直接有，java里不流行这些，流行的是xml

#11

public class IniFile {
	private Map<String, Map<String, String>> values = new HashMap<String, Map<String,String>>();
	public IniFile(File file) throws IOException {
		BufferedReader reader = new BufferedReader(new FileReader(file));
		String line;
		String section = null;
		while((line = reader.readLine()) != null) {
			line = line.trim();
			if(line.length() == 0)
				continue;
			if(line.startsWith("#"))
				continue;
			if(line.startsWith("["))
				section = line.substring(1, line.lastIndexOf(']'));
			else {
				int index = line.indexOf('=');
				if(index < 0)
					continue;
				String key = line.substring(0, index);
				String value = line.substring(index + 1);
				Map<String, String > sectionValues = values.get(section);
				if(sectionValues == null) {
					sectionValues = new HashMap<String, String>();
					values.put(section, sectionValues);
				}
				sectionValues.put(key, value);
			}
		}
		reader.close();
	}

	public String getProperty(String section, String key, String defaultValue) {
		Map<String, String> sectionValues = values.get(section);
		if(sectionValues == null)
			return defaultValue;
		String value = sectionValues.get(key);
		if(value == null)
			return defaultValue;
		else
			return value;
	}
}

随便写一个例子

#12

其实早有免费的jar包可以用了
http://ini4j.sourceforge.net/

#13

ls提供的东东貌似不错哦

#14

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class Ini implements Iterable<Section> {
    
    private Map<String, Section> sections = null;
    
    public Ini() {
    }
    
    public void load(InputStream in) throws IOException {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(in));
            Section section = Section.getDefaultSection();
            for(String str = null; (str = br.readLine()) != null; ) {
                Item item = parseItem(str, section);
                if(item == null) {
                    continue;
                }
                if(item instanceof Section) {
                    section = addSection((Section)item);
                    continue;
                }
                if(item instanceof Pair) {
                    addPair((Pair)item);
                    continue;
                }
            }
        } finally {
            closeIO(br);
        }
    }
    
    public Section getSection(String sectionName) {
        return sections.get(sectionName);
    }
    
    public Pair getPair(String sectionName, String pairName) {
        Section section = getSection(sectionName);
        if(section == null) {
            return null;
        }
        return section.getPair(pairName);
    }
    
    private void addPair(Pair pair) {
        initSections();
        Section section = addSection(pair.getSection());
        section.addItem(pair);
    }
    
    private Section addSection(Section section) {
        initSections();
        if(sections.get(section.getName()) == null) {
            sections.put(section.getName(), section);
        }
        return section;
    }
    
    private void initSections() {
        if(sections == null) {
            sections = new LinkedHashMap<String, Section>();
        }
    }
    
    private void closeIO(Closeable io) throws IOException {
        if(io != null) {
            io.close();
        }
    }
    
    private Item parseItem(String line, Section section) {
        if(line == null || (line = line.trim()).length() == 0) {
            return null;
        }
        line = escape(line);                       
        if((line = line.trim()).length() == 0) {
            return null;
        }
        
        int idx = line.indexOf('=');
        if(idx > 0) {
            return new Pair(line.substring(0, idx).trim(), line.substring(idx + 1).trim(), section);
        }        
        if(line.startsWith("[") && line.endsWith("]")) {
            return new Section(line.substring(1, line.length() - 1).trim());
        }
        return null;
    }
    
    private String escape(String line) {
        if(line.indexOf('\\') < 0 && line.indexOf('#') < 0) {
            return line;
        }
        char[] chs = line.toCharArray();
        char[] nchs = new char[chs.length];
        
        boolean preBackslash = false;
        int k = 0;
        for(int i = 0; i < chs.length; i++) {            
            if(chs[i] == '\\') {                
                if(!preBackslash) {                    
                    nchs[k++] = '\\';
                }
                preBackslash = !preBackslash;
                continue;
            }
            if(chs[i] == '#') {
                if(!preBackslash) {
                    return new String(nchs, 0, k);
                }
                preBackslash = false;
                nchs[k - 1] = '#';
                continue;
            }
            if(preBackslash) {
                preBackslash = false;
            }
            nchs[k++] = chs[i];
        }
        return new String(nchs, 0, k);
    }
    
    public String toString() {
        if(sections == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        for(Map.Entry<String, Section> entry : sections.entrySet()) {
            sb.append(entry.getValue().serialize()).append("\n");
            for(Pair p : entry.getValue()) {
                sb.append(p.serialize()).append("\n");
            }
        }
        return sb.toString();
    }

    public Iterator<Section> iterator() {
        if(sections == null) {
            return null;
        }
        return sections.values().iterator();
    }
    
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Ini ini = new Ini();
        ini.load(new FileInputStream("mysql.ini"));        
        System.out.println(ini.toString());
        
        System.out.println(ini.getPair("mysqld", "datadir").serialize());        
    }
}

public abstract class Item {

    protected String name;
    
    public Item(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public abstract String serialize();
}

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class Section extends Item implements Iterable<Pair> {

    private Map<String, Pair> items;
    
    public final static String DEFAULT_SECTION_NAME = "default-section-name";
    
    private static Section defaultSection = new Section(DEFAULT_SECTION_NAME);
    
    public static Section getDefaultSection() {
        return defaultSection;
    }
    
    public Section(String name) {
        super(name);
    }
    
    public int size() {
        if(items == null) {
            return 0;
        }
        return items.size();
    }

    public Pair addItem(Pair item) {
        if(items == null) {
            items = new LinkedHashMap<String, Pair>();
        }
        return items.put(item.getName(), item);
    }
    
    public Pair addItem(String key, String value) {
        return addItem(new Pair(key, value, this));
    }
    
    public Pair removeItem(Pair item) {
        if(items == null) {
            return null;
        }
        return items.remove(item.getName());
    }
    
    public Pair removeItem(String key) {
        if(items == null) {
            return null;
        }
        return items.remove(key);
    }
    
    public String serialize() {
        return "[" + getName() + "]";
    }

    public Iterator<Pair> iterator() {
        if(items == null) {
            return null;
        }
        return items.values().iterator();
    }
    
    public Pair getPair(String pairName) {
        if(items == null) {
            return null;
        }
        return items.get(pairName);
    }
}

public class Pair extends Item {

    private String value;
    private Section section;
    
    public Pair(String name, String value, Section section) {
        super(name);
        this.value = value;
        this.section = section;
    }
    
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    public Section getSection() {
        return section;
    }
    public void setSection(Section section) {
        this.section = section;
    }
    
    public String serialize() {
        return getName() + "=" + getValue();
    }
}