JavaSE-工具类
1、API
(Application Programming Interface) 应用程序接口Java中的API，就是JDK提供的各种功能的Java类。
常用的Java包介绍:
java.lang：Java语言包，包含String、StringBuffer、Integer、Math、System。任何类中，该包中的类都会被自动导入。
java.util：java工具包，包含一些实用的工具类（ 包含list, calendar, date等类）。
java.io：输入输出编程接口
java.ne：网络编程接口
java.net：网络编程接口
2、Object类
Object是所有子类的直接父类或间接父类，即是所有类的超类。Object是Java语言中唯一一个没有父类的类。
2.1 equals
equals方法是java.lang.Object类提供的方法，用于判断两个对象的数据值是否相等(或某些对象的值是否相等)。如果子类没有equals方法，默认调用父类的方法。
equals方法默认判断两个对象的哈希值是否相同，故equals方法默认判断两个对象的引用是否指向同一个对象。
例1：判断一个数字是否是回文数组(equals).
package chap9.work;
import java.util.Scanner;
public class SubjectS55 {
public static void main(String[] args) {
System.out.println("input");
Scanner scanner = new Scanner(System.in);
String sc= scanner.next();
StringBuilder buffer = new StringBuilder(sc);
buffer=buffer.reverse();
if(sc.equals(buffer.toString())) {
System.out.println("是回文数");
}else {
System.out.println("不是");
}
}
}
例2：判断a=”abc”和b=”ab”值是否相等
String a = "abc";
String b = "ab";
if(a.equals(b)){
System.out.println("y");
}else{
System.out.println("n");
}
2.2 hashCode(),toString()
hashCode是哈希码，哈希码是通过哈希算法为每一个对象计算出的唯一值，每个对象的哈希码都是不同。哈希码是16进制的。可以通过重写equals方法判断两个数据值是否相等。
当使用输出语句输出一个对象，默认会调用该对象toString()方法，把对象转换成字符串输出，默认输出对象的：类名@hashCode(使用16进制表示)。 如果需要输出对象的数据，需要重写toString()方法。
例1：创建一个学生类，属性有学号和姓名，赋值后输出。
步骤一：创建Student父类，创建对象：学号和姓名，然后封装（封装略）。
package classroom.chap9;
public class Student {
private int id;
private String name;
}
步骤二：新建一个ObjectClass类，对对象赋值，输出结果。
package classroom.chap9;
public class ObjectClass{
public static void main(String[] args) {
Student st1 = new Student(001,"jack");
System.out.println(st1);
}
}
结果为: [email protected]
步骤三：输出语句会默认toString方法输出，所以需回到Student类中重写toString方法。
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
结果为：Student [id=0, name=jack]
例2：在例1的基础上再创建1个对象st2，学号和姓名与st1相同，比较st1和st2两个对象是否相同。
步骤四：在ObjectClass类创建st2对象，并判断，输出结果
Student st2 = new Student(001,"jack");
System.out.println(st1==st2);
System.out.println(st1.equals(st2));
结果为：false false
原因：
a) ==运算符在判断引用数据类型时，它的功能是判断两个对象的地址是否相同。而数据在存储时，会首先存储在常量池，常量池是Java语言提供的一种特殊的内存结构，用于储存程序运行过程中的常量对象。如果常量池中有相同数据值，则会复制该对象值到堆中，在堆中时，哪怕对象值相同，其位置都是不一样的。
b) 输出语句输出对象，会默认toString()方法，默认输出格式为类名@hashCode，而每一个对象的哈希值都不同。所以，
st1：classroom.chap9[email protected]
st2：[email protected]
步骤五：需要在Student类中重写equals方法，才能判断st1和st2是否相等。
@Override
public boolean equals(Object obj) {
if(obj instanceof Student){
boolean ret = this.hashCode()==obj.hashCode();
Student s = (Student)obj;
ret = ret || (id==s.getId() && name.equals(s.name));
return ret;
}else{
return false;
例2：查询a=”abc”和b=”ab”哈希值
String a = "abc";
String b = "ab";
System.out.println("a.hashcode="+a.hashCode());
System.out.println("b.hashcode="+b.hashCode());
3、包装类
包装类可以把基本数据类型转化为对象。在功能上包装类能够完成数据类型之间（除boolean）的相互转换，尤其是基本数据类型和String类型的转换。
数据类型包装类
数据类型 包装类
boolean Boolean
byte Byte
char Character
double Double
float Float
int Integer
long Long
short Short
包装类的主要用途是完成基本数据类型和字符串间的互相转换，或在基本数据类型间转换；提供了一些重要的属性。基本类型与包装类之间转换规则（以整型为例）：
基本数据类型转换为包装类：Integer a = new Integer(基本数据类型);
字符串转换为包装类：①Integer b = new Integer(字符串); ②Integer b = Integer.valueOf(字符串);
包装类转换为基本数据类型：int c = new Integer(20).intValue();
格式：基本数类型 名称 = 包装类.基本数据类型Value();
包装类转换为字符串：String d = new Integer().toString();
字符串转换为基本数据类型：int e = Integer.parseInt(字符串);long e = Long.parseInt(字符串);
格式为：基本数据类型 名称 = 基本数据类型的包装类.parse基本数据类型
字符串和基本数据类型的转换可以通过包装类进行转换。
拆箱与装箱：
拆箱：把包装类转换为原始数据类型的过程。
自动拆箱：把包装类的对象直接赋值给原始数据类型。
装箱：把原始数据类型转换为包装类的过程。
自动装箱：把原始数据类型直接赋值给包装类对象的过程。
4、字符串类
字符串的表现形式有两种：String和StringBuffer。
4.1 String
String类是final类型的类。
String对象代表一组不可改变的Unicode字符串序列，每次修改字符串都会分配新的内存空间。String类对象的内容一旦被初始化就不能再改变，所以String类的修改性能很低。
连接操作符“+”，可以将其它各种类型的数据转换成字符串，并前后连接成新的字符串。字符串可以重置equals方法，用于比较两个字符串的内容。
在Java中，存放字符串常量的对象属于String类对象。
例1：String对象的修改
String s = new String("abc");
s=new String("nu9gefd");
例2：String对象的创建
public class TestStringCharset {
public static void main(String[] args) {
byte [] bname = new byte[10];
String name0 = "张三";
try {
//.getBytes()将字符串编码存储到新的byte中
bname = name0.getBytes("utf-8");
System.out.println(bname);
//new String(bytes类型,String类型名字)
String name1 = new String(bname,"utf-8");
System.out.println("name1="+name1);
for(int i=0;i<bname.length;i++){
System.out.print(bname[i]+" ");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
例3：三位数数字转化字符串补零，如：数字1转化后为“001”
public class StringAdd {
public static String Add(int num){
String string = String.valueOf(num);
if(num<10){
string = "00"+string;
}else if(num<100){
string = "0"+string;
}
return string;
}
public static void main(String[] args) {
System.out.println("input:");
int input = new Scanner(System.in).nextInt();
String s = Add(input);
System.out.println(s);
}
}
4.2 String类常用方法
① boolean equals(String)：判断两个字符串对象的内容是否相等。
String a = "abc";
String b = "abc";
boolean bool0 = a.equals(b);
System.out.println(bool0);//true
② boolean equalsIgnoreCase(String)：比较两个字符串的内容是否相等，忽略大小写。
String a = "abc";
String b = "abc";
String c = "Abc";
boolean bool = a.equalsIgnoreCase(c);
System.out.println(bool);//true
③ String toUpperCase( )：把所有字符转换为大写
String c = "Abc";
String d = c.toUpperCase();
d的结果为：ABC
④ String toLowerCase( )：所有字符转换为小写
String c = "Abc";
String d = c.toUpperCase();
d的结果为：ABC
⑤ char charAt(int) ：返回指定索引处的 char 值
String a = "abc";
char e = a.charAt(1);d的结果为：ABC
e的结果为：b
⑥ String substring(int begin,int end)：返回一个从begin开始到end-1结束的新字符串。
String b = "abcfde";
char e = a.charAt(1);
String f = b.substring(1, 3);
f的结果为：bc
⑦ int indexOf/lastIndexOf(char)：返回指定字符在此字符中第一次/最后一次出现的索引。
String b = "abcfccde";
int first = b.indexOf("c");
int last = b.lastIndexOf("c");
System.out.println("first="+first+",last="+last);
结果为：first=2,last=5
⑧ String trim( )：返回忽略前后空白的新的字符串。
String b = " abcfccde ";
String trim = b.trim();
结果为：abcfccde
⑨ int length( )：返回字符串长度，包括空格。
String b = " abcfccde ";
int length = b.length();
length的结果为：12
⑩ String concat(String str)：将指定字符串连接到此字符串的结尾。
String a = "abc";
String b = " abcfccde ";
String concat = a.concat(b);
Concat的结果为：abc abcfccde
⑪ byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte序列，并将结果存储到一个新的 byte 数组中。
byte [] bname = new byte[10];
String name0 = "张三";
try {
bname = name0.getBytes("utf-8");
System.out.println(bname);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
⑫ String[] split(String regex)：根据给定的正则表达式的匹配拆分字符串。
String a = "a b c";
String[] bString = a.split(" ");
for(int i=0;i<bString.length;i++){
System.out.print(bString[i]+" ");
}
结果为：a b c
⑬ String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String a = "a b c";
String b = a.replace("b", "v");
b的结果为：a v c
⑭ boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。
boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。
String a = "a b c";
boolean b = a.startsWith("a");
d的结果为：true
4.3 StringBuffer类
StringBuffer对象代表一组可改变的Unicode字符序列。可以使用StringBuffer来对字符串的内容进行动态操作，不会产生额外的对象。
新建：StringBuffer buffer = new StringBuffer();
添加：buffer.append(false);
插入：buffer.insert(4,“hdfuahsifd”);
删除：buffer.delete(6, 9);
删除语法：StringBuffer delete(int begin,int end)
返回容量：int a = buffer.capacity();
返回长度（字符数）： int b = buffer.length();
反转字符串： StringBuffer re = buffer.reverse()
通过索引访问字符：int ind=buffer.charAt(2);
截取字符：String sub = buffer.substring(0, 4);
例：输入一个手机号码，将中间四位使用星号替代。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String phone = sc.nextLine();
//把String转换为StringBuffer
StringBuffer buffer = new StringBuffer(phone);
buffer.replace(3, 7,"****");
System.out.println(buffer.toString());
}
4.4 StringBuilder类
StringBuilder类是一个可变的字符序列。JDK自从5.0版本后引入。StringBuilder类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候 。
String类与StringBuilder类的比较：
同：
String与StringBuffer两个类都来封装对字符串的各种操作；
String类与StringBuffer类都被放到了java.lang包中。
异：
String类对象中的内容初始化不可以改变；
StringBuffer类对象中的内容可以改变。
StringBuffer与StringBuilder的比较：
同：
StringBuffer和StringBuilder都是长度可变的字符串。
StringBuffer和StringBuilder的操作基本相同。
异：
StringBuffer类是线程安全的；StringBuilder类是线程不安全的。
StringBuffer在JDK1.0中就有，而StringBuilder是在JDK5.0后才出现的。
StringBuilder的一些方法实现要比StringBuffer快些。
5、Math类
Math类是final类，因此不能从Math类继承。Math类中的方法都是static方法，因此不必创建Math类的对象就可以直接使用该类的方法。
Math类中的常用方法：
方法 含义
static int abs(int) 返回参数的绝对值，返回值类型与参数类型相同
static double abs(double) 返回参数的绝对值
static double ceil(double) 返回大于所给参数的最小的整数值
static double floor(double) 返回不大于所给参数的最大的整数值
static int max(int a,int b) 返回两个int值中较大的一个
static double max(double,double) 返回两个double值中较大的一个
static int min(int a,int b) 返回两个int值中较小的一个
static double min(double,double) 返回两个double值中较小的一个
static double random( ) 返回在0.0~1.0之间的随机的double值
static int round(double) 返回同所给值最接近的整数，采用4舍5入法
static double sin/cos/tan(double) 返回给定的弧度值对应的三角函数值
static double sqrt(double) 返回所给值的平方根，若所给值为负数则返回NaN
例：从键盘输入三个整数作为三角形的三边，使用海伦公式求出该三角形的面积。
public class TriangleArea {
public static void main(String[] args) {
System.out.println("input:");
Scanner sc = new Scanner(System.in);
double a,b,c;
a = sc.nextDouble();
b = sc.nextDouble();
c = sc.nextDouble();
if((a+b>c && a-b<c && b-a<c) || (a+c>b && a-c<b && c-a<b)
|| (b+c>a && b-c<a && c-b<a)){
double p=(a+b+c)/2;
double s = Math.round(Math.sqrt(p*(p-a)*(p-b)*(p-c)));
System.out.println("area="+s);
}else{
System.out.println("failure");
}
}
}
6、日期类
java.util.Date。Date 类表示指定的时间信息，可以精确到毫秒。不支持国际化。
java.util.Calendar。常用的日期处理的对象。可以设置自己的时区和国际化格式。
java.text.SimpleDateFormat。可以选择任何用户定义的日期-时间格式的模式。
&emsp**;yyyy-年，MM-月，dd-日，HH-24小时，mm-分钟，ss-秒钟,SSS-毫秒**
例1：获取当前系统时间。
M1：Date now = new Date();结果为：Sat Aug 10 14:53:19 CST 2019
M2：long now1 = now.getTime();
long time = System.currentTimeMillis();
结果都为：1565420074256(毫秒)
在有些数据库设计中，使用long类型保存时间。
例2：分别获取当前年份，月份，日，小时，分钟，秒钟，毫秒
Calendar calendar = Calendar.getInstance();
String year = new Integer(calendar.get(Calendar.YEAR)).toString();
//使用calendar获取的月份是0~11的
String month = new Integer(calendar.get(Calendar.MONTH)+1).toString();
String date = new Integer(calendar.get(Calendar.DATE)).toString();
//星期是从星期天开始的，范围是从1-7
String dayWeek = new Integer(calendar.get(Calendar.DAY_OF_WEEK)-1).toString();
//12小时进制:0~11
String hour = new Integer(calendar.get(Calendar.HOUR)).toString();
//24小时进制:0~23
String hourDay = new Integer(calendar.get(Calendar.HOUR_OF_DAY)).toString();
String minute = new Integer(calendar.get(Calendar.MINUTE)).toString();
String second = new Integer(calendar.get(Calendar.SECOND)).toString();
String milliSecond = new Integer(calendar.get(Calendar.MILLISECOND)).toString();
结果为：
year=2019，month=8，date=10，dayWeek=6，hour=3，hourDay=15，minute=1
second=43，milliSecond=930
例2：输入日期数字格式转换为日期类型
public class DateClass {
public static void main(String[] args) {
//yyyy-年，MM-月，dd-日，HH-24小时，mm-分钟，ss-秒钟,SSS-毫秒
String pattern = "yyyy-MM-dd HH:mm:ss.SSS";
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
try{
pattern = "yyyy年MM月dd日 HH时:mm分:ss秒SSS毫秒 EE";
Date date3 = sdf.parse("2019-8-7 15:15:15.34");
sdf.applyPattern(pattern);
String date1 = sdf.format(date3);
System.out.println(date1);
}catch(ParseException e){
e.printStackTrace();
}
}
}
7、练习
1.输入日期格式字符串作为商品的生产日期，输入保质期（天）；计算截止到今天，该商品还有多少天会过保质期。
控制台输入字符串转为日期格式
将输入日期增加保质期天数
取得当前系统日期，比较两个日期，如果过期输出“该商品已经过期”
如果没有过期，输出天数
public class Project {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("input production date:");
String produce = sc.next();
System.out.println("input expiration date:");
int exp = sc.nextInt();
SimpleDateFormat dat = new SimpleDateFormat("yyyy-MM-dd");
//显示当前系统时间
Date now = new Date();
//设定当前系统时间输出格式
SimpleDateFormat dat1 = new SimpleDateFormat("yyyy-MM-dd");
String nowtime = dat1.format(now);
System.out.println("today:"+nowtime);
try {
//.parse字符串转日期
Date date = dat.parse(produce);
//.format日期转字符串
long a = now.getTime();
long b = date.getTime();
int c = (int) (a-b);
c=c/86400000;
if(c>exp){
System.out.println("该商品已过期");
}else{
long cexp = exp-c;
System.out.println("还有"+cexp+"天过期");
}
} catch (Exception e) {
e.printStackTrace();
}
sc.close();
}
}
2.编写一个程序，实现从命令行参数输入一字符串，统计该字符串中字符“e”出现的次数。
public class Subject2 {
public static void main(String[] args) {
//charAt(int)
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
//a.contains("e");判断是否包含e
int k=0;
for(int i=0;i<input.length();i++){
char b = input.charAt(i);
if(b=='e'){
k++;
}
}
System.out.println("e的个数为:"+k);
}
}
3.生成十个0~100之间的随机数，放到数组中，然后排序输出。
public class Subject3 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
double a = Math.random();
arr[i]=(int) Math.round(a*100);
System.out.print(arr[i]+" ");
}
System.out.println();
/*冒泡排序
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int t = arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}*/
for(int i=0;i<arr.length;i++){
int min=i;
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min=j;
}
}
int t = arr[min];
arr[min]=arr[i];
arr[i]=t;
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
4.解析一个邮箱地址是否合法，如果合法则打印出用户名部分和该邮箱所属的网站域名，如果邮箱地址不合法则显示不合法的原因。
提示：邮箱地址不合法的因素：
邮箱地址中不包含@或.
邮箱地址中含有多了@或.
邮箱地址中.出现在@的前面
用户名里有其他字符
public class EmailAnswer {
public static void main(String[] args) {
Scanner cs = new Scanner(System.in);
System.out.println("input:");
String eString = cs.nextLine();
//2.1.1邮箱地址中不包含@或.
if(eString.indexOf("@")==-1 || eString.indexOf(".")==-1){
System.out.println("邮箱地址中不包含@或.");
}else if(eString.indexOf("@")!=eString.lastIndexOf("@")
|| eString.indexOf(".")!=eString.lastIndexOf(".")){
System.out.println("邮箱地址中含有多了@或.");
}else if(eString.indexOf("@")>eString.indexOf(".")){
System.out.println("邮箱地址中.出现在@的前面");
}else if(!checkEmail(eString)){
System.out.println("用户名里有其他字符");
}else{
System.out.println("有效字符");
}
}
String patternString = "^[0-9a-z]+\\w*@([0-9a-z]+\\.)[0-9a-z]+$";
private static boolean checkEmail(String email){
for(int i=0;i<email.length();i++){
char c = email.charAt(i);
boolean flag= c>='A'&& c<='Z' || c>='a' && c<='z' || c=='@' || c=='.';
if(flag){
continue;
}else{
return false;
}
}
return true;
}
}
5.有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。
public class SubjectS4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
StringBuilder builder = new StringBuilder(str);
int i = 0;
while (builder.length() != 0) {
System.out.print(builder.substring(0, 1) + ", ");
builder.deleteCharAt(0);
i++;
}
System.out.println();
System.out.println("字符个数为：" + i);
}
}
6.有一种数叫回文数，正读和反读都一样，如12321便是一个回文数。编写一个程序，从命令行得到一个整数，判断该数是不是回文数。
M1：
public class SubjectS55 {
public static void main(String[] args) {
System.out.println("input");
Scanner scanner = new Scanner(System.in);
String sc= scanner.next();
StringBuilder buffer = new StringBuilder(sc);
buffer=buffer.reverse();
if(sc.equals(buffer.toString())) {
System.out.println("是回文数");
}else {
System.out.println("不是");
}
}
}
M2：
public class SubjectS5 {
/*
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.next();
StringBuffer buffer = new StringBuffer(input);
int a = Integer.parseInt(buffer.toString());
int b = Integer.parseInt(buffer.reverse().toString());
if(a==b){
System.out.println("是回文");
}else{
System.out.println("不是回文");
}
sc.close();
}*/
public static void main(String[] args) {
if(foo()){
System.out.println("是回数");
}else{
System.out.println("不是回数");
}
}
public static boolean foo(){
System.out.println("请输入一串整数：");
Scanner in = new Scanner(System.in);
String s = in.next();
int j = s.length()-1;
for(int i=0;i<s.length()/2;i++){
if(s.charAt(i)!=s.charAt(j)){
return false;
}
j--;
}
return true;
}
}