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

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、测试

package cn.tedu.api;

//这个类用来测试 Object工具类
//总结：
//1、toString():默认使用的是Object里的，也就是打印地址值，如果你要查看属性值，需要重写toString()
//2、hashCode():获取对象在内存中的哈希码值
//3、equals():如果比较的是对象的地址值，直接使用默认的object提供的就可以，如果要比较的是属性值就需要重写
public class Test_Object {
	public static void main(String[] args) {
		//1、给属性设置值，两种方式：调用set() + 创建对象时利用构造方法
		Student s = new Student("daniel",18,"山东",130);// -- 触发含参构造
		//2、想要查看属性的值
		System.out.println(s.getAddr()+s.getAge()+s.getName()+s.getScore());//山东18daniel130.0
		//3、能不能简化，查看属性的值 -- 在打印对象时，底层会自动调用toString()
		//默认使用的是Object父类提供的,就相当于直接打印对象在内存中的地址值
		//重写toString前：cn.tedu.api.Student@380fb434
		//重写toString后：Student [name=daniel, age=18, addr=山东, score=130.0]
		System.out.println(s);
		System.out.println(s.hashCode());//5、返回对象在内存中的哈希码值 -- 编号940553268
		System.out.println("运算对象的地址值是："+Integer.toHexString(940553268));//模拟对象的地址值的获取
		
		//equals():比较两个对象是否相等？
		Student s2 = new Student("daniel",18,"山东",130);
		//默认使用了Object提供的equals(),使用==比较
		// ==比较引用类型变量时，比较的是地址值
		// ==比较基本类型变量时，比较的是值本身
		//重写equals()前：false，因为比较的是地址值
		System.out.println(s.equals(s2));
	}
}

//创建学生类
class Student extends Object{
	//构造方法
	public Student() {}
	
	//含参构造，右键 source --> 倒数第三个
	public Student(String name, int age, String addr, double score) {
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
		this.score = score;
	}

	// 封装 属性
	private String name;
	private int age;
	private String addr;
	private double score;
	
	//提供全局访问点,get获取，set设置
	public String getName() {
		return name;
	}
	public void setName(String name) {
		//当变量名相同时，通过this调用成员变量
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getAddr() {
		return addr;
	}
	public void setAddr(String addr) {
		this.addr = addr;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}

	/*
	 * 重写tostring():
	 *  -- 由于目前student类中没有提供toString(),如果打印对象时，
	 * 		就会找object里的toString()采用默认实现方式，来实现对象的地址值
	 * 解决方案：
	 * 	-- 不能改Object里的toString() -- 我们只能重写toString()
	 */
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", addr=" + addr + ", score=" + score + "]";
	}
	//7、重写equals()方法,因为默认使用Object的equals()方法就是比较两个对象的地址值
	//比较两个对象间的属性值，就算是new两次，但是两次的属性一模一样，必须认为两个对象是同一个人，让equals()返回true
//	@Override
//	public boolean equals(Object obj) {
//		//要求参数obj必须是学生类型
//		Student s = (Student) obj;//向下转型
//		
//		//如果两个对象所有属性值相同，返回true
//		if (this.name == s.name && this.addr == s.addr && this.age == s.age && this.score == s.score) {
//			return true;
//		}
//		return false;
//    }

	//自动生成的重写的equals();方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;//向下转型
		if (addr == null) {
			if (other.addr != null)
				return false;
		} else if (!addr.equals(other.addr))
			return false;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score))
			return false;
		return true;
	}
}

二、String

1、特点

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

2、创建String对象

String s = "abc";
String(char[] value) 
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、测试案例

package cn.tedu.String;

import java.util.Arrays;

//这个类用来测试String工具类
//String 是一个最终类，不能被继承
//String 底层维护了一个char[]，一旦被创建，长度不能修改
public class Test_String {
	public static void main(String[] args) {
		//1、创建字符串对象
		
		char[] chars = {'a','b','c'};
		String str = new String(chars);//自动匹配char[]构造
		
		byte[] bytes = {97,98,99,100};
		String str2 = new String(bytes);//自动匹配byte[]构造
		
		String str3 = "abc";
		//2、调用常见功能
		System.out.println(str.charAt(2));//c，获取指定下标对应的字符
		System.out.println(str.concat(" + concat拼接字符串"));//相当于拼接字符串
		
		//判断是否以指定元素结尾
		System.out.println(str.endsWith("a"));//false
		System.out.println(str.endsWith("c"));//true
		
		System.out.println(str=="abc");//false，==比较的是引用类型的变量，比较地址值
		System.out.println(str.equals("abc"));//true，判断是否与指定数据相等，String已经重写了equals()可以比较属性值
		System.out.println(str.getBytes());//[B@380fb434，用来把数据存入byte数组
		System.out.println(str.hashCode());//96354，获取对象在内存中的哈希码值
		System.out.println(str.indexOf("a"));//0，返回指定数据在字符串中第一次出现的下标
		
		str = "abcdea";//思考：我们真的把str的值改掉了吗？？
						//-- 原来的值不会改变，看起来的重新赋值动作在底层会创建新的字符串
		System.out.println(str.lastIndexOf("a"));//获取指定数据在字符串中最后一次出现的下标
		System.out.println(str.length());//
		System.out.println(str.replace('a', 'x'));//把字符串中出现的所有a字符，替换成x字符
		
		str = "a0bdcc0gh";
		System.out.println(Arrays.toString(str.split("0")));//按照指定数据切割字符串
		System.out.println(str.startsWith("a"));//判断是否以指定数据开始
		System.out.println(str.substring(1));//从指定下标处开始，向后截取所欲字符串[1,n]
		System.out.println(str.substring(0, 2));//从指定下标处开始，到指定处结束，但是含头不含尾[a,b)
		
		str = "aBcDeF";
		System.out.println(str.toLowerCase());//将字符串中的所有元素变成小写
		System.out.println(str.toUpperCase());//将字符串中的所有元素变成大写
		
		str = "       aBcD  eF         ";
		System.out.println(str.trim());//去除前导和后导的空格，不管中间的
		
		System.out.println(String.valueOf(9.9)+1);//把其他类型转成String类型
		//+1是为了验证9.9是不是字符串类型
	}
}

三、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、测试案例

package cn.tedu.String;

//这个类用来测试字符串优化效率
/*
 * 总结：
 * 	1、因为+拼接字符串效率低，因为字符串是常量，不能改，每次拼接时都会产生新的字符串对象
 * 	2、现在用工具类拼接字符串对象
 */
public class Test_StringBufferOrBuilder {
	public static void main(String[] args) {
		method2();
		method();//先用“+”拼接字符串
	}

	public static void method() {
		//1、定义字符串
		String str = "字符串";
		//2、拼接1000次并输出
		//定义变量，记录拼接结果
		String result = "";
		
		long start = System.currentTimeMillis();//计时开始ms
		for (int i = 0; i < 1000; i++) {
			result = result + str;
		}
		long end = System.currentTimeMillis();//计时结束
		System.out.println(end - start);//4
	}
	public static void method2() {
		String str = "字符串";
		
		//1、创建工具类对象、
		StringBuilder sb = new StringBuilder();

		long start = System.currentTimeMillis();//计时开始ms
		for (int i = 0; i < 10000; i++) {
			sb.append(str);//用工具类拼接
		}
		long end = System.currentTimeMillis();//计时结束
		System.out.println(end - start);//for循环执行时间--0
	}
}

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、概念

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

• 与基本类型的对应关系

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

（一）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、测试案例

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

package cn.tedu.api;

//这个类用来测试包装类
public class Test_Integer {
	public static void main(String[] args) {
		//包装类和基本类型可以相互转换
		//基本类型转包装类：valueOf() 或者构造方法 -- 目的是使用包装类型身上的功能 -- 自动装箱
		//包装类转基本类型：intValue() -- 拿到包装类包着的值做运算 -- 自动拆箱

		//1、创建Integer对象
		//就是拿到基本类型 的参数 5 ，经过包装，，形成了包装类型的对象
		Integer in = new Integer(5);
		Integer in2 = Integer.valueOf(5);
		
		//静态方法valueOf()高效(-128~127范围内)，超出范围就不高效了
		//如果要保存相同数据，只是第一次没存时会存一次，以后要存相同的数据时就不会再存储了。
		Integer in3 = Integer.valueOf(5);
		System.out.println(in2);
		System.out.println(in3);
		System.out.println(in2 == in3);//true
		
		Integer in4 = Integer.valueOf(500);
		Integer in5 = Integer.valueOf(500);
		System.out.println(in4 == in5);//false
		
		//2、调用常用方法
		int value = in.intValue();
		
		int sum = in.parseInt("100");//把字符串类型的数字转换成基本类型
		System.out.println(sum + 1);//101
		
		
		//TODO double -- Double 
		//自动装箱：把基本类型double变成包装类型，Double --valueOf()
//		Double d1 = new Double(9.9);
		Double d = Double.valueOf(9.9);
		
		//自动拆箱：把包装类型转换成基本类型 --doubleValue()
		double d4 = d.doubleValue();
		double d3 = d.parseDouble("8.8");//把字符串类型的数字，转换成基本类型
		
	}
}

自动装箱和自动拆箱：

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、测试案例

package cn.tedu.api;

//这个类用来测试包装类
public class Test_Integer {
	public static void main(String[] args) {
		//包装类和基本类型可以相互转换
		//基本类型转包装类：valueOf() 或者构造方法 -- 目的是使用包装类型身上的功能 -- 自动装箱
		//包装类转基本类型：intValue() -- 拿到包装类包着的值做运算 -- 自动拆箱

		//1、创建Integer对象
		//就是拿到基本类型 的参数 5 ，经过包装，，形成了包装类型的对象
		Integer in = new Integer(5);
		Integer in2 = Integer.valueOf(5);
		
		//静态方法valueOf()高效(-128~127范围内)，超出范围就不高效了
		//如果要保存相同数据，只是第一次没存时会存一次，以后要存相同的数据时就不会再存储了。
		Integer in3 = Integer.valueOf(5);
		System.out.println(in2);
		System.out.println(in3);
		System.out.println(in2 == in3);//true
		
		Integer in4 = Integer.valueOf(500);
		Integer in5 = Integer.valueOf(500);
		System.out.println(in4 == in5);//false
		
		//2、调用常用方法
		int value = in.intValue();
		
		int sum = in.parseInt("100");//把字符串类型的数字转换成基本类型
		System.out.println(sum + 1);//101
		
		
		//TODO double -- Double 
		//自动装箱：把基本类型double变成包装类型，Double --valueOf()
//		Double d1 = new Double(9.9);
		Double d = Double.valueOf(9.9);
		
		//自动拆箱：把包装类型转换成基本类型 --doubleValue()
		double d4 = d.doubleValue();
		double d3 = d.parseDouble("8.8");//把字符串类型的数字，转换成基本类型
		
	}
} 

六、日期工具----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、练习：计算自己的生存天数

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

package cn.tedu.api;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

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

七、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、测试案例

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

package cn.tedu.api;

import java.math.BigDecimal;
import java.util.Scanner;


public class Test_BigDecimal {
	public static void main(String[] args) {
//		method();//暴露不精确的现象
		method2();//解决方案
	}

	public static void method2() {
		double a = new Scanner(System.in).nextDouble();
		double b = new Scanner(System.in).nextDouble();
		
		//1、把a和b变成BigDecimal类型
		//！！！构造方法不建议使用double参数的（还是不精确），我们建议使用String参数的构造方法
		BigDecimal bd = new BigDecimal(a+"");//加上一个空字符串使其转换成字符串类型
		BigDecimal bd2 = new BigDecimal(b+"");
		
		BigDecimal bd3,bd4,bd5,bd6;
		bd3 = bd.add(bd2);//加法运算
		bd4 = bd.subtract(bd2);//减法运算
		bd5 = bd.multiply(bd2);//乘法运算
		
//		bd6 = bd.divide(bd2);//除法运算，
		//除法报错，如果除法运算不精确就会报异常，BigDecimal.divide(BigDecimal) line: not available	
		//divide(m,n,o);m是要做除法运算的对象名，n是要保留几位小数，o是舍入方式（四舍五入）
		BigDecimal bd7 = bd.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
		
		System.out.println(bd3);
		System.out.println(bd4);
		System.out.println(bd5);
//		System.out.println(bd6);
		System.out.println(bd7);
	}

	public static void method() {
		//1、接收用户输入的两个整数
		double a = new Scanner(System.in).nextDouble();
		double b = new Scanner(System.in).nextDouble();
		
		//2、做+-*/运算
		System.out.println(a+b);//不精确
		System.out.println(a-b);//不精确
		System.out.println(a*b);//不精确
		System.out.println(a/b);//不精确
	}
}

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

【下篇预告】

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

转载：https://blog.csdn.net/qq1808814025/article/details/105523143