Java常见类型转换

java常见的类型转换

1.基本数据类型与字符串之间的互转

1.1基本类型转换成String(以int为例)

eg:int类型转换成String类型.
1.int类型+"";
2.Integer.toString（int num）
    //基本类型的封装类调用toString()方法,传入的参数为int类型.
3.static String valueOf(int i) --- 返回 int 参数的字符串表示形式。
    //通过String类中的valueOf(任意类型)方法,将任意类型参数转换成String类型的字符串.
    String s = String.valueOf(3);
    System.out.println(s);

1.2String转换成基本类型(以int为例)

//方法一:
static int  parseInt(String s) --- 将字符串参数作为有符号的十进制整数进行解析。
    String s = "1232123"; 
    int parseInt = Integer.parseInt(s);
    System.out.println(parseInt);

//方法二       
static Integer  valueOf(int i) --- 返回一个表示指定的 int 值的 Integer 实例。
    int intValue() --- 以 int 类型返回该 Integer 的值。
    int intValue = Integer.valueOf(s).intValue();
    System.out.println(intValue);

2.数组与字符串之间的互转

2.2数组转换成String(代码实现在下边几行)

1,Arrays工具类中的toString(参数:数组)方法.
2,遍历数组添加到创建的StringBuffer中,再直接打印成字符串.

2.2String转换成数组(代码实现在下边几行)

1,String中的toCharArray()方法;
2,String中的charAt()方法,再通过遍历添加到创建的字符数组中.

import java.util.Arrays;

public class Change {
    public static void main(String[] args) {
        //数组--->字符串.
        char[] chArr = {'1','2','a','3','b'};

        //方法一
        //通过调用Arrays工具类中的toString(参数:数组)方法.
        //Arrays工具类的toString(参数:数组)源代码
        //底层是通过创建StringBuider类来实现的,为了区分是数组类变成String类,所以两边添加了[].
        String s1 = Arrays.toString(chArr);
        System.out.println(s1);
        //System.out.println(chArr.toString());//不能直接调用toString方法,因为没有重写打印出来的是地址值.

        //方法二
        //先用String类中charAt()方法获取每个索引位置字符子串,再通过遍历挨个添加到创建的StringBuffer中.源码底层是StringBuild实现的,是线程不安全的.
        StringBuffer sb = new StringBuffer();
        for (char c : chArr) {
            sb.append(c);
        }
        //StringBuffer的toString方法已经重写了,所以直接可以打印即为字符串.
        System.out.println(sb);
        //System.out.println(sb.toString());//效果一样的.
        //System.out.println(sb+"");//这也是其他类转换成字符串类的一种方式.

        //Arrays工具类toString实现的源码.
        //      public static String toString(char[] a) {
        //          if (a == null)
        //              return "null";
        //          int iMax = a.length - 1;
        //          if (iMax == -1)
        //              return "[]";
        //
        //          StringBuilder b = new StringBuilder();
        //          b.append('[');
        //          for (int i = 0; ; i++) {
        //              b.append(a[i]);
        //              if (i == iMax)
        //                  return b.append(']').toString();
        //              b.append(", ");
        //          }
        //      }
    }
}

2.3String和byte之间的特殊转换

String转换成Byte[]数组
String s = "abc";
byte[] b = s.getBytes();

for (int i = 0; i < b.length; i++) {
    System.out.println(b[i]);//97//98//99
}

Byte[]数组转换成字符串,用字符串的构造方法.
byte[] b1 = {97,98,99};
String s1 = new String(b1);
System.out.println(s1);//abc

3.集合与数组之间的互转

3.1集合转换成数组

1,Object[]  toArray() ---返回包含此 collection 中所有元素的数组。
通过集合实现类的对象调用toArray()方法,返回一个Object类型的数组.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("z");
        list.add("a");
        list.add("w");

        Object[] arr = list.toArray();
        System.out.println(Arrays.toString(arr));//用数组工具类中的toString方法获取字符串

        for (int i = 0; i < arr.length; i++) {//也可以通过遍历得到元素
            System.out.println(arr[i]);
        }

2,<T> T[] ---toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

        //定义好集合要转换的数组类型,通过传入新创建的数组类型,这里定义数组长度为0.
        String[] array = list.toArray(new String[0]);//list.size()
        //这里边涉及到两个长度问题//1,集合的长度//2,设定的数组的长度//两个长度比一比,谁长听谁的,不足null补齐.
        //如何理解呢?就是集合转成数组,数组可以提前定义好长度,或者集合默认长度list.size();
        //转换的时候,哪个长度长就以哪个为准.而元素未添加满的,用null补齐.
        for (String string : array) {
            System.out.println(string);
        }

3.2数组转换成集合

1,static<T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。
通过数组工具类中的asList()方法

//导包
public class CollectionDemo {
    public static void main(String[] args) {
        //首先这样的做法是错误的,因为数组可以存储基本数据类型和引用数据类型,而集合只能存储引用数据类型,
        //这里虽然不报错,是因为把int[](int类型的数组)当成了泛型进行存储.
        int[] arr1 = { 11, 22, 33 };
        List<int[]> as1 = Arrays.asList(arr1);
        System.out.println(as1.size());//1//存储的是一个数组,所以长度只有1
        System.out.println(as1);//[[I@7852e922]

        System.out.println("--------------------------");

        //Arrays的asList()方法,返回一个受指定数组支持的固定大小的列表。
        //因为数组和集合最大的区别就是集合的长度是不固定的,把固定类型的数组转换成集合,那么使集合的长度也"变得"固定了,因此无法使用集合中的set(增)和remove(删)方法.因为转换后的集合长度被数组固定住了.
        Integer[] arr2 = { 11, 22, 33 };
        List<Integer> as2 = Arrays.asList(arr2);
        System.out.println(as2);//[11, 22, 33]
        //迭代过程正常
        Iterator<Integer> it2 = as2.iterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
        //要想把上边转换而来固定长度的集合进行增删,可以通过再创建(复制)成新的集合进行增删操作.
        ArrayList<Integer> list2 = new ArrayList<>(as2);
        list2.add(100);
        System.out.println(list2);//[11, 22, 33, 100]

        System.out.println("--------------------------");

        //String本身是引用数据类型,可以当做集合的元素进行存储.
        String[] s = { "a", "b", "c" };
        List<String> ass = Arrays.asList(s);
        System.out.println(ass);//[a, b, c]

        System.out.println("--------------------------");

        //static <T> List<T>   asList(T... a) //这里的(T... a)是1.5新特性,是可变参数 
        List<String> str = Arrays.asList("a","b","c");//传入可变参数
        System.out.println(str);//[a, b, c]
    }
}

2,通过遍历数据添加到创建的集合中.

4.其他各种转换总结(开发中经常用到的转换方法)

4.1任意类型转成字符串类型

1,任意类型 + ""
2,引用数据类型toString()方法
3,String.valueOf(参数);参数传递任意类型，返回值是String

4.2字符串转成字节数组:

String s = "abc";
byte[] bytes = s.getBytes();//在IO流的时候用到--- 字节流往外写一个字符串的时候

4.3字节数组转字符串:

byte [] bys = {97,98,99};
String s = new String(bys);
System.out.println(s);

4.4字符串转成字符数组：

String s = "abc";
char[] ch = s.toCharArray();//返回值ch是每一个字符组成的数组 [a,b,c]
得到字符串的每一个字符还可以通过charAt()方法遍历得到

4.5字符串转成基本数据类型：//以int类型为例

String s = "123";
int ps = Integer.parseInt(s);

4.6字符串转成StringBuffer：

1,构造函数
    String s = "abc";
    StringBuffer sb = new StringBuffer(s);//在要用到StringBuffer里面的方法的时候使用，比如反转，比如添加
2,通过append()方法
    String s = "abc";
    StringBuffer sb = new StringBuffer();
    sb.append(s);

4.7StringBuffer转成字符串：

1,任意类型 + ""
2,引用数据类型toString()方法
3,String.valueOf(参数);参数传递任意类型，返回值是String
4,构造        
    StringBuffer sb = new StringBuffer("abc");
    String s = new String(sb);//s就是转换后的结果
5,subString
    StringBuffer sb = new StringBuffer("abc");
    String s = sb.subString(0,sb.length());//s就是转换后的结果

4.8基本数据类型与其包装类之间的手动转换：

int ---> Integer(手动装箱)
    int i = 10;
    Integer ii = new Integer(i);//其中ii就是手动包装后的引用数据类型对象

Integer ---> int(手动拆箱)
    Integer i = new Integer(10);
    int iv = i.intValue();//iv就是由Integer转换成int得到的值

4.9毫秒值转成日期对象

1，先有一个毫秒值Long类型的d
2，转换
    Date date = new Date(d);
    或者
    Date date = new Date();
    date.setTime(d);
//两种方法中的date就是将毫秒值转换成的日期对象

4.10日期对象转换成毫秒值

1，先有一个 Date 类型的时间对象
2，直接通过getTime的方法获取毫秒值

4.11将日期对象转换成字符串

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(new Date());//传递时间对象，返回格式化后的字符串

4.12将字符串转换成字符串日期对象

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sdf.parse("2000年10月10日 10:10:10");//传递时间对象，返回格式化后的字符串