三种思路

1.  前后替换，类似于冒泡排序的核心理念
 public static ArrayList returnList(ListNode listNode) {
        ArrayList list = new ArrayList<Integer>();
        //新建一个前节点，赋值为null
        ListNode previous = null;
        ListNode curr = listNode;
        //遍历链表
        while (curr != null) {
            //需要转换next节点为他的上一个节点，把当前节点转换成他的下一个节点，因此需要一个中间值保存它的next节点
            ListNode temp = curr.next;
            //把他的上一个节点放到它下一个节点的位置
            curr.next = previous;
            //转换位置，当前是next节点的备用，把当前节点放到它的前节点
            previous = curr;
            //curr节点此时变成了前节点，把curr的next节点放到前面
            curr = temp;
        }
        //遍历完之后，链表已经实现反转，再次遍历，之前的头节点变成了尾节点，因此需要放入previous
        for (; previous != null; previous = previous.next){
            list.add(previous.val);
        }
        return list;
    }
2. 利用栈解决问题，先进后出
 public static ArrayList returnList(ListNode listNode) {
    //新建一个数组
    List<Integer> list = new ArrayList<>();
    //新建一个栈
    Stack<Integer> stack = new Stack<>();
    //遍历链表,将链表中的值压入栈，add（）和push（）都可以
    for(;listNode != null; listNode = listNode.next){
        stack.push(listNode.val);
    }
    //从栈中依次取出数据并放入list
    for(;!stack.empty();){
        list.add(stack.pop());
    }
    /* 
    1.stream遍历 List<Integer> collect = stack.stream().map(index -> stack.get(stack.size() - 1 - index)).collect(Collectors.toList());
    2.List遍历，stack底层也是数组；
    int i = stack.size() - 1;
    for(;i >=0; size--){
        list.add(stack.get(i));
    }*/
    return list;
}
3.ArrayList.add(0,Object)方***将数据插入数组第一个位置
 public static ArrayList returnList(ListNode listNode) {
    //NEW一个ArrayList
    ArrayList<Integer> list = new ArrayList<>();
    //遍历链表
    for(;listNode != null;listNode = listNode.next) {
        list.add(0, listNode.val);
    }
    return list;

 }