题目描述

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

题目代码

/**
 * @program: JavaCode
 * @description:输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
 * @author: Yukai Fan
 * @create: 2018-08-15 20:28
 **/
public class LinkListPrint {

    public static void main(String[] args) {
        LinkListPrint llp = new LinkListPrint();

        ListNode listNode = new ListNode(1);
        listNode.next = new ListNode(2);
        listNode.next.next = new ListNode(3);
        listNode.next.next.next = new ListNode(4);

        ArrayList<Integer> arrayList = printLinkListFromTailToHead(listNode);
        ArrayList<Integer> arrayList2 = printLinkListFromTailToHead2(listNode);
        ArrayList<Integer> arrayList3 = llp.printLinkListFromTailToHead3(listNode);

        System.out.println(arrayList);
        System.out.println(arrayList2);
        System.out.println(arrayList3);
    }
    /*
    方法一：利用堆栈后进先出的特性，将链表的值先push堆栈，然后在一一将值pop到ArrayList集合中输出
     */
    public static ArrayList<Integer> printLinkListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (!stack.isEmpty()) {
            arrayList.add(stack.pop());
        }
        return arrayList;
    }
    /*
    方法二：利用Collections集合的API方法reverse()可以反转集合中的数值
     */
    public static ArrayList<Integer> printLinkListFromTailToHead2(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        while (listNode != null) {
            list.add(listNode.val);
            listNode = listNode.next;
        }
        if (list != null && list.size() > 0) {
            Collections.reverse(list);
        }
        return list;
    }

    /*
    方式三：利用递归的方式(超简洁)
    作者：grass_stars
    递归的点在printListFromTailToHaed(listNode.next)这个节点，
    那么在最后一次递归方法返回以后，每一层的递归方法都会做一个arrayList.add(lizxstNode.val)这个操作，
    从最后一次到第一次，逆向的调用了后面的方法。因为之前的递归点已经返回了。
     */
    ArrayList<Integer> list = new ArrayList<>();
    public  ArrayList<Integer> printLinkListFromTailToHead3(ListNode listNode) {
        if (listNode != null) {
            this.printLinkListFromTailToHead3(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}

题目延伸

1、java堆、栈、堆栈的区别

2、java的main方法为什么必须是static的，它调用的方法是不是一定要static的

为什么main方法是静态的（static）

1. 正因为main方法是静态的，JVM调用这个方法就不需要创建任何包含这个main方法的实例。
2. 因为C和C++同样有类似的main方法作为程序执行的入口。
3. 如果main方法不声明为静态的，JVM就必须创建main类的实例，因为构造器可以被重载，JVM就没法确定调用哪个main方法。
4. 静态方法和静态数据加载到内存就可以直接调用而不需要像实例方法一样创建实例后才能调用，如果main方法是静态的，那么它就会被加载到JVM上下文中成为可执行的方法。

为什么main方法是公有的（public）

Java指定了一些可访问的修饰符如：private、protected、public，任何方法或变量都可以声明为public，Java可以从该类之外的地方访问。因为main方法是公共的，JVM就可以轻松的访问执行它。

为什么main方法没有返回值（Void） 

因为main返回任何值对程序都没任何意义，所以设计成void，意味着main不会有任何值返回

为什么main方法是静态的（static）,它调用的方法是不是一定要static的

1. static表示这个方法不属于这个内，而是所有内对象共有的。会在类对象定义之前，这样的方法就已经构建完成，就是这个方法游离于类对象之外，否则想要使用main函数，就要先定义类，而main又是所有程序的入口，这样就会矛盾了。
2. 而非static的方法，成员都要通过类对象调用；而静态的可以直接通过类名调用，而同一个类中，类名也可以省掉。
3. 没有static修饰的方法，在调用的时候需要先创造对象。有static修饰的方法，在调用的时候直接调用也就是说：没有static修饰的，它们在生成的时候，就属于对象。有static修饰的，它们在生成的时候，就属于类。main方法是java自带的，我们创建它的时候，就已经注定了它的必然性——静态方法。在静态方法中，只能访问静态的变量，还有静态的其他方法。

总结

1. main方法必须声明为public、static、void，否则JVM没法运行程序
2. 如果JVM找不到main方法就抛出NoSuchMethodError:main异常，例如：如果你运行命令：java HelloWrold，JVM就会在HelloWorld.class文件中搜索public static void main (String[] args) 放法
3. main方式是程序的入口，程序执行的开始处。
4. main方法被一个特定的线程”main”运行，程序会一直运行直到main线程结束或者non-daemon线程终止。
5. 当你看到“Exception in Thread main”如：Excpetion in Thread main:Java.lang.NullPointedException ,意味着异常来自于main线程
6. 你可以声明main方法使用java1.5的可变参数的方式如：

   public  static void main(String... args)

7. 除了static、void、和public，你可以使用final，synchronized、和strictfp修饰符在main方法的签名中，如：

   public  strictfp final  synchronized static  void main(String[] args)

8. main方法在Java可以像其他方法一样被重载，但是JVM只会调用上面这种签名规范的main方法。
9. 你可以使用throws子句在方法签名中，可以抛出任何checked和unchecked异常
10. 静态初始化块在JVM调用main方法前被执行，它们在类被JVM加载到内存的时候就被执行了。

转载请注明出处：http://www.cnblogs.com/numen-fan/

3、递归

/** * @program: JavaCode * @description:输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。* @author: Yukai Fan * @create: 2018-08-15 20:28 **/public class LinkListPrint {

public static void main(String[] args) {        LinkListPrint llp = new LinkListPrint();

ListNode listNode = new ListNode(1);listNode.next = new ListNode(2);listNode.next.next = new ListNode(3);listNode.next.next.next = new ListNode(4);

ArrayList<Integer> arrayList = printLinkListFromTailToHead(listNode);ArrayList<Integer> arrayList2 = printLinkListFromTailToHead2(listNode);ArrayList<Integer> arrayList3 = llp.printLinkListFromTailToHead3(listNode);

System.out.println(arrayList);System.out.println(arrayList2);System.out.println(arrayList3);}    /*方法一：利用堆栈后进先出的特性，将链表的值先push堆栈，然后在一一将值pop到ArrayList集合中输出     */public static ArrayList<Integer> printLinkListFromTailToHead(ListNode listNode) {        Stack<Integer> stack = new Stack<>();        while (listNode != null) {            stack.push(listNode.val);listNode = listNode.next;}        ArrayList<Integer> arrayList = new ArrayList<>();        while (!stack.isEmpty()) {            arrayList.add(stack.pop());}        return arrayList;}    /*方法二：利用Collections集合的API方法reverse()可以反转集合中的数值     */public static ArrayList<Integer> printLinkListFromTailToHead2(ListNode listNode) {        ArrayList<Integer> list = new ArrayList<>();        while (listNode != null) {            list.add(listNode.val);listNode = listNode.next;}        if (list != null && list.size() > 0) {            Collections.reverse(list);}        return list;}

/*方式三：利用递归的方式(超简洁)作者：grass_stars递归的点在printListFromTailToHaed(listNode.next)这个节点，    那么在最后一次递归方法返回以后，每一层的递归方法都会做一个arrayList.add(lizxstNode.val)这个操作，    从最后一次到第一次，逆向的调用了后面的方法。因为之前的递归点已经返回了。     */ArrayList<Integer> list = new ArrayList<>();    public  ArrayList<Integer> printLinkListFromTailToHead3(ListNode listNode) {        if (listNode != null) {            this.printLinkListFromTailToHead3(listNode.next);list.add(listNode.val);}        return list;}}

原文地址：https://www.cnblogs.com/FanJava/p/9484444.html