没事写的，实际更加推荐使用网上一些更加完善的在线工具
效果
正向转换
原内容

转换结果

反向
原内容

结果

主要类

public class p2y {

    private static final String REVERSE = "-r";
    private static final Pattern PATTERN = Pattern.compile("(.+)\\[(\\d+)]$");

    public static void main(String[] args) throws IOException {
        args = new String[]{"src/p2y/test.yaml","-r"};
        if (args.length == 1) {
            handleP2y(args[0]);
        } else if (args.length == 2) {
            if (args[1].equals(REVERSE)) {
                handleY2p(args[0]);
            } else {
                printHelp();
            }
        } else {
            printHelp();
        }
    }

    private static void handleY2p(String path) throws IOException {
        List<String> lines = Files.readAllLines(Paths.get(path), Charset.forName("UTF-8"));
        LinkedList<State> stack = new LinkedList<>();
        for (String line : lines) {
            handleLine(stack, line);
        }
    }

    private static void handleLine(LinkedList<State> stack, String line) {
        int index;
        String name;
        String value;
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            switch (c) {
                case ' ':
                case '\t':
                    break;
                case '#':
                    System.out.println(line);
                    return;
                case '-':
                    stack.peekLast().index++;
                    index = line.indexOf(':');
                    if(index!=-1){
                        name=line.substring(i+2,index).trim();
                        while (!stack.isEmpty()&&stack.peekLast().num>=i+2){
                            stack.pollLast();
                        }
                        stack.addLast(new State(name,i+2));
                    }else {
                        value=line.substring(i+2).trim();
                        printLine(stack,null,value);
                    }
                    return;
                default:
                    index = line.indexOf(':');
                    name=line.substring(i,index);
                    value=line.substring(index+1);
                    while (!stack.isEmpty()&&stack.peekLast().num>=i){
                        stack.pollLast();
                    }
                    if(value.trim().length()>0){
                        printLine(stack,name,value);
                    }else {
                        stack.addLast(new State(name,i));
                    }
                    return;
            }
        }
    }

    private static void printLine(LinkedList<State> stack, String name, String value) {
        StringBuilder builder=new StringBuilder();
        for (State state:stack){
            builder.append(state.getValue()).append('.');
        }
        if(name!=null){
            builder.append(name);
        }else {
            builder.setLength(builder.length()-1);
        }
        builder.append('=').append(value.trim());
        System.out.println(builder);
    }

    static class State {

        private String name;
        private int num;
        private int index;

        public State(String name, int num) {
            this.name = name;
            this.num = num;
            index=-1;
        }

        public String getValue() {
            if(index!=-1){
                return name+"["+index+"]";
            }else {
                return name;
            }
        }

    }

    private static void handleP2y(String path) throws IOException {
        List<String> lines = Files.readAllLines(Paths.get(path), Charset.forName("UTF-8"));
        Node root = new Node();
        for (String line : lines) {
            handleLine(root, line);
        }
        for (Map.Entry<String, Node> entry : root.map.entrySet()) {
            printYaml(entry.getKey(), entry.getValue(), 0);
        }
    }

    private static void printYaml(String name, Node node, int num) {
        if (node.value != null) {//普通值
            if (name != null) {
                print(num, name + ": " + node.value);
            } else {
                print(num, "- " + node.value);
            }
        } else if (node.map != null) {// map
            if (name != null) {
                print(num, name + ":");
                for (Map.Entry<String, Node> entry : node.map.entrySet()) {
                    printYaml(entry.getKey(), entry.getValue(), num + 2);
                }
            } else {
                // 注意第一次
                boolean first = true;
                for (Map.Entry<String, Node> entry : node.map.entrySet()) {
                    if (first) {
                        first = false;
                        printYaml("- " + entry.getKey(), entry.getValue(), num);
                    } else {
                        printYaml(entry.getKey(), entry.getValue(), num + 2);
                    }
                }
            }
        } else {//数组情况
            print(num, name + ":");
            for (Node chid : node.list) {
                printYaml(null, chid, num + 2);
            }
        }
    }

    private static void print(int num, String msg) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < num; i++) {
            builder.append(' ');
        }
        builder.append(msg);
        System.out.println(builder);
    }

    private static void handleLine(Node root, String line) {
        int index = line.indexOf('=');
        if (index == -1) return;
        String[] names = line.substring(0, index).split("\\.");
        next(root, names, 0, line.substring(index + 1));
    }

    private static void next(Node node, String[] names, int index, String value) {
        if (index < names.length) {
            next(node.getOrAdd(names[index]), names, index + 1, value);
        } else {
            node.value = value;
        }
    }

    static class Node {

        private Map<String, Node> map;
        private List<Node> list;
        private String value;

        public Node getOrAdd(String name) {
            Matcher matcher = PATTERN.matcher(name);
            if (matcher.find()) {
                Node node = handleMap(matcher.group(1));
                return node.handleList(Integer.parseInt(matcher.group(2)));
            } else {
                return handleMap(name);
            }
        }

        private Node handleList(int index) {
            if (list == null) list = new ArrayList<>();
            while (list.size() <= index) {
                list.add(new Node());
            }
            return list.get(index);
        }

        private Node handleMap(String name) {
            if (map == null) map = new HashMap<>();
            if (!map.containsKey(name)) {
                map.put(name, new Node());
            }
            return map.get(name);
        }

        @Override
        public String toString() {
            return "Node{" +
                    "map=" + map +
                    ", list=" + list +
                    ", value='" + value + '\'' +
                    '}';
        }

    }

    private static final String HELP = "功能:用于prop与yaml文件互转\n参数错误!\n需要先指明文件路径\n可以使用" + REVERSE +
            "指定y->p,默认是p->y\n可以使用>重定向到指定文件,默认输出到屏幕";

    private static void printHelp() {
        System.err.println(HELP);
    }

}

原类默认是为了写成，控制台程序的方便使用 使用控制台参数