Java常用类

最新推荐文章于 2024-05-13 07:00:15 发布

Bonney_ 圆

最新推荐文章于 2024-05-13 07:00:15 发布

阅读量112

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_37725808/article/details/128403142

版权

Object类

object是所有类的父类，任何类都可以继承object
理论上Object类是所有类得父类，即直接或者间接得继承Java.lang.Object类，由于所有得类都继承在Object类因此省略了extends Object关键字
该类中主要的方法

toString()
getClass()
equals()
clone()
finalize()

1、clone()方法

    protected native Object clone() throws CloneNotSupportedException;

clone意思就是复制，在Java语言中给，clone方法被对象调用所以会复制对象意思就分配一个和源对象同样大小得空间，在Java语言中用有
1 使用new操作符创建一个对象
2 使用clone方法复制一个对象

那么这两种方式有什么相同和不同呢？ new操作符的本意是分配内存。程序执行到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。而clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部

复制对象 OR 复制引用
在Java中，以下类似的代码非常常见：

pe p = new pe("wang",52);
        pe p1 = p;
        System.out.println(p);   //objects.pe@1540e19d
        System.out.println(p1);  //objects.pe@1540e19d

打印的地址值是相同的，既然地址都是相同的，那么肯定是同一个对象。p和p1只是引用而已，他们都指向了一个相同的对象,这种现象叫引用复制
在这里插入图片描述

Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
System.out.println(p);  //Person@2f9ee1ac
System.out.println(p1); //Person@67f1fba0

在这里插入图片描述
2、toString()方法

public static toString(){
    return getClass().getName()+"@"+Inneger.toHexString(hasCode());

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”
和此对象哈希码的无符号十六进制表示组成。
该方法用得比较多，一般子类都有覆盖。
我们推荐在学习阶段所有有属性的类都加上toString() 方法！

public static void main(String args[]){
    Object o1 = new Object();
    System.out.println(o1.toString());

3、getClass()方法

public final native Class<?> getClass();

返回次Object的运行时类类型。
不可重写，要调用的话，一般和getName()联合使用，如getClass().getName();

Object o1 = new Object();
System.out.println(o1.getClass()); //class java.lang.Object

4、finalize()方法

  protected void finalize() throws Throwable { }

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
Java允许在类中定义一个名为finalize()的方法。它的工作原理是：一旦垃圾回收器准备好释放对象占用
的存储空间，将首先调用其finalize()方法。并且在下一次垃圾回收动作发生时，才会真正回收对象占用
的内存
关于垃圾回收，有三点需要记住：
1、对象可能不被垃圾回收。只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不
到释放。
2、垃圾回收并不等于“析构”。
【科普：析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完
毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟
了一片内存空间，delete会自动调用析构函数后释放内存）。】
3、垃圾回收只与内存有关。使用垃圾回收的唯一原因是为了回收程序不再使用的内存
finalize()的用途：
无论对象是如何创建的，垃圾回收器都会负责释放对象占据的所有内存。
这就将对finalize()的需求限制到一种特殊情况，即通过某种创建对象方式以外的方式为对象分配了存储
空间。不过这种情况一般发生在使用“本地方法”的情况下，本地方法是一种在Java中调用非Java代码的方式。

5、equals()方法

 public boolean equals(Object obj) {
        return (this == obj);
    }

Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参
obj所引用的对象是否是同一对象，
所谓同一对象就是指内存中同一块存储单元，如果this和obj指向的hi同一块内存对象，则返回true,如果
this和obj指向的不是同一块内存，则返回false。
注意：即便是内容完全相等的两块不同的内存对象，也返回false。
如果是同一块内存，则object中的equals方法返回true,如果是不同的内存，则返回false
如果希望不同内存但相同内容的两个对象equals时返回true,则我们需要重写父类的equal方法
String类已经重写了object中的equals方法（这样就是比较内容是否相等了）
【演示：查看String类源码equals方法】

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

6、hashCode()方法
返回该对象的哈希码值。
该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写
hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash Code() == obj2.hashCode()，但是
hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
7、wait()方法

 public final void wait() throws InterruptedException {
        wait(0);
    }
 public final native void wait(long timeout) throws InterruptedException;
 public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

可以看到有三种重载
在这里插入图片描述
方法中的异常：

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。
wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，
如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
8、notify()方法

public final native void notify();

该方法唤醒在该对象上等待的某个线程。

public final native void notifyAll();

该方法唤醒在该对象上等待的所有线程。

包装类

1、包装类介绍
虽然 Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类
型的数据不具备“对象”的特性——不携带属性、没有方法可调用。沿用它们只是为了迎合人类根深蒂固
的习惯，并的确能简单、有效地进行常规数据处理。
这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要
转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的toString()即可，而基本数据
类型转换为 String 类型则要麻烦得多。为解决此类问题，Java为每种基本数据类型分别设计了对应的
类，称之为包装类(Wrapper Classes)，也有教材称为外覆类或数据类型类。
在这里插入图片描述
每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一
经创建，其内容（所封装的基本类型数据值）不可改变。
基本类型和对应的包装类可以相互装换：
由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；
包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。
2、包装类的应用
【1、实现 int 和 Integer 的相互转换】
可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

public class IntInteger {
    public static void main(String[] args) {
        int s = 333;
        Integer obj = new Integer(s); //装箱
        int n = obj.intValue(); //拆箱
        System.out.println("n= "+n);
        Integer obj1 = new Integer(333);
        System.out.println("obj是否等价与obj1? "+obj.equals(obj1)); //true
    }
}

【2、将字符串转换为整数】
Integer 类有一个静态的 paseInt() 方法，可以将字符串转换为整数，语法为：

//s 为要转换的字符串，radix 为进制，可选，默认为十进制。
public static int parseInt(String s, int radix) throws NumberFormatException

下面将展示什么字符串会转换为整数

String[] str = {"23","ew23","22wrw2","ddsd"};
        for(String str1:str){
            try {
                int m = Integer.parseInt(str1,10);
                System.out.println("str1转换为整数："+m);
            }catch (Exception e){
                System.out.println(str1+" 无法转换");
            }
        }
 //结果
str1转换为整数：23
ew23 无法转换
22wrw2 无法转换
ddsd 无法转换

【 3、将整数转换为字符串】
Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串。或者直接在整数后面加空字符串即可！

 int a = 411;
 String str2 = Integer.toString(a);
 String str3 = a +" ";
 System.out.println(str3);

3、自动拆箱和装箱
上面的例子都需要手动实例化一个包装类，称为手动拆箱装箱。Java 1.5(5.0) 之前必须手动拆箱装箱。
Java 1.5 之后可以自动拆箱装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进
行，这将大大方便程序员的代码书写。

public static void main(String[] args) {
        int a= 700;
        Integer m = a; //装箱
        int n =m;  //拆箱
        System.out.println("n = "+n);
        Integer m1 = 700;
        System.out.println("n是否等价与m1? "+m.equals(m1));
    }
    //结果
n = 700
n是否等价与m1? true

自动装箱与拆箱的功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的语法，决定是否进
行装箱或拆箱动作。例如

Integer i = 100; "等价与"  Integer i = new Integer(100);

所以自动装箱与拆箱的功能是所谓的“编译器蜜糖”(Compiler Sugar)，虽然使用这个功能很方便，但在程
序运行阶段您得了解Java的语义。例如下面的程序是可以通过编译的：

//编译时正常，运行时报错
Integer i = null;
int j = i;

因为这种写法相当于：

Integer i = null;
int j = i.intValue();

null表示i 没有参考至任何的对象实体，它可以合法地指定给对象参考名称。由于实际上i并没有参考至任
何的对象，所以也就不可能操作intValue()方法，这样上面的写法在运行时会出现NullPointerException错误
自动拆箱装箱是常用的一个功能，需要重点掌握。
一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
**

Math类

**
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
【演示：查看Math类的源码】

public final class Math {}

【常用值与函数】
Math.PI 记录的圆周率
Math.E 记录e的常量
Math中还有一些类似的常量，都是一些工程数学常用量。
Math.abs 求绝对值
Math.sin 正弦函数 Math.asin 反正弦函数
Math.cos 余弦函数 Math.acos 反余弦函数
Math.tan 正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数
Math.toDegrees 弧度转化为角度 Math.toRadians 角度转化为弧度
Math.ceil 得到不小于某数的最大整数
Math.floor 得到不大于某数的最大整数
Math.IEEEremainder 求余
Math.max 求两数中最大
Math.min 求两数中最小
Math.sqrt 求开方
Math.pow 求某数的任意次方, 抛出ArithmeticException处理溢出异常
Math.exp 求e的任意次方
Math.log10 以10为底的对数
Math.log 自然对数
Math.rint 求距离某数最近的整数（可能比某数大，也可能比它小）
Math.round 同上，返回int型或者long型（上一个函数返回double型）
Math.random 返回0，1之间的一个随机数

    public static void main(String[] args) {
/**
 *Math.sqrt()//计算平方根
 *Math.cbrt()//计算立方根
 *Math.pow(a, b)//计算a的b次方
 *Math.max( , );//计算最大值
 *Math.min( , );//计算最小值
 */
        System.out.println(Math.sqrt(16)); //4.0
        System.out.println(Math.cbrt(8)); //2.0
        System.out.println(Math.pow(3, 2)); //9.0
        System.out.println(Math.max(2.3, 4.5));//4.5
        System.out.println(Math.min(2.3, 4.5));//2.3
/**
 * abs求绝对值
 */
        System.out.println(Math.abs(-10.4)); //10.4
        System.out.println(Math.abs(10.1)); //10.1
/**
 * ceil天花板的意思，就是返回大的值
 */
        System.out.println(Math.ceil(-10.1)); //-10.0
        System.out.println(Math.ceil(10.7)); //11.0
        System.out.println(Math.ceil(-0.7)); //-0.0
        System.out.println(Math.ceil(0.0)); //0.0
        System.out.println(Math.ceil(-0.0)); //-0.0
        System.out.println(Math.ceil(-1.7)); //-1.0
/**
 * floor地板的意思，就是返回小的值
 */
        System.out.println(Math.floor(-10.1)); //-11.0
        System.out.println(Math.floor(10.7)); //10.0
        System.out.println(Math.floor(-0.7)); //-1.0
        System.out.println(Math.floor(0.0)); //0.0
        System.out.println(Math.floor(-0.0)); //-0.0
/**
 * random 取得一个大于或者等于0.0小于不等于1.0的随机数 [0,1)
 */
        System.out.println(Math.random()); //小于1大于0的double类型的数
        System.out.println(Math.random() + 1);//大于1小于2的double类型的数
/**
 * rint 四舍五入，返回double值
 * 注意.5的时候会取偶数 异常的尴尬=。=
 */
        System.out.println(Math.rint(10.1)); //10.0
        System.out.println(Math.rint(10.7)); //11.0
        System.out.println(Math.rint(11.5)); //12.0
        System.out.println(Math.rint(10.5)); //10.0
        System.out.println(Math.rint(10.51)); //11.0
        System.out.println(Math.rint(-10.5)); //-10.0
        System.out.println(Math.rint(-11.5)); //-12.0
        System.out.println(Math.rint(-10.51)); //-11.0
        System.out.println(Math.rint(-10.6)); //-11.0
        System.out.println(Math.rint(-10.2)); //-10.0
/**
 * round 四舍五入，float时返回int值，double时返回long值
 */
        System.out.println(Math.round(10.1)); //10
        System.out.println(Math.round(10.7)); //11
        System.out.println(Math.round(10.5)); //11
        System.out.println(Math.round(10.51)); //11
        System.out.println(Math.round(-10.5)); //-10
        System.out.println(Math.round(-10.51)); //-11
        System.out.println(Math.round(-10.6)); //-11
        System.out.println(Math.round(-10.2)); //-10
    }

Random类

**
ava中存在着两种Random函数：

一、java.lang.Math.Random;
调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是
[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。例子如下：

public static void main(String[] args) {
        System.out.println("Math.Random "+Math.random());
        int i = (int) (Math.random()*3);
        System.out.println(i);
    }
 //结果
Math.Random 0.9590517420499478
0

二、java.util.Random
下面是Random()的两种构造方法：
Random()：创建一个新的随机数生成器。
Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。
你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。
如下面的Java代码：
【演示一】
在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
rand.nextInt(100)中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

    public static void main(String[] args) {
        Random random = new Random();
        int i = random.nextInt(100);
        System.out.println(i);
    }
    //结果
    49

【演示二】
对于种子相同的Random对象，生成的随机数序列是一样的。
【方法摘要】

protected int next(int bits)：生成下一个伪随机数。
boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

日期时间类

1、Date类
java.util 包提供了 Date 类来封装当前的日期和时间。
Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。

 public Date() {
        this(System.currentTimeMillis());
    }

第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

public Date(long date) {
        fastTime = date;
    }

Date对象创建以后，可以调用下面的方法。
在这里插入图片描述
【演示：获取当前日期时间】
Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间
如下所示：

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.toString());
}
//结果
Sat May 06 11:13:10 CST 2023

【演示：日期比较】
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。

public static void main(String[] args) {
        Date date = new Date();
        long time1 = date.getTime();
        long time2 = date.getTime();

使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2,12).before(new Date (99, 2, 18)) 返回true。

boolean before = new Date(97,01,05).before(new Date(99,11,16));
        System.out.println(before);

2、SimpleDateFormat
【演示：使用 SimpleDateFormat 格式化日期】
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许
你选择任何用户自定义日期时间格式来运行。例如：

Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(simpleDateFormat.format(date));

其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。
注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。
时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：
在这里插入图片描述
【演示：使用printf格式化日期】
printf方法使用说明
printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

public static void main(String[] args) {
        Date date = new Date();
        //c的作用
        System.out.printf("全部日期和时间信息：%tc%n",date);
        //F的作用
        System.out.printf("年-月-日格式：%tF%n",date);
        //d的作用
        System.out.printf("月/日/年格式：%td%n",date);
        //r的作用
        System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
        //T的作用
        System.out.printf("HH:MM:SS PM格式（24时制）：%tT%n",date);
        //R的作用
        System.out.printf("HH:MM PM格式（24时制）：%tR%n",date);
       
//结果
全部日期和时间信息：星期六 五月 06 14:26:56 CST 2023
年-月-日格式：2023-05-06
月/日/年格式：06
HH:MM:SS PM格式（12时制）：02:26:56 下午
HH:MM:SS PM格式（24时制）：14:26:56
HH:MM PM格式（12时制）：14:26

【时间休眠：休眠(sleep)】
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。你可以让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。例如，下面的程序会休眠3秒：

public static void main(String args[]) {
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3); // 休眠3秒
            System.out.println(new Date( ) + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }

3、Calendar类
我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar类。Date中有很多方法都已经废弃了！Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

创建一个代表系统当前日期的Calendar对象

public static void main(String args[]) {
        Calendar calendar = Calendar.getInstance(); //默认当前日期
        System.out.println(calendar);
//结果
java.util.GregorianCalendar[time=1683355182477,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=2023,MONTH=4,WEEK_OF_YEAR=18,WEEK_OF_MONTH=1,DAY_OF_MONTH=6,DAY_OF_YEAR=126,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MINUTE=39,SECOND=42,MILLISECOND=477,ZONE_OFFSET=28800000,DST_OFFSET=0]

创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

Calendar calendar = Calendar.getInstance();
calendar.set(2023,05,05);

Calendar类对象字段类型
Calendar类中用以下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
在这里插入图片描述

public static void main(String args[]) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2023,05,05);
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH)+1;
        int date =calendar.get(Calendar.DATE);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        int week = calendar.get(Calendar.DAY_OF_WEEK);

【演示：设置某个字段】

calendar.set(Calendar.DATE,10);
calendar.set(Calendar.YEAR,2022);

【add设置】

//calendar对象的日期加上10，也就是calendar也就表示为10天后的日期，其它所有的数值会被重新计算
calendar.add(Calendar.DATE,10);
//calendar对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
calendar.add(Calendar.DATE,-10);

【演示：GregorianCalendar】

String months[] = {"Jan", "Feb", "Mar", "Apr","May", "Jun", "Jul", "Aug","Sep", "Oct", "Nov", "Dec"};
int year;
// 初始化 Gregorian 日历
// 使用当前时间和日期
// 默认为本地时间和时区
GregorianCalendar gcalendar = new GregorianCalendar();
// 显示当前时间和日期的信息
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// 测试当前年份是否为闰年
if(gcalendar.isLeapYear(year)) {
System.out.println("当前年份是闰年");
}
else {
System.out.println("当前年份不是闰年");
}
}

String类

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

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

【String的成员变量】

private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

从源码看出String底层使用一个字符数组来维护的。
成员变量可以知道String类的值是final类型的，不能被改变的，所以只要一个值改变就会生成一个新的
String类型对象，存储String数据也不一定从数组的第0个元素开始的，而是从offset所指的元素开始。
【String的构造方法】

String()
//初始化一个新创建的 String 对象，使其表示一个空字符序列。
String(byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, Charset charset)
//通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, int offset, int length)
//通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, Charset charset)
//通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, int offset, int length, String charsetName)
//通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。
String(byte[] bytes, String charsetName)
//通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
String(char[] value)
//分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String(char[] value, int offset, int count)
//分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
String(int[] codePoints, int offset, int count)
//分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
String(String original)
//初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
String(StringBuffer buffer)
//分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
String(StringBuilder builder)
//分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

2、创建字符串对象方式
直接赋值方式创建对象是在方法区的常量池

String str = "hello"

通过构造方法创建字符串对象是在堆内存

String str = new String("hello")

【两种实例化方式的比较】

编写代码比较

public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        String str3 = str2; //引用传递，str3直接指向str2的堆内存地址
        String str4 = "hello";
        /**
         * ==:
         * 基本数据类型：比较的是基本数据类型的值是否相同
         * 引用数据类型：比较的是引用数据类型的地址值是否相同
         * 所以在这里的话：String类对象==比较，比较的是地址，而不是内容
         */
        System.out.println(str1==str2);//false
        System.out.println(str1==str3);//false
        System.out.println(str3==str2);//true
        System.out.println(str1==str4);//true
    }

内存图分析

可能这里还是不够明显，构造方法实例化方式的内存图：String str = new String(“Hello”);
首先：

当我们再一次的new一个String对象时：

【字符串常量池】
在字符串中，如果采用直接赋值的方式（String str=“Lance”）进行对象的实例化，则会将匿名对象“Lance”放入对象池，每当下一次对不同的对象进行直接赋值的时候会直接利用池中原有的匿名对象，我们可以用对象手工入池；

public static void main(String[] args) {

        String str = new String("hello").intern();  //对匿名对象hello进行手工入池操作
        String str1 = "hello";
        System.out.println(str == str1); //true

【两种实例化方式的区别】

直接赋值（String str = “hello”）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。
构造方法（String str= new String(“hello”);）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。
在开发的过程中不会采用构造方法进行字符串的实例化
【避免空指向】
首先了解： == 和public boolean equals()比较字符串的区别==在对字符串比较的时候，对比的是内存地址，而equals比较的是字符串内容，在开发的过程中，equals()通过接受参数，可以避免空指向。

String str = null;
if(str.equals("hello")){//此时会出现空指向异常
...
}
if("hello".equals(str)){//此时equals会处理null值，可以避免空指向异常
...
}

【String类对象一旦声明则不可以改变；而改变的只是地址，原来的字符串还是存在的，并且产生垃圾】
在这里插入图片描述
3、String常用的方法

1、String的判断
【常用方法】

    public boolean equals(Object obj) //比较字符串的内容是否相同
    public boolean equalsIgnoreCase(String str) //比较字符串的内容是否相同,忽略大小写
    public boolean startsWith(String str) //判断字符串是否是以指定str开头
    public boolean endsWith(String str) //判断字符串是否是以指定str结尾

【演示】

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "Hello";

        System.out.println(s1.equals(s2)); //true
        System.out.println(s1.equals(s3));  //false

        System.out.println(s1.equalsIgnoreCase(s3)); //true
        System.out.println(s1.equalsIgnoreCase(s2)); //true

        System.out.println(s1.startsWith("he")); //true
        System.out.println(s1.endsWith("ll")); //false

2、String的截取
【常用方法】

public int length() //获取字符串的长度
public char charAt(int index) //获取指定索引处的字符
public int indexOf(String str) //获取str在字符串对象中第一次出现的索引位置
public String substring(int start) //从start处截取字符串
public String substring(int start,int end) //从start开始到end结束截取字符串 包括start 不包括end

public static void main(String[] args) {
        String str = "Helloworld";

        System.out.println(str.length());
        System.out.println(str.charAt(1));
        System.out.println(str.indexOf("l"));
        System.out.println(str.substring(3));
        System.out.println(str.substring(2,8));

3、String的转换
【常用方法】

char[] toCharArray() //把字符串转换为字符数组
String toLowerCase()  //把字符串转换为小写字符串
String toUpperCase()  //把字符串转换为大写字符串

public static void main(String[] args) {
        String str = "Helloworld";
        char[] chars = str.toCharArray();
        for (int i=0;i<chars.length;i++){
            System.out.println(chars[i]);
        }

        System.out.println(str.toLowerCase());
        System.out.println(str.toUpperCase());

4、其他方法
【常用方法】

String trim() //去除字符串两端的空格
String[] split(String str) //按照指定字符号分割字符串

public static void main(String[] args) {
        String str = "  hello wrold  ";
        System.out.println(str.trim());
        String str1 = "qq,bb,cc,dd";
        String[] s = str1.split(",");
        for (int i=0;i<s.length;i++){
            System.out.println(s[i]);
        }

4、String的不可变性
我想大家应该就知道为什么String不可变了，String类被final修饰，官方注释说明创建后不能被改变，但是为什么String要使用final修饰呢？
【了解一个经典的面试题】

public static void main(String[] args) {
	String a = "abc";
	String b = "abc";
	String c = new String("abc");
	System.out.println(a==b); //true
	System.out.println(a.equals(b)); //true
	System.out.println(a==c); //false
	System.out.println(a.equals(c)); //true
}

内存分析
在这里插入图片描述
【分析】
因为String太过常用，JAVA类库的设计者在实现时做了个小小的变化，即采用了享元模式,每当生成一个
新内容的字符串时，他们都被添加到一个共享池中，当第二次再次生成同样内容的字符串实例时，就共
享此对象，而不是创建一个新对象，但是这样的做法仅仅适合于通过=符号进行的初始化。
需要说明一点的是，在object中，equals()是用来比较内存地址的，但是String重写了equals()方
法，用来比较内容的，即使是不同地址，只要内容一致，也会返回true，这也就是为什么a.equals©返
回true的原因了。
【String不可变的好处】
1.可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。
2.我们的程序中大量使用了String字符串，有可能是出于安全性考虑。
3.大家都知道HashMap中key为String类型，如果可变将变的多么可怕。
4.当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的
5.话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失。
5、字符串常量池
【字符串常量池概述】

常量池表（Constant_Pool table）
Class文件中存储所有常量（包括字符串）的table。这是Class文件中的内容，还不是运行时的内容，不要理解它是个池子，其实就是Class文件中的字节码指令。
运行时常量池（Runtime Constant Pool）
JVM内存中方法区的一部分，这是运行时的内容。这部分内容（绝大部分）是随着JVM运行时候，从常量池转化而来，每个Class对应一个运行时常量池。上一句中说绝大部分是因为：除了 Class中常量池内容，还可能包括动态生成并加入这里的内容。
字符串常量池（String Pool）
这部分也在方法区中，但与Runtime Constant Pool不是一个概念，String Pool是JVM实例全局共享的，全局只有一个。JVM规范要求进入这里的String实例叫“被驻留的interned string”，各个JVM可以有不同的实现，HotSpot是设置了一个哈希表StringTable来引用堆中的字符串实例，被引用就是被驻留。
【亨元模式】
其实字符串常量池这个问题涉及到一个设计模式，叫“享元模式”，顾名思义 - - - > 共享元素模式也就是说：一个系统中如果有多处用到了相同的一个元素，那么我们应该只存储一份此元素，而让所有地方都引用这一个元素 Java中String部分就是根据享元模式设计的，而那个存储元素的地方就叫做“字符串常量池 - String Pool”
【详细分析】

int x = 10;
String y = "hello"

首先， 10 和 “hello” 会在经过javac（或者其他编译器）编译过后变为Class文件中
constant_pool table 的内容
当我们的程序运行时，也就是说JVM运行时，每个Class constant_pool table 中的内容会被加
载到JVM内存中的方法区中各自Class的 Runtime Constant Pool。
一个没有被String Pool包含的Runtime Constant Pool中的字符串（这里是"hello"）会被加入到
String Pool中（HosSpot使用hashtable引用方式），步骤如下：
在Java Heap（堆）中根据"hello"字面量create一个字符串对象
将字面量"hello"与字符串对象的引用在hashtable中关联起来键 - 值形式是：“hello” = 对象的引用地址。
另外来说，当一个新的字符串出现在Runtime Constant Pool中时怎么判断需不需要在Java Heap中创建新对象呢？
策略是这样：会先去根据equals来比较Runtime Constant Pool中的这个字符串是否和String Pool中某一个是相等的（也就是找是否已经存在），如果有那么就不创建，直接使用其引用；反之，就如同上面的第三步。如此，就实现了享元模式，提高的内存利用效率。
举例：

使用String s = new String("hello");会创建几个对象
答：会创建2个对象
首先，出现了字面量"hello"，那么去String Pool中查找是否有相同字符串存在，因为程序就这一行
代码所以肯定没有，那么就在Java Heap中用字面量"hello"首先创建1个String对象。
接着，new String("hello")，关键字new又在Java Heap中创建了1个对象，然后调用接收String
参数的构造器进行了初始化。最终s的引用是这个String对象.

StringBuilder 和 StringBuffer

**
源码

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口。StringBuffer 也是继承于AbstractStringBuilder的子类；但是，StringBuilder和StringBuffer不同，前者是非线程安全的，后者是线程安全的。
StringBuilder 和 CharSequence之间的关系图如下
在这里插入图片描述
2、常用方法

1.insert

private static void testInsertAPIs(){
	System.out.println("---------- testInsertAPIs -----------");
	StringBuilder sbuilder = new StringBuilder();
	// 在位置0处插入字符数组
	sbuilder.insert(0, new char[]{'a', 'b', 'c', 'd', 'e'});
	// 在位置0处插入字符数组。0表示字符数组起始位置，3表示长度
	sbuilder.insert(0, new char[]{'A', 'B', 'C', 'D', 'E'}, 0, 3);
	// 在位置0处插入float
	sbuilder.insert(0, 1.414f);
	// 在位置0处插入double
	sbuilder.insert(0, 3.14159d);
	// 在位置0处插入boolean
	sbuilder.insert(0, true);
	// 在位置0处插入char
	sbuilder.insert(0, '\n');
	// 在位置0处插入int
	sbuilder.insert(0, 100);
	// 在位置0处插入long
	sbuilder.insert(0, 12345L);
	// 在位置0处插入StringBuilder对象
	sbuilder.insert(0, new StringBuilder("StringBuilder"));
	// 在位置0处插入StringBuilder对象。6表示被在位置0处插入对象的起始位置(包括)，13是
	结束位置(不包括)
	sbuilder.insert(0, new StringBuilder("STRINGBUILDER"), 6, 13);
	// 在位置0处插入StringBuffer对象。
	sbuilder.insert(0, new StringBuffer("StringBuffer"));
	// 在位置0处插入StringBuffer对象。6表示被在位置0处插入对象的起始位置(包括)，12是结
	束位置(不包括)
	sbuilder.insert(0, new StringBuffer("STRINGBUFFER"), 6, 12);
	// 在位置0处插入String对象。
	sbuilder.insert(0, "String");
	// 在位置0处插入String对象。1表示被在位置0处插入对象的起始位置(包括)，6是结束位置(不包括)
	sbuilder.insert(0, "0123456789", 1, 6);
	sbuilder.insert(0, '\n');
	// 在位置0处插入Object对象。此处以HashMap为例
	HashMap map = new HashMap();
	map.put("1", "one");
	map.put("2", "two");
	map.put("3", "three");
	sbuilder.insert(0, map);
	System.out.printf("%s\n\n", sbuilder);
}

2、append

/**
* StringBuilder 的append()示例
*/
private static void testAppendAPIs() {
	System.out.println("------------------- testAppendAPIs -----------------
	--");
	StringBuilder sbuilder = new StringBuilder();
	// 追加字符数组
	sbuilder.append(new char[]{'a','b','c','d','e'});
	// 追加字符数组。0表示字符数组起始位置，3表示长度
	sbuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);
	// 追加float
	sbuilder.append(1.414f);
	// 追加double
	sbuilder.append(3.14159d);
	// 追加boolean
	sbuilder.append(true);
	// 追加char
	sbuilder.append('\n');
	// 追加int
	sbuilder.append(100);
	// 追加long
	sbuilder.append(12345L);
	// 追加StringBuilder对象
	sbuilder.append(new StringBuilder("StringBuilder"));
	// 追加StringBuilder对象。6表示被追加对象的起始位置(包括)，13是结束位置(不包括)
	sbuilder.append(new StringBuilder("STRINGBUILDER"), 6, 13);
	// 追加StringBuffer对象。
	sbuilder.append(new StringBuffer("StringBuffer"));
	// 追加StringBuffer对象。6表示被追加对象的起始位置(包括)，12是结束位置(不包括)
	sbuilder.append(new StringBuffer("STRINGBUFFER"), 6, 12);
	// 追加String对象。
	sbuilder.append("String");
	// 追加String对象。1表示被追加对象的起始位置(包括)，6是结束位置(不包括)
	sbuilder.append("0123456789", 1, 6);
	sbuilder.append('\n');
	// 追加Object对象。此处以HashMap为例
	HashMap map = new HashMap();
	map.put("1", "one");
	map.put("2", "two");
	map.put("3", "three");
	sbuilder.append(map);
	sbuilder.append('\n');
	// 追加unicode编码
	sbuilder.appendCodePoint(0x5b57); // 0x5b57是“字”的unicode编码
	sbuilder.appendCodePoint(0x7b26); // 0x7b26是“符”的unicode编码
	sbuilder.appendCodePoint(0x7f16); // 0x7f16是“编”的unicode编码
	sbuilder.appendCodePoint(0x7801); // 0x7801是“码”的unicode编码
	System.out.printf("%s\n\n", sbuilder);

3、replace

/**
* StringBuilder 的replace()示例
*/
private static void testReplaceAPIs() {
	System.out.println("------------------- testReplaceAPIs-----------------
	--");
	StringBuilder sbuilder;
	sbuilder = new StringBuilder("0123456789");
	sbuilder.replace(0, 3, "ABCDE");
	System.out.printf("sbuilder=%s\n", sbuilder);
	sbuilder = new StringBuilder("0123456789");
	sbuilder.reverse();
	System.out.printf("sbuilder=%s\n", sbuilder);
	sbuilder = new StringBuilder("0123456789");
	sbuilder.setCharAt(0, 'M');
	System.out.printf("sbuilder=%s\n", sbuilder);
	System.out.println();
}

4、delete

private static void testDeleteAPIs() {
	System.out.println("------------------- testDeleteAPIs -------------------");
	StringBuilder sbuilder = new StringBuilder("0123456789");
	// 删除位置0的字符，剩余字符是“123456789”。
	sbuilder.deleteCharAt(0);
	// 删除位置3(包括)到位置6(不包括)之间的字符，剩余字符是“123789”。
	sbuilder.delete(3,6);
	// 获取sb中从位置1开始的字符串
	String str1 = sbuilder.substring(1);
	// 获取sb中从位置3(包括)到位置5(不包括)之间的字符串
	String str2 = sbuilder.substring(3, 5);
	// 获取sb中从位置3(包括)到位置5(不包括)之间的字符串，获取的对象是CharSequence对
	象，此处转型为String
	String str3 = (String)sbuilder.subSequence(3, 5);
	System.out.printf("sbuilder=%s\nstr1=%s\nstr2=%s\nstr3=%s\n",
	sbuilder, str1, str2, str3);

5、index

/**
* StringBuilder 中index相关API演示
*/
private static void testIndexAPIs() {
	System.out.println("--------------------------------testIndexAPIs --------------------------------");
	StringBuilder sbuilder = new StringBuilder("abcAbcABCabCaBcAbCaBCabc");
	System.out.printf("sbuilder=%s\n", sbuilder);
	// 1. 从前往后，找出"bc"第一次出现的位置
	System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")",
	sbuilder.indexOf("bc"));
	// 2. 从位置5开始，从前往后，找出"bc"第一次出现的位置
	System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)",
	sbuilder.indexOf("bc", 5));
	// 3. 从后往前，找出"bc"第一次出现的位置
	System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")",
	sbuilder.lastIndexOf("bc"));
	// 4. 从位置4开始，从后往前，找出"bc"第一次出现的位置
	System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)",
	sbuilder.lastIndexOf("bc", 4));
	System.out.println();
}

6、其他API

private static void testOtherAPIs() {
System.out.println("----------- testOtherAPIs -----------");
StringBuilder sbuilder = new StringBuilder("0123456789");
int cap = sbuilder.capacity();
System.out.printf("cap=%d\n", cap);
/*
capacity()返回的是字符串缓冲区的容量
StringBuffer( ); 分配16个字符的缓冲区
StringBuffer( int len ); 分配len个字符的缓冲区
StringBuffer( String s ); 除了按照s的大小分配空间外,再分配16个 字符的缓冲区
你的StringBuffer是用字符构造的，"0123456789"的长度是10另外再分配16个字符，所
以一共是26。
*/
char c = sbuilder.charAt(6);
System.out.printf("c=%c\n", c);
char[] carr = new char[4];
sbuilder.getChars(3, 7, carr, 0);
for (int i=0; i<carr.length; i++){
System.out.printf("carr[%d]=%c ", i, carr[i]);
}
System.out.println();
}

3、StringBuffer
和StringBulider用法差不多，不过多介绍，主要看一下三者的区别
4、小结
【String、StringBuffer、StringBuilder之间的区别】
首先需要说明的是：

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

在大多数情况下三者在执行速度方面的比较：StringBuilder > StringBuffer > String

File类

**
1、File类的基本用法

java.io.File类：文件和目录路径名的抽象表示形式

public File(String pathname)

以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。

File的静态属性String separator存储了当前系统的路径分隔符。
通过File对象可以访问文件的属性。

public boolean canRead()
public boolean exists()
public boolean isFile()
public long lastModified()
public String getName()
public boolean canWrite()
public boolean isDirectory()
public boolean isHidden()
public long length()
public String getPath()

通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。

public boolean createNewFile()throws IOException
public boolean delete()
public boolean mkdir()， mkdirs()

【演示】

import java.io.File;
import java.io.IOException;
public class TestFile {
/**
* File文件类 1.代表文件 2.代表目录
*/
public static void main(String[] args) {
	File f = new File("d:/src3/TestObject.java");
	File f2 = new File("d:/src3");
	File f3 = new File(f2, "TestFile.java");
	File f4 = new File(f2, "TestFile666.java");
	File f5 = new File("d:/src3/aa/bb/cc/dd");
	//f5.mkdirs();
	f5.delete();
	try {
	f4.createNewFile();
	System.out.println("文件创建成功！");
	} catch (IOException e) {
	e.printStackTrace();
	}
	if (f.isFile()) {
	System.out.println("是一个文件！");
	}
	if (f2.isDirectory()) {
	System.out.println("是一个目录！");
	}
	if (f3.isFile()) {
	System.out.println("是一个文件奥");
	}
}