Java -- 浅谈API几个常用的类

野性酷女 2023-07-25 12:35 100阅读 0赞

Java有一个API手册，建议先看1.6或者1.8版本的，虽然有很多已经过时了，但是相对来说比较稳定，更有利于新手的学习和日常操作的使用，不建议一味地追求新版本，稳定最重要！
在一个城市站稳脚跟

API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。
java.lang包，这个包会自动导入。
java.lang.Object
java.lang.String
java.lang.StringBuilder/StringBuffer
正则表达式
包装类等

一些简单的用法作用都融合在代码里面进行讲解

一、Object

1、概念
  • 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
2、常用方法
  • toString()返回该对象的字符串表示；
  • hashCode()返回该对象的哈希码值；
  • equals(Object obj)指示其他某个对象是否与此对象“相等”。
3、测试
  1. package cn.tedu.api;
  3. //这个类用来测试 Object工具类
  4. //总结：
  5. //1、toString():默认使用的是Object里的，也就是打印地址值，如果你要查看属性值，需要重写toString()
  6. //2、hashCode():获取对象在内存中的哈希码值
  7. //3、equals():如果比较的是对象的地址值，直接使用默认的object提供的就可以，如果要比较的是属性值就需要重写
  8. public class Test_Object { 
  9.     public static void main(String[] args) { 
  10.         //1、给属性设置值，两种方式：调用set() + 创建对象时利用构造方法
  11.         Student s = new Student("daniel",18,"山东",130);// -- 触发含参构造
  12.         //2、想要查看属性的值
  13.         System.out.println(s.getAddr()+s.getAge()+s.getName()+s.getScore());//山东18daniel130.0
  14.         //3、能不能简化，查看属性的值 -- 在打印对象时，底层会自动调用toString()
  15.         //默认使用的是Object父类提供的,就相当于直接打印对象在内存中的地址值
  16.         //重写toString前：cn.tedu.api.Student@380fb434
  17.         //重写toString后：Student [name=daniel, age=18, addr=山东, score=130.0]
  18.         System.out.println(s);
  19.         System.out.println(s.hashCode());//5、返回对象在内存中的哈希码值 -- 编号940553268
  20.         System.out.println("运算对象的地址值是："+Integer.toHexString(940553268));//模拟对象的地址值的获取
  22.         //equals():比较两个对象是否相等？
  23.         Student s2 = new Student("daniel",18,"山东",130);
  24.         //默认使用了Object提供的equals(),使用==比较
  25.         // ==比较引用类型变量时，比较的是地址值
  26.         // ==比较基本类型变量时，比较的是值本身
  27.         //重写equals()前：false，因为比较的是地址值
  28.         System.out.println(s.equals(s2));
  29.     }
  30. }
  32. //创建学生类
  33. class Student extends Object{ 
  34.     //构造方法
  35.     public Student() { }
  37.     //含参构造，右键 source --> 倒数第三个
  38.     public Student(String name, int age, String addr, double score) { 
  39.         super();
  40.         this.name = name;
  41.         this.age = age;
  42.         this.addr = addr;
  43.         this.score = score;
  44.     }
  46.     // 封装 属性
  47.     private String name;
  48.     private int age;
  49.     private String addr;
  50.     private double score;
  52.     //提供全局访问点,get获取，set设置
  53.     public String getName() { 
  54.         return name;
  55.     }
  56.     public void setName(String name) { 
  57.         //当变量名相同时，通过this调用成员变量
  58.         this.name = name;
  59.     }
  60.     public int getAge() { 
  61.         return age;
  62.     }
  63.     public void setAge(int age) { 
  64.         this.age = age;
  65.     }
  66.     public String getAddr() { 
  67.         return addr;
  68.     }
  69.     public void setAddr(String addr) { 
  70.         this.addr = addr;
  71.     }
  72.     public double getScore() { 
  73.         return score;
  74.     }
  75.     public void setScore(double score) { 
  76.         this.score = score;
  77.     }
  79.     /* * 重写tostring(): * -- 由于目前student类中没有提供toString(),如果打印对象时， * 就会找object里的toString()采用默认实现方式，来实现对象的地址值 * 解决方案： * -- 不能改Object里的toString() -- 我们只能重写toString() */
  81.     @Override
  82.     public String toString() { 
  83.         return "Student [name=" + name + ", age=" + age + ", addr=" + addr + ", score=" + score + "]";
  84.     }
  85.     //7、重写equals()方法,因为默认使用Object的equals()方法就是比较两个对象的地址值
  86.     //比较两个对象间的属性值，就算是new两次，但是两次的属性一模一样，必须认为两个对象是同一个人，让equals()返回true
  87. // @Override
  88. // public boolean equals(Object obj) { 
  89. // //要求参数obj必须是学生类型
  90. // Student s = (Student) obj;//向下转型
  91. // 
  92. // //如果两个对象所有属性值相同，返回true
  93. // if (this.name == s.name && this.addr == s.addr && this.age == s.age && this.score == s.score) { 
  94. // return true;
  95. // }
  96. // return false;
  97. // }
  99.     //自动生成的重写的equals();方法
  100.     @Override
  101.     public boolean equals(Object obj) { 
  102.         if (this == obj)
  103.             return true;
  104.         if (obj == null)
  105.             return false;
  106.         if (getClass() != obj.getClass())
  107.             return false;
  108.         Student other = (Student) obj;//向下转型
  109.         if (addr == null) { 
  110.             if (other.addr != null)
  111.                 return false;
  112.         } else if (!addr.equals(other.addr))
  113.             return false;
  114.         if (age != other.age)
  115.             return false;
  116.         if (name == null) { 
  117.             if (other.name != null)
  118.                 return false;
  119.         } else if (!name.equals(other.name))
  120.             return false;
  121.         if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score))
  122.             return false;
  123.         return true;
  124.     }
  125. }

二、String

1、特点

String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为String 对象是不可变的，所以可以共享。

2、创建String对象
  1. String s = "abc";
  2. String(char[] value) 
  3. String(byte[] bytes)
3、常用方法
  • char charAt(int index)
    返回指定索引处的 char 值。
  • String concat(String str)
    将指定字符串连接到此字符串的结尾。
  • boolean endsWith(String suffix)
    测试此字符串是否以指定的后缀结束。
  • boolean equals(Object anObject)
    将此字符串与指定的对象比较。
  • byte[] getBytes()
    使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
  • int hashCode()
    返回此字符串的哈希码。
  • int indexOf(String str)
    返回指定子字符串在此字符串中第一次出现处的索引。
  • int lastIndexOf(String str)
    返回指定子字符串在此字符串中最右边出现处的索引。
  • int length()
    返回此字符串的长度。
  • String replace(char oldChar, char newChar)
    返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
  • String[] split(String regex)
    根据给定正则表达式的匹配拆分此字符串
  • boolean startsWith(String prefix)
    测试此字符串是否以指定的前缀开始。
  • String substring(int beginIndex)
    返回一个新的字符串，它是此字符串的一个子字符串。
  • String substring(int beginIndex, int endIndex)
    返回一个新字符串，它是此字符串的一个子字符串。
  • String toLowerCase()
    使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
  • String toUpperCase()
    使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
  • String trim()
    返回字符串的副本，忽略前导空白和尾部空白。
  • static String valueOf(long l)
    返回 long 参数的字符串表示形式。
4、测试案例
  1. package cn.tedu.String;
  3. import java.util.Arrays;
  5. //这个类用来测试String工具类
  6. //String 是一个最终类，不能被继承
  7. //String 底层维护了一个char[]，一旦被创建，长度不能修改
  8. public class Test_String { 
  9.     public static void main(String[] args) { 
  10.         //1、创建字符串对象
  12.         char[] chars = { 'a','b','c'};
  13.         String str = new String(chars);//自动匹配char[]构造
  15.         byte[] bytes = { 97,98,99,100};
  16.         String str2 = new String(bytes);//自动匹配byte[]构造
  18.         String str3 = "abc";
  19.         //2、调用常见功能
  20.         System.out.println(str.charAt(2));//c，获取指定下标对应的字符
  21.         System.out.println(str.concat(" + concat拼接字符串"));//相当于拼接字符串
  23.         //判断是否以指定元素结尾
  24.         System.out.println(str.endsWith("a"));//false
  25.         System.out.println(str.endsWith("c"));//true
  27.         System.out.println(str=="abc");//false，==比较的是引用类型的变量，比较地址值
  28.         System.out.println(str.equals("abc"));//true，判断是否与指定数据相等，String已经重写了equals()可以比较属性值
  29.         System.out.println(str.getBytes());//[B@380fb434，用来把数据存入byte数组
  30.         System.out.println(str.hashCode());//96354，获取对象在内存中的哈希码值
  31.         System.out.println(str.indexOf("a"));//0，返回指定数据在字符串中第一次出现的下标
  33.         str = "abcdea";//思考：我们真的把str的值改掉了吗？？
  34.                         //-- 原来的值不会改变，看起来的重新赋值动作在底层会创建新的字符串
  35.         System.out.println(str.lastIndexOf("a"));//获取指定数据在字符串中最后一次出现的下标
  36.         System.out.println(str.length());//
  37.         System.out.println(str.replace('a', 'x'));//把字符串中出现的所有a字符，替换成x字符
  39.         str = "a0bdcc0gh";
  40.         System.out.println(Arrays.toString(str.split("0")));//按照指定数据切割字符串
  41.         System.out.println(str.startsWith("a"));//判断是否以指定数据开始
  42.         System.out.println(str.substring(1));//从指定下标处开始，向后截取所欲字符串[1,n]
  43.         System.out.println(str.substring(0, 2));//从指定下标处开始，到指定处结束，但是含头不含尾[a,b)
  45.         str = "aBcDeF";
  46.         System.out.println(str.toLowerCase());//将字符串中的所有元素变成小写
  47.         System.out.println(str.toUpperCase());//将字符串中的所有元素变成大写
  49.         str = " aBcD eF ";
  50.         System.out.println(str.trim());//去除前导和后导的空格，不管中间的
  52.         System.out.println(String.valueOf(9.9)+1);//把其他类型转成String类型
  53.         //+1是为了验证9.9是不是字符串类型
  54.     }
  55. }

三、StringBuffer/StringBuilder

1、特点
  1. 封装了char[]数组；
  2. 是可变的字符序列；
  3. 提供了一组可以对字符内容修改的方法；
  4. 常用append()来代替字符串做字符串连接；
  5. 内部字符数组默认初始容量是16：initial capacity of 16 characters；
  6. 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
  7. StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全
2、构造方法
  • StringBuilder()
    构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
3、常用方法
  • StringBuilder append(String str)
    将指定的字符串追加到此字符序列。
4、测试案例
  1. package cn.tedu.String;
  3. //这个类用来测试字符串优化效率
  4. /* * 总结： * 1、因为+拼接字符串效率低，因为字符串是常量，不能改，每次拼接时都会产生新的字符串对象 * 2、现在用工具类拼接字符串对象 */
  5. public class Test_StringBufferOrBuilder { 
  6.     public static void main(String[] args) { 
  7.         method2();
  8.         method();//先用“+”拼接字符串
  9.     }
  11.     public static void method() { 
  12.         //1、定义字符串
  13.         String str = "字符串";
  14.         //2、拼接1000次并输出
  15.         //定义变量，记录拼接结果
  16.         String result = "";
  18.         long start = System.currentTimeMillis();//计时开始ms
  19.         for (int i = 0; i < 1000; i++) { 
  20.             result = result + str;
  21.         }
  22.         long end = System.currentTimeMillis();//计时结束
  23.         System.out.println(end - start);//4
  24.     }
  25.     public static void method2() { 
  26.         String str = "字符串";
  28.         //1、创建工具类对象、
  29.         StringBuilder sb = new StringBuilder();
  31.         long start = System.currentTimeMillis();//计时开始ms
  32.         for (int i = 0; i < 10000; i++) { 
  33.             sb.append(str);//用工具类拼接
  34.         }
  35.         long end = System.currentTimeMillis();//计时结束
  36.         System.out.println(end - start);//for循环执行时间--0
  37.     }
  38. }

StringBuilder和StringBuffer的区别：
1、 在线程安全上，
–StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
–StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
2、 在执行效率上，StringBuilder > StringBuffer > String
3、 源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了>同步关键字，使得程序可以保证线程安全问题。
abstract class AbstractStringBuilder implements Appendable, CharSequence {}
在这里插入图片描述
在这里插入图片描述

四、包装类

1、概念

为了丰富基本类型的功能，提供了对应的包装类型；

  • 与基本类型的对应关系









































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

☆ 简单介绍两个的用法，其余的都一样

（一）Integer

Integer ——包装了基本类型的int

1、创建对象
  • Integer(int value)
    构造一个新分配的 Integer 对象，它表示指定的 int 值。
  • static Integer valueOf(int i)
    返回一个表示指定的 int 值的 Integer 实例。
2、常用方法
  • int intValue()
    以 int 类型返回该 Integer 的值。
  • static int parseInt(String s)
    将字符串参数作为有符号的十进制整数进行解析。
3、测试案例

测试案例内部涉及【自动装箱】和【自动拆箱】的功能

  1. package cn.tedu.api;
  3. //这个类用来测试包装类
  4. public class Test_Integer { 
  5.     public static void main(String[] args) { 
  6.         //包装类和基本类型可以相互转换
  7.         //基本类型转包装类：valueOf() 或者构造方法 -- 目的是使用包装类型身上的功能 -- 自动装箱
  8.         //包装类转基本类型：intValue() -- 拿到包装类包着的值做运算 -- 自动拆箱
  10.         //1、创建Integer对象
  11.         //就是拿到基本类型 的参数 5 ，经过包装，，形成了包装类型的对象
  12.         Integer in = new Integer(5);
  13.         Integer in2 = Integer.valueOf(5);
  15.         //静态方法valueOf()高效(-128~127范围内)，超出范围就不高效了
  16.         //如果要保存相同数据，只是第一次没存时会存一次，以后要存相同的数据时就不会再存储了。
  17.         Integer in3 = Integer.valueOf(5);
  18.         System.out.println(in2);
  19.         System.out.println(in3);
  20.         System.out.println(in2 == in3);//true
  22.         Integer in4 = Integer.valueOf(500);
  23.         Integer in5 = Integer.valueOf(500);
  24.         System.out.println(in4 == in5);//false
  26.         //2、调用常用方法
  27.         int value = in.intValue();
  29.         int sum = in.parseInt("100");//把字符串类型的数字转换成基本类型
  30.         System.out.println(sum + 1);//101
  33.         //TODO double -- Double 
  34.         //自动装箱：把基本类型double变成包装类型，Double --valueOf()
  35. // Double d1 = new Double(9.9);
  36.         Double d = Double.valueOf(9.9);
  38.         //自动拆箱：把包装类型转换成基本类型 --doubleValue()
  39.         double d4 = d.doubleValue();
  40.         double d3 = d.parseDouble("8.8");//把字符串类型的数字，转换成基本类型
  42.     }
  43. }

自动装箱和自动拆箱：

1、自动装箱：把基本类型包装成一包装类的对象
Integer a = 5;//a是引用类型，引用了包装对象的地址。
编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);

2、自动拆箱：从包装对象中，自动取出基本类型值
int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。
编译器会完成自动拆箱：int i = a.intValue();

五、日期类

1、概述
  • 存在于java.util.Date包；
  • 用来封装一个毫秒值表示一个精确的时间点；
  • 从1970-1-1 0点开始的毫秒值。
2、创建对象
  • Date()
    分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）；
  • new Date()：封装的是系统当前时间的毫秒值
  • new Date(900000000000L)：封装指定的时间点
3、常用方法
  • int getDate()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY_OF_MONTH) 取代；
  • int getDay()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY_OF_WEEK) 取代；
  • int getHours()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.HOUR_OF_DAY) 取代；
  • int getMinutes()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MINUTE) 取代；
  • int getMonth()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MONTH) 取代；
  • int getSeconds()
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.SECOND) 取代；
  • long getTime()
    返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数；

虽然这些方法都已经过时，但是不影响我们的正常使用，他只是被某些新的方法替代了而已。

4、测试案例
  1. package cn.tedu.api;
  3. //这个类用来测试包装类
  4. public class Test_Integer { 
  5.     public static void main(String[] args) { 
  6.         //包装类和基本类型可以相互转换
  7.         //基本类型转包装类：valueOf() 或者构造方法 -- 目的是使用包装类型身上的功能 -- 自动装箱
  8.         //包装类转基本类型：intValue() -- 拿到包装类包着的值做运算 -- 自动拆箱
  10.         //1、创建Integer对象
  11.         //就是拿到基本类型 的参数 5 ，经过包装，，形成了包装类型的对象
  12.         Integer in = new Integer(5);
  13.         Integer in2 = Integer.valueOf(5);
  15.         //静态方法valueOf()高效(-128~127范围内)，超出范围就不高效了
  16.         //如果要保存相同数据，只是第一次没存时会存一次，以后要存相同的数据时就不会再存储了。
  17.         Integer in3 = Integer.valueOf(5);
  18.         System.out.println(in2);
  19.         System.out.println(in3);
  20.         System.out.println(in2 == in3);//true
  22.         Integer in4 = Integer.valueOf(500);
  23.         Integer in5 = Integer.valueOf(500);
  24.         System.out.println(in4 == in5);//false
  26.         //2、调用常用方法
  27.         int value = in.intValue();
  29.         int sum = in.parseInt("100");//把字符串类型的数字转换成基本类型
  30.         System.out.println(sum + 1);//101
  33.         //TODO double -- Double 
  34.         //自动装箱：把基本类型double变成包装类型，Double --valueOf()
  35. // Double d1 = new Double(9.9);
  36.         Double d = Double.valueOf(9.9);
  38.         //自动拆箱：把包装类型转换成基本类型 --doubleValue()
  39.         double d4 = d.doubleValue();
  40.         double d3 = d.parseDouble("8.8");//把字符串类型的数字，转换成基本类型
  42.     }
  43. }

六、日期工具——SimpleDateFormat

1、概述

日期格式化工具，可以把Date对象格式化成字符串，也可以日期字符串解析成Date对象；

2、创建对象

  • SimpleDateFormat(String pattern)
    用给定的模式和默认语言环境的日期格式符号构造

    new SimpleDateFormat(格式)
    格式：yyyy-MM-dd HH:mm:ss
    MM/dd/yyyy..

在这里插入图片描述
以下示例显示如何在美国地区中解释日期和时间模式。 给定的日期和时间是2001-07-04 12:08:56当地时间在美国太平洋时间时区。
在这里插入图片描述

3、常见方法
  • Date parse(String text)
    解析字符串的文本，生成 Date。
  • String format(Date date)
    将Date类型的日期，转成 字符串类型
4、练习：计算自己的生存天数

接收用户输入的出生日期，计算存活天数

  1. package cn.tedu.api;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Scanner;
  8. //这个类用来测试日期格式化工具：计算存活天数
  9. public class Test_SimpleDateFormat { 
  10.     public static void main(String[] args) throws ParseException { 
  11.         //1、输入出生日期 -- String 
  12.         //nextLine():接收用户输入的一整行数据
  13.         String birthday = new Scanner(System.in).nextLine();
  15.         //2、把String类型的日期转成Date类型
  16.         //参数中需要指定日期的格式 ：y-年，M-月，d-天
  17.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  18.         Date birth = sdf.parse(birthday);
  20.         //3、做个时间差
  21.         long bir = birth.getTime();//获取到出生日期对应的毫秒值
  22.         long now = System.currentTimeMillis();//获取现在的毫秒值
  23.         System.out.println((now - bir)/1000/60/60/24);
  24.     }
  25. }

七、BigDecimal/BigInteger

1、概念
  • BigDecimal用来解决java中浮点数运算不精确的现象
  • BigInteger用来解决java中大整数的运算

以BigDecimal为例

1、概念

用来解决java中浮点数运算不精确的现象

2、创建对象
  • BigDecimal(double val)
    将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。
  • BigDecimal(String val)
    将 BigDecimal 的字符串表示形式转换为 BigDecimal。
3、常用方法
  • add(BigDecimal bd)： 做加法运算
  • subtract(BigDecimal bd) ： 做减法运算
  • multiply(BigDecimal bd) ： 做乘法运算
  • divide(BigDecimal bd) ： 做除法运算（比较特殊，注意与其他方法的区别）
  • divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
  • setScale(保留位数，舍入方式)：同上
  • pow(int n)：求数据的几次幂
4、测试案例

接收用户输入的两个数字，做运算。

  1. package cn.tedu.api;
  3. import java.math.BigDecimal;
  4. import java.util.Scanner;
  7. public class Test_BigDecimal { 
  8.     public static void main(String[] args) { 
  9. // method();//暴露不精确的现象
  10.         method2();//解决方案
  11.     }
  13.     public static void method2() { 
  14.         double a = new Scanner(System.in).nextDouble();
  15.         double b = new Scanner(System.in).nextDouble();
  17.         //1、把a和b变成BigDecimal类型
  18.         //！！！构造方法不建议使用double参数的（还是不精确），我们建议使用String参数的构造方法
  19.         BigDecimal bd = new BigDecimal(a+"");//加上一个空字符串使其转换成字符串类型
  20.         BigDecimal bd2 = new BigDecimal(b+"");
  22.         BigDecimal bd3,bd4,bd5,bd6;
  23.         bd3 = bd.add(bd2);//加法运算
  24.         bd4 = bd.subtract(bd2);//减法运算
  25.         bd5 = bd.multiply(bd2);//乘法运算
  27. // bd6 = bd.divide(bd2);//除法运算，
  28.         //除法报错，如果除法运算不精确就会报异常，BigDecimal.divide(BigDecimal) line: not available 
  29.         //divide(m,n,o);m是要做除法运算的对象名，n是要保留几位小数，o是舍入方式（四舍五入）
  30.         BigDecimal bd7 = bd.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
  32.         System.out.println(bd3);
  33.         System.out.println(bd4);
  34.         System.out.println(bd5);
  35. // System.out.println(bd6);
  36.         System.out.println(bd7);
  37.     }
  39.     public static void method() { 
  40.         //1、接收用户输入的两个整数
  41.         double a = new Scanner(System.in).nextDouble();
  42.         double b = new Scanner(System.in).nextDouble();
  44.         //2、做+-*/运算
  45.         System.out.println(a+b);//不精确
  46.         System.out.println(a-b);//不精确
  47.         System.out.println(a*b);//不精确
  48.         System.out.println(a/b);//不精确
  49.     }
  50. }

【温馨提示】
API里面的内容很多，方法也很多，需要自己抽出时间去测试每个方法的使用，并且记忆；单靠这几个常用的是不能保证自己的工作效率的，当然你也可以选择使用的时候去api里面查，现学现卖！！

在这里插入图片描述

【下篇预告】

  • IO流
  • IO工具类们~~~

发表评论

表情：
评论列表 （有 0 条评论，100人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JAVA浅谈Pair抽象类

    1.业务场景 业务开发中会遇到一种情况，返回两个参数值，这两个参数值都有用到，所以我们一般都会用map集合进行key-value封装，或者写一个类来封装两个属性来返回，还有

    心已赠人心已赠人/ 0 赞/ 36 阅读

    相关 Java -- 浅谈API几个常用的类

    Java有一个API手册，建议先看1.6或者1.8版本的，虽然有很多已经过时了，但是相对来说比较稳定，更有利于新手的学习和日常操作的使用，不建议一味地追求新版本，稳定最重要！

    野性酷女野性酷女/ 0 赞/ 101 阅读

    相关 浅谈Java中的几种随机数

    摘要：众所周知，随机数是任何一种编程语言最基本的特征之一。而生成随机数的基本方式也是相同的：产生一个0到1之间的随机数。看似简单，但有时我们也会忽略了一些有趣的功能。 众所周

    Dear 丶Dear 丶/ 0 赞/ 270 阅读