Java常用类库笔记

1.Java类库概述

Java包下的一些常用子包

Java.lang	语言包
Java.util	使用包
Java.awt	抽象窗口工具包
Java.applet	Applet包
Java.text	文本包
Java.io	输入/输出包
Java.net	网络功能包
Java.rmi	远程方法调用功能包
Java.sql	JDBC接口包

    1.语言包

lang包主要提供Java语言最基础的类
①Object类，是Java的根类，是所有类的共同祖先。因此Object类中的方法在任何类中都可以使用

②数据类型包装类（the data type wrapper）：对应着八个基本数据类型，包装类有Byte、Short、Integer、Long、Float、Double、Character、Boolean

③字符串类：Java将字符串作为类来应用，主要有String和StringBuffer两个类

④数字型Math类：提供一组静态常量和静态方法，包括E(e)和PI(Π)常数，求绝对值的abs方法，计算三角函数的sin和cos方法，求最值的min和max方法，求随机数的random方法等。

⑤系统运行时类System、Runtime：可利用它们访问系统和运行时环境资源

⑥类Class：为类提供运行时信息，如名字、类型以及父类信息

⑦错误和异常处理类：Throwable、Exception、Error

⑧线程类：Thread

⑨过程类：Process 得到其他进程控制对象，实现不同进程间的相互通信

⑩反射包类：提供方法获得类和对象的反射信息，也就是类或对象的描述信息


    2.实用包

①日期类：包括Date、Calendar类，它们描述日期和时间，提供对日期的操作方法，如获得当前日期，比较两个日期，判断日期的先后等

②集合类：包括多种集合Collection（无序集合）、Set（不重复集合）、List（有序集合）、Enumeration（集合类枚举操作）、Iterator（集合类迭代操作），以及表示数据结构的多个类，如LinkedList（链表）、Vector（向量）、Stack（栈）、Hashtable（散列表）、TreeSet（树）等


    3.抽象窗口工具包

抽象窗口工具包（AWT）用来构建和管理应用程序的图形用户界面
①java.awt包：是用来构建图形用户界面（GUI）的类库，它包括许多界面元素和资源，主要在三个方面提供界面设计支持：
低级绘图操作类Graphics；图形界面组件和布局管理，如Checkbox类、Container类、LayoutManager接口等；用户界面交互控制和事件响应，如Event类

②java.awt.event包：定义了许多事件类和监听接口

③java.awt.image包：用来处理和操纵来自网上的图片


4.Applet包

包含用来实现运行于浏览器的Applet和一些相关接口


5.文本包

包中的Format、DateFormat、SimpleDateFormat等类提供各种文本或日期格式


6.输入/输出流包

包含了实现Java程序与操作系统、用户界面以及其他Java程序做数据交换所使用的类，如基本输入/输出流，文件输入/输出流、过滤输入/输出流、管道输入/输出流等。凡是需要完成与操作系统有关的、较底层的出入/输出操作都要用到包中的类。


7.网络功能包

用来实现Java的网络功能，主要有低层的网络通信（如实现套接字通信的Socket类、ServerSocket类）和高层的网络通信（如基于http新应用的URL类及URLConnection）。


8.远程方法调用功能包

这三个包用来实现远程方法调用（Remote Method Invocation，RMI）功能。利用RMI，用户程序可以在本地计算机上以代理的方式使用远程计算机上的对象提供的服务


9.JDBC接口包

提供JDBC（Java database connection）规范中的主要接口和一些常用类。利用包中的接口以统一的方式访问不同类型的数据库，从而使Java程序在具有平台无关性的同时，也具有以相同的逻辑无差异访问数据库的能力。

2.String与StringBuffer

2.1String

String的初始化方式

String str = "Hello!";
String str = new String("Hello");

String的特点是一旦赋值，便不能更改其指向的字符对象。如果更改，则会指向一个新的字符对象。

2.1.1String作为参数传递的特点

public class Test {
    public void changePara(String s){
        s = s+"a";
        System.out.println("changePara："+s);
    }
    public void invoke(){
        String s = "b";
        changePara(s);
        System.out.println("invoke："+s);
    }

    public static void main(String[] args) {
        new Test().invoke();
    }

}

运行结果：
	changePara：ba
	invoke：b

invoke结果是b而不是ba，原因是invoke中的s与changePara中的s不是指向同一个对象。changePara中的s指向一个新的字符串ba

2.1.2字符串的值比较和引用比较

public class StringEqualTest {
    private static String s = new String("Hello");
    private static String t = new String("Hello");

    public static void main(String[] args) {
        StringEqualTest stringEqualTest = new StringEqualTest();
        System.out.println("字符串s ："+s);
        System.out.println("字符串t ："+t);
        System.out.print("引用比较结果:");
        stringEqualTest.yinyongCompare();
        System.out.print("值比较结果:");
        stringEqualTest.zhiCompare();
    }
    public void yinyongCompare(){//引用地址比较
        if(s==t){
            System.out.println("相等");
        }else{
            System.out.println("不相等");
        }
    }
    public void zhiCompare(){//值比较
        if(s.equals(t)){
            System.out.println("相等");
        }else{
            System.out.println("不相等");
        }
    }
}

运行结果：
    字符串s ： Hello
    字符串t ： Hello
    引用比较结果：不相等
    值比较结果：相等

引用比较比较的是地址，所以不相等，字符串的值比较一定要用equals()方法
如果要忽略大小写，应调用方法equalsIgnoreCase()

2.2StringBuffer

    public static StringBuffer changeStr(StringBuffer s){
        return s.append("英雄联盟");
    }

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("欢迎来到");
        System.out.println(changeStr(s));
    }
    
    运行结果：
    欢迎来到英雄联盟

结论：显然StringBuffer作为参数传递以后做的改变不会指向新的对象
这一点与String是截然不同的

public static void main(String[] args) {
    StringBuffer a = new StringBuffer("A");
    StringBuffer b = new StringBuffer("B");
    operate(a,b);
    System.out.println(a+","+b);
}

private static void operate(StringBuffer x, StringBuffer y){
        x.append(y);
        y = x;
}

运行结果：
    AB,B

a=“AB” 因为StringBuffer不会指向新的对象，所以引用对象本身被拼接了
b!=“AB” 因为String类型一经改变会指向新的对象，改变的是y，而不是b

2.3StringBuffer与String的相互转化

​ StringBuffer的构造方法可将String转化为StringBuffer，而StringBuffer的toString方法可将StringBuffer转化为String

public class StringBufferTest {
    //去除字符串中的汉字
    public static String deal(String s){
        //将s由String转为StringBuffer的sb
        StringBuffer sb = new StringBuffer(s);
        //se用于存放处理后的结果
        StringBuffer se = new StringBuffer();
        char c;
        for(int i = 0; i<sb.length(); i++){
            c=sb.charAt(i);
            //如果是ASCII码，则保存到se中
            if(c>40 && c<127){se.append(c);}
        }
        return se.toString();//se 转换为String
    }
    public static void main(String[] args) {
        String str = "a英b雄c联d盟e";
        System.out.println(deal(str));
    }
}

运行结果：
    abcde

3.系统类和时间类

3.1System类

3.2Runtime类

​ 每个Java程序有且只有一个Runtime类的实例，允许应用程序与其进行的环境进行交互。要得到该类的实例，不能用new，只能调用该类的getRuntime方法
​ 它是System类中许多静态方法的真正执行者

3.3Date类

3.4Calender类

​ 对实践操作的主要类，同样不能用new，要调用其静态方法getInstance，之后再利用相应的对象方法

package com.calendar;

import java.util.Calendar;
import java.util.Date;

public class CalengarTest {
    public static void main(String[] args) {
        Calendar cd = Calendar.getInstance();
//        Date d = cd.getTime();
        System.out.println(cd.getTime().toString());
    }
}

运行结果：
    Tue Aug 04 11:09:51 CST 2020

4.格式化类

4.1格式化数字

4.1.1NumberFormat类

public class NumberFormatTest {
    /*NumberFormat类，该类提供了格式化4种数字的方法：
    * 整数、小数、货币和百分比，通过静态方法getIntegerInstance、
    * getNumberInstance、getCurrencyInstance、getPercentInstance
    * 方法获得相应格式化类的实例*/
    public static void main(String[] args) {
        NumberFormat integer = NumberFormat.getIntegerInstance();
        NumberFormat number = NumberFormat.getNumberInstance();
        NumberFormat currency = NumberFormat.getCurrencyInstance();
        NumberFormat percent = NumberFormat.getPercentInstance();
        System.out.println(integer.format(888.88));
        System.out.println(number.format(888.88));
        System.out.println(currency.format(888.88));
        System.out.println(percent.format(888.88));

    }
}

运行结果：
    889
	888.88
	￥888.88
	88,888%

4.1.2DecimalFormat类

public class DecimalFormatTest {
    public static void main(String[] args) {
        DecimalFormat df1 = new DecimalFormat("000");
        DecimalFormat df2 = new DecimalFormat("#,##0");
        DecimalFormat df3 = new DecimalFormat("0.0#%");
        System.out.println(df1.format(12345.54));
        System.out.println(df1.format(54));
        System.out.println(df2.format(12345));
        System.out.println(df3.format(0.4));
    }
}

运行结果：
    12346
    054
    12，345
    40.0%

4.2格式化日期

​ SimpleDateFormat类，其对象的format方法是将Date转为指定日期格式的String，而parse方法是将String转为Date

public class SimpleDateFormatTest {
    public static void main(String[] args) {
        SimpleDateFormat sdf1 = new SimpleDateFormat(
                "yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf1.format(new Date()));
        SimpleDateFormat sdf2 = new SimpleDateFormat(
                "yy-M-d HH:mm:ss");
        System.out.println(sdf2.format(new Date()));
        SimpleDateFormat sdf3 = new SimpleDateFormat(
                "yy-MMM-d HH:mm:ss");
        System.out.println(sdf3.format(new Date()));
    }
}

运行结果：
    2020-08-04 17:15:20
    20-8-4 17:15:20
    20-八月-4 17:15:20

5.BigDecimal和BigInteger

BigDecimal：常用来解决精确的浮点数运算

BigInteger：常用来解决超大的整数运算

创建对象：

BigDecimal.valueOf(2);

查用方法：

add(BigDecimal bd)： 做加法运算
substract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂

//测试BigDecimal类
public class TestBigDecimal {
    public static void main(String[] args) {
        //键入a,b
        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//不精确
        System.out.println("===上面的除法不精确===");
        BigDecimal bd1 = BigDecimal.valueOf(a);
        BigDecimal bd2 = BigDecimal.valueOf(b);
        BigDecimal bd3;
        bd3=bd1.add(bd2);
        System.out.println(bd3.doubleValue());
        bd3=bd1.subtract(bd2);
        System.out.println(bd3.doubleValue());
        bd3=bd1.multiply(bd2);
        System.out.println(bd3.doubleValue());
//           bd3=bd1.divide(bd2);//报错除不尽
        //保留位数和舍入方式
        bd3=bd1.divide(bd2,5,BigDecimal.ROUND_HALF_UP);
        bd3=bd3.setScale(2, BigDecimal.ROUND_HALF_UP);//保留两位
        System.out.println(bd3.doubleValue());
    }
}

//运行结果：
10
3
13.0
7.0
30.0
3.3333333333333335
===上面的除法不精确===
13.0
7.0
30.0
3.33