Java API

写在开头

 我有罪,我是鸽子王 ( ･᷄д･᷅ )我错辣

 今天我们说一下Java编程的很重要的一部分:API.

API

---

 APIA是 Apsplication Programming Interface 的缩写,意为应用程序编程接口.

 在编写程序的时候，通常有很多功能是通用的，或者是很基础的，可以用这些功能来组成更复杂的功能代码。比如文件操作，不同程序对文件的操作基本都是一样的，打开文件，关闭文件，读取文件里面的数据，往文件中写数据等等。所不同的仅仅是文件路径不相同，文件内容不同。如果把文件相关的操作编写成一个通用的类，不管哪个程序员都可以直接使用，而不必自己重新编写一遍操作文件的所有代码，那么程序员的工作效率就会大大提高。像这样把一些具有通用的功能编写成相应的类代码，就形成了类库。

 Java 的类库是 Java 语言提供的已经实现的标准类的集合，是 Java 编程的 API（Application Program Interface），它可以帮助开发者方便、快捷地开发 Java 程序。程序员在开发程序的时候，直接调用这些现成的类就可以了。这些类根据实现的功能不同，可以划分为不同的集合，每个集合组成一个包，称为类库。Java 类库中大部分都是由Sun 公司提供的，这些类库称为基础类库。

 Java API文档下载_中文版

 Java API文档在线_中文版

 Java API文档在线_英文版

 我们对常用的API类进行下简单的介绍

Object 类

---

• Object类来自于JDK中java.lang.Object
• Object类是一个顶层根类,是所有类的直接或者间接的默认父类
• 在实际开发过程中,Object类都是最先进入到内存中

package io.cnfox.demo;

public class Person {
	
	public static void main(String[] args) {

		Person p =  new Person();
// Person默认继承Object类,toString方法来自父类
		p.toString();
		Object obj = new Object;
//Object可以创建对象
        obj.toString();
//使用效果同上
	}

}

getClass() 方法

• 功能:获取到类的字节码文件对象

• 返回值:Class

• 结果:带有包名的全类名

  • 链式调用方法:getName()
  • 方法作用:将Class类型的返回值转换成String类型展示

  package io.cnfox.demo;
  
  public class ObjectDemo {
  
  	public static void main(String[] args) {
          // 创建Object类对象
  		Object obj = new Object();
          // getClass() 方法获取到带有完整包名的类名,返回值类型Class类型
  		System.out.println(obj.getClass());
  		//class java.lang.Object
  		
  		Person p = new Person();
         // Person类因为继承Object,因此可以使用父类中的getClass()方法
  		System.out.println(p.getClass());
  	   //class io.cnfox.demo.Person
  		
  		Person p1 = new Person();
  		
  		System.out.println(p1.getClass().getName());
  		//io.cnfox.demo.Person
  	}
  }

hashCode() 方法

• 功能:将任意的一个对象转化成一个整数进行输出,这个整数叫做哈希码值
• 返回值:哈希码值

toString() 方法

• 功能:打印引用数据类型在内存中的地址值,重写后打印引用数据类型中的成员变量的值
• 返回值:引用数据类型在内存中的地址值

equals(Object obj)方法

• 功能:比较对象是否相等
• 返回值:Boolean 布尔类型

String 类

• 打印引用数据类型在内存中的地址值,重写后打印引用数据类型中的成员变量的值

1. length() : 求字符串的长度, 对比: 数组求长度.length
2. charAt(int index):将给定的index所以对应的字符,返回回来
3. subString(int beginIndex): 截取字符串一部分,从给定的索引beginIndex开始,将剩下的字符都截取到,返回一个新的字符串
4. subString(int beginIndex,int endIndex):截取字符串一部分,从给定的索引beginIndex开始,到结束索引endIndex为止,将中间的字符都截取到,返回一个新的字符串
   说明: 包含开始说索引,不包含结束索引
   小规则: 一般JDK写好的方法中,如果出现了两个索引的情况,一般情况下,都是包含开始索引不包含结束索引
5. indexOf(String str) : 求str字符串在要验证的字符串中,第一次出现的索引位置,没有匹配到合适的位置,返回-1(因为索引值没有负数的)
6. getBytes() : 将一个字符串转换成一个字节数组(与构造方法String(byte[])),功能正好相反
7. toCharArray(): 将一个字符串转换成一个字符数组(与构造方法String(char[])),功能正好相反
8. toUpperCase() : 将这个字符串的所有字符转成大写
9. toLowerCase(): 将这个字符串的所有字符转成小写
10. valueOf(参数参见API) : 将任意类型转换成字符串类型
11. trim() : 将字符串前后的空格或者制表符去掉,中间的空格无法去除

package io.cnfox.t2;
//三个方法放在一起展示了
public class Person {
//定义两个变量
	 String name ;
	 int  age ;
//重新空参数构造	 
	 public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	 
// 重写toString()	 
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}


// 重写hashCode()
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

// 重写equals()
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	 
   
}

//方法实现区
package io.cnfox.t2;
import java.util.Arrays;
public class Test1 {

	public static void main(String[] args) {

//重写Object 获取name字节码对象地址	
		Object name = new Object();
		System.out.println(name.getClass());

//重写Persion 
		Person p = new Person("xxx",21);
		Person p1 = new Person("xxx",21);
// Person类重写了hashCode()方法后,传入相同值,有一样的哈希值
		System.out.println(p.hashCode());
        System.out.println(p1.hashCode());
//重写toString()方法打印引用数据类型中的成员变量的值
        System.out.println(p.toString());
//Person重写了equals后,比较的是对象的成员值,返回值为Boolean类型
        System.out.println(p.equals(p1));

//输出如下 :   
/*class java.lang.Object
120772
120772
Person [name=xxx, age=21]
ture
*/

// String:
// 求字符串的长度
        String ss = "abc";
		System.out.println(ss.length());//3
		
		String ss1 = "";
		System.out.println(ss1.length());//0
		
		int[] i = {};
		System.out.println(i.length);//0
		
		String ss2 = "  ";
		System.out.println(ss2.length());//2
		
		/*String ss3 = null;
		System.out.println(ss3.length()); 报错,空指针异常
		*/
// 返回指定index的对应字符
	    String a = "abcdfeg";// 长度7
		System.out.println(a.charAt(4));//f
//截取指定index字符,可以只包含开始没有结束
		System.out.println(a.substring(2));// cdfeg
		System.out.println(a.substring(2,5));// cdf
//要验证的字符在字符串中第一次出线的索引
		System.out.println(a.indexOf("b"));//1

//String类型转换成byte数组
        byte[] by1 = a.getBytes();
//[115, 100, 97, 102, 99, 100, 119, 100, 115]	        
        System.out.println(Arrays.toString(by1));

//String类型转换成char数组
		char[] ch1 = a.toCharArray();
// [s, d, a, f, c, d, w, d, s]		
		System.out.println(Arrays.toString(ch1));

        String a = "abC";
//转化成大写-输出
		System.out.println(a.toUpperCase());//ABC
//转化成小写-输出		
		System.out.println(a.toLowerCase());//abc

// i live  YOu 要求 将这个字符串首字母大写,剩下所有小写
		String result = "i live  YOu";
//获取首字母
        Stringfirst = result.substring(0, 1);
     System.out.println(first);//i

// 获取剩余字母
     String last = result.substring(1);
     System.out.println(last); //live  YOu

//输出    
     System.out.println(first.toUpperCase()+last.toLowerCase());//I live  you	
	}

}

== 和 equals 的区别

1. 比较内容:

== 可以比较基本数据类型,与可以比较引用数据类型
equals 只能比较引用数据类型

2. 比较的方式:

== 比较基本数据类型,判断值是否相等; == 比较引用数据类型,判断两个对象的地址值是否相等

equals 没重写之前,比较两个对象的地址值; equals 重写之后,比较的是两个对象的内容是否相等

equals 最常用的是比较字符串,String类型

字符串缓冲区(生成器) StringBuilder

---

• 性质:可变得字符序列
• 返回值:String builder
  • length() 获取数组长度
  • capacity() 获取数组容量
• 添加和获取功能
  • append() 拼接
  • insert() 指定地址插入
  • deleter() 删除指定索引内容
  • replace() 替换
  • reverse() 反转

package io.cnfox.Stringbuilder;

public class Stringbuildert {

	public static void main(String[] args) {
		//创建一个字符串缓冲区,默认的大小为16,相当于char[16]
		StringBuilder st = new StringBuilder();
		System.out.println(st.capacity());//16
		StringBuilder stt = new  StringBuilder(4);
		System.out.println(stt.capacity());//4
		StringBuilder s= new StringBuilder("abc");
        System.out.println(s.capacity());//19
        //构建一个初始化为指定字符串内容的字符串,默认缓冲区大小构造器
        System.out.println(s.length());//3
        //Stringbuilder 拼接任意类型的数据,也可以连续链式拼接,返回值为Stringbuilder类型
        System.out.println(s.append("StringBuilder添加功能").append(666).append(true).append("可以像这样子;连续的添加"));
        //abcStringBuilder添加功能666true可以像这样子;连续的添加
        //指定地址拼接
        System.out.println(s.insert(0, 666));
        //666abcStringBuilder添加功能666true可以像这样子;连续的添加
        System.out.println(s.delete(0, 18));
        //r添加功能666true可以像这样子;连续的添加
        System.out.println(s.deleteCharAt(0));
        //添加功能666true可以像这样子;连续的添加
        
        //指定地址替换
        System.out.println(s.replace(0, 7, "都替换掉了"));
        //反转
        System.out.println(s.reverse());
	}

}

String和StringBuilder的区别和相同

1. String定长的字符序列,不可变的
   StringBuilder 可变长度的字符序列
2. String 底层是一个字符数组,final修饰
   StringBuilder 底层也是一个字符数组,没有使用final修饰
3. 创建对象个数
   String创建对象的个数多
   StringBuilder 创建对象的个数少

使用场景方面:
 如果有字符串的拼接的话,优先使用StringBuilder,节省内存空间,并且针对字符的操作,相对灵活

StringBuffer 和 StringBuilder的区别

 StringBuffer和StringBuilder功能基本一致,都是用来做字符序列的拼接
都是使用append和insert
 StringBuffer 线程安全的,运行的速度慢
 StringBuilder 线程不安全,运行速度快
 因此,在单线程的程序下(main,一条执行通路),更建议使用StringBuilder

Math 类

---

• 功能:计算各种数学公式的API
• 返回值:

public class MathDemo {

	public static void main(String[] args) {
		System.out.println(Math.PI);//3.141592653589793
        System.out.println(Math.E);//2.718281828459045
        
	    System.out.println(Math.abs(-5));//Math.abs求绝对值 5
	    
	    System.out.println(Math.max(44, 33));//Math.max求较大值 44
	    System.out.println(Math.min(-33, 11));//Math.min求较小值 -33
	    
	    System.out.println(Math.ceil(3.14));//向上取整(非四舍五入)
	    System.out.println(Math.floor(3.14));//向下取整(非四舍五入)
	    
	    System.out.println(Math.round(3.14));
	    System.out.println(Math.round(3.55));//四舍五入
	}

}

包装类

功能:实现String-Integer-int三种类型的转换

实际的开发过程中: 年龄是以String类型传递的,解决一个问题: 前台给的String类型age,如何能转化成普通的int类型,存储到数据库中
解决方式如下:

1. Integer i = new Integer(“123”);

   int x = i.intValue();
   System.out.println(x);

2. String s = “4567”;

   int y = Integer.parseInt(s);
   System.out.println(y);

包装类 Integer的构造方法

包装过程:

• Integer(intvalue):将一个int类型的数据value,封装成一个Integer类型的对象,这个对象的内容就表示这个整数

• Integer(String s) : 将一个String类型的字符(数字字符的字符串),包装成一个Integer类型的对象

• intValue() : 表示将Integer类型的对象,转换成int类型,返回值类型int

• parseInt(String s) : 将一个字符串s变成一个十进制数,这个方法,是静态的,返回值类型是int

• valueOf(int i) : 将一个int类型的数据i,封装成Integer类型的对象,静态方法

• valueOf(Sting s) : 将一个String类型的数据s,封装成Integer类型的对象,静态方法

package io.cnfox.Integert;

public class Integert {

	public static void main(String[] args) {
		//将String类型和int类型的数据封装成一个Integer类型
		Integer st = new Integer("321");
		Integer in = new Integer(55);
		System.out.println(st);
		System.out.println(in);
		
		//将Integer类型的对象,转换成int类型,返回值类型int
		int i = st.intValue();
		System.out.println(i);

		//将一个字符串s变成一个十进制数,这个方法,是静态的,返回值类型是int
		String s = "123";
		int ss = Integer.parseInt(s);
		System.out.println(ss);
		
		//将一个int类型的数据i,封装成Integer类型的对象,静态方法
		System.out.println(Integer.valueOf(99));// 99
				
		//将一个String类型的数据s,封装成Integer类型的对象,静态方法
		System.out.println(Integer.valueOf("1908"));//1908

//自动装箱
        //1. 自动装箱, 99这个基本数据类型,通过自动装箱,封装成了一个Integer类型的对象
		Integer i = 99;
		
		//2.   1) 自动拆箱,i当与int类型的数据7进行运算时,i先进行自动的拆箱动作,由Integer类型变成了int类型, int类型的99与int类型的7相加了
		//     2)  上述计算完毕,结果106是int类型, 然后将int类型自动装箱,封装成Intrger类型,赋值给i
		i = i + 7;
		
		System.out.println(i);// 106 

	}

}

System 类

---

System:系统类-system.out-system.in-system.err

Date 日期类

---

• 功能:计算时间的API
• 返回值:

1. getTime() : 获取到当前Date日期的毫秒值
2. setTime(long time): 设置此 Date对象表示的日期 //实际参数为Long time

DateFormat

---

• 功能:输出格式化日期
• 返回值:DateFormat

1. format(Date date) : 功能,将一个Date日期对象转换成字符串,返回值String类型
2. parse(String source) : 功能,将String类型转换成日期对象,返回值类型为Date类型

SimpleDateFormat : DateFormat是抽象类,simpleDateFormat的一个实现类,用于进行日期的格式化,可以将一个日期,以用户想要的任何格式类型返回回来

SimpleDateFormat() : 默认格式化字符串类型 19-6-14 下午2:07
SimpleDateFormat(String pattern) : 格式化的方式与给出的pattern保持一致

pattern 常见输入规则:
y—- 年
M—月
d—日
H—小时
m–分钟
s– 秒

package io.cnfox.Systemt;

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

public class Systemt {

	//syetem类 
	public static void main(String[] args) throws ParseException {
	//输出当前时间的毫秒值,以1970.1.1 00:00为起点 毫秒值为0
	System.out.println(System.currentTimeMillis());
    //当前毫秒值距离1970年的时间
    System.out.println((((((System.currentTimeMillis())/1000)/60)/60)/24)/365);

	//date类
    //获取格式化时间
    Date d = new Date();
    System.out.println(d);
    //获取当前时间的毫秒值
    System.out.println(d.getTime());
   //设置毫秒值
    d.setTime(1560600522442L);
    System.out.println(d);
    
    Date dd = new Date(0);
    System.out.println(dd);
    
    //Dateformat类
    //格式化输出当前时间
    SimpleDateFormat si = new SimpleDateFormat();
    System.out.println(si.format(new Date()));
    
    //自定义输出格式
    SimpleDateFormat sii = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    System.out.println(sii.format(new Date()));
    //自定义输出格式 并转化成String类型
    SimpleDateFormat ssi= new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    String date1 = ssi.format(new Date());
    System.out.println(date1);
   
    
    
    
	}
}

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MathDemo {

	public static void main(String[] args) 
	{
    
/*
		 * 客户要查询自己的购买的产品信息,这个查询功能,有限制条件,要求客户每次查询的时间段不能超过3个月, 如何控制客户的时间不超过3个月,
		 * 
		 * 解决思路: 开始时间-结束时间, 将这两个时间点之间的毫秒值计算出来, 某毫秒值/1000/60/60/24 = 天数 ,得到天数,
		 * 3个月控制手段(中国,连续的3个月,最长的天数92,)
		 * 
		 * 天数 <= 92
		 */
    //实例化adteformat的实现类simpledateformat
    SimpleDateFormat sdf = new SimpleDateFormat();
    //键入开始结束时间
    String beginTime = "2019-04-22";
	String endTime = "2019-07-24";
    //string类型转date类型
	Date beginDate = sdf.parse(beginTime);
	Date endDate = sdf.parse(endTime);

    //date类型计算毫秒值
    
	long begin = beginDate.getTime();
	long end = endDate.getTime();

    //判断时间是否小于92天
    if((end - begin)/1000/60/60/24  <= 92) {	
		System.out.println("登录成功");
	}else {
		System.out.println("客户时间输入错误");
	}

	}
}

package io.cnfox.calender;

import java.util.Calendar;

public class CalenderDemo {

	public static void main(String[] args) {
		//Calendar是抽象类无法实例化
		Calendar ca =Calendar.getInstance();
		//GregorianCalendar包含类所能获取得所有时间信息,通过变量来调用
		System.out.println(ca);
/*java.util.GregorianCalendar[time=1560499686418,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=5,WEEK_OF_YEAR=24,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=165,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=8,SECOND=6,MILLISECOND=418,ZONE_OFFSET=28800000,DST_OFFSET=0]*/
        
        int year = ca.get(Calendar.YEAR);
        System.out.println(year);//2019
        int month = ca.get(Calendar.MONTH);
        System.out.println(month);//6
        int day = ca.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);//14
        //设定
        ca.set(Calendar.YEAR,2020);
        System.out.println(ca.get(Calendar.YEAR));//2020
        //增加
        ca.add(Calendar.YEAR, 3);
        System.out.println(ca.get(Calendar.YEAR));//2023
        //减少
        ca.add(Calendar.YEAR, -3);
        System.out.println(ca.get(Calendar.YEAR));//2020
        //也可以不set,直接动态获取当前时间,然后做增加减少操作
        ca.add(Calendar.DAY_OF_MONTH, 3);
        System.out.println(ca.get(Calendar.DAY_OF_MONTH));
	}

}

Calendar 类

---

package io.cnfox.calender;

import java.util.Calendar;

public class CalenderDemo {

	public static void main(String[] args) {
		//Calendar是抽象类无法实例化
		Calendar ca =Calendar.getInstance();
		//GregorianCalendar包含类所能获取得所有时间信息,通过变量来调用
		System.out.println(ca);
/*java.util.GregorianCalendar[time=1560499686418,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=5,WEEK_OF_YEAR=24,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=165,DAY_OF_WEEK=6,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=8,SECOND=6,MILLISECOND=418,ZONE_OFFSET=28800000,DST_OFFSET=0]*/
        
        int year = ca.get(Calendar.YEAR);
        System.out.println(year);//2019
        int month = ca.get(Calendar.MONTH);
        System.out.println(month);//6
        int day = ca.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);//14
        //设定
        ca.set(Calendar.YEAR,2020);
        System.out.println(ca.get(Calendar.YEAR));//2020
        //增加
        ca.add(Calendar.YEAR, 3);
        System.out.println(ca.get(Calendar.YEAR));//2023
        //减少
        ca.add(Calendar.YEAR, -3);
        System.out.println(ca.get(Calendar.YEAR));//2020
        //也可以不set,直接动态获取当前时间,然后做增加减少操作
        ca.add(Calendar.DAY_OF_MONTH, 3);
        System.out.println(ca.get(Calendar.DAY_OF_MONTH));
	}

}