如何用用户定义的对象填充数组？

Question

I am writing a program that creates an object (Line) that contains a name and two nodes (x,y,z coordinates) which are then stored in a separate object (class LineModel). Within the class LineModel a method, getNodes(), is created that should return an array containing all the nodes.

My problem lies within the method getNodes(), as I am struggling to populate the array. My code is below.

public class LineModel {

    // Object attributes
    private String name;
    private Line[] lines;
    private int numLines;

    // Constructor
    public LineModel(String name, int maxLines) {
        this.name = name;
        lines = new Line[maxLines];
        numLines = 0;
    }

    public void addLine(Line line) {
        if (contains(line)) {
            System.out.println("Line " + line.getName() + " already in model");
            return;
        }
        if (numLines < lines.length) {
            lines[numLines] = line;
            numLines++;
        } else {
            System.out.println("Increase lines array size.");
            System.exit(1);
        }
    }

    public boolean contains(Line line) {
        for (int i = 0; i < numLines; i++) {
            if (line == lines[i])
                return true;
        }
        return false;
    }

    public Line getLine(String name) {
        for (int i = 0; i < numLines; i++) {
            if (lines[i].getName().equals(name))
                return lines[i];
        }
        System.out.println("Line " + name + " not found");
        return null;
    }

    public void printModel() {
        System.out.println('\n' + "Line model: " + name);
        for (int i = 0; i < numLines; i++) {
            System.out.println(lines[i]);
        }
    }

    public Node getNode(String name) {
        // Loop through lines
        for (int i = 0; i <= numLines; i++) {
            // Check if node 1 is contained in the line and returns if true
            if (lines[i].getN1().getName().equals(name)) {
                return lines[i].getN1();
            }
            // Check if node 2 is contained in the line and returns if true
            else if (lines[i].getN2().getName().equals(name)) {
                return lines[i].getN2();
            }
        }
        return null;
    }

    public Node[] getNodes() {
        Node[] nodes = new Node[2 * numLines];
        for (int i = 0; i < numLines; i++) {
            Node start = lines[i].getN1();
            Node end = lines[i].getN2();
            for (int j = 0; j < nodes.length - 1; j++) {
                nodes[j] = start;
                for (int k = 1; k <= nodes.length - 1; k++) {
                    nodes[k] = end;
                }
            }
        }
        return nodes;
    }
}

Classes Node and Line are below

public class Node {
    // Object attributes
    private String name;
    private double[] coordinates;

    // Constructor(s)
    public Node(String name, double x) {
        this.name = name;
        coordinates = new double[1];
        coordinates[0] = x;
    }

    public Node(String name, double x, double y) {
        this.name = name;
        coordinates = new double[2];
        coordinates[0] = x; coordinates[1] = y;
    }

    public Node(String name, double x, double y, double z) {
        this.name = name;
        coordinates = new double[3];
        coordinates[0] = x; coordinates[1] = y; coordinates[2] = z;
    }

    // Object methods
    public String getName(){
        return name;
    }
    
    public double[] getCoordinates(){
        return coordinates;
    }
    
    public double getX() {
        if (coordinates.length > 0){
            return coordinates[0];
        } else {
            return Double.NaN;
        }
    }
    
    public double getY() {
        if (coordinates.length > 1){
            return coordinates[1];
        } else {
            return Double.NaN;
        }
    }
    
    public double getZ() {
        if (coordinates.length > 2){
            return coordinates[2];
        } else {
            return Double.NaN;
        }
    }

    public String toString() {
        return "Node "+name+" "+Arrays.toString(coordinates);
    }
}

public class Line {
    // Object attributes
    private String name;
    private Node n1, n2;
    
    // Constructor(s)
    public Line(String name, Node n1, Node n2){
        this.name = name;
        this.n1 = n1;
        this.n2 = n2;
    }
    
    public String getName(){ return name; }
    
    // Object methods
    public double length(){
        double[] n1C = n1.getCoordinates();
        double[] n2C = n2.getCoordinates();
        if(n1C.length == n2C.length){
            double pythagoras = 0;
            for (int i = 0; i < n1C.length; i++) {
                double dv = n2C[i] - n1C[i];
                pythagoras += dv*dv;
            }
            return Math.sqrt(pythagoras);
        }
        return Double.NaN;
    }

    @Override
    public String toString(){
        return "Line "+name+" "+n1.getName()+"-->"+n2.getName()+" Length = "+length();
    }

My current output is this:

[L_22751459.Node;@7530d0a

Answer 1

You just need to replace your getNodes() method with below code.

Need to introduce extra variable count and for every added node simply increment it. So automatically for two lines it will add four nodes like node[0],node[1],node[2],node[3]

public Node[] getNodes() {
        int count=0;
        Node[] nodes = new Node[2 * numLines];
        for (int i = 0; i < numLines; i++) {
            nodes[count]=lines[i].getN1();
            nodes[count+1]=lines[i].getN2();
            count=count+2;
        }
        return nodes;
    }



public static void main(String[] args) {
    LineModel obj2=new LineModel("l2",2);
    obj2.addLine(new Line("name1",new Node("x",1.0),new Node("y",2.0)));
    obj2.addLine(new Line("name2",new Node("x",2.0),new Node("y",3.0)));
    Node[] arr=obj2.getNodes();
    Arrays.stream(arr).forEach(node -> System.out.println(node.toString()));
}

Above code printing below Output which is perfectly fine.

Node x [1.0]
Node y [2.0]
Node x [2.0]
Node y [3.0]