精华内容
下载资源
问答
  • Java数据类型转换

    2020-11-18 17:52:56
    Java数据类型转换 Java的数据类型分为两类:基本数据类型和引用数据类型, 基本数据类型包括boolean类型和数值类型。数值类型有整数类型和浮点类型。整数类型包括 byte、short、int、long、char,浮点类型包括float...

    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、下图输出结果是什么?
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201118165923127.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjYyNjgwOA==,size_16,color_FFFFFF,t_70#pic_center

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

    在这里插入图片描述输出结果是否与您答案一致,如果不同为什么会出现这样的结果?
    首先前两个都是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数据类型转换

    2019-06-13 16:52:20
    数据类型转换 1、基本数据类型转换 自动类型转换:容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为: ​ 有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的 那种数据类型,...

    数据类型转换

    1、基本数据类型转换

    自动类型转换:容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为:
    在这里插入图片描述

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

    2、强制类型转换

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

    千次阅读 2018-11-20 11:20:32
      本博文部分原创,部分转载整理,侵删!...数据类型转换遵循原则:范围小的数据类型,可以转换成范围大的数据类型。eg:byte转int。范围大的数据类型不可以转换成范围小的数据类型。 jav...

     

     

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

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

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

    2010-05-19 15:14:00
    JAVA数据类型转换 一些初学JAVA的朋友可能会遇到JAVA的数据类型之间转换的苦恼,例如,整数和float,double型之间的转换,整数和String类型之间的转换,以及处理、显示时间方面的问题等。下面笔者就开发中的一些体会...
    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

    展开全文
  • JAVA 数据类型转换

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,535
精华内容 10,214
关键字:

java数据类型转换

java 订阅