精华内容
下载资源
问答
  • JAVA与SQL对应数据类型转换
    千次阅读
    2022-03-16 15:19:09
    java类型SQL类型
    booleanBIT
    byteTINYINT
    shaotSMALLINT
    intINTEGER
    longBIGINT
    StringCHAR,VARCHAR,LONGVARCHAR
    byte arrayBINARY,VAR BINARY
    java.sql.DateDATE
    java.sql.TimeTIME
    java.sql.TimestampTIMESTAMP
    更多相关内容
  • 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数据类型转换超详解

    千次阅读 2021-09-01 13:41:23
    Java数据类型转换 java数据类型的转换一般分三种,分别是: 一. 简单数据类型之间的转换 在Java中整型、实型、字符型被视为简单数据类型,这些类型由低级到高级分别为(byte,short,char)–int–long–float–double ...

    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-1020: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型。

    展开全文
  • 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数据类型转换大全

    万次阅读 多人点赞 2016-12-15 18:20:52
    JAVA数据类型转换大全 1)将字符串转化为整型; int i = Integer.parseIn(String str); int i = Integer.valueOf().intValue(); 注:Integer.parseIn 和 Integer.valueOf 不同,前者生成的是整型,而后者是一...
  • Java数据类型转换原则

    千次阅读 2018-06-15 00:37:44
    一、数据类型分类:主要分为 基本类型、引用类型...从高位类型到低位类型需要强制类型转换: (1)布尔型和其它基本数据类型之间不能相互转换; (2)byte型可以转换为short、int、、long、float和double; (3)...
  • java基本数据类型之间的转换

    万次阅读 多人点赞 2019-01-18 19:13:36
    1、数据类型的分类     2、比较数据类型之间的字节大小  1字节=8位 、 3、转换中的知识点 *java中整数类型默认的int类型;小数类型默认的double; *String的字符串转化为char类型时,只能用char类型的...
  • java中的基本数据类型转换规则

    千次阅读 2019-07-17 20:50:59
    java数据类型以及转换原则 一、数据类型分类:主要分为 基本类型、引用类型两大类; 二、基本类型 转换原则 1、类型转换主要在在 赋值、方法调用、算术运算 三种情况下发生。  a、赋值和方法调用 转换规则:...
  • Java语言基础中, 数据类型分为基本数据类型和引用数据类型. 在这里, 从计算机底层(二进制的层面)介绍和分析基本数据类型(也就是四类八种)的转换. 而且转换分为两种 -- 隐式转换和强制转换. 隐式转换  A: 案例...
  • 自动数据类型转换自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下: 低———————————————>高 byte,short,char-> int -> long -> float -> double运算中,不同类型的数据先转化为同一...
  • 1.String 转 BigDecimal BigDecimal bd = new BigDecimal(str); ########int 转 BigDecimal String str= "1"; int a = Integer.parseInt(str); System.out.println(a);...BigDecimal bigDecimal = new BigDecimal(a)....
  • java基本数据类型自动转换规则

    千次阅读 2017-08-03 09:38:02
    一、java基本数据类型 Java提供了八种基本类型,其中包括六种数字类型(四个整数型,两个浮点型),一种字符类型和一种布尔型。  整型: short, int, long, byte;  浮点型:float, double;  字符型:char;  ...
  • Java数据类型转换:隐式(自动)转换与强制转换

    万次阅读 多人点赞 2015-08-17 10:09:25
    一些初学JAVA的朋友可能会遇到JAVA数据类型之间转换的苦恼,例如,整数和float,double型之间的转换,整数和String类型之间的转换,以及处理、显示时间方面的问题等。下面笔者就开发中的一些体会介绍给大家。  ...
  • 在前几期的文章中介绍了Java中的数据类型,在Java中数据类型之间可以进行转换,本期就来介绍一下两种数据类型转换的方式。 数据类型转换是将一个值从一种类型更该为另一种类型的过程。例如可以将String类型的数据456...
  • 分析Java中基本数据类型转换及强转带来精度丢失问题
  • 从高位类型到低位类型需要强制类型转换: (1)布尔型和其它基本数据类型之间不能相互转换; (2)byte型可以转换为short、int、long、float和double; (3)short可转换为int、long、float和doubl...
  • Java基本数据类型转换

    千次阅读 2021-12-31 22:15:27
    Java基本数据类型转换,简介
  • Java基础_引用数据类型的强制类型转换

    千次阅读 多人点赞 2019-05-23 20:01:07
    其实不然,他们之间的强制类型转换是有条件的。 当我们用一个类型的构造器构造出一个对象时,这个对象的类型就已经确定的,也就说它的本质是不会再发生变化了。在Java中我们可以通过继承、向上转型的...
  • Java基本数据类型以及强制类型转换

    千次阅读 2020-12-12 21:42:32
    1Java基本数据类型 1. 1数据类型(应用) 1.1.1 计算机存储单元 我们知道计算机是可以用来存储数据的,但是无论是内存还是硬盘,计算机存储设备的最小信息单元叫“位(bit)”,我们又称之为“比特位”,通常用小写...
  • 小范围类型-->-->大范围类型:自动类型转换。 2.大范围类型-->-->小范围类型: 1.若大范围类型的数超出小范围类型的值的范围: 报错,精度会有损失。 2.若大范围类型的数没有超出小范围类型值范围: 1. 若小范围类型...
  • 1、自动类型转换 2、强制类型转换
  • Java基本数据类型转换java基本类型转换优先级转换类型1. 自动类型转换: 编译器自动完成类型转换,不需要再程序中编写代码转换规则: 从存储范围小的类型到存储范围大的类型具体规则 : byteàcharàshortàintàlong...
  • byte→short(char)→int→long→float→double(这里指的是只有前面的数据类型能随便转换成后面的) —实际开发中这样的类型转换很多,但没有为这种转换提供专门的语法,都是由虚拟机自动完成。 3、例子: byte b = ...
  • java JNI到C++中调用时候各种常见类型数据如何转换,通过程序演示Java通过JNI调用C++的API读取电脑名称和系统用户名。
  • java类型转换

    千次阅读 2018-07-02 15:27:03
    类型转换Java中的类型转换可以分为13种,1 标识转换 是最简单的就是同种类型之间的转换。2 拓展简单类型转换 拓展简单类型转换涉及到基本数据类型,比如byte转换为short,int,long,float,double;short转换为int,long...
  • JAVA数据类型转换

    千次阅读 2008-03-17 12:27:00
    Java语言是典型的支持面向对象的程序语言,但考虑到有些基本数据类型的结构简单,占内存小且存取速度快等优点,Java依然提供了对这些非面向对象的简单数据类型的支持。当然,Java在提供大量的其它类时,也提供了与简单...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 800,025
精华内容 320,010
关键字:

java数据类型转换

java 订阅
友情链接: 编程样例(C#).rar