第七章常用类

默默无闻，低调做人

已于 2024-01-31 13:03:32 修改

阅读量328

点赞数

分类专栏：尚硅谷JavaSE 文章标签： java eclipse jvm

于 2022-10-29 01:22:07 首次发布

本文链接：https://blog.csdn.net/weixin_44530052/article/details/127581423

版权

尚硅谷JavaSE 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1.包装类

java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量有类的特征。基本数据类型、包装类、String三者之间的转换；包装类默认为null。Byte、Short、Ingeger、Long、Float、Double的父类是Number。

1.1.包装类转换

装箱和拆箱，装箱：基本类型 --> 包装类，例如：把int 转化为 Integer；拆箱：包装类-- > 基本类型，例如：把Integer 转化为int。JDK5.0新特性：自动装箱和自动拆箱。

1.2.Integer类

int的包装类。1.构造方法：Integer(int value)：构造一个Integer对象，他的值是int；Integer(String s)：构造一个Integer对象，他的值是s（s必须用双引号包裹的整型）。

Integer i1 = new Integer(100);
System.out.println(i1);

Integer i2 = new Integer("100");
System.out.println(i2);

1.2.1.常用方法

优先考虑parseInt

方法	返回值	说明
toString()	String	将INTEGER对象转化为String类型对象
equals(INTEGER another)	boolean	比较此对象与指定对象是否相等
compareTo(Integer another)	Int	两个对象比较，相等，返回0；调用对象小于another，返回-1.调用对象大于another，返回1.
valueOf(String s)	Integer	把String类型的s转化为Integer类型
parseInt(String s)	int	把数字字符串转化为int数值

注意：在将字符串类转化为int数值的时候，如果字符串中包含非数值类型的字符，则程序执行会出现异常。Integer内部定义了IntegerCache结构，IntegerCache种定义了Integer[]，保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，会直接返回缓存中的对象，而不是新创建一个对象。目的：提高效率。

String str = "456";
int num = Integer.parseInt(str);//把字符串转化为int
System.out.println(num);

Integer num2 = Integer.valueOf(str);//把字符串转化为int
System.out.println(num2);

String s = num2.toString();
System.out.println(s);

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false
Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true
Integer x = 128;
Integer y = 128;
System.out.println(x == y);//false

//进制转化
int num = 40;
String str = Integer.toString(num);//将整型 -- > 字符串
String str2 = Integer.toBinaryString(num); // 转化为二进制
String str8 = Integer.toOctalString(num);//转化为8进制
String str16 = Integer.toHexString(num); // 转化为16进制
System.out.println(str2);//101000
System.out.println(str8);//50
System.out.println(str16);//28

1.2.2.常量

MAX_VALUE：2的31次方-1 ，他表示的是整型的最大值；MIN_VALUE：-2的31次方，表示的是整型的最小值。

int maxValue = Integer.MAX_VALUE;
int minValue = Integer.MIN_VALUE;
System.out.println(maxValue);
System.out.println(minValue);

1.3.Float类

float的包装类。1.构造方法：Float(String s)：构造一个Float对象，表示把s参数所表示的值转化float；Float(float value)：构造一个Float对象，表示把value参数所表示的值转化float；Float(double value)：构造一个Float对象，表示把value参数所表示的值转化float。

Float f1 = new Float(3.14356);
Float f2 = new Float(6.5F);
Float f3 = new Float("3.1415");

1.3.1.常用方法

方法	返回值	说明
isNaN()	boolean	如果不是数字，返回true。否则返回false。
toString()	String	将float类型转化为String类型。
valueOf(String s)	Float	将字符串s表示的数值转化为Float类型的数值
parseFloat(String s)	Float	将字符串s表示的数值转化为Float类型的数值

public static void main(String[] args) {
    String str = "456.7";
    float f = Float.parseFloat(str);
    float e = 12.3F + f;
    System.out.println(e);
    String str2 = Float.toString(e);
    String first = str2.substring(0, 1);
    System.out.println(first);
}

1.4.Double类

double的包装类。1.构造方法：Double(double value)：构造一个Double类型的对象，并且分配一个value值；Double(String s)：构造一个Double类型的对象，把String类型的数字转化为Double类型。

Double d1 = new Double(23.456) ;
Double d2 = new Double("4567.89");

1.4.1.常用方法

方法	返回值	说明
isNaN()	boolean	如果不是数字，返回true。否则返回false。
toString()	String	将double类型转化为String类型。
valueOf(String s)	Double	将字符串s表示的数值转化为Double类型的数值
parseDouble(String s)	Double	将字符串s表示的数值转化为Double类型的数值

String str = "234.6587";
Double d = Double.valueOf(str);//将字符串 --> double

double dd = 123.4567;
String s = Double.toString(dd);

1.5.Character类（char）

1.5.1.常用方法

方法	说明
Character(char value)	构造方法
char charValue	返回次Character对象的值
compareTo(Character another)	根据数字比较两个Character对象
isDigit(char ch)	指定的字符是不是为数字，是的话返回true
isLower(char ch)	指定的ch是否为小写字母。
isUpper(char ch)	指定的ch是否为大写字母
toLowerCase(char ch)	将ch转化为小写字母
toUpperCase(char ch)	将ch转化为大写字母

1.5.2.示例：

// 示例1
public static void main(String[] args) {
    Character a = new Character('李');
    System.out.println(a + 0);
    Character c = new Character('王');
    System.out.println(c + 0);
    int compareTo = a.compareTo(c);
    System.out.println(compareTo);
}

// 示例2
public static void main(String[] args) {
    Character ch = new Character('D');
    char lowerCase = Character.toLowerCase(ch);//d
    System.out.println(lowerCase);
    boolean upperCase = Character.isUpperCase(ch);//true
    System.out.println(upperCase);
}

1.6.Boolean类

1.6.1.常用方法

方法	返回值	说明
booleanValue()	boolean	将Boolean对象的值以对应的boolean值返回。
equals(Object obj)	boolean	判断调用对象的方法对象是否和obj对象相等。
toString()	String	将布尔值转化为字符串
valueOf(String s)	boolean	将字符串类型转化为布尔类型

1.6.2.示例

布尔在构造对象的时候，是不区别大小写的，如果传入的是true，返回true。传入其他全部返回false。

Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("true");
Boolean b3 = new Boolean("ok");//false
Boolean b4 = new Boolean("TrUE");

1.6.3.常量

TRUE：boolean类型的true；FALSE：boolean类型的false。

2.数字的处理

2.1.Math类常用的方法

位于java.lang包下

方法	描述
abs	绝对值
acos,asin,atan,cos,sin,tan	三角函数
sqrt	平方根
pow(double a,doble b)	a的b次幂
log	自然对数
exp	e为底指数
max(double a,double b)
min(double a,double b)
random()	返回0.0到1.0的随机数
long round(double a)	double型数据a转换为long型（四舍五入）
toDegrees(double angrad)	弧度—>角度
toRadians(double angdeg)	角度—>弧度

2.2.静态常量、最值和绝对值

// 静态常量
System.out.println(Math.PI);
System.out.println(Math.E);

// 求最值和绝对值
System.out.println(Math.max(10, 20)); // 20
System.out.println(Math.min(12.3, 34.7));// 12.3
System.out.println("-12的绝对值是：" + Math.abs(-12));// 12

2.3.求整运算

ceil：向上取整，返回double；floor：向下取整，返回double；rint：四舍五入，返回double（如果两个同样接近的整数，返回偶数：86.5）；round：四舍五入。返回整数。

double sum = 98.5;
System.out.println("ceil:" + Math.ceil(sum));// 99.0
System.out.println("floor:" + Math.floor(sum));// 98.0
System.out.println("round:" + Math.round(sum));// 99
System.out.println("rint:" + Math.rint(sum));// 98.0

2.4.三⻆函数的运算

sin(double a) ：正弦，参数：弧度；cos(double a) ：余弦；asin(double a)：反正弦值；atan(double a) ：反正切值；tan(double a) ：正切值；toDegrees(double a)：弧度⻆转化为⻆度的⻆；toRadians(double a)：⻆度⻆转化为弧度⻆。

public static void main(String[] args) {
    System.out.println("90度的正弦值" + Math.sin(Math.PI/2));// 90度的正弦值1.0
    System.out.println("0度的余弦值：" + Math.cos(0));// 0度的余弦值：1.0
    System.out.println("1的反正切值" + Math.atan(1));// 1的反正切值0.7853981633974483
    System.out.println("120度的弧度制：" + Math.toRadians(120.0));// 120度的弧度制：2.0943951023931953
}

2.5.指数运算

xp(double a) ：返回e的a次方；pow(double a,double b) ：返回a的b次方；sqrt(double a ) ：返回a的平方根；cbrt(double a ) ：返回a的立方根；log(double a) ：返回a的自然对数，lna；log10(double a) ：返回以10为底a的对数。

public static void main(String[] args) {
    System.out.println("4立方：" + Math.pow(4, 3));// 4立方：64.0
    System.out.println("16的平方根：" + Math.sqrt(16));// 16的平方根：4.0
    System.out.println("以10为底2的对数：" + Math.log10(2));// 以10为底2的对数：0.3010299956639812
}

2.6.生成随机数

Math类里面的random()方法可以产生一个[0,1)的double类型随机数。对random()方法进行稍加处理，即可实现产生任意范围内的随机数。产生一个区间整数： int s = (int) (Math.random() * （最大值-最小值+1）) + 最小值;

// 产生一个 2- 100 的整数
public static void main(String[] args) {
    int s = (int) (Math.random() * 99) + 2;
    System.out.println(s);
}

// 产生一个2到100的偶数
public static void main(String[] args) {
    int s = (int) (Math.random() * 99) + 2; //2-100
    if (s % 2 == 0) {//偶数
        System.out.println("随机数：" + s);
    }else {//奇数
        System.out.println("随机数是：" + (s+1));
    }
}

3.Java比较器

Java实现对象排序的方式有两种：自然排序：java.lang.Comparable；定制排序：java.util.Comparator。

/*
    一、Java中的对象，正常情况下，只能进行比较：==或!=。不能适用>或<的但是在开发场景中，
    我们需要对多个对象进行排序，言外之一，就需要比较对象的大小。如何实现？适用两个接口中
    的任意一个：Comparable或Comparator
    二、Comparable的适用
    1.String、包装类实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
    2.String、包装类重写compareTo(obj)方法，进行从小到大排序
    3.重写compareTo(obj)方法的规则：当前对象this大于形参obj，返回正整数，小于负整数，等于返回零


 */
public class CompareTest {
    @Test
    public void test(){
        String str[] = new String[]{"AA","CC","KK","MM","GG"};
        Arrays.sort(str);
        System.out.println(Arrays.toString(str));// [AA, CC, GG, KK, MM]
    }
}

3.1.自然排序

java.lang.Comparable：Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序；实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零；实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器；对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。
Comparable 的典型实现：(默认都是从小到大排列的)

方法	描述
String	按照字符串中字符的Unicode值进行比较
Character	按照字符的Unicode值来进行比较
数值类型对应的包装类以及BigInteger、BigDecimal	按照它们对应的数值大小进行比较
Boolean	true 对应的包装类实例大于 false 对应的包装类实例
Date、Time等	后面的日期时间比前面的日期时间大

class Goods implements Comparable {
    private String name;
    private double price;
    //按照价格，比较商品的大小
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods) {
            Goods other = (Goods) o;
            if (this.price > other.price) {
                return 1;
            } else if (this.price < other.price) {
                return -1;
            }
            return 0;
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
    //构造器、getter、setter、toString()方法略
}

public class ComparableTest{
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("《红楼梦》", 100);
        all[1] = new Goods("《西游记》", 80);
        all[2] = new Goods("《三国演义》", 140);
        all[3] = new Goods("《水浒传》", 120);
        Arrays.sort(all);
        System.out.println(Arrays.toString(all));
    }
}

3.2.定制排序

java.util.Comparator：当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排序的比较；重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制；还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的
顺序，或者为那些没有自然顺序的对象 collection 提供排序。

Goods[] all = new Goods[4];
all[0] = new Goods("War and Peace", 100);
all[1] = new Goods("Childhood", 80);
all[2] = new Goods("Scarlet and Black", 140);
all[3] = new Goods("Notre Dame de Paris", 120);
Arrays.sort(all, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        Goods g1 = (Goods) o1;
        Goods g2 = (Goods) o2;
        return g1.getName().compareTo(g2.getName());
    }
});
System.out.println(Arrays.toString(all));

4.System类

        System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。位于java.lang包；y因该类的构造器是private的，所以无法创建该类的对象，也就无法实例化该类。其内部的成员变量和成员方法都是static的，就很方便的进行调用。
        成员变量：System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
        成员方法：native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
        void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
        void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
        String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

属性名	属性说明
java.version	Java运行时环境版本
java.home	Java安装目录
os.name	操作系统的名称
os.version	操作系统的版本
user.name	用户的账户名称
user.home	用户的主目录
user.dir	用户的当前工作目录

String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion);

String javaHome = System.getProperty("java.home");
System.out.println("java的home:" + javaHome);

String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName);

String osVersion = System.getProperty("os.version");
System.out.println("os的version:" + osVersion);

String userName = System.getProperty("user.name");
System.out.println("user的name:" + userName);

String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome);

String userDir = System.getProperty("user.dir");
System.out.println("user的dir:" + userDir);

5.BigInteger和BigDecimal

5.1.BigInteger类

Integer类作为int的包装类，能存储的最大整型值为2^31-1，Long类也是有限的，最大为2^63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
构造器：BigInteger(String val)：根据字符串构建BigInteger对象。
常用方法：

方法	描述
public BigInteger abs()	返回此 BigInteger 的绝对值的 BigInteger
BigInteger add(BigInteger val)	返回其值为 (this + val) 的 BigInteger
BigInteger subtract(BigInteger val)	返回其值为 (this - val) 的 BigInteger
BigInteger multiply(BigInteger val)	返回其值为 (this * val) 的 BigInteger
BigInteger divide(BigInteger val)	返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
BigInteger remainder(BigInteger val)	返回其值为 (this % val) 的 BigInteger
BigInteger[] divideAndRemainder(BigInteger val)	返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组
BigInteger pow(int exponent)	返回其值为 (thisexponent) 的 BigInteger

5.2.BigDecimal类

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类；BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造器：

        public BigDecimal(double val)

        public BigDecimal(String val)。
常用方法：

        public BigDecimal add(BigDecimal augend)
        public BigDecimal subtract(BigDecimal subtrahend)
        public BigDecimal multiply(BigDecimal multiplicand)
        public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

public void testBigInteger() {
    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    // System.out.println(bd.divide(bd2));
    System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
    // 保留15位小数
    System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
}

6.字符编码

6.1.有关编码的基础知识

        位bit最小的单元；字节byte机器语言的单位 1byte=8bit：1KB=1024byte；1MB=1024KB；1GB=1024MB。
        字符：是各种文字和符号的总称，包括各个国家的文字，标点符号，图形符号，数字等。
        字符集：字符集是多个符号的集合，每个字符集包含的字符个数不同。
        字符编码：字符集只是规定了有哪些字符，而最终决定采用哪些字符，每一个字符用多少字节表示等问题，则是由编码来决定的。计算机要准确的处理各种字符集文字，需要进行字符编码，以便计算机能够识别和存储各种文字。

6.2.Unicode

        Unicode的缺点：英文字母只用一个字节表示就够了；区别Unicode和ASCII，分别表示两个符号还是一个字符；如果和GBK等双字节编码方式一样，用最高位是1或0表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。
        面向传输的众多 UTF（UCS Transfer Format）标准出现了，顾名思义，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。
        Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。