JAVA各种数据类型的互相转换

一：String与基础类型与包装类的互转

1：Java基础类型转换为String类型都可以先尝试String.valueOf()方法;

2：将String类型转换为基础类型或其包装类可以使用下面2种方法：

将string转换为基础类型
1). int i = Integer.parseInt(String);        
i = Integer.parseInt([String],[int radix]); 
将string转换为包装类
2). int i = Integer.valueOf(String).intValue();    
intValue()可以省略，Integer.valueOf(String)返回的是Integer类型，包装类可以自动拆箱转换为int
注: 字串转成 Double, Float, Long 的方法大同小异

3：基础类型对应的包装类可以直接互转，基础类型和包装类之间可以自动装箱和拆箱，所以不用额外的去转换。

Integer i= 1;

4：包装类转换为String类型，直接包装类.tostring即可

Integer integer1 = 1;
Integer.toString(integer1);
也可以使用String.valueOf()，这里涉及拆箱操作

5：包装类和基础类型转换

正向转换：通过类包装器来new出一个新的类类型的变量
Integer a= new Integer(2);

反向转换：通过类包装器来转换
int b=a.intValue();

其他：

StringBuilder转化为String

    String str = "abcdefghijklmnopqrs";
    StringBuilder stb = new StringBuilder(str);

整型数组转化为字符串

    StringBuilder s = new StringBuilder();
    for(i=1;i<=n;i++) {
        s.append(String.valueOf(a[i]));
    }
    String str = ""+s;                   

字符串转化为整形数组

    String str="123456";
    int[] a = new int[str.length()];
    for(int i=0;i<str.length();i++) {
        a[i]  = str.charAt(i)-'0';
    }

字符串转化为字符数组

    String str="123456";
    char[] c = str.toCharArray() ;
    System.out.println(c);

字符数组转化为整型数组

    char[] c = { '1', '2', '3', '4', '5', };
    int[] a = new int[c.length];
    for (int i = 0; i < 5; i++) {
        a[i] = c[i] - '0';
        System.out.println(a[i]);
    }

整型数组转化为字符数组

    int[] a = {1,2,3,4,5};
    char[] c = new char[a.length];
    for (int i = 0; i < 5; i++) {
        c[i] = (char) (a[i]+'0');
        System.out.println(c[i]);
    

二：集合与数组与String之间的互转

1、集合转成数组：

　　转之前集合里面存的什么类型的数据，就new什么类(特别：存的是基本数据的封装类，就要new他的封装类)

　　例如：

　　1.1集合：　　　

　　　　ArrayList<Character> list = new ArrayList<Character>();

　　1.2转成数组：

　　　　Character help[] = list.toArray(new Character[list.size()]);

　　1.3再转成字符串：

　　　　此时注意不能简单粗暴的直接用String的valueOf方法，那样会返回地址

　　　　例如：

　　　　　　String str2 = String.valueOf(help);

　　　　　　输出str2为地址：[Ljava.lang.Character;@16de49c

　　　　---------------------------------------------------------------------------

　　　　重点来啦:

　　　　　　先创建一个字符串缓冲区：

　　　　　　　　StringBuffer sb = new StringBuffer();

　　　　　　再用for循环把包装类数组中的数据一个一个加进去

　　　　　　　　for(Character c : help){

　　　　　　　　　　sb.append(c);

　　　　　　　　}

　　　　　　再返回次序列中字符串的表示形式toString()

　　　　　　　　sb.toString();

　　　　　　再输出就是字符串啦！！！！！

2、数组转成集合

　　　　2.1例如上述的数组：

　　　　　　　Character help[] = list.toArray(new Character[list.size()]);

　　　　2.2转成集合：

　　　　　　　List<Character> list1 = Arrays.asList(help); 

　　　　2.3集合再转成String：

　　　　　　重复1的方法

　　　　2.4数组直接转成字符串：

　　　　　　包装类的数组转成字符串建议采用1中的1.2和1.3，要是用valueOf(help),得到的就是地址

　　　　　　基本类型的数组转成字符串：

　　　　　　　　　char c1[] = {'a','b','c'};

　　　　　　　　String str = String.valueOf(c1);

　　　　　　　　得到的就是"abc"

3、字符串转成集合

　　先把字符串转成数组再转成集合

　　

4、字符串转成数组：

　　    String str ="abc";直接用toCharArray()/getBytes()

　　 String str1 = "a,b,c";用分割字符串即可

三：map list set 数组互转

 list,set,map,数组间的相互转换 1：

list,set,map,数组间的相互转换
1.list转set
Set set = new HashSet(new ArrayList());

2.set转list
List list = new ArrayList(new HashSet());

3.数组转为list
List stooges = Arrays.asList("Larry", "Moe", "Curly");
//此时stooges中有有三个元素。注意：此时的list不能进行add操作，否则会报 “java.lang.UnsupportedOperationException”，Arrays.asList()返回的是List,而且是一个定长的List，所以不能转换为ArrayList，只能转换为AbstractList
原因在于asList()方法返回的是某个数组的列表形式,返回的列表只是数组的另一个视图,而数组本身并没有消失,对列表的任何操作最终都反映在数组上. 所以不支持remove,add方法的。

或者
String[] arr = {"1", "2"};
List list = Arrays.asList(arr);

4.数组转为set
int[] a = { 1, 2, 3 };
Set set = new HashSet(Arrays.asList(a));

5.map的相关操作。
Map map = new HashMap();
map.put("1", "a");
map.put('2', 'b');
map.put('3', 'c');
System.out.println(map);
// 输出所有的值
System.out.println(map.keySet());
// 输出所有的键
System.out.println(map.values());
// 将map的值转化为List
List list = new ArrayList(map.values());
System.out.println(list);
// 将map的值转化为Set
Set set = new HashSet(map.values());
System.out.println(set);

6.list转数组
List list = Arrays.asList("a","b");
String[] arr = (String[])list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));

运行：

{1=a, 2=b, 3=c}
[1, 2, 3]
[a, b, c]
[a, b, c]
[a, b, c]
[a, b]

遍历map时：

public static void main(String[] args) {


  Map<String, String> map = new HashMap<String, String>();
  map.put("1", "value1");
  map.put("2", "value2");
  map.put("3", "value3");
  
  //第一种：普遍使用，二次取值
  System.out.println("通过Map.keySet遍历key和value：");
  for (String key : map.keySet()) {
   System.out.println("key= "+ key + " and value= " + map.get(key));
  }
  
  //第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value：");
  Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry<String, String> entry = it.next();
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }
  
  //第三种：推荐，尤其是容量大时
  System.out.println("通过Map.entrySet遍历key和value");
  for (Map.Entry<String, String> entry : map.entrySet()) {
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第四种
  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
  for (String v : map.values()) {
   System.out.println("value= " + v);
  }
 }

list,set,map,数组间的相互转换2：

package com.example.test; 
 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.List; 
import java.util.Map; 
import java.util.Set; 
 
public class ConvertorTest { 
 
    /**
     * @param args
     */ 
    public static void main(String[] args) { 
 
        testList2Array(); 
        testArray2List(); 
        testSet2List(); 
        testList2Set(); 
        testSet2Array(); 
        testArray2Set(); 
        testMap2Set(); 
        testMap2List(); 
    } 
 
    private static void testMap2List() { 
 
        Map<String, String> map =new HashMap<String, String>();   
        map.put("A","ABC");   
        map.put("K","KK");   
        map.put("L","LV");   
 
        // 将Map Key 转化为List     
        List<String> mapKeyList =new ArrayList<String>(map.keySet());   
        System.out.println("mapKeyList:"+mapKeyList); 
 
        // 将Map Key 转化为List     
        List<String> mapValuesList =new ArrayList<String>(map.values());   
        System.out.println("mapValuesList:"+mapValuesList); 
 
    } 
 
    private static void testMap2Set() { 
 
        Map<String, String> map =new HashMap<String, String>();   
        map.put("A","ABC");   
        map.put("K","KK");   
        map.put("L","LV");   
 
        // 将Map 的键转化为Set     
        Set<String> mapKeySet = map.keySet();   
        System.out.println("mapKeySet:"+mapKeySet); 
 
        // 将Map 的值转化为Set     
        Set<String> mapValuesSet =new HashSet<String>(map.values());   
        System.out.println("mapValuesSet:"+mapValuesSet); 
    } 
 
    private static void testArray2Set() { 
 
        String[] arr = {"AA","BB","DD","CC","BB"};   
 
        //数组-->Set   
        Set<String> set =new HashSet<String>(Arrays.asList(arr));   
        System.out.println(set);   
    } 
 
    private static void testSet2Array() { 
        Set<String> set =new HashSet<String>(); 
        set.add("AA"); 
        set.add("BB"); 
        set.add("CC"); 
 
        String[] arr =new String[set.size()];   
        //Set-->数组   
        set.toArray(arr);  
        System.out.println(Arrays.toString(arr));   
    } 
 
    private static void testList2Set() { 
 
        List<String> list =new ArrayList<String>(); 
        list.add("ABC"); 
        list.add("EFG"); 
        list.add("LMN"); 
        list.add("LMN"); 
 
        //List-->Set 
        Set<String> listSet =new HashSet<String>(list); 
        System.out.println(listSet); 
    } 
 
    private static void testSet2List() { 
 
        Set<String> set =new HashSet<String>(); 
        set.add("AA"); 
        set.add("BB"); 
        set.add("CC"); 
 
        //Set --> List 
        List<String> setList =new ArrayList<String>(set); 
        System.out.println(setList);   
    } 
 
    private static void testList2Array() { 
        //List-->数组   
        List<String> list =new ArrayList<String>();   
        list.add("AA");   
        list.add("BB");   
        list.add("CC");   
        Object[] objects = list.toArray();//返回Object数组   
        System.out.println("objects:"+Arrays.toString(objects));   
 
        String[] arr =new String[list.size()];   
        list.toArray(arr);//将转化后的数组放入已经创建好的对象中   
        System.out.println("strings1:"+Arrays.toString(arr));   
    } 
 
    private static void testArray2List() { 
        //数组-->List   
        String[] ss = {"JJ","KK"};   
        List<String> list1 = Arrays.asList(ss);   
        List<String> list2 = Arrays.asList("AAA","BBB");   
        System.out.println(list1);   
        System.out.println(list2);   
    } 
 
}