【Java常用工具类之包装类与字符串】看完不懂把舍友去给你刷马桶

wuchangjian2021-11-10 03:37:54编程学习

前言

继上次讲完异常之后,今天我们来讲包装类这一块,这一块也是非常的重要,学完这一块你就更加能理解Java是面向对象的编程语言了!,,谁说得?

我说的!
好了接下来我们正式开始:

目录

  • 前言
  • 初识包装类
    • 什么是包装类?
    • 包装类有什么作用?
  • 拆箱与装箱
    • 装箱
      • 自动装箱
      • 手动装箱
    • 拆箱
      • 自动拆箱
      • 手动拆箱
  • 字符串
    • 字符串与基本数据类型
      • 基本数据类型转换成字符串
      • 字符串转换为基本数据类型
    • String和StringBuilder
      • String
      • StringBuilder
      • String和StringBuilder的区别
      • String类与StringBuilder类的相互转换
    • 字符串的不可变性

初识包装类

什么是包装类?

这是Java中的数据类型在这里插入图片描述
我们都知道Java设计中一个核心的原则,即万物皆对象,也就是说一切要求用对象的形式描述,但是基本数据类型不是对象。那么该如何解决此问题呢?

可以把基本数据类型包装成一个对象,以面向对象的思想去使用这些类型。

所以产生了,我们的包装类。每一种基本数据类型都有它对应的包装类,如下:
在这里插入图片描述

包装类有什么作用?

采用基本数据类型包装的形式描述,让功能变得更加健壮,例如: Integer默认不是int的 0 而是 null ,那么比起基本数据类型,包装类对象它就多了一个状态。

还有一个比较直观的,就是包装类给我们提供了很多方法可以使用,例如:数据可以转二进制,查看最大值最小值等等。

例如:

//此方法可以把数字直接转换为字符串类型
Integer.toString()

除了上面还有一个要点: 集合中不能存放基本数据类型,只能存放对象,所以当使用集合时,我们的就需要使用到包装类对象。

Ps:集合我们下一节讲,这里先做一个了解就行。如果想看可以先关注我!

拆箱与装箱

现在我们知道了基本数据类型与它们对应包装类之间的关系了,那么我们应该对它们进行转换呢?

其实这个转换就是我们在这里讲的装箱与拆箱。

装箱

装箱就是将基本数据类型封装为包装类对象。

这里又分为自动装箱与手动装箱!

自动装箱

自动装箱其实非常简单,就是直接是包装类的引用等于一个对应基本数据类型的值就行。

例如:

Integer num=10;

手动装箱

手动装箱较自动装箱麻烦许多,需要创建相应的类的引用并且实例化对象才行。

int num = 10;
Integer integer = Integer.valueOf(num);

这里valueOf() 方法用于返回给定参数的原生 Number 对象值,参数可以是原生数据类型, String等;

不过这个并不重要在jdk5以后自动装箱与拆箱就出来了,手动的基本已经被废弃了,大家重点还是把握住自动的就可以。

拆箱

包装类向对应的基本类型转换称为拆箱,例如把 Integer 类的对象重新简化为 int

它也分为了自动和手动拆箱。

自动拆箱

自动的看起来都是十分的简洁,也是很好用的。

如下

//integer2为Integer类的实例化
int n3 = integer2;

手动拆箱

手动拆箱就还是通过调用了对应类实例化对象的方法来实现。

Integer num=10;
int i = num.intValue();

字符串

这里我们为什么要把字符串拿出来单独讲呢?

因为字符串广泛应用 在 Java 中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。

很多操作都离不开字符串,它是非常非常重要的。

字符串与基本数据类型

在很多时候我们都会用到字符串与基本数据类型之间的转换,所以我们单独来讲下

基本数据类型转换成字符串

有三种办法:

1.基本类型数据的值+"" (最常用,最简单)
2.使用包装类中的静态方法 static String toString(int i)返回一个表示指定整数的String 对象。
3.使用String类中的静态方法 static String value0f(int i) 返回int 参数的字符串表示形式。

String 类别中已经提供了将基本数据型态转换成 String 的 static 方法也就是 String.valueOf() 这个参数多载的方法

String.valueOf(boolean b) 
//将 boolean 变量 b 转换成字符串 
String.valueOf(char c) 
//将 char 变量 c 转换成字符串 
String.valueOf(char[] data)
//将 char 数组 data 转换成字符串 
String.valueOf(char[] data, int offset, int count)
//将char数组data中由data[offset]开始取 count个元素转换成字符串 
String.valueOf(double d)
//将 double 变量 d 转换成字符串 
String.valueOf(float f)
//将 float 变量 f 转换成字符串 
String.valueOf(int i)
//将 int 变量 i 转换成字符串 
String.valueOf(long l)
//将 long 变量 l 转换成字符串 
String.valueOf(Object obj)
//将 obj 对象转换成 字符串, 等于 obj.toString() 

因为是静态方法所以不需要实例化。

字符串转换为基本数据类型

一般使用包装类的静态方法parseXX( “字符串”)

要将 String 转换成基本数据类型大多需要使用基本数据型态的包装类别,比如说 String 转换成 byte可以使用 Byte.parseByte(String s)

Byte.parseByte(String s)
//将 s 转换成 byte 
Byte.parseByte(String s, int radix)
//以 radix 为基底 将 s 转换为 byte
Double.parseDouble(String s)
//将 s 转换成 double 
Float..parseFloat(String s)
//将 s 转换成 float  
Integer.parseInt(String s)
//将 s 转换成 int 
Long.parseLong(String s)
//将 s 转换成 long

注意这里也是静态方法,只不过都是对应包装类的静态方法

String和StringBuilder

String

String 类代表字符串,Java 程序中的所有字符串文字(例如“abc”)都被实现为此类的实例。也就是说,Java程序中所有的双引号字符串,都是 String 类的对象。String 类在 java.lang 包下,所以使用的时候不需要导包!

String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了

string类的特点:

字符串不可变,他们的值在创建后不能被改变
虽然String的值是不可变的,但是它们可以被共享
字符串效果相当于字符数组(char[]),但是底层原理是字节数组(byte[])

创建String对象的两种方法:

//方法一:直接创建
String s1= "白白 超牛的";
//方法二:对象创建
String s2 = new String("白白 超牛的"); 
String s3 = new String();//也可以创建一个空串 

虽然两种方法看起来是一样的但是本质上是不一样的。
String 创建的字符串存储在公共池中,而 new 创建的字符串对象在堆上。那公共池(常量池)与堆有什么不一样吗?

我们来举个例子:

String s1 = "白白 超牛的";              // String 直接创建
String s2 = "白白 超牛的";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("白白 超牛的");   // String 对象创建
String s5 = new String("白白 超牛的");   // String 对象创建

直接创建的字符串时,会先在公共池中找有没有这样的字符串,如果有那就将引用直接指向它,而不去开发新的空间。在这里s1,s2,s3这三个引用指向了公共池中的同一块内存。

对象创建时,每次都会在堆上开新的空间来存放字符串,也就是说s4,s5分别指向在堆上的两块不同的内存,只不过这两块内存里面都储存着相同的东西

还有就是字符串的索引(index)了
例如:白白 超牛的
它的索引对应为:

012345

取的时候

s="白白 超牛的"
System.out.print(s.charAt(4)+);

输出为:

StringBuilder

StringBuilder 是一个可变的字符串类,我们可以把它看成是一个容器,这里的可变指StringBuilder对象中的内容是可变的。

在这里插入图片描述
StringBuilder类常用的方法(构造方法)

StringBuilder() 
//构造一个不带任何字符的字符串生成器,其初始容量为 16 个字符。
StringBuilder(CharSequence seq) 
//构造一个字符串生成器,它包含与指定的 CharSequence 相同的字符。
StringBuilder(int capacity) 
//构造一个不带任何字符的字符串生成器,其初始容量由 capacity 参数指定。
StringBuilder(String str) 
//构造一个字符串生成器,并初始化为指定的字符串内容。
append(任意类型)  
//追加到字符串后面
reverse 
//反转字符串
insert(int offset, 任意类型)  
//在某个index后插入字符串

可以看出来,构建一个StringBuilder的对象只能使用它的构造方法来构造,不像String一样可以直接String s= "123"来创建

因为StringBuilder类对象是可变的,所以当我们对一个字符串需要进行改变比较多的时候一般定义为StringBuilder类。

String和StringBuilder的区别

String 对象是不可改变的。每次使用 System.String 类中的方法之一时,都要在内存中创建一个新的字符串对象,这就需要为该新对象分配新的空间。

StringBuilder 对象是动态对象,允许扩充它所封装的字符串中字符的数量,但是您可以为它可容纳的最大字符数指定一个值,当修改 StringBuilder 时,在达到容量之前,它不会为其自己重新分配空间。当达到容量时,将自动分配新的空间且容量翻倍。也就是说当对字符串进行改变时,都是对当前对象的状态进行更新的。

可以使用重载的构造函数之一来指定 StringBuilder 类的容量。

选择String的场景:

1.当你的应用将对字符串进行的更改数量很小时。 在这些情况下tringBuilder 可能会提供可忽略或不会提高性能的性能 String 。
2.当你执行固定数量的串联操作时,尤其是字符串文本。 在这种情况下,编译器可能会将串联操作合并为单个操作。
3.在生成字符串时,必须执行大量的搜索操作。 StringBuilder类缺少搜索方法,如 IndexOf 或 StartsWith 。 StringBuilder对于这些操作,必须将对象转换为 String ,这可能会使使用不会带来性能优势 StringBuilder 。

选择StringBuilder的场景:

  1. 如果希望应用在设计时对字符串进行未知数量的更改 (例如,当你使用循环来连接包含用户输入) 的随机数量的字符串时。
  2. 希望应用对字符串进行大量更改时。

还有它们的连接(追加)字符的方法也是不同的,String可以直接使用+来连接,而StringBuilder使用append()方法,它们具体的方法建议大家熟悉熟悉,可以去这里看看:
String常见方法
StringBuilder常用方法

String类与StringBuilder类的相互转换

String类转换为StringBuilder类

public class String{
    public static void main(String[] args){
        String s = "baibai";
        StringBuilder s1 = new StringBuilder(s);
        System.out.println(s1);
    }
}

StringBuilder类转换为String类

public class String {
    public static void main(String[] args){
        StringBuilder s1 = new StringBuilder();
        //连续连接
        s1.append("abc").append("efg");
        String s = s1.toString();
        System.out.println(s);
    }
}

字符串的不可变性

不可变性:当你给一个字符串重新赋值之后,老值并没有在内存中销毁,而是重新开辟一块空间存储新值

也就是说一旦一个String对象在内存中创建,它将是不可改变的,所有的String类中方法并不是改变String对象自己,而是重新创建一个新的String对象
例如:

String s="baibai";
String s="baba"

当s的值发生改变之后,baba这个值并没有覆盖baibai,只是重新开发了一个新的空间去储存baba然后将s指向它。

如果我们在实际开发中对很含有大量字符的字符串进行遍历赋值修改,会对内存中产生很多无法释放的字符串对象,造成内存垃圾

正因为String对象的不可变性,如果需要对字符串进行大量的修改、添加字符、删除字符等操作尽量不要使用String对象,因为这样会频繁的创建新的对象导致程序的执行效率下降。这时我们可以使用字符串生成StringBuilder。

整理总结
持续更新…

相关文章

发表评论    

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。