数据格式转化

int

int->long互转:
a , b
long, int 　　b=(int)a;
long,Integer 　　 b= new Long(a).intValue();
Long,int b= a.inValue();
Long,Integer b= a.intValue()
int, long　　　　　 b= a
int,Long b= new Integer(a).LongValue();
Integer,long　　 b= a.longValue()
Inter,long b= a.longValue();

bigdecimal

//数字字符串

String StrBd="1048576.1024"; 

//构造以字符串内容为值的BigDecimal类型的变量bd

BigDecimal bd=new BigDecimal(StrBd); 

//设置小数位数，第一个变量是小数位数，第二个变量是取舍方法(四舍五入)

bd=bd.setScale(2, BigDecimal.ROUND_HALF_UP); 

//转化为字符串输出

String OutString=bd.toString();

补充:原 Integer转BigDecimal

new BigDecimal(Integer.parseInt(findCcid.toString()))

BigDecimal转Integer

Object转BigDecimal类型：

  public static BigDecimal getBigDecimal(Object value) {
        BigDecimal ret = null;
        if (value != null) {
            if (value instanceof BigDecimal) {
                ret = (BigDecimal) value;
            } else if (value instanceof String) {
                ret = new BigDecimal((String) value);
            } else if (value instanceof BigInteger) {
                ret = new BigDecimal((BigInteger) value);
            } else if (value instanceof Number) {
                ret = new BigDecimal(((Number) value).doubleValue());
            } else {
                throw new ClassCastException("Not possible to coerce [" + value + "] from class " + value.getClass() + " into a BigDecimal.");
            }
        }
        return ret;
    }

BigDecimal与int long相互转换：
int 转换成 BigDecimal 数据类型

//int  转换成  bigDecimal类型
 public static BigDecimal intToBigDecimal(int i){
     BigDecimal b = new BigDecimal(i);
 return b;
　　

二、Lont 转换成 BigDecimal 数据类型

//Long 类型转换成 bigDecimal
   public static BigDecimal longToBigDecimal(Long l){
       BigDecimal b = new BigDecimal(l);
       return b;

三、BigDecimal 转换成 Long数据类型

//bigDecimal  转换成  Long类型
    public static Long bigDecimalToLong(BigDecimal b){
        BigDecimal c = new BigDecimal(b);
        Long l = c.longValue();
        return l;
        }

四、BigDecimal 转换成 int数据类型

//bigDecimal  转换成  int类型
       public static void bigDecimalToInt(BigDecimal b){
           BigDecimal c = new BigDecimal(b);
           int i = c.intValue();

String

将字符串中的字符以；进行分割：

String a []  = s.split(";")

将两个字符串以“,”进行拼接：

String wechat = "Hollis";

String introduce = "召唤师峡谷";
1.使用+拼接字符串
String hollis = wechat + "," + introduce;
2.concat
String hollis = wechat.concat(",").concat(introduce);
3.stringbuffer
StringBuffer wechat = new StringBuffer("Hollis");

String introduce = "召唤师峡谷";

StringBuffer hollis = wechat.append(",").append(introduce);
4.stringbuilder
StringBuilder wechat = new StringBuilder("Hollis");

String introduce = "召唤师峡谷";

StringBuilder hollis = wechat.append(",").append(introduce);
5.stringutils.join
StringUtils.join(wechat, ",", introduce)

String是否包含某子串：
方法一：JDK原生方法String.indexOf
在String的函数中，提供了indexOf（subStr）方法，返回子串subStr第一次出现的位置，如果不存在则返回-1。例子如下：

//包含Java
assertEquals(7, "Pkslow Java".indexOf("Java"));
//如果包含多个，返回第一次出现位置
assertEquals(0, "Java Java".indexOf("Java"));
//大小写敏感
assertEquals(-1, "Google Guava".indexOf("guava"));

2.2 JDK原生方法String.contains
最直观判断的方法是contains（subStr），返回类型为boolean，如果包含返回true，不包含则返回false。例子如下：

//包含Java
assertTrue("code in Java".contains("Java"));
//大小写敏感，不包含GO
assertFalse("Let's go".contains("GO"));
//转为大写后包含
assertTrue("Let's go".toUpperCase().contains("GO"));

实际上，String的contains方法是通过调用indexOf方法来判断的，源码如下：

public boolean contains(CharSequence s) {
  return indexOf(s.toString()) > -1;
}

2.3 JDK原生正则匹配Pattern
通过强大的正则匹配来判断，虽然有点杀鸡用牛刀的感觉，但也不是不能用，例子如下：

Pattern pattern = Pattern.compile("Java");
//包含Java
Matcher matcher1 = pattern.matcher("Python, Java, Go, C++");
assertTrue(matcher1.find());
//不包含Java
Matcher matcher2 = pattern.matcher("Python, C, Go, Matlab");
assertFalse(matcher2.find());

2.4 Apache库StringUtils.contains
Apache的commons-lang3提供许多开箱即用的功能，StringUtils就提供了许多与字符串相关的功能，例子如下：

//包含sub
assertTrue(StringUtils.contains("String subString", "sub"));
//大小写敏感
assertFalse(StringUtils.contains("This is Java", "java"));
//忽略大小写
assertTrue(StringUtils.containsIgnoreCase("This is Java", "java"));

字符串截取：
字符串截取:

1 取字符串的前i个字符
str=str.substring(0,i);

2 去掉字符串的前i个字符
str=str.substring(i);

3 从右边开始取i个字符
str=str.substring(str.length()-i);
str=str.substring(str.length()-i,str.length());

4 从右边开始去掉i个字符
str=str.substring(0,str.Length-i);

5 如果字符串中有"abc"则替换成"ABC"
str=str.replace(“abc”,“ABC”);

date

获取当前系统时间和日期并格式化输出:

import java.util.Date;  
import java.text.SimpleDateFormat;  
  
public class NowString {  
   public static void main(String[] args) {   
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式  
      System.out.println(df.format(new Date()));// new Date()为获取当前系统时间  
   }  
}  

二、 Date转换为Datetime

Date date = new Date();   
  
Timestamp timestamp = new Timestamp(date.getTime()); //2013-01-14 22:45:36.484   

三、String转换为Date

//String转换为java.util.Date   
  
String str = "2013-01-14";   
  
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");   
  
Date date = null; //初始化date   
  
try {   
  
date = sdf.parse(str); //Mon Jan 14 00:00:00 CST 2013   
  
} catch (ParseException e) {   
  
e.printStackTrace();   
  
}   

四、Date转换为String

//java.util.Date转换为String   
  
Date date = new Date();   
  
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");   
  
String str = format.format(date); //2013-01-14   

五、 String转化为java.sql.Date

//String转换为java.sql.Date   
  
String str = "2013-01-14";   
  
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");   
  
java.sql.Date sdate = null; //初始化   
  
try {   
  
java.util.Date udate = sdf.parse(str);   
  
sdate = new java.sql.Date(udate.getTime()); //2013-01-14   
  
} catch (ParseException e) {   
  
e.printStackTrace();   
  
}  

六、SimpleDateFormat格式说明

import java.text.*;  
import java.util.Date;  
public class FormatDateTime {  
     public static void main(String[] args) {  
        ///   打印出2006年11月17日 15时19分56秒  
         SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");  
        //打印   06/11/17 15:19  
         SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");    
    
         //2006-11-17 15:19:56  
        SimpleDateFormat myFmt2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
          
      //2006年11月17日 15时19分56秒 星期五  
      SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");  
  
        // 一年中的第 321 天 一年中第46个星期 一月中第3个星期 在一天中15时 CST时区  
       SimpleDateFormat myFmt4=new SimpleDateFormat(  
                    "一年中的第 D 天 一年中第w个星期 一月中第W个星期 在一天中k时 z时区");  
        
      Date now=new Date();  
System.out.println(myFmt.format(now));  
         System.out.println(myFmt1.format(now));  
         System.out.println(myFmt2.format(now));  
         System.out.println(myFmt3.format(now));  
         System.out.println(myFmt4.format(now));  
         System.out.println(now.toGMTString());// 17 Nov 2006 07:19:56 GMT  
         System.out.println(now.toLocaleString());// 2006-11-17 15:19:56  
         System.out.println(now.toString());// Fri Nov 17 15:19:56 CST 2006  
     }      
}  

七、将Unix时间戳转换成指定格式日期

public String TimeStamp2Date(String timestampString, String formats){    
  Long timestamp = Long.parseLong(timestampString)*1000;    
  String date = new java.text.SimpleDateFormat(formats).format(new java.util.Date(timestamp));    
  return date;    
}  

当调用TimeStampToDate(“1252639886”, “yyyy-MM-dd HH:mm:ss”);

返回值：2009-11-09 11:31:26

bean与map之间转换

javabean与map的转换有很多种方式，比如:

1、通过ObjectMapper先将bean转换为json，再将json转换为map，但是这种方法比较绕，且效率很低，经测试，循环转换10000个bean，就需要12秒！！！不推荐使用

2、通过Java反射，获取bean类的属性和值，再转换到map对应的键值对中，这种方法次之，但稍微有点麻烦

3、通过net.sf.cglib.beans.BeanMap类中的方法，这种方式效率极高，它跟第二种方式的区别就是因为使用了缓存，初次创建bean时需要初始化，之后就使用缓存，所以速度极快，经测试，循环bean和map的转换10000次，仅需要300毫秒左右。

 /** 
 * 将对象装换为map 
 * @param bean 
 * @return 
 */  
public static <T> Map<String, Object> beanToMap(T bean) {  
    Map<String, Object> map = Maps.newHashMap();  
    if (bean != null) {  
        BeanMap beanMap = BeanMap.create(bean);  
        for (Object key : beanMap.keySet()) {  
            map.put(key+"", beanMap.get(key));  
        }             
    }  
    return map;  
}  
  
/** 
 * 将map装换为javabean对象 
 * @param map 
 * @param bean 
 * @return 
 */  
public static <T> T mapToBean(Map<String, Object> map,T bean) {  
    BeanMap beanMap = BeanMap.create(bean);  
    beanMap.putAll(map);  
    return bean;  
}  
  
/** 
 * 将List<T>转换为List<Map<String, Object>> 
 * @param objList 
 * @return 
 * @throws JsonGenerationException 
 * @throws JsonMappingException 
 * @throws IOException 
 */  
public static <T> List<Map<String, Object>> objectsToMaps(List<T> objList) {  
    List<Map<String, Object>> list = Lists.newArrayList();  
    if (objList != null && objList.size() > 0) {  
        Map<String, Object> map = null;  
        T bean = null;  
        for (int i = 0,size = objList.size(); i < size; i++) {  
            bean = objList.get(i);  
            map = beanToMap(bean);  
            list.add(map);  
        }  
    }  
    return list;  
}  
  
/** 
 * 将List<Map<String,Object>>转换为List<T> 
 * @param maps 
 * @param clazz 
 * @return 
 * @throws InstantiationException 
 * @throws IllegalAccessException 
 */  
public static <T> List<T> mapsToObjects(List<Map<String, Object>> maps,Class<T> clazz) throws InstantiationException, IllegalAccessException {  
    List<T> list = Lists.newArrayList();  
    if (maps != null && maps.size() > 0) {  
        Map<String, Object> map = null;  
        T bean = null;  
        for (int i = 0,size = maps.size(); i < size; i++) {  
            map = maps.get(i);  
            bean = clazz.newInstance();  
            mapToBean(map, bean);  
            list.add(bean);  
        }  
    }  
    return list;  
}  

String boolean

String 转 boolean）String str = “true”; boolean a = Boolean.parseInt(str);
（boolean 转 String）boolean a = true; String str = a + “”;
注：i. 字符串不能直接转成字符类型，需要使用String类中的charAt方法去字符串中的取一个字符
ii. 若字符串转数值类型时，若字符串中存在不能表示数值的字符时，抛出java.lang.NumberFormatException异常
iii. 字符串转布尔类型时，当且仅当字符串是“true”时，结果为true，否则其他任意字符串转布尔类型结果都是false
3、String类中的valueOf方法：boolean boo = true; String str = String.valueOf(boo);

String 与list

1.字符串转字符数组

 String str =" aa.png,a2.png,a3.png";

  String[] arrayStr =new String[]{};

  arrayStr = str.split(",");

2.字符数组转list

 List list = java.util.Arrays.asList(arrayStr);

3.list转化为字符数组

String[] storeStr = list.toArray(new String[list.size()]);

map与jsonObject

将map转换成jsonObject

JSONObject itemJSONObj = JSONObject.parseObject(JSON.toJSONString(itemMap));

将Map类型的itemInfo转换成json，再经JSONObject转换实现。

2、//将jsonObj转换成Map
Map<String, Object> itemMap = JSONObject.toJavaObject(itemJSONObj, Map.class);

//JOSN.parseObjet()方法同样可以转换

3、//将List转换成JSONArray

JSONArray ja = JSONArray.parseArray(JSON.toJSONString(itemList));

4、//将JSONArray转换成List

这个涉及功能比较广，有达人整理的更为完善。

链接如下：
http://www.cnblogs.com/goody9807/p/4244862.html

5 json转成对象

List channelItemList = JSON.parseArray(itemJson,ChannelItem.class);

set、List、Array

1.list-array

（1）Array转List

String[] s = new String[]{"A", "B", "C", "D","E"};
List<String> list = Arrays.asList(s);

注意这里list里面的元素直接是s里面的元素( list backed by the specified array)，换句话就是说：对s的修改，直接影响list。
（2）List转Array

String[] dest = list.toArray(new String[0]);//new String[0]是指定返回数组的类型
System.out.println("dest: " + Arrays.toString(dest));

输出结果

dest: [AA, B, C, D, E]

注意这里的dest里面的元素不是list里面的元素，换句话就是说：对list中关于元素的修改，不会影响dest。
2.list-set
因为List和Set都实现了Collection接口，且addAll(Collection<? extends E> c);方法，因此可以采用addAll()方法将List和Set互相转换；另外，List和Set也提供了Collection<? extends E> c作为参数的构造函数，因此通常采用构造函数的形式完成互相转化。

//List转Set
Set<String> set = new HashSet<>(list);
System.out.println("set: " + set);
//Set转List
List<String> list_1 = new ArrayList<>(set);
System.out.println("list_1: " + list_1);

MAP、LIST转换

Map转List

@Data
@NoArgsConstructor
@AllArgsConstructor
class KeyValue {
	private Integer key;
	private String value;

	@Override
	public String toString() {
		return key + " ==> " + value;
	}

}
Copy
Map<Integer, String> map = new HashMap<>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");

// key 转 List
List<Integer> keyList = new ArrayList<>(map.keySet());
List<Integer> keyList2 = map.keySet().stream().collect(Collectors.toList());

keyList.forEach(System.out::println);
keyList2.forEach(System.out::println);

// value 转 List
List<String> valueList = new ArrayList<>(map.values());
List<String> valueList2 = map.values().stream().collect(Collectors.toList());

valueList.forEach(System.out::println);
valueList2.forEach(System.out::println);

// Iterator转List
List<KeyValue> keyValueList = new ArrayList<>();
Iterator<Integer> it = map.keySet().iterator();
while (it.hasNext()) {
	Integer k = (Integer) it.next();
	keyValueList.add(new KeyValue(k, map.get(k)));
}

keyValueList.forEach(System.out::println);

// Java8 Stream
List<KeyValue> list = map.entrySet().stream().map(c -> new KeyValue(c.getKey(), c.getValue()))
		.collect(Collectors.toList());
list.forEach(System.out::println);
2. List转Map
Copy
List<KeyValue> list = new ArrayList<>();
list.add(new KeyValue(1, "a"));
list.add(new KeyValue(2, "b"));
list.add(new KeyValue(3, "c"));

// 遍历
Map<Integer, String> keyValueMap = new HashMap<>();
for (KeyValue keyValue : list) {
	keyValueMap.put(keyValue.getKey(), keyValue.getValue());
}
keyValueMap.forEach((k, v) -> System.out.println(k + " ==> " + v));

// Java8 Stream
Map<Integer, String> map = list.stream().collect(Collectors.toMap(KeyValue::getKey, KeyValue::getValue));
map.forEach((k, v) -> System.out.println(k + " ==> " + v));