柏竹
柏竹
2020-02-18
目录

Java API

# Java API

包装类 最小值 最大值 字节数
Integer -2^31 2^31 -1 4
Character 0 65536 2
Float - - 4
Double - - 8
Boolean - - 1
Byte -128(-2^7) 127 (2^7-1) 1
Short -32768(-2^15) 32767(2^15-1) 2
Long -2^63 2^63-1 8

Number： Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字

# 装箱和拆箱操作

将一个基本数据类型变为包装类，那么这样的操作称为 装箱操作 将一个包装类变为一个基本数据类型，这样的操作称为 拆箱操作

/*过时的*/
int temp = 10 ; // 基本数据类型
Integer x = new Integer(temp) ; // 将基本数据类型变为包装类
/*JDK1.5 后 ，新版自动拆装箱*/
// 自动装箱
Float f = 10.3f ;
Integer i = 200;
// 自动拆箱
float x = f ;
int j = i;

# Object

Object是所有类的父类

如果一个类没有继承有其他类，则默认继承Object类

常用方法

返回 方法 说明
类<?> getClass() 获取 此运行时的Object类
int hashCode() 获取 对象的哈希码值
String toString() 返回 对象的字符串形式 (一般是 属性/地址)
boolean equals(Object obj) 比较 参数对象是否与此对象相同

# Integer

Integer构造方法

Integer(int number)

Integer(String str)

以上有两种方式获取 Integer对象

Integer常量

Integer.MAX_VALUE 返回int型的最大值

Integer.MIN_VALUE 返回int型的最小值

Integer.SIZE 用二进制补码形式表示 int位数

Integer.TYPE 基本类型int

public static void main(String[] args) {
    System.out.println("int最大值(max)："+Integer.MAX_VALUE);
    System.out.println("int最小值(min)："+Integer.MIN_VALUE);
    System.out.println("max："+Integer.SIZE);
    System.out.println("max："+Integer.TYPE);
}

/*

int最大值(max)：2147483647
int最小值(min)：-2147483648
max：32
max：int

*/

Integer方法

Integer.byteValue() 以 byte类型 返回

Integer.compareTo(Integer i) 比较是否相同，两值相同则返回 0，对象小于 参数i 返回负值，否则为正值

Integer.intValue() 以 int类型 返回

Integer.shortValue() 以 short类型 返回

Integer.toString() 返回 Integer值 的 String对象，返回String

Integer.valueOf(String str) 返回保存参数的 Integer对象

Integer.parseInt(String str) 返回参数中的数值

public class no1 {
    public static void main(String[] args) {
        Integer n = new Integer(12);
        
        System.out.println("byteValue() 以 byte类型 返回(12)："+n.byteValue());
        
        System.out.println("compareTo(Integer i)比较是否相同(12 v 10)："+n.compareTo(10));
    
        System.out.println("intValue()以 int类型 返回："+n.intValue());
    
        System.out.println("shortValue()以 short类型 返回："+n.shortValue());
    
        String str = new String("123");
        System.out.println("toString()返回 Integer值 的 String对象："+str.toString());
    
        System.out.println("valueOf(String str) 返回保存参数的 Integer对象((String)123) : "+n.valueOf("123"));
    
        System.out.println("parseInt(String str) 返回参数中的数值((String)123)："+n.parseInt("123"));
    }
}

/*

byteValue() 以 byte类型 返回(12)：12
compareTo(Integer i)比较是否相同(12 v 10)：1
intValue()以 int类型 返回：12
shortValue()以 short类型 返回：12
toString()返回 Integer值 的 String对象：123
valueOf(String str) 返回保存参数的 Integer对象((String)123) : 123
parseInt(String str) 返回参数中的数值((String)123)：123

*/

# Boolean

Boolean构造方法

Boolean(boolean value)

Boolean(String str)

以上有两种方式获取 Boolean对象

Boolean常量

Boolean.TRUE 对应基于true的 Boolean对象

Boolean.FALSE 对应基于false的 Boolean对象

Boolean.TYPE 基本类型Boolean

public static void main(String[] args) {
    System.out.println("Boolean.TRUE："+Boolean.TRUE);
    System.out.println("Boolean.FALSE："+Boolean.FALSE);
    System.out.println("Boolean.TYPE："+Boolean.TYPE);
}

/*

Boolean.TRUE：true
Boolean.FALSE：false
Boolean.TYPE：boolean

*/

Boolean方法

Boolean.BooleanValue() 将Boolean对象的值对应返回 Boolean值

Boolean.equsla(Object obj) 对象相同返回true，否则false

Boolean.parseBoolean(String s) 参数字符串解析为 Boolean值

Boolean.toString() 返回boolean值的String对象，返回String

Boolean.valueOf(String s) 返回参数Boolean值

public static void main(String[] args) {
    Boolean b1 = new Boolean(true);
    //默认false
    Boolean b2 = new Boolean("yes");
    System.out.println("BooleanValue(b1) : "+b1.booleanValue());
    System.out.println("BooleanValue(b2) : "+b2.booleanValue());

    System.out.println("b1.equsla(b2)："+b1.equals(b2));

    System.out.println("valueOf(b1)："+Boolean.valueOf(b1));
    System.out.println("valueOf(b2)："+Boolean.valueOf(b2));
    
    //String.valueOf(b1)：把b1引用的对象字符串化
    System.out.println("parseBoolean(b1)："+Boolean.parseBoolean(String.valueOf(b1)));
    //String.valueOf(b1)：把b2引用的对象字符串化
    System.out.println("parseBoolean(b2)："+Boolean.parseBoolean(String.valueOf(b2)));
}

/*

BooleanValue(b1) : true
BooleanValue(b2) : false
b1.equsla(b2)：false
valueOf(String s)：true
valueOf(String s)：false
parseBoolean(String s)：true
parseBoolean(String s)：false

*/

# Byte

Byte构造方法

Byte(byte value)

Byte(String str)

以上有两种方式获取 Byte对象

Byte常量

Byte.MAX_VALUE 返回byte型的最大值

Byte.MIN_VALUE 返回byte型的最小值

Byte.SIZE 用二进制补码形式表示 byte位数

Byte.TYPE 基本类型byte

public static void main(String[] args) {
    System.out.println("Byte.MAX："+Byte.MAX_VALUE);
    System.out.println("Byte.MIN："+Byte.MIN_VALUE);
    System.out.println("Byte.SIZE："+Byte.SIZE);
    System.out.println("Byte.TYPE："+Byte.TYPE);
}

/*

Byte.MAX：127
Byte.MIN：-128
Byte.SIZE：8
Byte.TYPE：byte

*/

Byte方法

Byte.parseByte(String str) 参数String以byte值返回

Byte.valueOf(String str) 参数String以byte对象返回

Byte.equals(Object obj) 两个Byte对象判断是否相同

Byte.byteValue() 返回此对象的byte值

Byte.intValue() 返回此对象的int值

Byte.doubleValue() 返回此对象的double值

public static void main(String[] args) {
//        Byte be = new Byte(12);  过时了
//        实例化对象的例子需要调用valueOf方法
        Byte b = Byte.valueOf((byte) 12);
//        或者
        Byte b2 = (byte)12;
    
        System.out.println("parseByte(String str)参数String以byte值返回："+b.parseByte("23"));
    
        System.out.println("valueOf(String str)参数String以byte对象返回："+b.valueOf("22"));
    
        System.out.println("equals(Object obj)两个Byte对象判断是否相同："+b.equals(b2));
    
        System.out.println("byteValue() 返回此对象的byte值："+b.byteValue());
    
        System.out.println("intValue()返回此对象的int值："+b.intValue());
    
        System.out.println("doubleValue() 返回此对象的double值："+b.doubleValue());
    }
}

/*

parseByte(String str)参数String以byte值返回：23
valueOf(String str)参数String以byte对象返回：22
equals(Object obj)两个Byte对象判断是否相同：true
byteValue() 返回此对象的byte值：12
intValue()返回此对象的int值：12
doubleValue() 返回此对象的double值：12.0

*/

# Character

Character构造方法

Character(char value)

Character常量

Character.CONNECTOR_PUNCTUATION 返回byte型值，表示Unicode的常规类别 Pc

Character.UNASSIGNED 返回byte型值，表示Unicode的常规类别 Cn

Character.TITLECASE_LETTER 返回byte型值，表示Unicode的常规类别 Lt

Character方法

Character.compareTo(Charcter char) 比较两个对象是否相同，相同则0

Character.equals(Object obj) 比较两对象的值，返回boolean值

Character.toUpperCase(char ch) 参数字母转化为大写doubleValue()

Character.toLowerCase(char ch) 参数字母转化为小写

Character.toString() 返回指定的char值的String对象

Character.charValue() 返回Character对象的值

Character.isUpperCase(char ch) 判断参数字符是否是大写

Character.isLowerCase(char ch) 判断参数字符是否是小写

public static void main(String[] args) {
        Character ch = new Character('S');
        Character ch2 = new Character('s');
    
        System.out.println("compareTo(Charcter char)比较两个对象是否相同，相同则0："+ch.compareTo(ch2));
        
        System.out.println("equals(Object obj)比较两对象的值，返回boolean值："+ch.equals(ch2));
    
        System.out.println("toUpperCase(char ch)参数字母转化为大写："+Character.toUpperCase(ch));
    
        System.out.println("toLowerCase(char ch)参数字母转化为小写："+Character.toLowerCase(ch));
        
        System.out.println("toString()返回指定的char值的String对象："+ch.toString());
    
        System.out.println("charValue() 返回Character对象的值："+ch.charValue());
        
        System.out.println("isUpperCase(char ch) 判断参数字符是否是大写(S)："+Character.isUpperCase(ch));
        System.out.println("isUpperCase(char ch) 判断参数字符是否是大写(s)："+Character.isUpperCase(ch2));
        
        System.out.println("isLowerCase(char ch) 判断参数字符是否是小写(S)："+Character.isLowerCase(ch));
        System.out.println("isLowerCase(char ch) 判断参数字符是否是小写(s)："+Character.isLowerCase(ch2));
        
}

/*

compareTo(Charcter char)比较两个对象是否相同，相同则0：-32
equals(Object obj)比较两对象的值，返回boolean值：false
toUpperCase(char ch)参数字母转化为大写：S
toLowerCase(char ch)参数字母转化为小写：s
toString()返回指定的char值的String对象：S
charValue() 返回Character对象的值：S
isUpperCase(char ch) 判断参数字符是否是大写(S)：true
isUpperCase(char ch) 判断参数字符是否是大写(s)：false
isLowerCase(char ch) 判断参数字符是否是小写(S)：false
isLowerCase(char ch) 判断参数字符是否是小写(s)：true

*/

# Float

Float 类在对象中包装了一个基本类型 float 的值

Float构造方法

构造方法 说明
Float(double value) double 转换为 Float
Float(float value) 分配新对象
Float(String s) String 转换为 Float

Float常量

MAX_VALUE：float 类型的最大值 (1.4E38)

MIN_VALUE：float 类型的最小值 (3.4E-45)

MAX_EXPONENT: float 变量可能具有的最大指数

MIN_EXPONENT：标准化 float 变量可能具有的最小指数

MIN_NORMAL：保存 float 类型数值的最小标准值的常量，即 2-126

NaN：保存 float 类型的非数字值的常量

SIZE：用来以二进制补码形式表示 float 值的比特位数

TYPE：表示基本类型 float 的 Class 实例

Float方法

返回 方法 说明
int intValue() 强制转换为 int 类型
long longValue() 强制转换为 long 类型
·· ··(其他类型用法如此) ··
boolean isNaN() 是否为非数字值 NaN
boolean isNaN(float v) 参数是否为非数字值 NaN
Float valueOf(String s) String 强转为 Float对象
float parseFloat(String s) String 强转为 float

# Double

Double 类在对象中包装了一个基本类型 double 的值

Double构造方法

构造方法 说明
Double(double value) 分配新对象
Double(String str) String 转换为 Double

Double常量

MAX_EXPONENT 返回int值，double最大指数

MIN_EXPONENT 返回int值，double最小指数

TYPE 基本类型double

SIZE 用二进制补码形式表示 double位数

NEGATIVE_INFINITY 返回double值，保存double类型的负穷大值

POSITIVE_INFINITY 返回double值，返回double类型的正无穷大值

public static void main(String[] args) {
     System.out.println("Double.MAX："+Double.MAX_EXPONENT);
     System.out.println("Double.NIN："+Double.MIN_EXPONENT);
     System.out.println("Double.SIZE："+Double.SIZE);
     System.out.println("Double.TYPE："+Double.TYPE);
}

/*

Double.MAX：1023
Double.NIN：-1022
Double.SIZE：64
Double.TYPE：double

*/

Double方法

Double.byteValue() 以byte形式返回Double对象值

Double.compareTo(Double d) 两Double对象进行数值比较，相同则0

Double.equals(Object obj) 比较两对象是否相同，返回boolean

Double.intValue() 以int形式返回double值

Double.isNaN() 非数字值，则返回true，否则false

String.toString() 返回Double对象的字符串形式

Double.valueOf(String str) 返回保存参数的double值的对象

Double.doubleValue() 以double形式返回Double对象

Double.longValue() 以long形式返回double值

Double.parseDouble(String str)返回参数中的数值

public static void main(String[] args) {
        Double d = new Double(11.22);
        Double d2 = new Double(22);
        Double d3 = new Double(11.22);
        
        System.out.println("byteValue() 以byte形式返回Double对象值："+d.byteValue());
        
        System.out.println("compareTo(Double d) 两Double对象进行数值比较，相同则0(d2)："+d.compareTo(d2));
        System.out.println("compareTo(Double d) 两Double对象进行数值比较，相同则0(d3)："+d.compareTo(d3));
        
        System.out.println("equals(Object obj)比较两对象是否相同，返回boolean(d2)："+d.equals(d2));
        System.out.println("equals(Object obj)比较两对象是否相同，返回boolean(d3)："+d.equals(d3));
        
        System.out.println("intValue()以int形式返回double值："+d.intValue());
        
        System.out.println("isNaN()非数字值，则返回true，否则false(d2)："+d2.isNaN());
        
        System.out.println("toString()返回Double对象的字符串形式："+d.toString());
    
        System.out.println("valueOf(String str)返回保存参数的double值的对象："+d.valueOf("22.33"));
        
        System.out.println("doubleValue()以double形式返回Double对象："+d.doubleValue());
        
        System.out.println("longValue() 以long形式返回double值："+d.longValue());
    
    	System.out.println("parseDouble(String str)返回参数中的数值："+d.parseDouble("33.2"));
}

/*

byteValue() 以byte形式返回Double对象值：11
compareTo(Double d) 两Double对象进行数值比较，相同则0(d2)：-1
compareTo(Double d) 两Double对象进行数值比较，相同则0(d3)：0
equals(Object obj)比较两对象是否相同，返回boolean(d2)：false
equals(Object obj)比较两对象是否相同，返回boolean(d3)：true
intValue()以int形式返回double值：11
isNaN()非数字值，则返回true，否则false(d2)：false
toString()返回Double对象的字符串形式：11.22
valueOf(String str)返回保存参数的double值的对象：22.33
doubleValue()以double形式返回Double对象：11.22
longValue() 以long形式返回double值：11
parseDouble(String str)返回参数中的数值：33.2

*/

# Number

Number数值类是byte、Integer、long、float、Double、··· 的父类，Number的方法子类都可以用！！

Number方法

方法 返回值 说明
byteValue() byte 以byte形式返回数值
intValue() int 以int形式返回数值
floatValue() float 以float形式返回数值
shortValue() short 以short形式返回数值
longValue() long 以long形式返回数值
doubleValue() double 以double形式返回数值
public static void main(String[] args) {
     Number num = new Double(23000.23);
 
     System.out.println("以byte形式返回数值："+num.byteValue());
  
     System.out.println("以int形式返回数值："+num.intValue());
     
     System.out.println("以float形式返回数值："+num.floatValue());
     
     System.out.println("以short形式返回数值："+num.shortValue());
     
     System.out.println("以long形式返回数值："+num.longValue());
     
     System.out.println("以double形式返回数值："+num.doubleValue());
 }

/*

以byte形式返回数值：-40
以int形式返回数值：23000
以float形式返回数值：23000.23
以short形式返回数值：23000
以long形式返回数值：23000
以double形式返回数值：23000.23

*/

# System

System类 代表Java运行的平台，系统级的很多属性和控制方法都放置在该类的内部

静态变量

  • PrintStream out ：标准输出流 (用于输出打印
  • InputStream in ：标准输入流 (用于用户输入
  • PrintStream err ：错误输出流 (用于错误打印

方法

返回 方法 参数 说明
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) 1. 源数组
2. 源数组中的起始位置
3. 目标数组
4. 目标数据中的起始位置
5. 要复制的数组元素的数量		 数组复制，指定源数组中复制一个数组
static long currentTimeMillis() - 返回当前时间戳
static void exit(int status) static - 退出状态 终止JVM
static void gc() - 请求垃圾回收
static Properties getProperties() - 获取 当前系统所有数据
static String getProperty(String key) key - 系统属性 获取 指定的值

系统常见属性

属性名 说明
java.version Java 运行时环境版本
java.home Java 安装目录
os.name 操作系统的名称
os.version 操作系统的版本
user.name 用户的账户名称
user.home 用户的主目录
user.dir 用户的当前工作目录

# String

字符串方法

修饰 方法 说明
int length() 测长度 ，返回字符串长度
int indxOf(String s) 找参数的位置，返回参数字符串在字符串首个字符索引位置
int lastIndexOf(String s) 找参数最后出现的位置，返回指定参数的字符串最后一个出现的索引位置
char charAt(int i) 查找索引下标，返回指定索引处的字符
String substring(int i) 查找索引下标开始到结尾，返回指定位置开始到结尾的字符串
String substring(int i , int j) 获取指定范围字符串，返回指定位置范围的字符串
String trim() 去除多余空格，返回字符串副本，消除多余空格的
String replace(char str1,char str2) 字符串/字符替换，返回字符串副本，指定 字符 / 字符串 替换新的 字符 / 字符串
boolean startsWith(String p) 匹配前缀字符串，判定字符串前缀是否匹配参数字符串
boolean endsWith(String p) 匹配后缀字符串，判断字符串后缀是否匹配参数字符串
boolean equals(String str2) 判断是否相同，判断字符串与参数字符串的字符和长度是否相同
boolean equalsIgnoreCase(String str2) 判断是否相同，比较两个字符串的对象
int compareTo(String o) 比较顺序，按字典顺序比较两个字符串，参数位置前正，后负，等于0
String toLowerCase() 转换小写，字符串全部转换为小写
String toUpperCase() 转换大写，字符串全部转换为大写
String[] split(String sign) 分割字符串，指定分割符对字符串进行拆分
sign为分割的字符串，也可以是正则表达式
String[] split(String sign , int i) 分割字符串指定数量，指定分割符对字符串进行拆分，并限制拆分数
Appendable append(content) 添加数据，字符串后面追加内容，频繁操作时引用，限于StringBuilder对象的使用(16字节)
content可以是任何数据类型或其他对象
insert(int i , String str2) 插入数据，参数索引的后一位插入字符串数据
delete(int i , int j) 删除字符串
public static void main(String[] args) {
        String str = new String("I love Java  20.06.05   !!! , or not love Java");
        System.out.println("str："+str);
        String str2 = "Sanscan";
        System.out.println("str2："+str2+"\n");
        String str3 = "192.168.0.1";
        StringBuilder str4 = new StringBuilder("Sanscan");
    
        long no1 = System.currentTimeMillis();
        //length() 测长度
        System.out.println("str.length() 测长度："+str.length());
        //inexOf(String s)找字符串位置
        System.out.println("str.inexOf(String s)找Java字符串位置："+str.indexOf("Java"));
        //lastIndexOf(String s)找参数最后出现的位置
        System.out.println("str.lastIndexOf(String s)找参数最后出现的位置："+str.lastIndexOf("Java"));
        //charAt(int i)查找索引下标
        System.out.println("str.charAt(int i)查找索引下标："+str.charAt(7));
        //substring(int i) 查找索引下标开始到结尾
        System.out.println("str.ubstring(int i) 查找索引下标开始到结尾："+str.substring(5));
        //substring(int i , int j) 获取指定范围字符串
        System.out.println("str.substring(int i , int j)获取指定范围字符串: "+str.substring(3,6));
        //trim() 去除多余空格
        System.out.println("str.trim() 去除多余空格："+str.trim());
        //replace(char str1,char str2) 字符串/字符替换
        System.out.println("str.replace(char str1,char str2) 字符串/字符替换(javas)："+str.replace("Java","javas"));
        //startsWith(String p) 匹配字符
        System.out.println("str.startsWith(String p) 匹配字符(java)："+str.startsWith("java"));
        //endsWith(String p) 匹配后缀字符串
        System.out.println("str.endsWith(String p) 匹配后缀字符串(java): "+str.endsWith("java"));
        //equals(String str2) 判断是否相同
        System.out.println("str2.equals(String str2) 判断是否相同(Sanscan) :"+str2.equals("Sanscan"));
        //equalsIgnoreCase(String str2) 判断是否相同
        System.out.println("str2.equalsIgnoreCase(String str2)判断是否相同(Sanscan)："+str2.equalsIgnoreCase("Sanscan"));
        //compareTo(String o) 比较顺序
        System.out.println("str2.compareTo(String o)  比较顺序(sans)："+str2.compareTo("sans"));
        //toLowerCase() 转换小写
        System.out.println("str.toLowerCase() 转换小写："+str.toLowerCase());
        //toUpperCase() 转换大写
        System.out.println("str.toUpperCase() 转换大写： "+str.toUpperCase());
        //split(String sign) 分割字符串
        System.out.println("str.split(String sign) 分割字符串192.168.0.1："+ str3.split("\\."));
        //split(String sign ,int i) 分割字符串指定数量
        System.out.println("str.split(String sign) 分割字符串192.168.0.1："+ str3.split("\\.", 2));
        //append(content)添加数据
        System.out.println("str4.append(content)添加数据(Java)："+str4.append("Java"));
        //insert(int i , String str2) 插入数据
        System.out.println("str4.insert(int i , String str2) 插入数据(Java)："+str4.insert(2,"Java"));
        //delete(int i , int j) 删除字符串
        System.out.println("str4.delete(int i , int j) 删除字符串："+str4.delete(1,5));
        long no2 = System.currentTimeMillis();
        System.out.println("代码运行了："+(no2-no1));
}

/* 运行结果

str：I love Java  20.06.05   !!! , or not love Java
str2：Sanscan

str.length() 测长度：46
str.inexOf(String s)找Java字符串位置：7
str.lastIndexOf(String s)找参数最后出现的位置：42
str.charAt(int i)查找索引下标：J
str.ubstring(int i) 查找索引下标开始到结尾：e Java  20.06.05   !!! , or not love Java
str.substring(int i , int j)获取指定范围字符串: ove
str.trim() 去除多余空格：I love Java  20.06.05   !!! , or not love Java
str.replace(char str1,char str2) 字符串/字符替换(javas)：I love javas  20.06.05   !!! , or not love javas
str.startsWith(String p) 匹配字符(java)：false
str.endsWith(String p) 匹配后缀字符串(java): false
str2.equals(String str2) 判断是否相同(Sanscan) :true
str2.equalsIgnoreCase(String str2)判断是否相同(Sanscan)：true
str2.compareTo(String o)  比较顺序(sans)：-32
str.toLowerCase() 转换小写：i love java  20.06.05   !!! , or not love java
str.toUpperCase() 转换大写： I LOVE JAVA  20.06.05   !!! , OR NOT LOVE JAVA
str.split(String sign) 分割字符串192.168.0.1：[Ljava.lang.String;@cc34f4d
str.split(String sign) 分割字符串192.168.0.1：[Ljava.lang.String;@17a7cec2
str4.append(content)添加数据(Java)：SanscanJava
str4.insert(int i , String str2) 插入数据(Java)：SaJavanscanJava
str4.delete(int i , int j) 删除字符串：SanscanJava
代码运行了：5

*/

# Array

修饰 方法 参数 说明
static void sort(Object[] a) 1. 数组 升序排列数组
static Object[] copyOf(Object[] o , int count) 1. 数组
2. 长度		 复制数组
static Object[] copyOfRange(Object [] o , int head , int tail) 1. 数组
2. 开始范围
3. 截止范围		 范围复制数组
static int (下标索引) binarySearch(Object[] o , Object key) 1. 数组
2. 查找的值		 数组查询
static int (下标索引) binarySearch(Object[] o , int i , int j , Object key) 1. 数组
2. 开始范围
3. 截止范围
4. 查找的值		 数组范围查询

# Math

Math类提供了数学函数方法。不用实例调用，静态应用即可

Math 包含有

  • 三角函数方法
  • 指数函数方法
  • 取整函数方法
  • 最大、最小、绝对值函数方法
  • ....

# 随机数

Math类中的 random() 方法，用于产生随机数字，生成 [0,1) 之间的 double随机数

控制Math类生成随机数范围的方法

  1. ==Math.random()*m==
  2. ==0*m <= 随机值 * m < 1 * m==
  3. ==0 <= 随机值 < m==

# Random

Random类，Random对象创建随机数生成器

常用生成对随机数的方法

修饰符 方法 说明
int nextInt() 生成随机 整型
int nextInt(int n) 生成随机 整型 范围 [0,n)
E ==next<类型名称>()== 根据类型名称进行随机生成

# BigInteger

BigInteger类 可以准确地表示任何大小的整型而不会丢失数据

构造方法

构造方法 说明
BigInteger(String val) 十进制字符串实例
····

常用方法

返回 方法 说明
BigInteger abs() 获取 绝对值
BigInteger add(BigInteger val) 加法
BigInteger subtract(BigInteger val) 减法
BigInteger mulitply(BigInteger val) 乘法
BigInteger divide(BigInteger val) 除法
BigInteger remainder(BigInteger val) 取余
··· ··· ···

# BigDecimal

BigDecimal类 可以高精度浮动运算，支持任何精度的定点数

构造方法

构造方法 说明
BigDecimal(String val) 根据 String 进行转化 BigDecimal
BigDecima(double val) 根据 double 进行转化 BigDecimal

常用方法

返回 方法 说明
static BigDecima valueOf(double val) 获取 BigDecima对象，指定浮点
BigDecimal add(double val) 加法
BigDecimal subtract(double val) 减法
BigDecimal multiply(double val) 乘法
BigDecimal divide(double val) 除法

# Date

Date 类主要封装了系统的日期和时间的信息

构造方法

构造方法 说明
Date() 分配 Date对象
Date(long date) 根据时间戳 分配Date对象

方法

返回 方法 说明
boolean after(Date when) 判断此日期是否在 指定日期 之后
boolean before(Date when) 判断此日期是否在 指定日期 之前
int compareTo(Date anotherDate) 比较两个日期的顺序（原理类似相减时间戳进行判断顺序
long getTime() 获取 对象的时间戳

# Calendar

Calendar 类是一个抽象类，该类 会根据系统的日历来解释 Date 对象。

该类不能被new实例应用，需要 ==Calendar.getInstance()== 静态方法进行获取对象

应用大致：

  1. 获取 Calendar 对象 (通过该类的静态方法进行获取)
  2. 设置 指定时间 （如set指定新时间等
  3. 改变时间的方法 set()/add()/roll() PS：注意参数通常是 常量 和 指定变化的数值
  4. 通过 getTime() 返回Date对象

常用常量

常量 说明
YEAR 年份
MONTH 月份
DATE 日期
DAY_OF_MONTH 日期
HOUR 12小时制
HOUR_OF_DAY 24小时制
MINUTE 分钟
SECOND 秒
DAY_OF_WEEK 星期几

方法

返回 方法 描述
void add(int field, int amount) 更变 日历字段 field 添加/减去 指定的时间量
boolean after(Object when) 判断 Calendar 是否为 when 之后的时间
boolean before(Object when) 判断 Calendar 是否为 when 之前的时间
void clear() 清空 Calendar 中的日期时间值
int compareTo(Calendar anotherCalendar) 比较 两个 Calendar对象表示的时间值，大则返回 1，小则返回 -1，相等返回 0
int get(int field) 获取 指定日历字段 field 的值
int getActualMaximum(int field) 获取 指定日历字段 field 的最大值
int getActualMinimum(int field) 获取 指定日历字段 field 的最大值
static Calendar getInstance() 使用默认时区和语言坏境获得一个日历
Date getTime() 获取 Calendar 时间值的 Date 对象
long getTimeInMillis() 获取 Calendar 时间值的 时间戳
void set(int field, int value) 为指定的日历字段设置给定值
void set(int year, int month, int date) 设置 Calendar 时间值，以参数的 年月日
void set(int year, int month, int date, int hourOfDay, int minute, int second) 设置 Calendar 时间值，以参数的 年月日时分秒
void setTimeInMillis(long millis) 设置 Calendar 时间值，根据参数的时间戳

# Format

Format 是格式化模板的父类

# DecimalFormat

DecimalFormat 用于格式化十进制数字，该类有特殊字符 构成的格式化模板，是数字会按照特殊字符规则进行匹配

应用大致：

  1. 获取对象
  2. 指定 需要格式化的模板 （设置模板 new参数/applyPattern()方法
  3. 获取格式化后的字符串，通过 format() 指定格式化对象

特殊字符

字符 说明
0 一个数字，不存在则显示0
# 一个数字，存在则显示，否则不显示
. 小数分隔符或货币小数分隔符
- 符号
, 分组分隔符
E 分隔科学计数法中的尾数和指数
% 存在数字的前缀或后缀，乘100显示百分数
\u2030 存在数字的前缀或后缀，乘1000显示千分数
\u00A4 存在数字的前缀或后缀，显示货币记号
‘ 视为普通单引号处理

构造方法

构造方法 说明
DecimalFormat() -
DecimalFormat(String pattern) 指定 pattern模板 实例

常用方法

返回 方法 说明
void applyPattern(String pattern) 指定 pattern 为模板
字符串 format() 格式化对象以字符串生成

# DateFormat

DateFormat 是 日期/时间 格式化子类的抽象类，以与语言无关的方式格式化并解析 日期/时间

该类不能被new实例应用，需要 ==DateFormat.getDateInstance()== 静态方法进行获取对象

返回 方法 描述
static DateFormat getDateInstance() 获取 DateFormat 对象
格式：yyyy-MM-dd
static DateFormat getTimeInstance() 获取 DateFormat 对象
格式：HH:mm:ss
static DateFormat getDateTimeInstance() 获取 DateFormat 对象
格式：yyyy-MM-dd HH:mm:ss
String format(Date date) 获取 指定 Date 格式化日期字符串
Calendar getCalendar() 获取 此日期/时间格式相关联的日历
Date parse(String source) 获取 指定 String 字符串解析成 日期/时间
格式：yyyy-MM-dd HH:mm:ss (前提要对应模板)

# SimpleDateFormat

SimpleDateFormat 以与语言环境有关的方式来格式化和解析日期的具体类，格式/解析 均可操作

常量

字母 含义 示例
y 年份 yy 表示的年扮，如 11； 使用 yyyy 表示的年份，如 2011
M 月份 MM 表示的月份，如 05
d 天数 dd 表示的天数，如 10
D 年份中的天数 D 表示的年份中的天数，如 295
E 星期几 E 表示星期几
H 小时数24制 HH 表示的小时数，如 18
h 小时数12制 hh 表示的小时数，如 10 (无上下午区分)
m 分钟数 mm 表示的分钟数，如 29
s 秒数 ss 表示的秒数，如 38
S 毫秒数 SSS 表示的毫秒数，如 156

构造方法

构造方法 说明
SimpleDateFormat() -
SimpleDateFormat(String pattern) 指定 pattern模板 实例

方法

返回 方法 说明
void applyPattern(String pattern) 指定 pattern 为模板
字符串 format() 格式化对象以字符串生成
String toPattern() 获取 pattern模板
Date parse() 获取 指定模板 解析成 Date
#Java
上次更新: 2023/03/12, 00:43:49

← Java三大特性→

最近更新
01
HTTPS自动续签
10-21
02
博客搭建-简化版(脚本)
10-20
03
ruoyi-vue-plus-部署篇
07-13
更多文章>
Theme by Vdoing | Copyright © 2019-2024 | 桂ICP备2022009417号-1