java学习（5.常用类）

Object类

hashCode()

• 概念

public native int hashCode();

目的：返回对象的哈希码值，即对象内存地址经过哈希算法转换的一个数字。可以等同看做内存地址。

toString()

• 概念

//源码
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

  - 源代码上toString()方法实现：
    		类名@对象的内存地址转换为十六进制的形式
  - 作用：将java类型的格式转换成字符串
  - 建议所有子类重写toString()

• 注意点：
  未重写：（类名@对象的内存地址转换为十六进制的形式）
  例如：com.CommonlyUsedClass.MyTime@154617c
  重写后： 输出重写后的指定格式
  例如：1998年11月23日
  输出引用时，自动调用该引用的toString()方法
• 参考示例

//ToStringMethond类
 public class ToStringMethond{
    public static void main(String[] args) {
        Object a = 0;
        System.out.println(a.toString());
        
        MyTime myTime=new MyTime(1998,11,23);
        //toString 未重写，输出com.CommonlyUsedClass.MyTime@154617c（类名@对象的内存地址转换为十六进制的形式）
        //toString 重写后， 输出1998年11月23日
        System.out.println(myTime.toString());
        //输出引用时，自动调用该引用的toString()方法
        System.out.println(myTime);
    }
}
//MyTime类
class MyTime {
    int year;
    int month;
    int day;    
    //无参构造
    public MyTime() {
    }
    //有参构造
    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    //重写toString()方法
    @Override
    public String toString() {
        return year +"年" + month + "月" + day + "日";
    }
}

• 重写toString() 快捷键:alt+insert
  

clone()

• 概念

protected native Object clone() throws CloneNotSupportedException;

• 目的：实现对象的浅复制，即创建并返回此对象的一个副本。“副本”的准确含义可能依赖于对象的类。
• 注意只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
• 参考示例

public class CloneMethond {
//注意只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
    public static void main(String[] args) throws CloneNotSupportedException {
        MyTime myTime =new MyTime(1998,11,23);
        MyTime myTime1 = (MyTime) myTime.clone();
        System.out.printf(myTime1.toString());

    }
}
//要实现实现Cloneable接口才能调用clone()
public class MyTime implements Cloneable {
    int year;
    int month;
    int day;

    //无参构造
    public MyTime() {
    }

    //有参构造
    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    //重写toString()方法
    @Override
    public String toString() {
        return year + "年" + month + "月" + day + "日";
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return (MyTime)super.clone();
    }
}

getClass()

• 概念

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

• 目的： 返回getClass().getName() + ‘@’ + Integer.toHexString(hashCode())，即类名+’@’+Integer.toHexString(hashCode())
• 一般与getName() 一起使用
• 参考示例：
  XXX类.getClass().getName()
  返回结果：XXX包名.XXX包名…XXX类名
  例如：com.CommonlyUsedClass.MyTime

notify()和wait()

• notify() 和 wait() 主要是用来多个线程之间的协作。
  wait() ：导致当前线程等待，直到另一个线程调用该对象的notify()或者notifyAll()方法
  notify() ：唤醒正在等待对象监视器的单个线程。
  
• wait()​ wait()提供三种构造方法，但前两种最为常用，wait()是让线程一直处于等待状态，直到手动唤醒，而wait(long timeout)可以指定等待时间，之后会自动唤醒。
  调用wait方法可以让当前线程进入等待唤醒状态，该线程会处于等待唤醒状态直到另一个线程调用了object对象的notify方法或者notifyAll方法。
• notify()
  ​​ notify()唤醒等待的线程，如果监视器种只有一个等待线程，使用notify()可以唤醒。但是如果有多条线程notify()是随机唤醒其中一条线程，与之对应的就是notifyAll()就是唤醒所有等待的线程
• 参考案例

//​ 1，定义线程。
public class SetTarget implements Runnable {
    private Demo demo;

    public SetTarget(Demo demo) {
        this.demo = demo;
    }
    @Override
    public void run() {
        demo.set();
    }
}
public class GetTarget implements Runnable {
    private Demo demo;
    public GetTarget(Demo demo) {
        this.demo = demo;
    }
    @Override
    public void run() {
        demo.get();
    }
}

//​ 2，编写main方法。
public class Demo {

    // 定义一个信号量
    private volatile int signal;

    public static void main(String[] args) {

        Demo demo = new Demo();
        SetTarget set = new SetTarget(demo);
        GetTarget get = new GetTarget(demo);

        // 开启线程，
        new Thread(get).start();
        new Thread(get).start();
        new Thread(get).start();
        new Thread(get).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(set).start();
    }

    // set方法唤醒线程
    public synchronized void set() {
        signal = 1;
        // notify方法会随机叫醒一个处于wait状态的线程
//        notify();
        // notifyAll叫醒所有的处于wait线程，争夺到时间片的线程只有一个
        notifyAll();
        System.out.println("叫醒线程叫醒之后休眠开始...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // get方法使线程进入等待状态
    public synchronized int get() {
        System.out.println(Thread.currentThread().getName() + " 方法执行了...");
        if (signal != 1) {
            try {
                wait();
                System.out.println("叫醒之后");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 方法执行完毕...");
        return signal;
    }
}

转载地址：https://www.cnblogs.com/fenjyang/p/11603229.html
https://www.cnblogs.com/fanerwei222/p/11398563.html

finalize()

• 概念

protected void finalize() throws Throwable { }

• 目的：在垃圾回收时由垃圾收集器在对象上调用
  Called by the garbage collector on an object when garbage collection
  由GC：负责调用

• finalize()只有一个方法体，里面没有代码，这个方法由protected 修饰

• 该方法不用程序员手动调用，由JVW的垃圾回收器来调用，所有finalize()只需要负责重写就好了，会被自动调用。

• 参考示例

public class FinalizeMenthond {
    public static void main(String[] args) {
        //方法1：数量达到一定数量后才会经行垃圾回收
        for(int i=0;i<100000;i++){
            MyTime myTime = new MyTime(1998,11,23);
            //把myTime处理为垃圾
            myTime=null;
        }
        //方法2：建议启动垃圾处理器，只是建议，可能不启动
        MyTime myTime1 = new MyTime(1998,11,23);
        //把myTime处理为垃圾
        myTime1=null;
        System.gc();
    }
}

public class MyTime {
    int year;
    int month;
    int day;

    //无参构造
    public MyTime() {
    }

    //有参构造
    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    //重写finalize（）方法
    @Override
    protected void finalize() throws Throwable {
        System.out.println("即将销毁！");
        super.finalize();
    }
}

equals()

• 概念

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

• 目的：通过equals方法判断两个对象是否相等，
  （比较："==" 为什么不行，因为它比较的是两个对象的内存地址是否相同）
• 官方给的equals方法使用的是"=="进行的比较，由示例得他是是不够用的,需要重写
  equals重写要彻底，当类套类的时候，被套的类里面equals方法也要重写
• 参考示例

//EqualsMethond类
public class EqualsMethond {
    public static void main(String[] args) {
        //判断两个基本数据类型是否一致，使用"=="就可以
        int a=100;
        int b=100;
        //比较a中保存的100与b中保存的100是否相等
        System.out.println(a==b);

        //判断两个java类型是否一致，不能使用"=="
        MyTime myTime1 = new MyTime(1998,11,23); //myTime1 = 0x1234
        MyTime myTime2 = new MyTime(1998,11,23); //myTime2 = 0x3698
        //比较myTime1中保存的内存地址（ 0x1234）和myTime2中的内存地址（0x3698）是否相等
        System.out.println(myTime1==myTime2);
        //未重写前，使用的是原本的“==”判断 比较内存地址
        //重写后，使用的是新的判断         比较内容
        System.out.println(myTime1.equals(myTime2));
    }
}

//MyTime类
public class MyTime {
    int year;
    int month;
    int day;
    
    public MyTime() {
    }
    
    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    //重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyTime myTime = (MyTime) o;
        return year == myTime.year &&
                month == myTime.month &&
                day == myTime.day;
    }
}

• 快捷键：alt+insert

Math类

• 常见常量
  1.Math.E：double值比其他任何一个都更接近 e ，自然对数的基数。
  2.Math.PI：double值比任何其他的更接近 pi ，圆周长与其直径的比率。
• 常见方法：
  1.abs：返回绝对值，支持类型：double,float,int,long
  2.cbrt：开立方根，如：Math.cbrt(8) ===>2.0
  3.ceil：向上取整，如：Math.ceil(1.22) ===> 1.0
  floor：向下取整，如：Math.floor(1.22) ===>2.0
  4.round：四舍五入返回一个整数，如：Math.round(2.4) ===>2
  5.random：
  a.返回值为 double值为正号，大于等于 0.0 ，小于 1.0 ：random()
  b. 产生一个大于等于a，小于b的随机整数：Math.round(Math.random()*b+a)
  6.max/min：返回入参的两个值中大/小的值，支持类型：double,float,int,long
  …

UUID+Random类

• 生成唯一标识：UUID.randomUUID()

File类

创建文件

1.boolean createNewFile() 不存在返回true 存在返回false
2.boolean mkdir() 创建目录，如果上一级目录不存在，则会创建失败
3.boolean mkdirs() 创建多级目录，如果上一级目录不存在也会自动创建

查看文件

• 获取：
  1.String getName() 获取此路径表示的文件或目录名称
  2.String getPath() 将此路径名转换为路径名字符串
  3.String getAbsolutePath() 返回此抽象路径名的绝对形式
  4.String getParent()//如果没有父目录返回null
  5.long lastModified()//获取最后一次修改的时间
  6.long length() 返回由此抽象路径名表示的文件的长度。
  7.boolean renameTo(File f) 重命名由此抽象路径名表示的文件。
  8.File[] liseRoots()//获取机器盘符
  9.String[] list() 返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
  10.String[] list(FilenameFilter filter) 返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录。
• 判断：
  1.boolean canExecute()判断文件是否可执行
  2.boolean canRead()判断文件是否可读
  3.boolean canWrite() 判断文件是否可写
  4.boolean exists() 判断文件或目录是否存在
  5.boolean isDirectory() 判断此路径是否为一个目录
  6.boolean isFile()　　判断是否为一个文件
  7.boolean isHidden()　　判断是否为隐藏文件
  8.boolean isAbsolute()判断是否是绝对路径 文件不存在也能判断

修改文件

删除文件

包装类

• 目的：有时候是需要将一些基本数据类型当做一个对象来处理的。
• 对应关系：

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Char
int	Int
long	Long
float	Float
double	Double

• 作用：
  1.提供字符串、基本类型数据、对象之间互相转化的方式
  2.包含每种基本数据类型的相关属性如最大值、最小值等

自动装箱和拆箱

自动装箱：自动装箱就是 基本类型 自动地封装到与它相同类型的包装中。
自动拆箱：自动将包装类 转化成 基本数据类型。

• 举例：

Integer num= 100; //装箱
int numInt = num;   //拆箱

日期相关类

Date

• 表示特定的瞬间，精确到毫秒。
• util与sql下的Date类为父子关系：
  java.util.Date类
  java.sql.Date类
• 使用说明：
  构造器1：Date()=》创建一个对应当前时间的Date对象
  构造器2：Date(long date)=》创建指定毫秒数的Date对象
  方法1：toString()=》显示当前的年、月、日、时、分、秒
  方法2：getTime()=》获取当前Date对象对应的毫秒数。（时间戳）
• 举例：

    //构造器一：Date()：创建一个对应当前时间的Date对象
    Date date1 = new Date();
    System.out.println(date1.toString());//Sat Feb 16 16:35:31 GMT+08:00 2019
    System.out.println(date1.getTime());//1550306204104
       
    //构造器二：创建指定毫秒数的Date对象
    Date date2 = new Date(155030620410L);
    System.out.println(date2.toString());//Sat Feb 16 16:35:31 GMT+08:00 2019

• java.sql.Date对应着数据库中的日期类型的变量
  ① 如何实例化：
  只有一个构造器：Date(long date)：创建指定毫秒数的Date对象
  ② 如何将java.sql.Date对象转换为java.util.Date对象（直接赋值–>多态）
  ③ 如何将java.util.Date对象转换为java.sql.Date对象

    //①创建java.sql.Date对象
    java.sql.Date date3 = new java.sql.Date(35235325345L);
    System.out.println(date3);//1971-02-13
    
    //③如何将java.util.Date对象转换为java.sql.Date对象
    //情况一：
    //③将java.sql.Date对象转换为java.util.Date对象（直接赋值-->多态）
	Date date4 = new java.sql.Date(2343243242323L);
    //强转
	java.sql.Date date5 = (java.sql.Date) date4;
    
    //情况二：
    Date date6 = new Date();
    java.sql.Date date7 = new java.sql.Date(date6.getTime());

SimpleDateFormat(yyyy-MM-dd HH:mm:ss)

• Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
• 两个操作
  ① 格式化：日期–>字符串
  ② 解析：字符串–>日期
• SimpleDateFormat的实例化

    //实例化SimpleDateFormat:使用默认的构造器
    SimpleDateFormat sdf = new SimpleDateFormat();

    //格式化：日期 --->字符串
    Date date = new Date();
    System.out.println(date);//Mon Feb 18 11:43:01 GMT+08:00 2019

    String format = sdf.format(date);
    System.out.println(format);//19-2-18 上午11:43
    
    //解析：格式化的逆过程，字符串 ---> 日期
    String str = "19-2-18 上午11:43";
    Date date1 = sdf.parse(str);
    System.out.println(date1);Mon Feb 18 11:43:01 GMT+08:00 2019

    //开发中常用此种构造器
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    //格式化
    Date date = new Date();
    String format1 = sdf1.format(date);
    System.out.println(format1);//2019-02-18 11:48:27
    
    //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
    //否则，抛异常
    Date date2 = sdf1.parse("2019-02-18 11:48:27");
    System.out.println(date2);//Mon Feb 18 11:48:27 GMT+08:00 2019

Calendar日历类(建议使用)

• 举例

  //1.实例化
    //方式一：创建其子类（GregorianCalendar）的对象
    //方式二：调用其静态方法getInstance()
    Calendar calendar = Calendar.getInstance();
	System.out.println(calendar.getClass());//class java.util.GregorianCalendar

    //2.常用方法
    //get()
    int days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);
    System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

    //set()
    //calendar可变性
    calendar.set(Calendar.DAY_OF_MONTH,22);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);

    //add()
    calendar.add(Calendar.DAY_OF_MONTH,-3);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);

    //getTime():日历类---> Date
    Date date = calendar.getTime();
    System.out.println(date);

    //setTime():Date ---> 日历类
    Date date1 = new Date();
    calendar.setTime(date1);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);

转载 ：https://www.cnblogs.com/zgy1996z/p/15154652.html

String类

• 不可变性字符序列
• 常用方法：
  length()：字符个数
  isEmpty()：是否为空
  isBlank()：空格+空
  startsWith(aa)/endsWith(aa)：以aa开始/结尾
  toLowerCase()/toUpperCase：转小写/大写

charAt(a)：查找a索引的值
substring(s)：前s个
substring(s,e)：s（包括）到e（不包括）
indexOf(str)：查找str在字符串的索引（第一个出现的str）
indexOf(str,s)：查找str在字符串第s个起的索引
lastIndexOf(str)：查找str在字符串的索引(从后往前)
split(a)：按照a分成数组
replace(a,b)：把a替换成b
replaceAll(a,b)：正则表达式a，替换成b
trim(a)：去掉a两端空格
toCharArray()：把字符串转成字符组
concat(a)：在字符串的末尾追加a

StringBuffer类

可变长 append() 多线程数据量较大 效率低，安全
https://www.runoob.com/java/java-stringbuffer.html

StringBuilder类

可变长 单线程数据量较大 效率高，不安全
https://www.cnblogs.com/songsongblue/p/9798651.html