12-Object与常用类

最新推荐文章于 2024-05-24 02:08:26 发布

静者，随心

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量95

点赞数

分类专栏： Java基础文章标签： java jvm 面试

本文链接：https://blog.csdn.net/yc_Cabbage/article/details/126174853

版权

Java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

引言

本节讨论java中提供的一些基础类，它们在各个细小的领域有这比较丰富的功能，虽然叫常用类，但是有些类并非经常使用。api在线文档
https://tool.oschina.net/apidocs/apidoc?api=jdk_7u4

一.Object类

Object 对象的意思，用它表示引用数据类型超类。这个类并没有提供什么实际意义的方法。它里面定义的都是一个非常基础的方法，这些方法，通常都不适用，往往要重写。

1.1 介绍

这个类是java.lang包下的一个类，直接使用无需导包。

1.2 常见方法

1.2.1 hashCode() : int

这个方法的作用是获得该对象的哈希码，hashcode折射出的是该对象的地址信息（并不是直接地址）

public static void main(String[] args){
        System.out.println("---------------hashcode()---------------");
        Object obj = new Object();
        int code = obj.hashCode();
        System.out.println(code);
}

不同对象的 hashcode 是不同的。两个对象不相等那么 hashcode也应该不同。

1.2.2 toString() : String

这个方法的作用是获得对象的字符串表达形式。默认实现的方案是全类名+@+16进制的hashcode.
这个方法通常需要我们自己重写一下。

public static void main(String[] args){
        System.out.println("--------------toString()-----");
        Foo foo =  new Foo("张三",90);
        System.out.println(foo);
}

1.2.3 equals( Object other) : boolean

这个方法用于判断两个对象是否相等，默认比较的方式是 == 比较地址，如果需要比较属性，需要重写。

通常 equals() 重写也需要把 hashCode()一并重写，因为要保证两者的统一，如果两个对象euqals()相等了那么hashCode也应该相同。

class Foo implements Cloneable {
    String name;
    int age;
    public Foo(){

    }
    public Foo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Foo foo = (Foo) o;

        if (age != foo.age) return false;
        return name != null ? name.equals(foo.name) : foo.name == null;
    }
}

1.2.4 getClass() :Class

这个方法的作用是获得对象类型信息,比如获得类名，属性信息，方法信息等。

public static void main(String[] args){
        System.out.println("--------------- getClass() --------------");
        Foo foo3 = new Foo("ADMIN",10);
        Class info = foo3.getClass();
        //我想知道这个类型有哪些属性
        Field[] arr = info.getDeclaredFields();
        for ( Field xx :arr){
            System.out.println(xx.getName());
        }
}

1.2.5 finalize():void

这个方法的作用是，当对象被标记为垃圾时，回调的方法，一个对象的这个方法只会调用一次，对象被标记为垃圾后，进入回收队列。

class Foo implements Cloneable {
    String name;
    int age;
    public Foo(){

    }
    public Foo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    protected void finalize() throws Throwable {
        System.out.println("GG");
    }
}
public static void main(String[] args){
        Foo foo6 = new Foo();
        foo6 = null;
        System.gc(); //调用gc 触发jvm垃圾对象回收。
}

1.2.6 wait() notify() notifyAll()

这几个方法是与多线程有关的方法，后续章节再来说。

1.2.7 clone( ) : Object

复制一个对象的方法。通常一个对象要支持克隆需要实现一个 Cloneable 接口，否则引发 CloneNotSupportedException 。如果不实现这个接口，需要手动创建对象填充属性值。

Cloneable 是一个标志接口，用于标识一个类是否支持克隆。

class Foo implements Cloneable {
    String name;
    int age;
    public Foo(){

    }
    public Foo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

面试题: clone 和 new 这个对象有什么区别；
效率问题：clone更快，new 稍慢

二. String类

2.1 不可变字符

不可变字符串指的是，一个字符串对象内容一旦赋值，不可再变化。如果对其拼接，其实就会创建一个新的字符串，然后这个引用指向了这个新的字符串。

2.1.1 String类

String 类是一个常用基础类型，但是引用数据类型，被设计为一个不可变字符串，位于java.lang包下。

2.1.2 String 创建方式

String(String xx)
String xx = “字符串内容”;

字符比较相等使用 equals() 根据内容比较

2.1.2 String 常用API 手册

`char`	`[charAt](../../java/lang/String.html#charAt(int))(int index)` 返回指定索引处的 `char` 值。
`int`	`[compareTo](../../java/lang/String.html#compareTo(java.lang.String))([String](../../java/lang/String.html) anotherString)` 按字典顺序比较两个字符串。
`int`	`[compareToIgnoreCase](../../java/lang/String.html#compareToIgnoreCase(java.lang.String))([String](../../java/lang/String.html) str)` 按字典顺序比较两个字符串，不考虑大小写。
`[String](../../java/lang/String.html)`	`[concat](../../java/lang/String.html#concat(java.lang.String))([String](../../java/lang/String.html) str)` 将指定字符串连接到此字符串的结尾。
`boolean`	`[contains](../../java/lang/String.html#contains(java.lang.CharSequence))([CharSequence](../../java/lang/CharSequence.html) s)` 当且仅当此字符串包含指定的 char 值序列时，返回 true。
`boolean`	`[endsWith](../../java/lang/String.html#endsWith(java.lang.String))([String](../../java/lang/String.html) suffix)` 测试此字符串是否以指定的后缀结束。
`boolean`	`[equals](../../java/lang/String.html#equals(java.lang.Object))([Object](../../java/lang/Object.html) anObject)` 将此字符串与指定的对象比较。
`boolean`	`[equalsIgnoreCase](../../java/lang/String.html#equalsIgnoreCase(java.lang.String))([String](../../java/lang/String.html) anotherString)` 将此 `String` 与另一个 `String` 比较，不考虑大小写。
`int`	`[indexOf](../../java/lang/String.html#indexOf(java.lang.String))([String](../../java/lang/String.html) str)` 返回指定子字符串在此字符串中第一次出现处的索引。
`int`	`[indexOf](../../java/lang/String.html#indexOf(java.lang.String, int))([String](../../java/lang/String.html) str, int fromIndex)` 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
`[String](../../java/lang/String.html)`	`[intern](../../java/lang/String.html#intern())()` 返回字符串对象的规范化表示形式。
`boolean`	`[isEmpty](../../java/lang/String.html#isEmpty())()` 当且仅当 `[length()](../../java/lang/String.html#length())` 为 0 时返回 true。
`int`	`[lastIndexOf](../../java/lang/String.html#lastIndexOf(java.lang.String))([String](../../java/lang/String.html) str)` 返回指定子字符串在此字符串中最右边出现处的索引。
`int`	`[lastIndexOf](../../java/lang/String.html#lastIndexOf(java.lang.String, int))([String](../../java/lang/String.html) str, int fromIndex)` 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
`int`	`[length](../../java/lang/String.html#length())()` 返回此字符串的长度。
`boolean`	`[matches](../../java/lang/String.html#matches(java.lang.String))([String](../../java/lang/String.html) regex)` 告知此字符串是否匹配给定的正则表达式。
`[String](../../java/lang/String.html)`	`[replace](../../java/lang/String.html#replace(java.lang.CharSequence, java.lang.CharSequence))([CharSequence](../../java/lang/CharSequence.html) target, [CharSequence](../../java/lang/CharSequence.html) replacement)` 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
`[String](../../java/lang/String.html)`	`[replaceAll](../../java/lang/String.html#replaceAll(java.lang.String, java.lang.String))([String](../../java/lang/String.html) regex, [String](../../java/lang/String.html) replacement)` 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
`[String](../../java/lang/String.html)`	`[replaceFirst](../../java/lang/String.html#replaceFirst(java.lang.String, java.lang.String))([String](../../java/lang/String.html) regex, [String](../../java/lang/String.html) replacement)` 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
`[String](../../java/lang/String.html)[]`	`[split](../../java/lang/String.html#split(java.lang.String))([String](../../java/lang/String.html) regex)` 根据给定正则表达式的匹配拆分此字符串。
`[String](../../java/lang/String.html)[]`	`[split](../../java/lang/String.html#split(java.lang.String, int))([String](../../java/lang/String.html) regex, int limit)` 根据匹配给定的正则表达式来拆分此字符串。
`boolean`	`[startsWith](../../java/lang/String.html#startsWith(java.lang.String))([String](../../java/lang/String.html) prefix)` 测试此字符串是否以指定的前缀开始。
`boolean`	`[startsWith](../../java/lang/String.html#startsWith(java.lang.String, int))([String](../../java/lang/String.html) prefix, int toffset)` 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
`[String](../../java/lang/String.html)`	`[substring](../../java/lang/String.html#substring(int))(int beginIndex)` 返回一个新的字符串，它是此字符串的一个子字符串。
`[String](../../java/lang/String.html)`	`[substring](../../java/lang/String.html#substring(int, int))(int beginIndex, int endIndex)` 返回一个新字符串，它是此字符串的一个子字符串。
`char[]`	`[toCharArray](../../java/lang/String.html#toCharArray())()` 将此字符串转换为一个新的字符数组。
`[String](../../java/lang/String.html)`	`[toLowerCase](../../java/lang/String.html#toLowerCase())()` 使用默认语言环境的规则将此 `String` 中的所有字符都转换为小写。
`[String](../../java/lang/String.html)`	`[toString](../../java/lang/String.html#toString())()` 返回此对象本身（它已经是一个字符串！）。
`[String](../../java/lang/String.html)`	`[toUpperCase](../../java/lang/String.html#toUpperCase())()` 使用默认语言环境的规则将此 `String` 中的所有字符都转换为大写。
`[String](../../java/lang/String.html)`	`[trim](../../java/lang/String.html#trim())()`

 public class StringApiDemo {

    public static void main(String[] args) {


        String s1 = "爸爸,的快乐你不懂,爸爸hehe嗒";
        String s2 = "卢俊义,40,男,cosplay";
        String s3 = "PHP是世上最好的语音java不服";
        String s4 = "苍老师经典集合.mp4";
        String s5 = "   hellojava   ";

        System.out.println("-------1.获得字符串长度 length():int -------------------");
        System.out.println(s1.length());
        System.out.println("-------2.获得字符串指定位置下的字符 charAt(int index):char -------------------");
        System.out.println(s1.charAt(3));
        System.out.println("-------3.获得子串首次出现的下标 indexOf(String son [,int fromIndex] ):int -------------------");
        System.out.println(s1.indexOf("快乐"));
        System.out.println("-------4.反向查找 lastIndexOf(String son [,int fromIndex] ):String -------------------");
        System.out.println(s1.lastIndexOf("爸爸",6));
        System.out.println("-------5.截取字符串 substring(int star [, int end] ):String -------------------");
        System.out.println(s1.substring(3, 8));
        System.out.println("-------6.替换 replace( String old,String new ):String -------------------");
        System.out.println(s1.replace("爸爸", "爷爷"));
        System.out.println("-------7.拆分 split( String flg ):String[] -------------------");
        String[] arr = s2.split(",");
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println("-------8.大小写转换 toUpperCase():String toLowerCase():String   -------------------");
        System.out.println(s3.toLowerCase());
        System.out.println(s3.toUpperCase());
        System.out.println("-------9.起始和结尾 startWidth(String prefix ):boolean  endsWith(String sufix ):boolean  -------------------");
        System.out.println(s4.startsWith("王老师"));
        System.out.println(s4.endsWith("mp4"));
        System.out.println("-------10.字符串转数组 toCharArray():char[]-------------------");
        char[] chars = s4.toCharArray();
        System.out.println(Arrays.toString(chars));
        System.out.println("-------11.去空格 trim():String 前后空格   -------------------");
        System.out.println(s5.trim());
        System.out.println("-------12.字符串连接 concat(String other):String ---------------");
        String s6 = "hello";
        String s7 = "hello";
        System.out.println(s6.concat(s7));
        System.out.println("--------13.包含 contains(String str):boolean  ");
        System.out.println(  s3.contains("java2") );

        System.out.println("---------14 比较值相等  equals(String other):boolean  -------");
        String s8="2TsQ";
        String s9="2tsq";
        System.out.println(s8.equals(s9));
        System.out.println(s8.equalsIgnoreCase(s9));
        System.out.println("---------15 比较字符大小 compareTo(String other):int   -----  ");
        String s10 = "z";
        String s11 = "a";
        int n = s10.compareTo(s11);
        System.out.println(n);
        System.out.println("----------16 静态方法 String.valueOf(Object obj):String -----------");
        int age = 10;
        String xx = String.valueOf(age);
        System.out.println(xx+10);
    }
}

2.2 可变字符串

指定的是可以在现有字符串对象基础上，继续修改，频繁拼接不会出现中间状态的垃圾字符串。

2.2.1 StringBuilder 可变字符串

为了解决 StringBuffer 效率问题，java 1.5 再推出这个StringBuilder，StringBuilder这个类是线程不安全的。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder ss = new StringBuilder("静夜诗");
        ss.append("床前明月光,疑是地上霜,");
        ss.append("举头望明月,低头思故乡。");
        ss.insert(3,"李白");
        ss.insert(5,"\n");
        System.out.println(ss);
    }
}

核心方法是追加新内容的方法 append(Object xx )

2.2.2 StringBuffer 可变字符串

这类是JDK1.0推出的可变字符串，这个类被设计为线程安全的，这个类的效率低。

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer ss = new StringBuffer("静夜诗");
        ss.append("床前明月光,疑是地上霜,");
        ss.append("举头望明月,低头思故乡。");
        ss.insert(3,"李白");
        ss.insert(5,"\n");
        System.out.println(ss);
    }
}

2.2.2 String StringBuilder StringBuffer 区别

可变性 String 是不可变，其他两个是可变的
安全性 StringBuffer 线程安全的。StringBulder不安全。 String视为安全的，他的方法都是建立副本，不再原有的基础上做修改。

三.包装类

java中有基本数据类型和引用类型，如果要把基本数据类型变成引用类型，那么需要一次包装，java中就给出了基本数据类型对应的包装。

3.1 基本数据类型包装类

byte	short	int	long	float	double	char	boolean
Byte	Short	Integer	Long	Float	Double	Character	Boolean
Number

3.2 Number 核心方法

Number 类是6个数值包装类的父类，它提供了6个拆箱方法

`byte`	`[byteValue](../../java/lang/Number.html#byteValue())()` 以 `byte` 形式返回指定的数值。
`abstract double`	`[doubleValue](../../java/lang/Number.html#doubleValue())()` 以 `double` 形式返回指定的数值。
`abstract float`	`[floatValue](../../java/lang/Number.html#floatValue())()` 以 `float` 形式返回指定的数值。
`abstract int`	`[intValue](../../java/lang/Number.html#intValue())()` 以 `int` 形式返回指定的数值。
`abstract long`	`[longValue](../../java/lang/Number.html#longValue())()` 以 `long` 形式返回指定的数值。
`short`	`[shortValue](../../java/lang/Number.html#shortValue())()` 以 `short` 形式返回指定的数值。

3.3 装箱拆箱

装箱：把一个基本数类型变成引用数据类型
拆箱：把引用数据类型变成基本数据类型

public class WarpDemo {
    public static void main(String[] args) {
        // JDK.1.5以前 手动完成 装箱 和 拆箱
        // 装箱： 把一个基本数类型 变成引用 数据类型
        int num = 100;                        // 基本数据类型
        Integer numPlus = new Integer( num ); // 引用数据类型

        // 拆箱： 把引用数据类型变成 基本数据类型
        Integer nPlus = new Integer(100);      //引用类型
        int n = nPlus.intValue();              // 基本数据类型
    }
}

自动装箱与拆箱[jdk5+]

public class WarpDemo {
    public static void main(String[] args) {
       //JDK 1.5+ 自动 装箱拆箱 , 使转换更容易。
       int x = 10;
       Integer xPlus = x; //自动装箱

       Integer yPlus = 100;
       int y = yPlus;     //自动拆箱
    }
}

3.4 包装类提供的方法

使用包装类，提供的静态方法完成一些简单功能。

public class WarpApi {
    public static void main(String[] args) {
        
        // 1. 查看类型的 取值区间
        System.out.println(  Integer.MIN_VALUE+ "-"+ Integer.MAX_VALUE  );

        
        // 2. 转进制
        System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.toHexString(10));

        
        // 3. 比较大小
        System.out.println(Integer.max(10, 50));
        System.out.println(Integer.min(10, 50));
        System.out.println(Integer.compare(10, 3));
        
    }
}

3.5 数值类型与字符串转换[掌握]

开发中很多时候，需要把字符串类型转成数值类型，比如需要把 String “99.8” 变成 double 99.8 。
字符串转数值类型，需要找到对应的包装类型，比如要转int 找Integer 转double就找Double。包装类提供 parseByte() parseShort() parseInt() parseLong() parseFloat() parseDouble 。

public class WarpApi {

    public static void main(String[] args) {
        
        System.out.println("------------------   String==> 数值  ----------------------");
        Scanner scanner = new Scanner(System.in);
        String price = scanner.next();
        double money =  Double.parseDouble( price );
        double xx  = money * 0.8;
        System.out.println(xx); 
        
        System.out.println("------------------  数值 ==> String  ----------------------");
        
        double abc = 120.0;
        String s=  String.valueOf(abc);
        System.out.println(s);
    }
}

3.2 BigDecimal

由于java中浮点数计算不精确，可以使用BigDecimal解决问题，需要注意的是必须以字符串方式构造BigDecimal。
BigDecimal 提供了API来计算：

add(_ BigDecimal other _):BigDecimal
subtract( _BigDecimal other _):BigDecimal
multiply( _BigDecimal other _):BigDecimal
divide( _BigDecimal other ,int scale , int rondModel _):BigDecimal

重点说明：
对于除法，因为存在无限循环小数，所以可能会引发异常，通过参数 scale 控制小数点位数， rondModel控制取舍策略。
常用取舍策略：
ROUND_UP = 0
ROUND_DOWN =1
ROUND_CEILING =2
ROUND_FLOOR = 3
ROUND_HALF_UP = 4 四舍五入

public class BigDecimalDemo {

    public static void main(String[] args) {

        double a = 1.0;
        double b = 0.9;
        System.out.println(a-b);//0.99999999998 不精确
       
        //包装
        BigDecimal n1 = new BigDecimal(   String.valueOf(a)  );
        BigDecimal n2 = new BigDecimal(   String.valueOf(b)  );
        
        System.out.println("-------加法------");
        BigDecimal result1 = n1.add(n2);
        System.out.println(result1.doubleValue());

        System.out.println("-------减法------");

        BigDecimal result2 = n1.subtract(n2);
        System.out.println(result2.doubleValue());

        System.out.println("-------乘法--------");
        BigDecimal result3 = n1.multiply(n2);
        System.out.println(result3.doubleValue());

        System.out.println("-------除法--------");
        BigDecimal result4 = n1.divide(n2,2,BigDecimal.ROUND_HALF_UP);
        System.out.println(result4.doubleValue());
    }
}

3.3 BigInteger

当运算数据非常大的情况下，基本数据类型无法完成运算，比如两个long的最大值相加，没有办法直接运算，这时可以借助 BigInter包装类使用API运算，API与BigDecimal完全一致

// 大数运算
public class BigInteDemo {

    public static void main(String[] args) {

        long x1 = 9223372036854775807L;
        long x2 = 9223372036854775807L;

        BigInteger n1 = new BigInteger( String.valueOf(x1) );
        BigInteger n2 = new BigInteger( String.valueOf(x2) );

        BigInteger result = n1.add(n2);
        System.out.println(ru); //18446744073709551614 
    }
}

大数运算不可拆箱，因为可能超过类型的范围。但是可以转字符串，保存这个字符串，日后可以继续运算。

四.日期相关类

4.1 Date类

Date类是用来描述时间的。一个时刻，一个瞬间都是 Date的实例。在java.util包中。

4.1.1 创建对象

** 系统时间对象**
** 毫秒数指定时间对象**
~~ 年月日直接对象(过期)~~

public class TestDate {

    public static void main(String[] args) {
        //获得当前系统时间对应Date 对象
        Date date = new Date();
        System.out.println(date);

        //构造一个指定时间的对象
        Date date2 = new Date(1000);
        System.out.println(date2);
        
        //过期了
        Date date3 = new Date(2021-1900,11,10);
        System.out.println(date3);
    }
}

4.1.2 常用方法

getTime():long 获得时间毫秒值
after(Date when ): 判断是否在指定日期前
before( Date when ):判断是否在指定日期后
~~getXXX():int 获得年、月、日过期了，不推荐使用~~

public class TestDateApi {
    public static void main(String[] args) {
        Date date = new Date();
        //1. 获得时间的毫秒数
        long time = date.getTime();
        System.out.println(time);

        //2. 日期比较 after before
        Date date2= new Date(1618191582373L);

        boolean after = date.before(date2);
        System.out.println(after);

        //3. 过期的方法
        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
    }
}

4.2 SimpleDateFormat 类[掌握]

是一个简单的日期格式化工具类，可以把日期对象通过日期的格式符号转换成一个字符串。

4.2.1 创建对象

 //SimpleDateFormat sdf = new SimpleDateFormat("包含格式符号的模板字符串");
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

格式符号： y: 年 M: 月 d: 日 h: 时 m: 分 s: 秒

4.2.2 核心方法 format(Date date)

public class TestSimpleDateFormat {
    public static void main(String[] args) {
        Date date = new Date();
        //格式化输出
        /**
         * 格式模板 yyyy-MM-dd hh:mm:ss
         * y:年   M:月  d:日   h:时   m:分  s:秒
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String strDate = sdf.format(date);
        System.out.println(strDate);
    }
}

开发中，可以通过常量接口定义各种格式化模板
public interface Paten {
_//常规格式
_public static final String _DATE _= “yyyy-MM-dd”;
public static final String _DATE_TIME _= “yyyy-MM-dd hh:mm:ss”;
public static final String _TIME _= “hh:mm:ss”;
_//中文格式
_public static final String _DATE_CHINA _= “yyyy年MM月dd日”;
public static final String _DATE_TIME_CHINA _= “yyyy年MM月dd日 hh:mm:ss”;
_//自定义格式
_public static final String _DATE_STYLE _= “dd/MM/yyyy”;
}

4.2.3 核心方法 parse( String str )

把一个字符串转换成日期对象，往往用户输入的都是字符串，即便是一个时间也是以一个字符串输入的比如 2008-10-10，而程序中需要的是一个对象。

Scanner scanner = new Scanner( System.in );
System.out.println("输入生日");
String birthdy = scanner.next(); // 2008-10-10
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
Date parseDate  = sdf2.parse(birthdy);
System.out.println(parseDate);

4.3 Calander 类

日历类，Date 绝大部分api过期了，很多功能就需要借助 Calander 完成。日历除了当前时间以外，还存储了与此相关的其他信息（日历字段）和处理日期一些方法。位于java.util包

4.3.1 创建

public class TestCalendar {
    public static void main(String[] args) {
        //获得实例
        Calendar calendar = Calendar.getInstance();
    }
}

4.3.2 核心方法

** get( int field):int **
** set( int field , int value )**
** add( int field , int amount)**
** getActualMaximum(int field)**
** getActualMinimum(int field)**

package case1.calander;

import java.util.Calendar;

public class TestCalendar {

    public static void main(String[] args) {

        //获得实例
        Calendar calendar = Calendar.getInstance();


        // get(int x):int 获得日历字段
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DATE);
        int h = calendar.get(Calendar.HOUR);
        int m = calendar.get(Calendar.MINUTE);
        int s = calendar.get(Calendar.SECOND);

        System.out.println( year );
        System.out.println( month+1);
        System.out.println( day );
        System.out.println("------------------------------");
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));

        //  set( int field , int value ): 修改日历字段值
        // calendar.set( Calendar.YEAR , 2099);


        // add( int filed, int amont ): 增加日历字段值
         calendar.add(Calendar.MONTH,1);


        // 获得当月最大实际日历信息
       // int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);

       // int minDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);

        //System.out.println(maxDay+"  "+minDay);

    }
}

4.3.3 日历案例

package case1.calander;

import java.util.Calendar;
import java.util.Map;

//日历
public class DisplayCalendar {
    public static void main(String[] args) {
        //获得日历
        Calendar calendar = Calendar.getInstance();
        calendar.set(2021,5,1);
        //输出日历头部
        String[] days = {"一","二","三","四","五","六","日"};
        for ( String day : days){
            System.out.print(day+"\t");
        }
        System.out.println();
        //输出日历身体
        int min = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
        int max = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        int xq = calendar.get(Calendar.DAY_OF_WEEK);
        //输出首行空格
        for(int i=1; i<=xq-2;i++){
            System.out.print("\t");
        }
        // 输出全部号数
        for(int i=min; i<=max; i++){
             System.out.print(i+"\t");
             calendar.set(Calendar.DAY_OF_MONTH,i); //把日历指向这一天
             int x=  calendar.get(Calendar.DAY_OF_WEEK) ; //如果这一天是星期天 则换行
             if (x==1){
                 System.out.println();
             }
        }
    }
}

五.其他的类

5.1 Arrays

它是一个数组的工具类，提供很多数组操作的方法。
核心方法：

package case1.arrays;

import java.util.Arrays;

// 数组工具类
public class TestArrays {
    public static void main(String[] args) {

        int[] arr = {45,29,16,5,20,23,22,9,4};

        // 1. toString(T[] arr)    // 数组转字符串
        System.out.println(  Arrays.toString(arr)  );

        // 2.  sort(T[] )          //  排序
        Arrays.sort(arr);
        System.out.println( Arrays.toString(arr));

        // 3.  binarySearch(T[] T key) // 二分查找
        System.out.println(Arrays.binarySearch(arr, 20));

        // 4. copyOf(int[] arr , int len)  // 数组拷贝
        int[] newArr = Arrays.copyOf(arr, 5);
        System.out.println(Arrays.toString(newArr));

        // 5.  copyOfRange(T[] arr, int from, int to)  // 数组区间拷贝
        int[] newArr2 = Arrays.copyOfRange(arr, 3, 7);
        System.out.println(Arrays.toString(newArr2));


        // 6. equals(T[] a1, T[] a2)  // 两数组相等比较
        int[] xrr = {1,2,3};
        int[] yrr = {1,2,3,4};
        System.out.println(Arrays.equals(xrr, yrr));


        // 7 .fill(T[] arr , int value)   // 数组元素填充
        int[] zrr = new int[10];
        Arrays.fill( zrr,2,5, -1 );
        System.out.println(Arrays.toString(zrr));
    }
}

5.2 Random

这类是一个生成伪随机数类，底层原理使用使用线性同余公式，生成的数字，如果种子相同，进行相同次数的调用得到的值是相同的。
nextInt( int n): int 生成一个0-N之间的整数
nextDouble() ：double 生成一个浮点数
nextBoolean(): boolean 生成一个Boolean值

public class TestRandom {
    public static void main(String[] args) {
        Random rd = new Random(100);// 100为随机数种子
        for (int i= 0; i<4; i++){
            int num = rd.nextInt(100);
            System.out.println(num);
        }
    }
}

5.3 UUID

这个类用于生成唯一字符串序列

public class TestUUID {

    public static void main(String[] args) {
        //获得一个随机的UUID
        UUID uuid =  UUID.randomUUID();
        //获得UUID字符串
        String uuidStr = uuid.toString();
        //替换 -
        uuidStr =  uuidStr.replace("-","");
        System.out.println(uuidStr);
    }
}

5.4 Math

它是一个数学工具类，提供了数学计算上的一些方法。全部是静态方法。

public class TestMath {
    public static void main(String[] args) {
        System.out.println(Math.PI);        // 获得 PI
        System.out.println(Math.abs(-100)); // 计算绝对值
        System.out.println(Math.pow(2, 11));// 计算次方 
        System.out.println( (int)(Math.random()*10)  ); // 随机数0.0-1.0间
        System.out.println(Math.round(3.7)); // 四舍五入
        System.out.println(Math.floor(3.9)); // 向下取整
        System.out.println(Math.ceil(3.1));  // 向上取整
        System.out.println(Math.sqrt(81));   // 开平方根
    }
}

5.4 Runtime

它的对象表示运行环境的对象，通过这个对象可以获得，运行平台的相关信息。

public class TestRuntime {

    public static void main(String[] args) throws IOException {

        //获得实例
        Runtime runtime = Runtime.getRuntime();

        //获得运行环境信息
        int n = runtime.availableProcessors(); // 获得处理器个数的
        System.out.println(n);

        //runtime.exec("C:/Program Files (x86)/Tencent/QQLive/QQLive.exe"); //打开一些软件

        //runtime.exit(0);  //立即退出

        long freeMemory = runtime.freeMemory();
        System.out.println(freeMemory/1024/1024);  // 返回 Java 虚拟机中的空闲内存量。

        long maxMemory = runtime.maxMemory();     // 返回 Java 虚拟机试图使用的最大内存量。
        System.out.println(maxMemory/1024/1024);

        long totalMemory = runtime.totalMemory(); //   返回 Java 虚拟机中的内存总量。
        System.out.println(totalMemory/1024/1024);

        System.out.println("over");
    }
}

5.4 System

System 类包含一些有用的类字段和方法。它不能被实例化。
在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

public class TestSystem {


    public static void main(String[] args) {

        // 输入流
        Scanner sc = new Scanner( System.in );
        //输出流
        System.out.println(  "hello");
        //错误，打印错误信息
        System.err.println("world");

        // 读取环境变量
        Map<String, String> info = System.getenv();
        System.out.println(info.get("KEY"));
    }
}