Java数据类型转换

Java的数据类型分为两类：基本数据类型和引用数据类型， 基本数据类型包括boolean类型和数值类型。数值类型有整数类型和浮点类型。整数类型包括 byte、short、int、long、char，浮点类型包括float和double，引用数据类型是指一个对象的引用，常见的引用数据类型有String、数组、集合等

一、基本数据类型与基本数据类型转换

1、自动类型转换（由低到高）

1）byte–>short–>int–>long–>float–>double ,小精度可转大精度，大转小会失去精度

输出结果：

2、强制类型转换（由高到低）

输出结果：

3、a=a+b和a+=b的区别

二、基本数据类型与引用数据类型转换

1、装箱与拆箱

那什么是装箱？什么是拆箱？装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。那自动装箱与自动拆箱也很好理解了，就是我们不用在代码里面显式的写装箱与拆箱的代码，由编译器帮我们完成这一操作。
下面是基本数据类型对应的包装器类型：

在Java SE5之前只能手动装箱与拆箱，之后可以自动装箱拆箱

二、常见的问题
1、下图输出结果是什么？

请仔细考虑这四个判断结果，下图为实际输出结果

输出结果是否与您答案一致，如果不同为什么会出现这样的结果？
首先前两个都是Integer对象调用equals方法比较，重写后的方法只是比较对象的int值，值相等则对象相等，所以均返回true。
后两天一个为true一个为false，则是因为使用“==”运算符就需要Integer对象直接比较内存地址
查看源码可知如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用，超过范围则新建一个Integer对象，因为100在取值范围内所以i1和i2指向同一个对象

2、 对下面这段代码的输出结果是否存在疑问？

为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。很简单：在某个范围内的整型数值的个数是有限的，而浮点数却不是。所以Duble类型没有设置缓存，每次都是新建一个对象。

3、Boolean只存在true和false两个常量属性结果，所以就不多加赘述。

三、总结：

1、知道基本数据类型的优先级，自动转换和强制转换处理
2、基本数据类型与他们的包装类转换，装箱和拆箱
3、装箱会创建对象，频繁的装箱会消耗许多内存，影响性能，所以能避免装箱的时应尽量避免。
4、对于两个包装类比较时的注意事项，分清比较地址还是比较数值

Java数据类型转换

java数据类型的转换一般分三种,分别是:

一. 简单数据类型之间的转换

在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为(byte，short，char)–int–long–float–double

简单数据类型之间的转换又可以分为：
●低级到高级的自动类型转换
●高级到低级的强制类型转换
●包装类过渡类型能够转换

低级变量可以直接转换为高级变量，笔者称之为自动类型转换,例如，下面的语句可以在Java中直接通过：

  byte b;
  int i=b;
  long l=b;
  float f=b;
  double d=b;

如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c';
int i=c;
System.out.println("output:" i);
输出：output:99;

对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99;
char c=(char)i;
System.out.println("output:" c);
输出：output:c;

但根据笔者的经验，byte,short,int三种类型都是整型，因此如果操作整型数据时，最好统一使用int型。

将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式：

int i=99;
byte b=(byte)i;
char c=(char)i;
float f=(float)i;

可以想象，这种转换肯定可能会导致溢出或精度的下降，因此笔者并不推荐使用这种转换。

1、float型转换为double型：

float f1=100.00f;
Float F1=new Float(f1);

//F1.doubleValue()为Float类的返回double值型的方法
double d1=F1.doubleValue();

2、double型转换为int型：

double d1=100.00;
Double D1=new Double(d1);
int i1=D1.intValue();

3、int型转换为double型：

int i1=200;
double d1=i1;

二. 字符串与其它数据类型的转换

4、字符串与其它类型间的转换：

⑴其它类型向字符串的转换

①调用类的串转换方法:X.toString();
②自动转换:X+“”;
③使用String的方法:String.volueOf(X);

⑵字符串作为值,向其它类型的转换

①先转换成相应的封装器实例,再调用对应的方法转换成其它类型
例如，字符中“32.1”转换double型的值的格式为**:new Float(“32.1”).doubleValue()**。

​ 也可以用:Double.valueOf(“32.1”).doubleValue()

②静态parseXXX方法

String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

③Character的**getNumericValue(char ch)**方法
具体可查阅api。

三. 其它实用数据类型转换

5．Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：
①Date(int year, int month, int date)：以int型表示年、月、日
②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分
③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、 分、秒

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。
而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，

import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();

//如果希望得到YYYYMMDD的格式

SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);

//如果希望分开得到年，月，日

SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

//js中将Data转换成String类型

\* 对Date的扩展，将 Date 转化为指定格式的String  
\* 月(M)、日(d)、12小时(h)、24小时(H)、分(m)、秒(s)、周(E)、季度(q) 可以用 1-2 个占位符  
\* 年(y)可以用 1-4 个占位符，毫秒(S)只能用 1 个占位符(是 1-3 位的数字)  
\* eg:  
\* (new Date()).pattern("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423  
\* (new Date()).pattern("yyyy-MM-dd E HH:mm:ss") ==> 2009-03-10 二 20:09:04  
\* (new Date()).pattern("yyyy-MM-dd EE hh:mm:ss") ==> 2009-03-10 周二 08:09:04  
\* (new Date()).pattern("yyyy-MM-dd EEE hh:mm:ss") ==> 2009-03-10 星期二 08:09:04  
\* (new Date()).pattern("yyyy-M-d h:m:s.S") ==> 2006-7-2 8:9:4.
 

6.字符型转时间型：（2005-10-1）

reportdate_str ＝ “2005-10-01”；
reportdate_str ＝ reportdate_str ＋ “ 00:00:00.0”
reportdate = java.sql.Timestamp.valueOf(reportdate_str);

7.时间型转字符型：

V_DATE = reportdate.toString();

8.将long型转化为String型

long APP_UNIT = (long) userview.getDEPT_ID();
String S_APP_UNIT = String.valeOf(APP_UNIT);
基本类型s都可以通过String.valeOf(s)来转化为String型。

本博文部分原创，部分转载整理，侵删！仅供学习研究！严禁商用！

不同数据类型一起运算之前是需要进行转换的，有的是自从转换，有的需要手动或者强制。同时，一个数据的表示也意味着可能有多种类型来表示，需要根据实际需要确定我们数据的具体类型。

数据类型的转换遵循原则：范围小的数据类型，可以转换成范围大的数据类型。eg:byte转int。范围大的数据类型不可以转换成范围小的数据类型。

java中数据类型转换的顺序  按照范围从小到大：

byte->short->int->long->float->double

除此之位，生活中还有跟多的其它复杂数据类型，可能在使用的时候存在类型的转换，这个时候单一的一句代码无法实现，需要相应的算法实现数据类型的转换。

eg: char->byte[],String->char[]...

1.1自动类型转换

eg:double d = 1000;

范围大的数据类型  变量 = 范围小的数据

自动类型转换，数据值的数学意义上的大小是不变的。

1.2强制转换

范围小的数据类型  变量 = （范围小的数据类型）范围大的数据

eg:int i = (int)6.718

强制类型转换，数据值的数学意义上的大小会被改变。

1.3对象具体类型指定转换

在一些存储的数据的时候，java类的数据通常以对象的形式出现，而获取到数据时，数据类型为object，这时候无法使用对象的get,set获取对象数据，我们需要给object指定具体的数据对象类型，这个对象类型可以是基本类型，通常是自定义对象。

具体对象类型   变量 = （具体类型类型）object数据

eg:list<String> ls = (list<String>)request.getAttribute("s");

1.4char，String，数组等复杂数据类型的转换

这类复杂数据类型转换通常需要算法实现

1.4.1：char->byte[]

public static byte[] charToByte(char c) {
		byte[] b = null;
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		DataOutputStream dataOut = new DataOutputStream(out);
		try {
			dataOut.writeChar(c);
			b = out.toByteArray();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return b;
	}

//char转化为byte
    public static byte[] charToByte2(char c) {
    	byte[] b = new byte[2];
        b[0] = (byte) ((c & 0xFF00) >> 8);
        b[1] = (byte) (c & 0xFF);
        return b;
    }

1.4.2 byte[] -> char

//byte转换为char
    public static char byteToChar(byte[] b) {
	    char c = (char) (((b[0] & 0xFF) << 8) | (b[1] & 0xFF));
	    return c;
    }

1.4.3 其它数据类型转string

1. int转String

string s = （int）i + "";
String s = String.valueOf(i);
String s = Integer.toString(i);

2.StringBuilder与StringBuffer.toString

涉及string拼接 ：String、StringBuilder、StringBuffer三者的执行效率：　　StringBuilder > StringBuffer > String

3.char[]转String

char data[] = {'h', 'e', 'l', 'l', 'o'};
 //法一
 String str1 = new String(data); 
 //法二
 String str2 = String.valueOf(data);

4 byte[] ->String

1 String isoString = new String(bytes,"ISO-8859-1");
2 String srt2=new String(midbytes,"UTF-8");

5 list -> String[] ->String

String[] ->String通过字符串拼接实现

list->String

//法一
List<String> strList = new ArrayList<String>();
strList.add("aa");
strList.add("bb");
Object[] objs = strList.toArray();
//如果要变成String数组，需要强转类型。
String[] strs = (String[]) strList.toArray();
//也可以指定大小：
final int size = strList.size();
String[] strs = (String[])strList.toArray(new String[size]);

//法二 笨方法
List<String> strList = new ArrayList<String>();
strList.add("aa");
strList.add("bb");
String[] strs = new String[strList.size()];
Iterator iter = strList.iterator();
int i = 0;
while(iter.hasNext()){
    strs[i] = (String) iter.next();
    i++;
}

6 date -> Sting

String sdate;  
Date ddate;  
……  
sdate=(new SimpleDateFormat("yyyy-MM-dd")).format(ddate);  

1.4.3 string转其它数据类型

1 string 转StringBuilder，StringBuffer

//法一
StringBuilder stringbuilder = New StringBuilder("abcd");
StringBuilder stringbuilder = New StringBuilder(str1);

StringBuffer stringbuffer = New StringBuffer("efgh");
StringBuffer stringbuffer = New StringBuffer(str2);
//法二
StringBuilder stringbuilder = New StringBuilder();
stringbuilder.append(str1);

StringBuffer stringbuffer = New StringBuffer();
stringbuffer.append(str2)

2 string->int（其它数值型类型类似）

//法一
int i = Integer.parseInt([String]); 
int i = Integer.parseInt([String],[int radix]);
//法二
int i = Integer.valueOf(my_str).intValue();

3 string ->char[]

//法一
char[] strChar = str.toCharArray();
//法二
int[] strChar = new int[str.length()];
for(int i = 0;i < str.length(); i++){
  strChar[i] = (int)str.charAt(i);
}

4 string->byte[]

 byte[] midbytes=isoString.getBytes("UTF8");
//为UTF8编码
 byte[] isoret = srt2.getBytes("ISO-8859-1");
 //为ISO-8859-1编码,其中ISO-8859-1为单字节的编码

5 String ->String[]-> list

String ->String[]通过字符串截取实现

//法一
String[] userid = {"aa","bb","cc"};
List<String> userList = Arrays.asList(userid);
//法二
String[] userid = {"aa","bb","cc"};
List<String> userList = new ArrayList<String>();
Collections.addAll(userList, userid);
//法三 最笨的方法
String[] userid = {"aa","bb","cc"};
List<String> userList = new ArrayList<String>(userid.length);
for(String uid: userid){
    userList.add(uid);
}

6 string -> data

String dateString = "2012-12-06 ";  
try  
{  
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ");  
    Date date = sdf.parse(dateString);  
}  
catch (ParseException e)  
{  
    System.out.println(e.getMessage());  
}  

import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Calendar;  
import java.util.Date;  
  
import org.apache.commons.lang.StringUtils;  
  
/** 
 * 日期Util类 
 *  
 * @author calvin 
 */  
public class DateUtil  
{  
    private static String defaultDatePattern = "yyyy-MM-dd ";  
  
    /** 
     * 获得默认的 date pattern 
     */  
    public static String getDatePattern()  
    {  
        return defaultDatePattern;  
    }  
  
    /** 
     * 返回预设Format的当前日期字符串 
     */  
    public static String getToday()  
    {  
        Date today = new Date();  
        return format(today);  
    }  
  
    /** 
     * 使用预设Format格式化Date成字符串 
     */  
    public static String format(Date date)  
    {  
        return date == null ? " " : format(date, getDatePattern());  
    }  
  
    /** 
     * 使用参数Format格式化Date成字符串 
     */  
    public static String format(Date date, String pattern)  
    {  
        return date == null ? " " : new SimpleDateFormat(pattern).format(date);  
    }  
  
    /** 
     * 使用预设格式将字符串转为Date 
     */  
    public static Date parse(String strDate) throws ParseException  
    {  
        return StringUtils.isBlank(strDate) ? null : parse(strDate,  
                getDatePattern());  
    }  
  
    /** 
     * 使用参数Format将字符串转为Date 
     */  
    public static Date parse(String strDate, String pattern)  
            throws ParseException  
    {  
        return StringUtils.isBlank(strDate) ? null : new SimpleDateFormat(  
                pattern).parse(strDate);  
    }  
  
    /** 
     * 在日期上增加数个整月 
     */  
    public static Date addMonth(Date date, int n)  
    {  
        Calendar cal = Calendar.getInstance();  
        cal.setTime(date);  
        cal.add(Calendar.MONTH, n);  
        return cal.getTime();  
    }  
  
    public static String getLastDayOfMonth(String year, String month)  
    {  
        Calendar cal = Calendar.getInstance();  
        // 年  
        cal.set(Calendar.YEAR, Integer.parseInt(year));  
        // 月，因为Calendar里的月是从0开始，所以要-1  
        // cal.set(Calendar.MONTH, Integer.parseInt(month) - 1);  
        // 日，设为一号  
        cal.set(Calendar.DATE, 1);  
        // 月份加一，得到下个月的一号  
        cal.add(Calendar.MONTH, 1);  
        // 下一个月减一为本月最后一天  
        cal.add(Calendar.DATE, -1);  
        return String.valueOf(cal.get(Calendar.DAY_OF_MONTH));// 获得月末是几号  
    }  
  
    public static Date getDate(String year, String month, String day)  
            throws ParseException  
    {  
        String result = year + "- "  
                + (month.length() == 1 ? ("0 " + month) : month) + "- "  
                + (day.length() == 1 ? ("0 " + day) : day);  
        return parse(result);  
    }  
}  

1.4.4  json/String  转  其它数据类型(解析json数据)

json:

JSON是一种取代XML的数据结构,和xml相比,它更小巧但描述能力却不差,由于它的小巧所以网络传输数据将减少更多流量从而加快速度。

JSON就是一串字符串 只不过元素会使用特定的符号标注。

{} 双括号表示对象

[] 中括号表示数组

"" 双引号内是属性或值

: 冒号表示后者是前者的值(这个值可以是字符串、数字、也可以是另一个数组或对象)

1 json->map

//1
Map map1 = JSON.parseObject(json);
System.out.println(map1.get("a"));
for (Object mapData : map.entrySet()) {
Map.Entry<String,String> entry = (Map.Entry<String,String>)mapData;
System.out.println(entry.getKey()+"--->"+entry.getValue());
}

//2
Map<String,Bar> map1 = (Map<String,Bar>)JSON.parse(json); 
for (String key : map1.keySet()) { 
System.out.println(key+":"+map1.get(key)); 
}

2 json->list

FastJSON

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

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

public class JsonTool {

    public static  T getPerson(String jsonstring, Class cls) {
        T t = null;
        try {
            t = JSON.parseObject(jsonstring, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return t;
    }

    public static  List getPersonList(String jsonstring, Class cls) {
        List list = new ArrayList();
        try {
            list = JSON.parseArray(jsonstring, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static  List> getPersonListMap1(
            String jsonstring) {
        List> list = new ArrayList>();
        try {
            list = JSON.parseObject(jsonstring,
                    new TypeReference>>() {
                    }.getType());

        } catch (Exception e) {
            // TODO: handle exception
        }

        return list;
    }
}

gson

import com.google.gson.Gson;

public class JsonUtils {

    public static String createJsonObject(Object obj) {
        Gson gson = new Gson();
        String str = gson.toJson(obj);
        return str;

    }
}
二、解析JSON

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

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

;
public class GsonTools {

    public GsonTools() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param 
     * @param jsonString
     * @param cls
     * @return
     */
    public static  T getPerson(String jsonString, Class cls) {
        T t = null;
        try {
            Gson gson = new Gson();
            t = gson.fromJson(jsonString, cls);
        } catch (Exception e) {
            // TODO: handle exception
        }
        return t;
    }

    /**
     * 使用Gson进行解析 List
     * 
     * @param 
     * @param jsonString
     * @param cls
     * @return
     */
    public static  List getPersons(String jsonString, Class cls) {
        List list = new ArrayList();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString, new TypeToken>() {
            }.getType());
        } catch (Exception e) {
        }
        return list;
    }

    /**
     * @param jsonString
     * @return
     */
    public static List getList(String jsonString) {
        List list = new ArrayList();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString, new TypeToken>() {
            }.getType());
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List> listKeyMaps(String jsonString) {
        List> list = new ArrayList>();
        try {
            Gson gson = new Gson();
            list = gson.fromJson(jsonString,
                    new TypeToken>>() {
                    }.getType());
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }
}

public static List getPersons(String key, String jsonString) {
        List list = new ArrayList();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            // 返回json的数组
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                Person person = new Person();
                person.setId(jsonObject2.getInt("id"));
                person.setName(jsonObject2.getString("name"));
                person.setAddress(jsonObject2.getString("address"));
                list.add(person);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List getList(String key, String jsonString) {
        List list = new ArrayList();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                String msg = jsonArray.getString(i);
                list.add(msg);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

    public static List> listKeyMaps(String key,
            String jsonString) {
        List> list = new ArrayList>();
        try {
            JSONObject jsonObject = new JSONObject(jsonString);
            JSONArray jsonArray = jsonObject.getJSONArray(key);
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonObject2 = jsonArray.getJSONObject(i);
                Map map = new HashMap();
                Iterator iterator = jsonObject2.keys();
                while (iterator.hasNext()) {
                    String json_key = iterator.next();
                    Object json_value = jsonObject2.get(json_key);
                    if (json_value == null) {
                        json_value = "";
                    }
                    map.put(json_key, json_value);
                }
                list.add(map);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return list;
    }

1.4.5  其它数据类型  转  json

1 map->json

json-lib是一个比较老的解决方案，近几年都没有升级过，它的适用环境是JDK1.5，使用JDK1.6就有可能会报错。所以配置上加入classifier-jdk15来解决这个问题。

<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			 <classifier>jdk15</classifier>

import java.util.HashMap;
import java.util.Map;
 
import net.sf.json.JSONObject;
 
public class aaa {
	  public static void main(String[] args) {
	        Map map = new HashMap();
	        map.put("msg", "yes");//map里面装有yes
	        JSONObject jsonObject = JSONObject.fromObject(map);
	        System.out.println("输出的结果是：" + jsonObject);
	        //3、将json对象转化为json字符串
	        String result = jsonObject.toString();
	        System.out.println(result);
	    }
}

alibaba:

JSONUtils.toJSONString(requestMap);    com.alibaba.fastjson.JSON

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.41</version>
</dependency>

Map<String, Integer> params = new HashMap<String, Integer>();
params.put("invateId", 1);
params.put("applySourceId", 1);

Object o = JSONObject.toJSON(params);
System.out.println(o.toString());

google

new Gson().toJson(param);         com.google.gson.2.2.2.jar   

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.3.1</version>
</dependency>

Gson gson = new Gson();
String s = gson.toJson(params);
System.out.println(s);

2 list - >json

//org.json.JSONArray包
//net.sf.json包下JSONArray的静态方法：fromObject(list) 这是网上大多是都是直接用此方法快捷转换JSON，但是对于Hibernate级联操作关联的对象，这个方法就会报错，如果将映射文件中的级联配置去掉就行了。

//另外对于list的要求就是其中的元素是字符串或对象，否则JSON不知道你想要的是什么数据。
List<Article> al = articleMng.find(f);
            System.out.println(al.size());
            HttpServletResponse hsr = ServletActionContext.getResponse();
            if(null == al){
                return ;
            }
            for(Article a : al){
                System.out.println(a.getId()+a.getDescription()+a.getTitle());
            }
            JSONArray json = new JSONArray();
            for(Article a : al){
                JSONObject jo = new JSONObject();
                jo.put("id", a.getId());
                jo.put("title", a.getTitle());
                jo.put("desc", a.getDescription());
                json.put(jo);
            }
            try {
                System.out.println(json.toString());
                hsr.setCharacterEncoding("UTF-8");
                hsr.getWriter().write(json.toString());
            } catch (IOException e) {
                e.printStackTrace();
            }

//<many-to-one name="cmsent" column="comment_tid" class="com.fcms.cms.entity.CmsComment" 
        not-null="false" cascade="delete">
//但是级联操作毕竟还是得存在，否则以后数据冗余、多余。

//解决方法就是：JSONArray subMsgs = JSONArray.fromObject(object, config);
JsonConfig config = new JsonConfig();
        config.setJsonPropertyFilter(new PropertyFilter() {
            public boolean apply(Object arg0, String arg1, Object arg2) {
                 if (arg1.equals("article") ||arg1.equals("fans")) {
                        return true;
                    } else {
                        return false;
                    }
            }
        });

//方法一

//首先导入jar包，json-rpc-1.0.jar
public class List2Json {
    public static JSONArray ProLogList2Json(List<ProgramLog> list){
         JSONArray json = new JSONArray();
         for(ProgramLog pLog : list){
             JSONObject jo = new JSONObject();
             jo.put("id", pLog.getId());
             jo.put("time", pLog.getBeginTime());
              
             json.put(jo);
         }
         return json;
    }
//方法二

//第二种方法更加简单，没有类似map操作的步骤，只需要引入相关jar包，就可以调用已有的函数fromObject()，其参数输入list，其返回值就是json。jar包如下：
//commons-beanutils-1.7.jar
//commons-collections.jar
//commons-lang.jar
//ezmorph.jar
//json-lib-2.2.2-jdk15.jar
import java.util.List;

import net.sf.json.JSONArray;


import com.test.vo.ProgramLog;

public class List2Json1 {
    public static JSONArray List2Json(List<ProgramLog> list){
         JSONArray json = JSONArray.fromObject(list);     
         return json;
    }
}

用@ResponseBody注解方法返回类型List，会把List转为json

@RequestMapping(value = "getOldNodes", method = RequestMethod.GET)
public @ResponseBody List getOldNodes(HttpSession session){     
    //转json传给js
    List list=new ArrayList() ;
    list.add(nodes);
    list.add(relations);
    return list;    
}