find the path between nodes in binary tree

I made this code, it is because I saw there is a problem in geeksforgeeks: link
But it only gets the distance of 2 nodes. I’m thinking how to get the path of the 2 nodes. The idea is inspired by Pavel Fusu’s code. link

The process is below:
1. Find the lca node. link
2. Find the path1 and path2 from the lca to the designated nodes.
3. Merge path1 and path2

1. public class LCA {
3.     public static void main(String[] args) {
4.         Tree tree = Tree.getTree();
5.         ArrayList<Integer> path = findNodesPath(tree, 9, 18);
6.         printPath(path);
7.     }
9.     /*
10.      * Find the LCA of node1 and node2
11.      */
12.     public static Tree findLca(Tree tree, MyInteger lcaNum, int node1, int node2){
13.         if(tree==null){
14.             return null;
15.         }
16.         MyInteger lLca = new MyInteger(0);
17.         Tree ltree = findLca(tree.left, lLca, node1, node2);
18.         if(lLca.i==2){
19.             lcaNum.i=2;
20.             return ltree;
21.         }
22.         MyInteger rLca = new MyInteger(0);
23.         Tree rtree = findLca(tree.right, rLca, node1, node2);
24.         if(rLca.i==2){
25.             lcaNum.i=2;
26.             return rtree;
27.         }
28.         int selfLca = 0;
29.         if(node1==tree.value||node2==tree.value){
30.             selfLca = 1;
31.         }
32.         lcaNum.i = lLca.i + rLca.i + selfLca;
33.         return tree;
34.     }
35.     /*
36.      * Find the path of node under root.
37.      */
38.     public static boolean findPath(Tree root, int node, ArrayList<Integer> path){
39.         if(root==null){
40.             return false;
41.         }
42.         boolean lHas = findPath(root.left, node, path);
43.         if(lHas){
44.             path.add(root.value);
45.             return true;
46.         }
47.         boolean rHas = findPath(root.right, node, path);
48.         if(rHas){
49.             path.add(root.value);
50.             return true;
51.         }
52.         if(root.value==node){
53.             path.add(root.value);
54.             return true;
55.         }
56.         return false;
57.     }
59.     /*
60.      * Find the path of node1(or node2) under root.
61.      */
62.     public static boolean findPath(Tree root, int node1, int node2, ArrayList<Integer> path){
63.         if(root==null){
64.             return false;
65.         }
66.         if(findPath(root.left, node1, node2, path)){
67.             path.add(root.value);
68.             return true;
69.         }
70.         if(findPath(root.right, node1, node2, path)){
71.             path.add(root.value);
72.             return true;
73.         }
74.         if(root.value==node1||root.value==node2){
75.             path.add(root.value);
76.             return true;
77.         }
78.         return false;
79.     }
81.     /*
82.      * Find the path between node1 and node2
83.      */
84.     public static ArrayList<Integer> findNodesPath(Tree tree, int node1, int node2){
85.         MyInteger lcaNum = new MyInteger(0);
86.         Tree lca = findLca(tree, lcaNum, node1, node2);
87.         if(lcaNum.i<2){
88.             return null;
89.         }
90.         ArrayList<Integer> path1 = new ArrayList<Integer>();
91.         ArrayList<Integer> path2 = new ArrayList<Integer>();
92.         findPath(lca.left, node1, node2, path1);
93.         findPath(lca.right, node1, node2, path2);
94.         path1.add(lca.value);
95.         while(!path2.isEmpty()){
96.             path1.add(path2.remove(path2.size()-1));
97.         }
98.         return path1;
99.     }
101.     public static void printPath(ArrayList<Integer> path){
102.         if(path==null){
103.             return;
104.         }
105.         Iterator<Integer> itr = path.iterator();
106.         while(itr.hasNext()){
107.             System.out.print(itr.next()+” “);
108.         }
109.         System.out.println();
110.     }
111. }
113. public class MyInteger{
114.     public int i = 0;
115.     public MyInteger(int i){
116.         this.i = i;
117.     }
118.     public String toString(){
119.         return String.valueOf(i);
120.     }
121. }