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、对于两个包装类比较时的注意事项，分清比较地址还是比较数值

数据类型转换
1、基本数据类型转换
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：



​	有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的

那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)， 基本数据类型的值将自动转化为字符串(String)类型。

2、强制类型转换

自动类型转换的逆过程， 将容量大的数据类型转换为容量小的数据类型。 使用时要加上强制转换符： ()， 但可能造成精度降低或溢出,格外要注意。
通常， 字符串不能直接转换为基本类型， 但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

 

 

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

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

数据类型的转换遵循原则：范围小的数据类型，可以转换成范围大的数据类型。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;    
}

 

JAVA数据类型转换









     
一些初学JAVA的朋友可能会遇到JAVA的数据类型之间转换的苦恼，例如，整数和float,double型之间的转换，整数和String类型之间的
转换，以及处理、显示时间方面的问题等。下面笔者就开发中的一些体会介绍给大家。

    
我们知道，Java的数据类型分为三大类，即布尔型、字符型和数值型，而其中数值型又分为整型和浮点型；相对于数据类型，Java的变量类型为布尔型
boolean；字符型char；整型byte、short、int、long；浮点型float、double。其中四种整型变量和两种浮点型变量分别
对应于不同的精度和范围。此外，我们还经常用到两种类变量，即String和Date。对于这些变量类型之间的相互转换在我们编程中经常要用到，在下面的
论述中，我们将阐述如何实现这些转换。

1 数据类型转换的种类/r

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

   
(1). 简单数据类型之间的转换 

   (2). 字符串与其它数据类型的转换 

   (3). 其它实用数据类型转换

   
下面我们对这三种类型转换分别进行论述。

2 简单数据类型之间的转换

   
在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为

[center]
(byte，short，char)--int--long--float--double[/center]

    
简单数据类型之间的转换又可以分为：

   ●低级到高级的自动类型转换

   ●高级到低级的强制类型转换

   
●包装类过渡类型能够转换

2.1自动类型转换

   
低级变量可以直接转换为高级变量，笔者称之为自动类型转换,例如，下面的语句可以在Java中直接通过：
byte b;int i=b;long l=b;float f=b;double d=b;
    如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如/r
   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
型。

2.2强制类型转换 

  将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式：
int i=99;byte b=(byte)i;char c=(char)i;float f=(float)i;
    可以想象，这种转换肯定可能会导致溢出或精度的下降，因此笔者并不推荐使用这种转换。

  2.3包装类过渡类型转换

   
在我们讨论其它变量类型之间的相互转换时，我们需要了解一下Java的包装类，所谓包装类，就是可以直接将简单类型的变量表示为一个类，在执行变量类型的
相互转换时，我们会大量使用这些包装类。Java共有六个包装类，分别是Boolean、Character、Integer、Long、Float和
Double，从字面上我们就可以看出它们分别对应于 
boolean、char、int、long、float和double。而String和Date本身就是类。所以也就不存在什么包装类的概念了。

  
 在进行简单数据类型之间的转换（自动转换或强制转换）时，我们总是可以利用包装类进行中间过渡。

   
一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

  
例1，当希望把float型转换为double型时：
  float f1=100.00f;   Float F1=new float(f1);   Double 
d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法
   当希望把double型转换为int型时：
   double d1=100.00;     Double D1=new Double(d1);     int 
i1=D1.intValue();
   当希望把int型转换为double型时，自动转换：
    int i1=200;     double d1=i1;
    简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：

Boolean(boolean 
value)、Character(char value)、Integer(int value)、Long(long 
value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()
的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对
应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

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

    
通过查阅类库中各个类提供的成员方法可以看到，几乎从java.lang.Object类派生的所有类提供了toString()方法，即将该类转换为字
符串。例如：Characrer,Integer,Float,Double,Boolean,Short等类的toString()方法
toString()方法用于将字符、整数、浮点数、双精度数、逻辑数、短整型等类转换为字符串。如下所示：
int i1=10;float f1=3.14f;double d1=3.1415926;Integer I1=new 
Integer(i1);//生成Integer类/rFloat F1=new Float(f1); //生成Float类/rDouble 
D1=new Double(d1); //生成Double类/r//分别调用包装类的toString()方法转换为字符串String 
si1=I1.toString();String sf1=F1.toString();String 
sd1=D1.toString();Sysytem.out.println("si1"+si1);Sysytem.out.println("sf1"+sf1);Sysytem.out.println("sd1"+sd1);
五、将字符型直接做为数值转换为其它数据类型

将字符型变量转换为数值型变量实际上有两种对应关系，在我们在第一部分所说的那种转换中，实际
上是将其转换成对应的ASCII码，但是我们有时还需要另一种转换关系，例如，'1'就是指的数值1，而不是其ASCII码，对于这种转换，我们可以使用
Character的getNumericValue(char ch)方法。

六、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型表示年、月、日、时、分、秒/r

在长整型和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);
结束语：

当然，笔者的论述只是一人之见，如果希望更多了解有关JAVA数据类型转换的知识，笔者建议参考JAVA类库
java.util.*下面的

Integer类/r

Boolean类/r

Character类/r

Float类/r

Double
类/r

String类/r

Date类 

根据自己的需要，参考不同类的各种成员方法进行数据类型之间的转换。

大家可以参考
JAVA的网上类库或下载一份，来更灵活的利用其中的成员方法进行数据类型之间的转换，地址：
http://java.sun.com/j2se/1.3/docs/api/index.html