java字符串转String Java字符串转int

文章目录

• 一, 概念
• 二, 种类 ✔
• 三, 装箱(基本数据类型->引用数据类型) (valueOf())

• 3.1 装箱的两种方法

• 四,拆箱(引用数据类型->基本数据类型) (xxvalue())
• 五, 基本数据类型和字符串之间的转换(▷)
• 六, 包装类的一些拓展知识

• 6.1, 包装类的初始值
• 6.2, 包装类对象之间的比较(重点,需要强化理解并记忆!)

一, 概念

• Java基本数据类型不具有对象特征,不能像对象一样,拥有属性和方法,同时也不能对象化交互.
• 为了使基本数据类型可以,Java引入了包装类,让基本数据类型像对象一样参与OO的编程;

二, 种类 ✔

• 各个基本数据类型对应的包装类

基本数据类型	对应的包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

除了int,char的包装类分别为Integer,Character, 其他基本数据类型的包装类都是首字母大写.
包装类中除了数值型数据类型包装类的**直接父类**是Number(Number继承自Object),其他的布尔型,字符型包装类的父类是Object.
Java中的包装类都是被final修饰的,所以这些包装类不能被继承,没有子类.

三, 装箱(基本数据类型->引用数据类型) (valueOf())

3.1 装箱的两种方法

1, 自动装箱:

• 直接把基本数据类型的变量或值赋给对应的包装类.
• 如:

Character ch = 'sb' ;
 		或: 
 		char y= 'sb';  
	    Character ch =y;

2.手动装箱 – 方式1

• 新建包装类的实例对象,然后把对应基本数据类型的变量或值通过构造函数传入;
  -如:

Int x=5;            
	Integer integer = new Integer(x);

2.手动装箱 – 方式2

• 使用 valueOf()方法, 等同于 new Integer()

Int x=5;            
	Integer integer = Integer.valueOf(x);

• valueOf()是包装类的静态方法:

public static Integer valueOf(int i)或者
public static Integer valueOf(String s)
//返回表示(指定的int值)或者是(保存int值的string对象)的Integer实例。

如果不需要新的Integer实例，则该方法通常应优先于构造函数Integer(int)使用

// 因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。
// 此方法将始终缓存-128到127（含）范围内的值，并可能会超出此范围之外的其他值。

---

用一段代码来说明自动,手动装箱以及valueOf()的使用

public static void main(String[] args) {
        int num =5;
        ///1. 自动装箱
        // 直接把int值赋给Integer,
        Integer numWraped = num;

        System.out.println("自动装箱"+numWraped);

        ///2.手动装箱-方式1
        // 创建Integer对象并通过Integre的带参构造把num传入
        Integer numWraped_01 = new Integer(num);

        System.out.println("手动装箱"+numWraped_01);
		
		///2.手动装箱-方式2
        /// 包装类的静态方法 valueOf(),等同于 new Integer();
        ///public static Integer valueOf(int i)或者
        ///public static Integer valueOf(String s)
         ///返回表示(指定的int值)或者是(保存int值的string对象)的Integer实例。
        // 如果不需要新的Integer实例，则该方法通常应优先于构造函数Integer(int)使用 ，
        // 因为该方法可能通过缓存经常请求的值而产生明显更好的空间和时间性能。
        // 此方法将始终缓存-128到127（含）范围内的值，并可能会超出此范围之外的其他值。
        Integer wrapedNum01 = Integer.valueOf(numWraped);
        System.out.println("valuOf方法可用于返回表示指定int值的Integer实例," +
                "类似于手动装箱中的构造函数,他的值也是:   "+wrapedNum01);
    }

将基本数据类型封装成包装类的好处在于可以在对象中定义更多的功能方法操作该数据;
常用的操作之一: 用于基本数据类型与字符串之间的相互转换(参见cp5);

• 拓展: 用包装类的静态方法,去判断数据类型表示的数的范围

public class ValueScale {
    public static void main(String[] args) {
        ///判断一个数是否在数据类型表示的范围内
        ///或者说你想看某个数据类型表示的数的范围
        /// public static final int MIN_MAXVALUE;
        /// public static final int MAX_MAXVALUE;

        System.out.println("int类型表示的数的最大范围"+Integer.MAX_VALUE);
        System.out.println("int类型表示的数的最小范围"+Integer.MIN_VALUE);
        System.out.println("=================================");
        System.out.println("char类型表示的数的最大范围"+Character.MAX_VALUE);
        System.out.println("char类型表示的数的最小范围"+Character.MIN_VALUE);
        System.out.println("=================================");
        System.out.println("long类型表示的数的最大范围"+Long.MAX_VALUE);
        System.out.println("long类型表示的数的最小范围"+Long.MIN_VALUE);
    }
}

四,拆箱(引用数据类型->基本数据类型) (xxvalue())

1.自动拆箱:

• 直接把包装类型的变量或值赋给基本数据类型的变量

Character ch = new Character('s');
	//自动拆箱
	char UW_ch = ch;

2. 手动拆箱

• 使用包装类的方法 xxValue(); xx指代的是包装类对应的基本数据类型;

Integer x =Integer.valueOf(18);
	//手动拆箱
	int UW_x = x.intValue();

public class UnWrapedTest {
    public static void main(String[] args) {
   
        Integer integer = new Integer(88);
        ///1. 自动拆箱
        int num = integer;

        System.out.println("自动拆箱的值为:"+num);

        ///2.手动拆箱
        ///需要用到 xxValue()方法,  xx为基本数据类型
        int num1 = integer.intValue();

        System.out.println("手动拆箱用到xxvalue()方法, 很方便的取出包装类的值为: "+num1);
    }
}

五, 基本数据类型和字符串之间的转换(▷)

拿 int 和String相互转换为例

示例代码:

public class IntAndStringDemo {
    public static void main(String[] args) {
        ///int 和 string类型值的相互转换

        //int----> string
        //1. 直接赋值;
        int num1 = 100;
        String str1= ""+num1;
        System.out.println("1.int转为String,直接转换: "+str1);
        //2.使用 String类的静态方法 valueOf()
                    //格式:public static String valueOf(int i)
        String str2 = String.valueOf(num1);
        System.out.println("2.使用String的静态方法 valueOf 去返回一个int参数的字符串,为: "+str2);
        //3. 使用包装类的toString方法
        String str11 = Integer.toString(num1);
        System.out.println("3.使用包装类的toString方法也可以哦, 为:"+str11);

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

        //string-->int
        //1. 间接转换, String-> Integer -> int
        ///使用到了拆箱时用到的 Integer的 intValue()方法
                    ///public int intValue()
        /// intValue(),返回Integer的值作为 int
        Integer integer = new Integer(str1);
        int num2 = integer.intValue(); //拆箱
        System.out.println("1. 字符串转为Integer, Integer再使用 intValue() 方法转为int值, 即间接转换, 为"+num2);
        //2.   直接接收一个String类型参数,同时返回int类型
        使用到 Integer 的 parseInt()方法
                    // public static int parseInt()
        int num3 = Integer.parseInt(str1);
        System.out.println("2. 使用Integer的静态方法 paesrInt(),直接传入string参数并返回int类型的值,为: "+num3);
    }
}

六, 包装类的一些拓展知识

6.1, 包装类的初始值

• 基本类型的初始值



• 包装类型的初始值, 一个字, null

6.2, 包装类对象之间的比较(重点,需要强化理解并记忆!)

Java中,包装类是一个对象,也是一个具体的数值.
所以说,对象比较用equals,数值比较用==

• Q:这段代码输出的五个结果是多少?



• A:

• 对以上问题的详细解读:
  对于1, java在堆中新建了两个不同的Integer对象one和two, 两者虽然同在堆中但地址是完全不相同的,所以在one == two即比较两者的地址是肯定为false的;
  对于2, Integer three =100显然是发生了自动装箱, 当three ==100时, 因为后者是数字所以我们需要比较两者的数字大小, 所以此时 three又会发生自动拆箱,所以为true;
  对于3,我们在写这句代码Integer three =100;时等价于Integer three = Integer.valueOf(100);调用这个方法后系统会把-128-127范围内参数放入对象常量池中，我们在声明four对象后会检查参数是否已经存在缓冲区内，如果有则直接产生，如果没有则实例化. 而five的参数大于了127，所以不会存入到缓冲区，而是直接实例化放在堆中,所以six就不等于five
  对于4, 跟2是类似的,Integer对象跟数值200比较时,Integer会发生自动拆箱.
  对于5,看上面.
• 再来一个栗子:

Double b1 = Double.valueOf(100);
        System.out.println("b1==100的结果"+(b1==100));

        Double b2 = Double.valueOf(100);
        System.out.println("b1==b2的结果"+(b1==b2));

要注意float和double类型是没有对象常量池的概念的，所以b1和b2不相等.哈哈被我骗到了吧