JAVA-8-常用API
常用API讲解
一：基本数据类型包装类
1.1为了方便基本类型的数据做更多的操作，java就针对每种基本类型的数据给出了对应的类类型。这就是我们说的基本类型的包装类。
1.2 Integer类型（查看api）
1.2.1 Integer类常用字段：
最大值：MAX_VALUE 获取int数据类型的最大值
最小值：MIN_VALUE 获取int数据类型的最小值
这两个均是Integer类的静态成员变量，可以通过类名Integer直接调用
package edu.integer;
/**
需求：假如我有一个数据，请问如何判断是否是int范围内的呢?
int范围 -2^31 ~ 2^31-1
字段：最大值：MAX_VALUE 最小值：MIN_VALUE
*/
public class IntegerDemo1 {
public static void main(String[] args) {
//定义一个整数
int a = 1000000000;
//使用if语句判断
if (a >= Integer.MIN_VALUE && a <= Integer.MAX_VALUE) {
System.out.println("您输入的数值在int范围内");
}else {
System.out.println("您输入的数值不在int范围内");
}
/** System.out.println(Integer.MIN_VALUE);//-2147483648
System.out.println(Integer.MAX_VALUE);//2147483647
*/
}//您输入的数值在int范围内
} 1.2.2 Integer类构造方法：
Integer(int value)
Integer(String s) 注意：这里的字符串必须是由数字组成的字符串，例如“946”。
package edu.integer;
/**
* 构造方法：
Integer(int value)
Integer(String s) 注意：这里的字符串必须是由数字组成的字符串
*/
public class IntegerDemo2 {
public static void main(String[] args) {
//利用Integer(int value)构建一个Integer对象
Integer i = new Integer(100);
System.out.println(i);//100，Integer，并不是输出地址值
//利用Integer(String s)构建一个Integer对象
// Integer i = new Integer("hello");java.lang.NumberFormatException
// 注意：这里的字符串形式必须是数字形式的字符串，如果不是就会抛出异常
Integer i3 = new Integer("345");
System.out.println(i3);//345，Integer
System.out.println("678");//678，字符
System.out.println(910);//910，int
}
} 1.2.3 Integer类常用成员方法：
转换为二进制：toBinaryString(int i)
转换为八进制：toOctalString(int i)
转换为十六进制：toHexString(int i)
这三个均是Integer类的静态成员变量，可以通过类名Integer直接调用。并且都是以N进制（基数 n）无符号整数形式返回一个整数参数的字符串表示形式。
package edu.integer;
/**
* 需求2：我有一个数据，我要得到该数据的二进制，八进制，十六进制如何实现呢?
按照以前讲过规律也可以进行计算，但是比较麻烦。
*/
public class IntegerDemo3 {
public static void main(String[] args) {
//定义一个int数据，求出对应的二进制，八进制，十六进制
int i = 102;
String bs = Integer.toBinaryString(i);//转二进制
System.out.println(bs);//1100110
String os = Integer.toOctalString(i);//转八进制
System.out.println(os);//146
String hs = Integer.toHexString(i);//转十六进制
System.out.println(hs);//66
}
} 1.2.4 int和String类型的相互转换（重点）：
int ——–>String
方式1：
String s = 100 +“”;（最常用）
方式2:
String.valueOf(int)
方式3：
Integer.toString(100);
String——–>int
方式1：
Integer.parseInt(String)
方式2：
Integer in = new Integer(“1000”);
int i = in.intValue(); 非静态
package edu.integer;
//int和String类型的相互转换：
public class IntegerDemo4 {
public static void main(String[] args) {
//int --->String类型的转换
int a = 520;
// 方式1：
String s1 = a+"";
System.out.println(s1);//520
// 方式2:
String s2 = String.valueOf(a);
System.out.println(s2);//520
// 方式3：
String s3 = Integer.toString(a);
System.out.println(s3);//520
//String-->int类型
// 方式1：
String b = "486";
int i = Integer.parseInt(b);
System.out.println(i);//486,int
// 方式2：
Integer it = new Integer(b);
int i2 = it.intValue();
System.out.println(i2);//486,int
}
} 1.2.5JDK5的新特性（重点）：
自动装箱：基本类型 – 包装类类型
Integer.valueOf(100)
自动拆箱：包装类类型 – 基本类型
i.intValue()
package com.edu.integer;
/**
* jdk5的新特性：
* 自动装箱：基本类型 -- 包装类类型
* 自动拆箱：包装类型 -- 基本类型
*/
public class IntegerDemo5 {
public static void main(String[] args) {
//自动装箱：基本类型 -- 包装类类型
//之前创建对象，将int类型的数据包装成Integer类型
Integer in = new Integer(100);
//自动装箱：基本类型 -- 包装类类型
//注意：其实说白了就是直接自动将int类型的数据自动转换成Integer类型，这就叫自动装箱
Integer in2 = 100;
//自动拆箱：包装类型 -- 基本类型
in2+=100;
/**
* 上面其实就做了一个自动拆箱动作：
* 原因：因为我们在做加法的时候，必须首先统一一下数据类型，才可以做加法，
* 但是现在in2是Integer类型，100这个值是int类型，上面的操作如果可以成功的话，
* 说明首先将Integer类型的数据自动拆箱成了Int类型，再去执行的加法运算
*/
System.out.println(in2);
}
}2: Character类的讲解
2.1 Character 类在对象中包装一个基本类型 char 的值
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
构造方法：public Character(char value)
2.2 成员方法
public static boolean isUpperCase(char ch) 判断是否是大写字符
public static boolean isLowerCase(char ch) 判断是否是小写字符
public static boolean isDigit(char ch) 判断是否是数字
public static char toUpperCase(char ch) 转成大写
public static char toLowerCase(char ch) 转成小写
package com.edu.character;
public class CharaterDemo {
public static void main(String[] args) {
//构造方法：public Character(char value)
char c = 'a';
Character ch = new Character(c);
System.out.println(ch);//a
System.out.println("-------------------");
System.out.println(Character.isUpperCase('a'));//false
System.out.println(Character.isUpperCase('A'));//true
System.out.println(Character.isUpperCase('0'));//false
System.out.println("-------------------");
System.out.println(Character.isLowerCase('a'));//true
System.out.println(Character.isLowerCase('A'));//false
System.out.println(Character.isLowerCase('0'));//false
System.out.println("-------------------");
System.out.println(Character.isDigit('a'));//false
System.out.println(Character.isDigit('A'));//false
System.out.println(Character.isDigit('0'));//true
System.out.println("-------------------");
System.out.println(Character.toUpperCase('a'));//A
System.out.println(Character.toUpperCase('A'));//A
System.out.println("-------------------");
System.out.println(Character.toLowerCase('a'));//a
System.out.println(Character.toLowerCase('A'));//a
}
}需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
package edu.character;
import java.util.Scanner;
public class CharacterDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串");
String s = sc.nextLine();
show(s);
}
public static void show(String s){
//定义三个变量用以接受次数
int num = 0;
int big = 0;
int small = 0;
//for循环 遍历字符，并计次数
for (int i = 0; i < s.length(); i++) {
//依次取出字符
char c = s.charAt(i);
//if语句判断，并累计次数
if (Character.isUpperCase(c)) {
big++;
}
if (Character.isLowerCase(c)) {
small++;
}
if (Character.isDigit(c)) {
num++;
}
}
//输出次数
System.out.println("大写字母个数："+big);
System.out.println("小写字母个数："+small);
System.out.println("大写字母个数："+num);
}
}二： Math：用于执行数学运算的类。
2.1 成员方法：
public static int abs(int a) 取绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static int max(int a,int b) 比较a，b的较大值
public static double pow(double a,double b) a的b次方
public static double random() 产生一个[0,1)区间的随机数
public static int round(float a) 四舍五入
2.2案例：猜数字小游戏
package com.edu.math;
import java.util.Scanner;
public class GuessNumber {
public static void main(String[] args) {
/**
* 猜数字小游戏分析：
* 1.生成随机数
* 2.获取键盘录入数据
* 3.while死循环进行判断，并给予提示
* 4.如果判断成功则跳出死循环
*/
//1.生成随机数
int ran = (int) (Math.random()*100+1);
//创建键盘录入对象，并获取键盘录入数据
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入你猜测得数字");
int guessNumber = sc.nextInt();
//进行判断并给予提示
if (ran>guessNumber) {
System.out.println("小了");
}
if (ran"大了");
}
if (ran==guessNumber) {
System.out.println("答对了");
break;
}
}
}
} 三： Object:是所有类的根类。所有的类都直接或者间接的继承自该类
3.1 创建学生对象打印学生对象的地址值（本质上是将地址通过哈希算法算出的哈希值）
package com.edu.object;
//创建一个学生类
class Student{
//姓名和年龄
private String name;
private int age;
//自动生成的快捷键shift+alt+s
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
}
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象，并打印学生对象
Student s1 = new Student("林", 50);
Student s2 = new Student("刘", 55);
//打印两个学生对象
System.out.println(s1);//com.edu.object.Student@3cf5b814
System.out.println(s2);//com.edu.object.Student@28084850
}
} 同一个对象的哈希值肯定是一样的。哈希值相同的对象的地址值未必一样。
新华字典,zhu – 456(哈希值) – 猪(第三个)，朱(第5个)，珠(第9个)
3.2为什么重写toString()方法
因为默认情况下，打印的是对象的字符串表示，意义不大。
包名…类名+@+该对象的哈希值的十六进制
所以，我们建议，所有子类重写该方法。
重写，自动生成即可。
表示该对象的数据：
[类名 成员变量1=数据值1,成员变量2=数据值2,…]
3.3 equals():
默认情况下，比较的是地址值。没有意义。所以，建议子类重写该方法。重写，自动生成即可。
这个生成的方法作用是比较对象的成员变量值是否相同。
3.4 ==和equals()的区别?
A:==的作用
a:基本类型 数据值
b:引用类型 地址值
B:equals()
只能比较引用类型。默认比较地址值。
如果重写后，是按照重写后的规则进行的。
四： Scanner
4.1 Scanner:帮助我们从键盘获取数据。
构造方法：
Scanner(InputStream source)
Scanner sc = new Scanner(System.in);
System.in
in是System类下面的一个静态的成员变量。
现在我们并不知道in这个成员变量的数据类型。
请看一下伪代码：
Scanner {
public Scanner(InputStream in){}
}
System {
public static final InputStream in;
}
InputStream System.in成员方法：
int nextInt():获取int类型的数据
String nextLine():获取String类型的数据
异常：InputMismatchException：输入的数据和最终的结果类型不匹配。建议：要什么类型，你就输入什么类型。反正将来也不用。
4.2当为同一个Scanner对象，数据的输入顺序问题：
String,String
String,int
int,int
int,String
出现的问题：先int再String就出现了问题，输入int数据后直接结束输入。
解决：A:我把所有的数据都按照String来拿。
String s1
String s2
String s3
将来你要什么，我就把String的数据转换为什么类型。(明天就可以实现)
B:重新创建一个新的Scanner对象。
五： Random：用于产生随机数的类。和种子相关（种子其实可以把它看成一个产生随机数的定义的规则）。
构造方法：
Random():没有指定种子，采用的是默认种子。
Random(long seed):可以指定种子。种子相同，产生的随机数就相同。
成员方法：
public int nextInt():返回int范围内的数据
public int nextInt(int n):返回[0,n)之间的整型数据
得到1-100之间的随机数：new Random().nextInt(100) + 1
package edu.random;
import java.util.Random;
//利用有参、无参构造创建随机数生成器，产生5个大小在[0,10)随机数，并比较二者的不同
public class RandomDemo {
public static void main(String[] args) {
//利用有参、无参构造创建随机数生成器
Random rd0 = new Random();
Random rd1 = new Random(2);
//无参，产生10个随机数
for (int i = 0; i < 10; i++) {
System.out.print(rd0.nextInt(10)+" ");
}
System.out.println();
//有参，产生10个随机数
for (int i = 0; i < 10; i++) {
System.out.print(rd1.nextInt(10)+" ");
}
}
// 第一次运行
/**
* 6 0 0 2 0 3 5 9 0 3
8 2 0 7 9 0 6 9 7 8
*/
// 第二次运行
/**
* 2 5 3 2 9 6 2 7 1 9
8 2 0 7 9 0 6 9 7 8
*/
// Random():没有指定种子，采用的是默认种子。每次产生的都不一样
// Random(long seed):可以指定种子。种子相同，产生的随机数就相同。
}六：System:
System 类包含一些有用的类字段和方法。它不能被实例化。
成员方法：
public static void exit(int status):终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。
public static long currentTimeMillis():获取当前时间的毫秒值。
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):复制数组
参数一：要复制的源数组
参数二：从源数组那个索引开始复制
参数三：需要复制到哪个数组中
参数四：从哪个索引开始进行覆盖
参数五：需要覆盖几个元素
package edu.system;
public class SystemDemo {
public static void main(String[] args) {
System.out.println("hello");
System.exit(100);//只要是非0的状态码都表示异常终止
System.out.println("world");
}
// 只输出hello
}求出打印1-10000之间的所有数字所需要的时间
package edu.system;
public class SystemDemo2 {
public static void main(String[] args) {
//获取开始时间
long start = System.currentTimeMillis();
//运行打印程序
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
//获取结束时间
long end = System.currentTimeMillis();
//输出时间差值
System.out.println(end-start);
}
}将arr2中的元素8，9使用arr数组中的2，3，覆盖
package edu.system;
import java.util.Arrays;
public class SystemDemo3 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] arr2 = {6,7,8,9,10};
//需求：将arr2中的元素8，9使用arr数组中的2，3，覆盖
System.arraycopy(arr, 1, arr2, 2, 2);
System.out.println(Arrays.toString(arr2));//[6, 7, 2, 3, 10]
}
}七： Date:类 Date 表示特定的瞬间，精确到毫秒。
构造方法：
Date():默认获取的是当前的日期时间
Date(long date):把当前日期按照指定的毫秒值进行设定
成员方法：
public long getTime()：获取日期对象的毫秒值
public void setTime(long time):设置日期对象的毫秒值
package edu.date;
import java.util.Date;//导包
public class DateDemo {
public static void main(String[] args) {
//新建Date对象
Date d = new Date();
System.out.println(d);//Mon Apr 24 15:31:50 CST 2017
System.out.println(d.getTime());//1493019110018,新建d时的系统时间的毫秒值
System.out.println(System.currentTimeMillis());//1493019110065
Date d2 = new Date(1493019034581L);
System.out.println(d2);//Mon Apr 24 15:30:34 CST 2017
Date d3 = new Date();
d3.setTime(10000000000000L);
System.out.println(d3);//Sun Nov 21 01:46:40 CST 2286
}
}八： DateFormat(格式化和解析日期对象)
**8.1**DateFormat是抽象类，我们用到它的子类SimpleDateFormat
格式化：
Date——>String
2015年9月27日 15:14:23
String format(Date d)
解析：
String——>Date
“2015-12-12”
Date parse(String s)
构造方法：
SimpleDateFormat()用默认的模式格式化日期对象
SimpleDateFormat(String pattern):用给定的模式格式化日期对象
成员方法：
public final String format(Date date)将一个 Date 格式化为日期/时间字符串
public Date parse(String source)throws ParseException从给定字符串的开始解析文本，以生成一个日期对象
package edu.dateformat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFoematDemo {
public static void main(String[] args) throws ParseException {
// 格式化 Date----->String
Date d = new Date();
//采用默认构造格式化
SimpleDateFormat sdf = new SimpleDateFormat();
String t = sdf.format(d);
System.out.println(t);//17-4-24 下午3:47
//采用自定义，格式化
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String t1 = sdf1.format(d);//2017-04-24 15:47:17
System.out.println(t1);
// 解析 String----->Date
// public Date parse(String source)throws ParseException
//从给定字符串的开始解析文本，以生成一个日期对象
String dateStr = "2017-04-22 16:11:56";//前后格式必须一样
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d2 = sdf2.parse(dateStr);
System.out.println(d2);//Sat Apr 22 16:11:56 CST 2017
}
}8.2做一个日期工具类DateUtils
package com.edu.dateformat;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 需求：
1.让外界无法创建这个类的对象(抽象类或者私有构造方法)
2.设置的方法直接可以通过类名调用
3.可以获取 yy年MM月dd日
4.可以获取 HH:mm:ss
5.可以获取 yy-MM-dd HH:mm:ss
*/
public class DateUtils {
//私有化构造
private DateUtils(){}
//3.可以获取 yy年MM月dd日
public static String getDate(){
//创建日期对象
Date d = new Date();
//创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yy年MM月dd日");
//调用方法格式化日期对象
String dateStr = sdf.format(d);
return dateStr;
}
// 4.可以获取 HH:mm:ss
public static String getTime(){
//创建日期对象
Date d = new Date();
//创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
//调用方法格式化日期对象
String dateStr = sdf.format(d);
return dateStr;
}
// 5.可以获取 yy-MM-dd HH:mm:ss
public static String getDateTime(){
//创建日期对象
Date d = new Date();
//创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
//调用方法格式化日期对象
String dateStr = sdf.format(d);
return dateStr;
}
}九： Calendar
9.1 Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法。
Calendar(日历类) – 获取年，获取月，获取日，获取时，获取分，获取秒。
public int get(int field):返回给定日历字段的值
package edu.calendar;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
/**
* 创建对象的方法：
* 1.new 类名();
* 2.有一些类是抽象类，他为我们提供了一个成员方法，
* 而这个成员方法的返回值就是这个抽象类的子类对象
*/
Calendar c = Calendar.getInstance();
//获取年份
System.out.println(c.get(Calendar.YEAR));
//获取月份,注意默认月份值是从0-11月，
//我们想要显示的更加付给我们的阅读规则，就必须手动给月份加上1
System.out.println(c.get(Calendar.MONTH)+1);
//获取日期
System.out.println(c.get(Calendar.DATE));
//获取时
System.out.println(c.get(Calendar.HOUR));
//获取分
System.out.println(c.get(Calendar.MINUTE));
//获取秒数
System.out.println(c.get(Calendar.SECOND));
}
} 9.2
public void add(int field,int amount):根据amount修改field的值
public void set(int year,int month,int date):设置当前日历的年月日
package edu.calendar;
import java.util.Calendar;
//需求：获取当前时间的5年后的3个月前的7天后。
public class CalendarDemo2 {
public static void main(String[] args) {
//创建日历对象
Calendar c = Calendar.getInstance();
c.add(Calendar.YEAR, 5);
c.add(Calendar.MONTH, -3);
c.add(Calendar.DATE, 7);
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH)+1);
System.out.println(c.get(Calendar.DATE));
// public void set(int year,int month,int date):设置当前日历的年月日
c.set(2016, 9, 9);
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH)+1);
System.out.println(c.get(Calendar.DATE));
}
}9.3键盘录入年份，获取任意一年的二月有多少天
package com.edu.calendar;
import java.util.Calendar;
import java.util.Scanner;
public class CalendarTest {
public static void main(String[] args) {
/**
* 1.获取年份
* 2.将日历对象的时间调到，此年的3月的第一天
* 3.将日期对象向前推一天
* 4.获取此天的日期
*/
System.out.println("请输入年份");
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
// 2.将日历对象的时间调到，此年的3月的第一天
Calendar c = Calendar.getInstance();
c.set(year, 2, 1);
//3.将日期对象向前推一天
c.add(Calendar.DATE, -1);
//4.获取此天的日期
System.out.println("该年的二月有"+c.get(Calendar.DATE));
}
}