`

两段java代码的比较

    博客分类：
  • java
JavaEXTJDKJ#SUN 
阅读更多

第一个程序：

import java.util.ArrayList;
import java.util.List;

public class TailRecursionTest {
    public static void main(String[] args) {
        TailRecursionTest t = new TailRecursionTest();
        for (int i = 0; i < 10000; i++)
            t.a(0);
    }

    public void a(int j) {
        j++;
        List list = new ArrayList<Integer>(100000);
        // 对list进行处理
    }
}
 

    没啥特殊的，仅仅是为了测试，我们将a方法调用10000次，a方法创建一个有100000个元素的list的局部变量。
第二个程序：

 

import java.util.ArrayList;
import java.util.List;

public class TailRecursionTest2 {
    public static void main(String[] args) {
        TailRecursionTest2 t = new TailRecursionTest2();
        t.a(0);
    }

    public void a(int j) {
        System.out.println(j);
        j++;
        if (j == 10000)
            return;
        List list = new ArrayList<Integer>(100000);
        // 对list进行处理
        a(j);
    }
}

     也没啥特殊的，就是将循环换成了递归，a方法做的事情没变。两个都跑一下，程序1顺利结束，程序2出问题了，啥问题？如下：

161
162
163
164
165
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.ArrayList.<init>(Unknown Source)
    at TailRecursionTest2.a(TailRecursionTest2.java:17)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)

    我倒，才运行166次了，heap就满了。问题在哪呢？oh,yep，你肯定想到了，是不是重复创建list这个大集合引起的呢？它不是局部变量吗？怎么 也会溢出？是的，list是局部变量，在a的方法栈里引用着，指向heap上的大对象，更关键的问题在于，java是没有尾递归优化的，递归方法是不会使 用同一个栈帧，每一次递归调用，都将压入新的栈帧，并且这个栈帧上又new了一个list变量，引用着heap上新的一个大集合。随着栈深度的增加， jvm里维持着一条长长的方法调用轨迹以便你能回来，在方法没有返回之前，这些list变量一直被各自的栈帧引用着，不能被GC，你说，能不OOM吗？

    也许，你想到了个补救方法来挽救程序2，就是每次在处理完list后，我把它设置为null，不让栈帧继续引用着它，咱编写对gc友好的代码，这不就行了，试试：

import java.util.ArrayList;
import java.util.List;

public class TailRecursionTest2 {
    public static void main(String[] args) {
        TailRecursionTest2 t = new TailRecursionTest2();
        t.a(0);
    }

    public void a(int j) {
        System.out.println(j);
        j++;
        if (j == 10000)
            return;
        List list = new ArrayList<Integer>(100000);
        // 对list进行处理
        list = null;  //gc友好
        a(j);
    }
}
 

    得意洋洋，我跑一下看看，这次跑到4000多次，但是：

......
4289
4290
4291
4292
java.lang.StackOverflowError
    at sun.nio.cs.ext.DoubleByteEncoder.encodeArrayLoop(Unknown Source)
    at sun.nio.cs.ext.DoubleByteEncoder.encodeLoop(Unknown Source)
    at java.nio.charset.CharsetEncoder.encode(Unknown Source)
 

    没办法啊，人家sun的jdk就是不支持尾递归优化(据说传闻在jdk5的某个版本是有尾递归优化的），很不给你面子的栈溢出了。ibm的jdk据说支持尾递归优化，上面这个程序在ibm的jdk上可能可以正常结束，未经测试。

总结：在java里，递归最好咱还是别用，老老实实地while、for；就算递归了，最好递归方法不要new太大的对象，除非你能确定递归的深度不是那么大，否则OOM和堆栈溢出的阴影将笼罩着你。

分享到：
| Logic Programming With Prolog学习笔记（ ...
评论
27 楼 sutra 2008-06-07  
在我的电脑上，第二个示例正常结束。

java -version
java version "1.5.0_13"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_13-b05-237)
Java HotSpot(TM) Client VM (build 1.5.0_13-119, mixed mode, sharing)
26 楼 mindxw 2008-06-06  
楼主的意思是递归所带来的垃圾回收的问题，对吧？
25 楼 faithyacht 2008-06-05  
我觉得编译器对这个优化置之不理还是很有道理的。
24 楼 hellohong 2008-06-05  
像这种线性的累加当然可以for或while循环,但是当碰到一棵时, 不用递归用while或for循环怎么来完成呢?
用一个while再一个栈来完成, 那也是递归啊!
23 楼 zgd 2008-06-05  
基本上禁止公司成员使用任何形式的递归
22 楼 guoxu1983 2008-06-05  
dennis_zane 写道
leelj 写道
import java.util.ArrayList;   
import java.util.List;   
  
public class TailRecursionTest {   
    public static void main(String[] args) {   
        TailRecursionTest t = new TailRecursionTest();   
        t.a(0);   
    }   
  
    public void a(int j) {   
        System.out.println(j);   
        j++;   
        if (j<10000)  //if (j!=10000) 也可以
            return;   
        List list = new ArrayList<Integer>(100000);   
        
        a(j);   
    }   
}

递归 ，学习，以上我把if条件小改动了下，可以成功，不知道怎么解释：）


无语了，0<10000，一次还没跑完。



^_^ 有意思
21 楼 leelj 2008-06-05  
dennis_zane 写道


无语了，0<10000，一次还没跑完。


我错了，撞墙  
20 楼 dennis_zane 2008-06-05  
leelj 写道
import java.util.ArrayList;   
import java.util.List;   
  
public class TailRecursionTest {   
    public static void main(String[] args) {   
        TailRecursionTest t = new TailRecursionTest();   
        t.a(0);   
    }   
  
    public void a(int j) {   
        System.out.println(j);   
        j++;   
        if (j<10000)  //if (j!=10000) 也可以
            return;   
        List list = new ArrayList<Integer>(100000);   
        
        a(j);   
    }   
}

递归 ，学习，以上我把if条件小改动了下，可以成功，不知道怎么解释：）


无语了，0<10000，一次还没跑完。
19 楼 leelj 2008-06-05   
import java.util.ArrayList;   
import java.util.List;   
  
public class TailRecursionTest {   
    public static void main(String[] args) {   
        TailRecursionTest t = new TailRecursionTest();   
        t.a(0);   
    }   
  
    public void a(int j) {   
        System.out.println(j);   
        j++;   
        if (j<10000)  //if (j!=10000) 也可以
            return;   
        List list = new ArrayList<Integer>(100000);   
        
        a(j);   
    }   
}

递归 ，学习，以上我把if条件小改动了下，可以成功，不知道怎么解释：）
18 楼 dennis_zane 2008-06-05  
Lucas Lee 写道
一般来说没有大问题的。除非很大的递归。这个一般也可以当作性能问题考虑，不用太早考虑，更用不着把一切递归的方法都改成循环。

嗯，这仅仅是对OOM问题的分析做多一种设想。
17 楼 LucasLee 2008-06-05  
一般来说没有大问题的。除非很大的递归。这个一般也可以当作性能问题考虑，不用太早考虑，更用不着把一切递归的方法都改成循环。
16 楼 410133062 2008-06-05  
递归  出栈入栈的事肯定多
15 楼 sailor_sky 2008-06-03  
以前遇到过这种问题, 最后还是改成循环调用解决的 ,
14 楼 everlasting_188 2008-06-03  
这个问题讨论的比较有意义啊
13 楼 kenan161621 2008-06-03  
楼上的楼上的代码好长
我以前写的递归基本上没有创建大的对象，所以没有碰到此问题，今天楼主提出来了，以后恐怕得多注意了
12 楼 wen870105 2008-06-02  
楼上代码看不懂~！
你方法里的代码是不是太长了啊~！
呵呵
11 楼 Joo 2008-06-02  
俺这个递归运行良好，如果从root object开始执行（一个XML的root element），大约100多个对象实例 

package byd.biz;

import javax.ejb.Stateless;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

/**
 *
 * @author ll258583
 */
@Stateless(name = "xoServiceBean")
public class xoServiceBean implements xoServiceLocal {

    @PersistenceContext(unitName = "xoServicePU")
    private EntityManager em;

    /**
     * Set JAXB object's value to the EntityBean object
     * @param jxo
     * @param eto
     */
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void x2o(Object jxo, Object eto) {
        System.out.println("------------------------------------------------------------------");
        System.out.println(eto.getClass().getName());
        //validate if two papramater are matchable
        if (eto.getClass().getPackage().getName().equals("byd.entity") && jxo.getClass().getPackage().getName().equals("byd.xoMapping.pip4A3") && eto.getClass().getName().substring(12).equals(jxo.getClass().getName().substring(21))) {

            Field[] etoDeclaredFields = eto.getClass().getDeclaredFields();
            Field[] jxoDeclaredFields = jxo.getClass().getDeclaredFields();


            for (int i = 0; i < etoDeclaredFields.length; i++) {
                for (int j = 0; j < jxoDeclaredFields.length; j++) {
                    Field etoField = etoDeclaredFields[i];
                    Class etoFieldType = etoField.getType();
                    String etoFieldName = etoField.getName();

                    Field jxoField = jxoDeclaredFields[j];
                    String jxoFieldName = jxoField.getName();

                    try {
                        if (etoFieldName.toLowerCase().equals(jxoFieldName.toLowerCase())) {
                            if (etoFieldType.getName().equals("java.lang.String")) {
                                //in case of basic type(java.lang.String) filed
                                System.out.println(etoFieldName + " : " + etoFieldType.getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method jxoGetMethod = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                String value = (String) jxoGetMethod.invoke(jxo, args);
                                if (value != null) {
                                    Method etoSetMethod = eto.getClass().getDeclaredMethod("set" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), etoFieldType);
                                    etoSetMethod.invoke(eto, value);
                                } else {
                                    System.out.println("STRING IS NULL");
                                }

                            } else if (etoFieldType.getName().equals("java.util.List")) {
                                //in case of java.util.List field
                                System.out.println(etoFieldName + " : " + etoFieldType.getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method jxoGetMethod = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                Method etoGetMethod = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                List jxoMemberList = (List) jxoGetMethod.invoke(jxo, args);
                                if (jxoMemberList.size() != 0 && jxoMemberList != null) {
                                    List etoMemberList = (List) etoGetMethod.invoke(eto, args);
                                    etoMemberList = new ArrayList();
                                    for (Object jxm : jxoMemberList) {
                                        Class C = Class.forName("byd.entity._" + jxm.getClass().getName().substring(21));
                                        Object etm = C.newInstance();
                                        this.x2o(jxm, etm);
                                        etoMemberList.add(etm);
                                    }
                                } else {
                                    System.out.println("LIST IS EMPTY OR NULL");
                                }
                            } else if (etoFieldType.getName().equals("java.util.ArrayList")) {
                                //in case of java.util.ArrayList<String>() field
                                System.out.println(etoFieldName + " : " + etoFieldType.getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method jxoGetList = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                List<String> stringList_1 = (List<String>) jxoGetList.invoke(jxo, args);
                                if (stringList_1 != null && stringList_1.size() != 0) {
                                    Method etoGetList = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                    ArrayList stringList_2 = (ArrayList) etoGetList.invoke(eto, args);
                                    stringList_2 = new ArrayList<String>();
                                    for (String str_1 : stringList_1) {
                                        String str_2 = new String(str_1);
                                        stringList_2.add(str_2);
                                    }
                                } else {
                                    System.out.println("ArrayList<String> IS NULL OR EMPTY");
                                }
                            } else {
                                //in case of other class type field
                                System.out.println(etoFieldName + " : " + etoFieldType.getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method jxoGetMethod = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                Object nextJxo = jxoGetMethod.invoke(jxo, args);
                                if (nextJxo != null) {
//                                    Method etoGetMethod = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                    Method etoSetMethod = eto.getClass().getDeclaredMethod("set" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), etoFieldType);
                                    Object nextEto = etoFieldType.newInstance();
                                    etoSetMethod.invoke(eto, nextEto);
                                    this.x2o(nextJxo, nextEto);
                                } else {
                                    System.out.println(jxoFieldName + " IS NULL");
                                }
                            }
                        }
                    } catch (ClassNotFoundException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (InstantiationException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (IllegalAccessException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (IllegalArgumentException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (InvocationTargetException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (NoSuchMethodException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (SecurityException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        } else {
//            throw new UnmatchableException();
            System.out.println("UnmatchableException");
        }

        //persist the entityBean object's value
        System.out.println("Persist : " + eto.getClass().getName());
        em.persist(eto);

    }

    /**
     * Set EntityBean's value to the JAXB object
     * @param eto
     * @param jxo
     */
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void o2x(Object eto, Object jxo) {
        System.out.println("------------------------------------------------------------------");
        System.out.println(eto.getClass().getName());
        //validate if two papramater are matchable
        if (eto.getClass().getPackage().getName().equals("byd.entity") && jxo.getClass().getPackage().getName().equals("byd.xoMapping.pip4A3") && eto.getClass().getName().substring(12).equals(jxo.getClass().getName().substring(21))) {

            Field[] etoDeclaredFields = eto.getClass().getDeclaredFields();
            Field[] jxoDeclaredFields = jxo.getClass().getDeclaredFields();

            for (int i = 0; i < jxoDeclaredFields.length; i++) {
                for (int j = 0; j < etoDeclaredFields.length; j++) {
                    Field jxoField = jxoDeclaredFields[i];
                    String jxoFieldName = jxoField.getName();
                    Field etoField = jxoDeclaredFields[j];
                    String etoFieldName = etoField.getName();

                    try {
                        if (etoFieldName.toLowerCase().equals(jxoFieldName.toLowerCase())) {
                            if (jxoField.getType().getName().equals("java.lang.String")) {
                                //in case of basic type(java.lang.String) filed
                                System.out.println(jxoField.getName() + " : " + jxoField.getType().getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method etoGet = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                String value = (String) etoGet.invoke(eto, args);
                                if (value != null) {
                                    Method jxoSet = jxo.getClass().getDeclaredMethod("set" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), jxoField.getType());
                                    jxoSet.invoke(jxo, value);
                                } else {
                                    System.out.println("STRING IS NULL");
                                }

                            } else if (jxoField.getType().getName().equals("java.util.List")) {
                                //in case of collection(java.util.List) field
                                System.out.println(jxoField.getName() + " : " + jxoField.getType().getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method etoGetList = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                List etoList = (List) etoGetList.invoke(eto, args);
                                if (etoList.size() != 0 && etoList != null) {
                                    Method jxoGetList = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                    List jxoList = (List) jxoGetList.invoke(jxo, args);
                                    jxoList = new ArrayList();
                                    for (Object etm : etoList) {
                                        Class C = Class.forName("byd.xoMapping.pip4A3." + etm.getClass().getName().substring(12));
                                        Object jxm = C.newInstance();
                                        this.o2x(etm, jxm);
                                        jxoList.add(jxm);
                                    }
                                } else {
                                    System.out.println("LIST IS NULL OR EMPTY");
                                }
                            } else if (etoField.getType().getName().equals("java.util.ArrayList")) {
                                //in case of ArrayList<String> field
                                System.out.println(jxoField.getName() + " : " + jxoField.getType().getName());
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Method etoGetList = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                ArrayList<String> stringList_1 = (ArrayList<String>) etoGetList.invoke(jxo, args);
                                if (stringList_1 != null && stringList_1.size() != 0) {
                                    Method jxoGetList = jxo.getClass().getDeclaredMethod("get" + jxoFieldName.substring(0, 1).toUpperCase() + jxoFieldName.substring(1), paras);
                                    List stringList_2 = (List) jxoGetList.invoke(jxo, args);
                                    stringList_2 = new ArrayList<String>();
                                    for (String str_1 : stringList_1) {
                                        String str_2 = new String(str_1);
                                        stringList_2.add(str_2);
                                    }
                                } else {
                                    System.out.println("ArrayList<String> IS NULL OR EMPTY");
                                }
                            } else {
                                //in case of other class type field
                                Class<?>[] paras = null;
                                Object[] args = null;
                                Object arg = null;
                                Method etoGet = eto.getClass().getDeclaredMethod("get" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), paras);
                                Object nextEto = etoGet.invoke(jxo, arg);
                                if (nextEto != null) {
                                    Method jxoSet = jxo.getClass().getDeclaredMethod("set" + etoFieldName.substring(0, 1).toUpperCase() + etoFieldName.substring(1), jxoField.getType());
                                    Object nextJxo = jxoField.getType().newInstance();
                                    jxoSet.invoke(jxo, nextJxo);
                                    this.o2x(nextEto, nextJxo);
                                } else {
                                    System.out.println(etoFieldName + " IS NULL");
                                }
                            }
                        }
                    } catch (InstantiationException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (IllegalAccessException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (ClassNotFoundException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (IllegalArgumentException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (InvocationTargetException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (NoSuchMethodException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (SecurityException ex) {
                        Logger.getLogger(xoServiceBean.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        } else {
//            throw new UnmatchableException();
            System.out.println("UnmatchableException");
        }
    }
}


10 楼 biubiu 2008-06-02  
Eastsun 写道
Java doesn't support this optimization for a number of reasons, including：
* the security model requires stack frame information
* reflection relies on "stack crawling"
* stack traces would be incomplete
* debugging would be problematic


You have the points.

BTW: It seems FF3 RC1 is not well supported by JavaEye.
9 楼 dmewy 2008-06-02  
第二段和第三段代码在webshpere5.1自带的JDK中顺利执行,应该是1.3的还是1.4的.不过可以确定的是J2EE标准遵循的是1.3的..
8 楼 Eastsun 2008-06-01  
Java doesn't support this optimization for a number of reasons, including：
     * the security model requires stack frame information
    * reflection relies on "stack crawling"
    * stack traces would be incomplete
    * debugging would be problematic
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java Excel比较代码 poi

    在Java代码中，我们通常会创建`HSSFWorkbook`或`XSSFWorkbook`对象来表示Excel工作簿，`HSSFSheet`或`XSSFSheet`对象来代表工作簿内的工作表，然后通过`HSSFRow`和`XSSFRow`以及`HSSFCell`和`XSSFCell`来操作行和...

    有用的java代码、java代码

    根据给定的信息，本文将对20个非常有用的Java代码片段进行详细解析，这些代码片段不仅涵盖了基础的数据类型转换、文件处理，还包括了日期格式化、数据库操作等实用功能。 ### 1. 整型数字转字符串与字符串转整型...

    java新手代码适合初学者简单经典.zip

    这个名为"java新手代码适合初学者简单经典.zip"的压缩包包含了两个示例文件：test1.java和test2.java，它们很可能是为帮助初学者理解Java编程基础而设计的一些简单程序。 1. **Java基础** - **变量与数据类型**：...

    java代码实现动态爱心代码示例

    下面，我们将深入探讨这个Java代码的工作原理、涉及的知识点以及如何进行扩展。 首先，我们看到一个名为`HeartShape`的公共类，它包含一个`main`方法，这是Java程序的入口点。在`main`方法中，我们定义了一个变量`...

    java代码优化大全

    ### Java代码优化技巧详解 #### 一、引言 在软件开发过程中，为了提升应用程序的性能，我们需要对Java代码进行优化。这是因为计算机系统的资源（如内存、CPU时间、网络带宽等）是有限的，而优化的目标就是使程序...

    Java代码简单按钮

    根据提供的文件信息，可以看出这是一段不完整的 Java 代码，主要涉及了 Java 中的基本界面构建、菜单栏设计以及按钮操作等内容。接下来将基于这段代码的关键部分进行知识点的梳理与总结。 ### Java GUI 基础 #### ...

    android JS与java代码相互调用

    在Android开发中，JavaScript（JS）与Java代码的相互调用是常见的需求，尤其是在混合式应用开发中。这种交互能够充分利用JavaScript的灵活性和Java的强大功能，实现更丰富的用户体验。本Demo旨在提供一个清晰、易懂...

    md5 java 代码

    给定的文件信息提供了一个Java代码示例，用于实现MD5哈希算法，下面将详细解析这段代码，并深入探讨MD5算法在Java中的应用。 ### MD5算法简介 MD5（Message-Digest Algorithm 5）是RSA数据安全公司设计的一种散列...

    解析pdm生成pojo（java代码生成器）

    "解析PDM生成POJO（Java代码生成器）"是一个这样的工具，它可以帮助开发者自动化创建JavaBean和HBM（Hibernate Mapping File）类，这两个是Java后端开发中的重要组成部分。本文将深入探讨这个主题，讲解相关知识点。...

    Java 代码重构实例

    Java代码重构是一种优化编程实践，旨在改进代码的结构和可读性，而不改变其外部行为。重构对于提高软件质量和维护性至关重要，尤其是在大型项目中。以下是一些在Java重构中的关键原则和技巧，通过实例来展示如何应用...

    SQL2JAVA-java字段串代码拼接小工具

    这暗示了工具可能包含两个核心功能：一是将SQL语句转换为Java代码，二是帮助生成字符串拼接的Java代码。在Java中，有多种方式可以实现字符串拼接，比如使用`+`操作符，但当拼接的字符串数量较多时，这种方式的效率较...

    C++/Java代码分析器

    总的来说，C++/Java代码分析器是一款强大的工具，它将C++和Java这两种广泛使用的编程语言的解析能力集成在一起，为用户提供了一个全面了解和优化代码的平台。无论是为了学习还是提高工作效率，这款分析器都值得...

    2048游戏java代码

    《2048游戏Java代码解析》 2048是一款简单却又极具挑战性的数字合成游戏，由意大利开发者Gabriele Cirulli于2014年推出。在这个游戏中，玩家需要通过滑动屏幕，使得相同的数字合并成更大的数字，最终目标是达到2048...

    利用Java写一段居于聊天室代码

    【Java实现聊天室代码详解】 Java作为一种广泛使用的编程语言，其强大的网络编程能力使得开发聊天室应用程序变得简单而高效。本篇文章将详细讲解如何利用Java编写一个基于GUI界面的服务器和客户端聊天程序。 首先...

    极光推送后台java代码demo

    【极光推送后台Java代码Demo】是针对极光推送服务的一个示例代码，它展示了如何在Java后端环境中集成和使用极光推送服务。极光推送（JPush）是一款广泛应用于移动应用开发中的消息推送服务，它允许开发者向Android、...

    简单实用java代码

    本文将围绕一个简单的Java代码片段进行深入解析，旨在揭示其背后的逻辑、应用场景以及可能的扩展思路，从而为读者提供一份详实的知识点总结。 ### 代码片段解读 #### 原始代码： ```java if(!"".equals(addrName) ...

    java代码适合学习

    【标题】：“Java代码适合学习” Java是一种广泛使用的高级编程语言，以其“一次编写，到处运行”的特性闻名。它在跨平台应用开发中占据主导地位，尤其在企业级软件、移动应用（尤其是Android）、Web应用以及云计算...

    经典Java程序源代码

    这段Java代码创建了一个简单的加法计算器。它使用了Java Swing库来构建图形用户界面（GUI），包括输入框（JTextField）、标签（JLabel）、按钮（JButton）以及面板（JPanel）。程序的核心是实现了ActionListener接口...

    java常用代码方法

    以下是一些关键的Java代码方法和相关知识点： 1. **字符串操作**： - `String` 类提供了多种方法，如 `length()`（获取字符串长度）、`substring()`（截取子字符串）、`indexOf()`（查找子串位置）和 `replace()`...

    java五子棋游戏代码

    同时，使用注释来解释关键代码段的功能，有助于他人理解你的代码。 总的来说，这个Java五子棋游戏项目为初学者提供了一个实践基础编程概念和技能的机会。通过分析和实现这个游戏，学习者可以提升对Java语言的理解，...

Magicbox
Global site tag (gtag.js) - Google Analytics