Remplissage d'une structure arborescente de Bean Java à partir d'un fichier plat csv

Vous pouvez essayer de voir le problème d'une manière un peu plus générale, jetez un oeil ci-dessous:

private void buildTree(final Node<T> rootNode, final ArrayList<Node<T>> groupNodes) {
    for (final Node<T> parentNode : groupNodes) {
        if (parentNode.getParent() == rootNode) {
            parentNode.setParent(rootNode);
            rootNode.addChild(parentNode);
        }
        for (final Node<T> childNode : groupNodes) {
            if (parentNode.getData().getGroupId().equalsIgnoreCase(childNode.getData().getParentId())) {
                childNode.setParent(parentNode);
                parentNode.addChild(childNode);
            }
        }
    }
}

Mon Node class a Getter et Setter pour un objet (Data) qui, entre autres, des propriétés a un GroupId et a ParentId la propriété

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

/**
 * A program that takes a comma seperated tree values and converts it into an image
 * Ex: root-child1,root-child2,child1-children1,child2-children2...
 * */
public class DrawGraph {

    private Hashtable listparent = new Hashtable();
    private Hashtable keyerrors = new Hashtable();
    private Hashtable nodetree = new Hashtable();
    private Hashtable connectNodes = new Hashtable();
    private LinkedList rowsLinkedList = new LinkedList();
    private static int start_xaxis = 0;
    private static int start_yaxis = 40;
    private static int xaxis = 800;
    private static int yaxis = 600;
    private static int end_xaxis = 0;
    private static int maxy = 0;
    private static int rectx = 0;
    private static int recty = 0;
    private int rows = 0;
    private static String root;
    private static Graphics2D g;
    private static int bigx = 0;
    private int bigy = 0;
    private Hashtable _listparent = new Hashtable();
    private Hashtable _keyerrors = new Hashtable();
    private Hashtable _nodetree = new Hashtable();
    private Hashtable _connectNodes = new Hashtable();
    private LinkedList _rowsLinkedList = new LinkedList();
    private static int _start_xaxis = 0;
    private static int _start_yaxis = 40;
    private static int _xaxis = 1000;
    private static int _yaxis = 800;
    private static int _end_xaxis = 0;
    private static int _maxy = 0;
    private static int _rectx = 0;
    private static int _recty = 0;
    private int _rows = 0;
    private static String _root;
    private static Graphics2D _g;

    public static void main(String args[]) {
        if (args.length == 0) {
            System.out.println("USAGE:  ");
            System.out.println("DrawGraph <queryString> <imagelocation>  ");
        }
        DrawGraph myn = new DrawGraph();
        args[0] = "root(1/2)-child1,root-child2,child1-children1,child2-children2(test1/test2)";
        args[1] = "c:/test.jpeg";
        myquery = args[0];
        myoutput = args[1];
        myn.initialize(args[0], args[1]);
    }
    private static String myquery = new String();
    private static String myoutput = new String();

    public String getErrors(String qstring) {

        StringBuffer sb = new StringBuffer();
        String[] namevalues = qstring.split(",");
        for (int i = 0; i < namevalues.length; i++) {
            String _key = namevalues[i].split("-")[0];
            String _children = namevalues[i].split("-")[1];

            String[] errors = _key.split("\\(");
            String[] errorsc = _children.split("\\(");

            String mykey = errors[0];
            String mychildrenkey = errorsc[0];

            LinkedList lk = new LinkedList();
            if (null != listparent.get(mychildrenkey)) {
                lk = (LinkedList) listparent.get(mychildrenkey);
            }

            lk.add(mykey);
            listparent.put(mychildrenkey, lk);

            if (i == 0) {
                root = mykey;
            }
            LinkedList _chil = new LinkedList();

            try {
                _chil = (LinkedList) nodetree.get(mykey);
                if (null == _chil) {
                    _chil = new LinkedList();

                }
            } catch (Exception ee) {
            }
            _chil.add(errorsc[0]);
            nodetree.put(mykey, _chil);

            sb.append(mykey + "-" + _children + ",");

            LinkedList l = new LinkedList();
            if (null != keyerrors.get(mykey)) {
                l = (LinkedList) keyerrors.get(mykey);
            }
            if (errors.length > 1) {
                String[] ers = errors[1].split("/");
                for (int j = 0; j < ers.length; j++) {
                    l.add(ers[j]);
                }
            }

            keyerrors.put(mykey, l);

            LinkedList lc = new LinkedList();
            if (null != keyerrors.get(mychildrenkey)) {
                lc = (LinkedList) keyerrors.get(mychildrenkey);
            }
            if (errorsc.length > 1) {

                String[] ersc = errorsc[1].split("/");
                for (int j = 0; j < ersc.length; j++) {
                    lc.add(ersc[j]);
                }
            }
            keyerrors.put(mychildrenkey, lc);
        }
        return (sb.toString());
    }

    public void initialize(String queryString, String outputfile) {

        getErrors(queryString);
        rowsLinkedList.add(root);
        String[] str = {root};
        drawTree(str);
        createImage(root, outputfile);
    }

    public void reinitialize(String queryString, String outputfile, int _xaxis, int _yaxis) {
        listparent = new Hashtable();
        keyerrors = new Hashtable();
        nodetree = new Hashtable();
        connectNodes = new Hashtable();
        rowsLinkedList = new LinkedList();

        System.out.println(_xaxis);
        getErrors(queryString);
        rowsLinkedList.add(root);
        String[] str = {root};
        drawTree(str);
        createImage(_xaxis, _yaxis, root, outputfile);
    }

    public void drawTree(String[] node) {
        String[] a = getGreatChildren(node);
        if (a.length > 0) {
            drawTree(a);
        }
    }

    public String[] getGreatChildren(String[] children) {
        StringBuffer sb = new StringBuffer();
        LinkedList ll = new LinkedList();
        for (int i = 0; i < children.length; i++) {

            if (null != getChildren(children[i])) {
                LinkedList temp = getChildren(children[i]);
                Iterator itr = temp.iterator();
                while (itr.hasNext()) {
                    String chld = itr.next().toString();
                    sb.append(chld);
                    sb.append(",");
                    ll.add(chld);
                }
            }
        }
        rows++;
        if (sb.toString().length() > 0) {
            rowsLinkedList.add(rows, sb.toString());
        }
        return convertLinkedListtoStringArray(ll);
    }

    public LinkedList getChildren(String node) {

        LinkedList l = new LinkedList();
        try {
            l = (LinkedList) nodetree.get(node);
            return l;
        } catch (Exception ee) {
        }

        return null;
    }

    public String[] convertLinkedListtoStringArray(LinkedList l) {

        String[] strnodes = null;
        int size = l.size();
        strnodes = new String[size];
        Object[] objectArray = l.toArray();
        new ArrayList();
        for (int i = 0; i < size; i++) {
            strnodes[i] = objectArray[i].toString();
        }

        return strnodes;
    }

    private String[] removeDuplicates(String[] l) {

        Hashtable h = new Hashtable();
        for (int i = 0; i < l.length; i++) {
            h.put(l[i], l[i]);
        }

        java.util.Enumeration enk = h.keys();
        LinkedList ll = new LinkedList();

        while (enk.hasMoreElements()) {
            String _as = enk.nextElement().toString();
            ll.add(_as);

        }

        return convertLinkedListtoStringArray(ll);
    }

    private void tmpinitialize() {

        _listparent = new Hashtable(listparent);
        _keyerrors = new Hashtable(keyerrors);
        _nodetree = new Hashtable(nodetree);
        _connectNodes = connectNodes;
        _rowsLinkedList = rowsLinkedList;
        _start_xaxis = start_xaxis;
        _start_yaxis = start_yaxis;
        _xaxis = xaxis;
        _yaxis = yaxis;
        _end_xaxis = end_xaxis;
        _maxy = maxy;
        _rectx = rectx;
        _recty = recty;
        _rows = rows;
        _root = root;
    }

    private void reset() {

        _listparent = listparent;
        _keyerrors = keyerrors;
        _nodetree = nodetree;
        _connectNodes = connectNodes;
        _rowsLinkedList = rowsLinkedList;
        _start_xaxis = start_xaxis;
        _start_yaxis = start_yaxis;
        _xaxis = xaxis;
        _yaxis = yaxis;
        _end_xaxis = end_xaxis;
        _maxy = maxy;
        _rectx = rectx;
        _recty = recty;
        _rows = rows;
        _root = root;

    }

    public void calculateXY() {

        tmpinitialize();

        Hashtable _allh = new Hashtable();
        int _noofrows = _rowsLinkedList.size();
        int _mxy = start_yaxis;
        for (int i = 0; i < _noofrows; i++) {

            String[] _tmpnodes = removeDuplicates(((String) _rowsLinkedList.get(i)).split(","));
            int _parts = calculateXY(_tmpnodes.length);

            start_yaxis = _mxy + 60;
            end_xaxis = 0;
            int _tmpy = start_yaxis;
            int _tmpx = 0;
            for (int j = 0; j < _tmpnodes.length; j++) {

                try {
                    if (j + 1 == 1) {
                        start_xaxis = _parts * (j + 1) - 20;
                    } else {
                        start_xaxis = _tmpx + _parts;// * (j + 1) - 50;
                    }

                    _tmpx = start_xaxis;
                    start_yaxis = _tmpy;

                    if (null == _allh.get(_tmpnodes[j])) {
                        drawNode(_tmpnodes[j]);
                    }
                    _allh.put(_tmpnodes[j], _tmpnodes[j]);
                    if (start_yaxis >= _mxy) {
                        _mxy = start_yaxis;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void createImage(String startNode, String outputfile) {

        BufferedImage image = new BufferedImage(xaxis, yaxis,
                BufferedImage.TYPE_INT_RGB);
        g = (Graphics2D) image.createGraphics();
        g.setColor(Color.white);
        g.fillRoundRect(0, 0, xaxis, yaxis, 0, 0);
        g.setColor(Color.white);
        Font f = new Font("SansSerif", Font.BOLD, 20);
        g.setFont(f);

        Hashtable allh = new Hashtable();
        int noofrows = rowsLinkedList.size();
        int mxy = start_yaxis;
        for (int i = 0; i < noofrows; i++) {

            String[] tmpnodes = removeDuplicates(((String) rowsLinkedList.get(i)).split(","));

            int parts = calculateXY(tmpnodes.length);

            start_yaxis = mxy + 60;
            end_xaxis = 0;
            int tmpy = start_yaxis;
            int tmpx = 0;
            int stringwidth = 0;
            for (int j = 0; j < tmpnodes.length; j++) {

                try {
                    if (j + 1 == 1) {
                        start_xaxis = parts * (j + 1) - 20;
                    } else {
                        start_xaxis = tmpx + parts;// * (j + 1) - 50;
                    }

                    tmpx = start_xaxis;

                    start_yaxis = tmpy;

                    if (null == allh.get(tmpnodes[j])) {
                        drawNode(tmpnodes[j]);
                    }
                    allh.put(tmpnodes[j], tmpnodes[j]);
                    if (start_yaxis >= mxy) {
                        mxy = start_yaxis;
                    }
                    FontMetrics ff = g.getFontMetrics();
                    stringwidth += (start_xaxis + ff.stringWidth(tmpnodes[j]));

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (stringwidth >= bigx) {
                bigx = stringwidth;
            }
            System.out.println("Row " + i + " " + stringwidth);
        }

        xaxis = bigx;
        yaxis = mxy + 40;

        System.out.println(xaxis);
        start_xaxis = 0;
        start_yaxis = 40;

        end_xaxis = 0;
        maxy = 0;
        rectx = 0;
        recty = 0;
        rows = 0;

        reinitialize(myquery, myoutput, bigx, mxy + 40);
    }

    public void createImage(int _xaxis, int _yaxis, String startNode, String outputfile) {

        BufferedImage image = new BufferedImage(_xaxis, _yaxis,
                BufferedImage.TYPE_INT_RGB);
        g = (Graphics2D) image.createGraphics();
        g.setColor(Color.white);
        g.fillRoundRect(0, 0, xaxis, yaxis, 0, 0);
        g.setColor(Color.white);
        Font f = new Font("SansSerif", Font.BOLD, 20);
        g.setFont(f);

        Hashtable allh = new Hashtable();
        int noofrows = rowsLinkedList.size();
        int mxy = start_yaxis;

        for (int i = 0; i < noofrows; i++) {

            String[] tmpnodes = removeDuplicates(((String) rowsLinkedList.get(i)).split(","));
            int parts = calculateXY(tmpnodes.length);

            start_yaxis = mxy + 60;
            end_xaxis = 0;
            int tmpy = start_yaxis;
            int tmpx = 0;
            for (int j = 0; j < tmpnodes.length; j++) {

                try {
                    if (j + 1 == 1) {
                        start_xaxis = parts * (j + 1) - 20;
                    } else {
                        start_xaxis = tmpx + parts;// * (j + 1) - 50;
                    }

                    tmpx = start_xaxis;
                    start_yaxis = tmpy;

                    if (null == allh.get(tmpnodes[j])) {
                        drawNode(tmpnodes[j]);
                    }
                    allh.put(tmpnodes[j], tmpnodes[j]);
                    if (start_yaxis >= mxy) {
                        mxy = start_yaxis;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        try {
            FileOutputStream jpegout = new FileOutputStream(
                    new File(outputfile));
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(jpegout);
            encoder.encode(image);

        } catch (Exception ee) {
            ee.printStackTrace();
        }
    }

    private int getMaxFm(String node) {

        int maxfm = 0;
        FontMetrics fm = g.getFontMetrics();
        maxfm = fm.stringWidth(node) + 10;

        LinkedList errorslist = (LinkedList) keyerrors.get(node);
        Iterator itr = errorslist.iterator();
        while (itr.hasNext()) {
            String eacherror = itr.next().toString();

            int tmpfm = fm.stringWidth(eacherror) + 10;
            if (tmpfm >= maxfm) {
                maxfm = tmpfm;
            }
        }

        return maxfm;
    }

    private int calculateXY(int nodecount) {
        try {
            return xaxis / (nodecount + 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public void drawNode(String node) {

        Font f = new Font("SansSerif", Font.BOLD | Font.BOLD, 20);
        g.setFont(f);
        recty = 0;
        maxy = 0;
        FontMetrics fm = g.getFontMetrics();
        int w = fm.stringWidth(node) + 10;
        int h = fm.getHeight() + 4;
        int x = 0;
        x = start_xaxis;
        int y = 0;
        y = start_yaxis;

        int startrect_xaxis = x - w / 2;
        if (startrect_xaxis < end_xaxis) {
            x = end_xaxis + w / 2 + 10;
            startrect_xaxis = x - w / 2;
        }
        int startnode_xaxis = x - (w - 10) / 2;
        int startnode_yaxis = (y - (h - 4) / 2) + fm.getAscent();

        int startrect_yaxis = y - h / 2;
        int xrectlength = w - 1;
        int yrectlength = h - 1;

        int end_yaxis = startrect_yaxis + yrectlength + 1;
        end_xaxis = startrect_xaxis + xrectlength + 1;
        g.setColor(Color.white);
        g.fillRect(startrect_xaxis, startrect_yaxis, w, h);
        g.setColor(Color.BLACK);

        g.drawString(node, startnode_xaxis, startnode_yaxis);
        recty = yrectlength;
        if (null != keyerrors.get(node)) {
            rectx = 0;
            f = new Font("SansSerif", Font.PLAIN, 20);
            g.setFont(f);
            drawNodeErrors(node, startnode_xaxis, end_yaxis);
            if (rectx <= xrectlength) {
                rectx = xrectlength;
            }
            g.setColor(Color.black);
            calculateEdges(node, startrect_xaxis, startrect_yaxis, rectx, recty + 2);
            g.setColor(Color.GRAY);
            g.drawRoundRect(startrect_xaxis, startrect_yaxis, rectx, recty + 2, 15, 15);
            start_yaxis = startrect_yaxis + recty;
        } else {
            g.setColor(Color.black);
            calculateEdges(node, startrect_xaxis, startrect_yaxis, xrectlength, yrectlength);
            g.setColor(Color.GRAY);
            g.drawRoundRect(startrect_xaxis, startrect_yaxis, xrectlength, yrectlength, 15, 15);
        }

        int bb = startrect_xaxis + xrectlength;
        if (bb >= bigx) {
            bigx = bb;
        }
    }

    public void drawNodeErrors(String node, int startnode_xaxis, int end_yaxis) {
        Iterator itr = ((LinkedList) keyerrors.get(node)).iterator();
        while (itr.hasNext()) {
            int startrect_xaxis = 0;
            int x = 0;
            int y = 0;
            int xrectlength = 0;
            node = itr.next().toString().replaceAll("\\)", "");
            FontMetrics fm = g.getFontMetrics();
            int w = fm.stringWidth(node) + 10;
            int h = fm.getHeight() + 4;
            x = start_xaxis;
            start_yaxis = start_yaxis + 20;
            y = start_yaxis;

            startrect_xaxis = x - w / 2;
            if (startrect_xaxis < end_xaxis) {
                x = end_xaxis + w / 2 + 10;
                startrect_xaxis = x - w / 2;
            }
            int startnode_yaxis = (y - (h - 4) / 2) + fm.getAscent();
            xrectlength = w - 1;
            g.setColor(Color.RED);
            g.drawString(node, startnode_xaxis, startnode_yaxis);
            recty += fm.getAscent();

            if (xrectlength >= rectx) {
                rectx = xrectlength;
            }
            if (recty >= maxy) {
                maxy = recty;
            }
        }
    }

    private void calculateEdges(String node, int startxaxis, int startyaxis,
            int xlength, int ylength) {

        int x1 = startxaxis + xlength / 2;
        int y1 = startyaxis;
        int x2 = x1;
        int y2 = startyaxis + ylength;

        middle m = new middle();
        m.setX1(x1);
        m.setY1(y1);
        m.setX2(x2);
        m.setY2(y2);
        m.setStartxaxis(startxaxis);

        connectNodes.put(node, m);
        try {
            String[] myparent = convertLinkedListtoStringArray((LinkedList) listparent.get(node));
            for (int j = 0; j < myparent.length; j++) {
                middle par = (middle) connectNodes.get(myparent[j]);

                int p[] = par.getBottom();
                int c[] = m.getTop();

                g.setColor(Color.black);
                int parentrectlength = p[0] - par.getStartxaxis();
                int parentendxaxis = par.getStartxaxis()
                        + (parentrectlength * 2);
                if (c[0] > par.getStartxaxis() && c[0] < parentendxaxis) {

                    drawArrow(g, c[0], p[1], c[0], c[1]);
                    drawMArrow(g, c[0], c[1], c[0], p[1]);
                } else {
                    drawArrow(g, p[0], p[1], c[0], c[1]);
                    drawMArrow(g, c[0], c[1], p[0], p[1]);
                }
            }
        } catch (Exception ee) {
        }
    }

    private void drawArrow(Graphics2D g, int x, int y, int xx, int yy) {
        float arrowWidth = 6.0f;
        float theta = 0.423f;
        int[] xPoints = new int[3];
        int[] yPoints = new int[3];
        float[] vecLine = new float[2];
        float[] vecLeft = new float[2];
        float fLength;
        float th;
        float ta;
        float baseX, baseY;

        xPoints[ 0] = xx;
        yPoints[ 0] = yy;

        vecLine[ 0] = (float) xPoints[ 0] - x;
        vecLine[ 1] = (float) yPoints[ 0] - y;

        vecLeft[ 0] = -vecLine[ 1];
        vecLeft[ 1] = vecLine[ 0];

        fLength = (float) Math.sqrt(vecLine[0] * vecLine[0] + vecLine[1] * vecLine[1]);
        th = arrowWidth / (2.0f * fLength);
        ta = arrowWidth / (2.0f * ((float) Math.tan(theta) / 2.0f) * fLength);

        baseX = ((float) xPoints[ 0] - ta * vecLine[0]);
        baseY = ((float) yPoints[ 0] - ta * vecLine[1]);

        xPoints[ 1] = (int) (baseX + th * vecLeft[0]);
        yPoints[ 1] = (int) (baseY + th * vecLeft[1]);
        xPoints[ 2] = (int) (baseX - th * vecLeft[0]);
        yPoints[ 2] = (int) (baseY - th * vecLeft[1]);

        g.drawLine(x, y, (int) baseX, (int) baseY);
        g.fillPolygon(xPoints, yPoints, 3);
    }

    private void drawMArrow(Graphics2D g, int x, int y, int xx, int yy) {
        float arrowWidth = 6.0f;
        float theta = 0.423f;
        int[] xPoints = new int[3];
        int[] yPoints = new int[3];
        float[] vecLine = new float[2];
        float[] vecLeft = new float[2];
        float fLength;
        float th;
        float ta;
        float baseX, baseY;

        xPoints[ 0] = xx;
        yPoints[ 0] = yy;

        vecLine[ 0] = (float) xPoints[ 0] - x;
        vecLine[ 1] = (float) yPoints[ 0] - y;

        vecLeft[ 0] = -vecLine[ 1];
        vecLeft[ 1] = vecLine[ 0];

        fLength = (float) Math.sqrt(vecLine[0] * vecLine[0] + vecLine[1] * vecLine[1]);
        th = arrowWidth / (2.0f * fLength);
        ta = arrowWidth / (2.0f * ((float) Math.tan(theta) / 2.0f) * fLength);

        baseX = ((float) xPoints[ 0] - ta * vecLine[0]);
        baseY = ((float) yPoints[ 0] - ta * vecLine[1]);

        xPoints[ 1] = (int) (baseX + th * vecLeft[0]);
        yPoints[ 1] = (int) (baseY + th * vecLeft[1]);
        xPoints[ 2] = (int) (baseX - th * vecLeft[0]);
        yPoints[ 2] = (int) (baseY - th * vecLeft[1]);

        g.fillPolygon(xPoints, yPoints, 3);

    }

    class middle {
        int x1;
        int y1;
        int x2;
        int y2;
        int startxaxis;

        public int getStartxaxis() {
            return startxaxis;
        }

        public void setStartxaxis(int startxaxis) {
            this.startxaxis = startxaxis;
        }

        public int getX1() {
            return x1;
        }

        public void setX1(int x1) {
            this.x1 = x1;
        }

        public int getY1() {
            return y1;
        }

        public void setY1(int y1) {
            this.y1 = y1;
        }

        public int getX2() {
            return x2;
        }

        public void setX2(int x2) {
            this.x2 = x2;
        }

        public int getY2() {
            return y2;
        }

        public void setY2(int y2) {
            this.y2 = y2;
        }

        public int[] getTop() {
            int t[] = new int[2];
            t[0] = this.x1;
            t[1] = this.y1;

            return t;
        }

        public int[] getBottom() {
            int t[] = new int[2];
            t[0] = this.x2;
            t[1] = this.y2;

            return t;
        }
    }
}