黑马程序员——Java基础---常用类，基本类型包装类，正则表达式

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、Arrays类

(一)Arrays类概述

针对数组进行操作的工具类。

提供了排序，查找等功能。

(二)成员方法

1. public static String toString(int[] a)：不是重写Object类的toString()，把数组变成字符串。

2. public static void sort(int[] a)：数组排序

3. public static int binarySearch(int[] a,int key)：key表示关键字，数组折半查找，返回关键字出现的索引，没有找到返回负数(-插入点-1)。

4. asList()：将数组转成集合

案例演示：

package arrays;

import java.util.Arrays;

public class ArraysDemo {

public static void main(String[] args) {

method();//升序排列方法Arrays.sort

method1();//折半查找方法Arrays.binarySearch

method2();//将数组变成字符串toString()

}

/*

 * 将数组变成字符串

 *   static String toString(数组)

 */

public static void method2(){

int[] arr = {4,1,6,3,8};

String s = Arrays.toString(arr);

System.out.println(s);

}

/*

 * 数组的折半查找方法 Arrays.binarySearch

 * 传递数组,关键字,返回索引

 * 数组必须是有序的

 * binarySearch 元素没有,返回值的计算方法：返回 -插入点-1

 * 插入点,关键字放到数组中,保证有序,这个索引就是插入点

 */

public static void method1(){

int[] arr = {1,4,7,9,11,15,17,19};

int index = Arrays.binarySearch(arr,6);

System.out.println("所要查找的数的索引为："+index);

}

/*

 * 数组的升序排列方法Arrays.sort

 */

public static void method(){

int[] arr = {7,5,-1,6,2,4,0,9,11};

Arrays.sort(arr);

System.out.print("排序后：[");

for(int x = 0 ; x < arr.length ; x++){

if (x!=arr.length-1) {

System.out.print(arr[x]+",");

}

else System.out.print(arr[x]+"]");

}

System.out.println();

}

}

运行结果：

 

二、基本类型包装类

(一)基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用的操作之一：用于基本数据类型与字符串之间的转换。

基本类型和包装类的对应

Byte，Short，Integer，Long，Float，Double，Character，Boolean

(二)Integer类

1. 概述及其构造方法

Integer 类在对象中包装了一个基本类型 int 的值

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

2. 构造方法

public Integer(int value)

public Integer(String s)

案例演示：

package datatype;

/*

 * Integer类的构造方法

 *   Integer(int value)

 *   Integer(String s)

 * 创建Integer类的对象,包装数据,可以是基本类型int，还可以是数字格式的字符串

 */

public class IntegerGouZao{

public static void main(String[] args) {

//创建Integer类的对象,传递基本类型

Integer i = new Integer(100);

//创建Integer类的对象,传递字符串,数字格式

Integer i2 = new Integer("123");

System.out.println(i);

System.out.println(i2);

}

}

运行结果：

 

3. Integer类成员方法

public int intValue()：将字符串转成基本类型int

public static int parseInt(String s)：将数字格式字符串,转成基本类型int

public static String toString(int i)：将基本类型变成字符串

public static Integer valueOf(int i)：将基本类型转成Integer类的对象

public static Integer valueOf(String s)

4. 常用的基本进制转换

public static String toBinaryString(int i)

public static String toOctalString(int i)

public static String toHexString(int i)

①十进制到其他进制：public static String toString(int i,int radix)

②其他进制到十进制：public static int parseInt(String s,int radix)

基本进制转换案例演示：

package datatype;

public class IntegerJinZhi {

public static void main(String[] args) {

//Integer类的静态方法进制转换，直接类名.方法名调用

String s1 = Integer.toBinaryString(40);

String s2 = Integer.toOctalString(40);

String s3 = Integer.toHexString(40);

System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

}

}

运行结果：

 

Integer类成员方法案例演示：

package datatype;

public class IntegerFunction {

public static void main(String[] args) {

method4();

method3();

method2();

method1();

method();

}

/*

 * Integer类静态方法static Integer valueOf(int) Integer类静态方法static Integer

 * valueOf(String s) 将基本类型转成Integer类的对象

 */

public static void method4() {

Integer i = Integer.valueOf(100);

Integer i2 = Integer.valueOf("100");

System.out.println(i);

System.out.println(i2);

}

/*

 * Integer类方法static toString(int i)将基本类型变成字符串 

 * static String toString(int i,int radix) 第一个参数是十进制数,后面的是要转的进制

 */

public static void method3() {

String s = Integer.toString(2);// 相当于2+""

System.out.println(s);

// 将十进制数15转成二进制数

String s1 = Integer.toString(15, 2);

System.out.println(s1);

}

/*

 * Integer类的方法 intValue()是非静态方法,需要对象调用

 * 将字符串转成基本类型int,转的是Integer构造方法中封装的字符串

 */

public static void method2() {

Integer i = new Integer("123");

int x = i.intValue();

System.out.println(x + 1);

}

/*

 * Integer类静态方法int parseInt(String s,int radix)

 * 将数字格式字符串,转成基本类型int

 * 第二个参数表示基数(进制),第二个参数,表明了前面字符串表示的数字的进制

 * 计算结果十进制 0-9A-Z

 */

public static void method1() {

int x = Integer.parseInt("110", 2);

System.out.println(x);

}

//Integer类静态方法int parseInt(String s) ,将数字格式字符串转成基本类型int

public static void method() {

int x = Integer.parseInt("123");

System.out.println(x + 1);

}

}

运行结果：

 

5. JDK5新特性

JDK1.5以后简化了定义方式。

Integer x = new Integer(4);可以直接写成

Integer x = 4;//自动装箱。

x  = x + 5;//自动拆箱。通过intValue方法。

案例演示：

package datatype;

public class ChaiX_ZhuangX {

public static void main(String[] args) {

//自动装箱，基本类型变成对象

Integer a=500;//Integer a=new Integer(500);

//自动拆箱，将对象变成基本类型

a=a+500;

System.out.println("a="+a);

}

}

运行结果：

 

6. 需要注意：在使用时，Integer  x = null;上面的代码就会出现NullPointerException。

(三)Character类

1. Character类概述

Character 类在对象中包装一个基本类型 char 的值

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

2. Character类的构造方法

public Character(char value)

3. Character类成员方法

public static boolean isUpperCase(char ch)：判断字符是不是大写

public static boolean isLowerCase(char ch)：判断字符是不是小写

public static boolean isDigit(char ch)：判断字符是不是数字

public static char toUpperCase(char ch)：字符转成大写

public static char toLowerCase(char ch)：字符转成小写

案例演示：

package datatype;

/*

 * Character类静态方法

 * 判断：返回都是布尔

 * isUpperCase(char ch)是不是大写

 * isLowerCase(char ch)是不是小写

 * isDight(char ch)是不是数字

 * 转换

 * char toUpperCase(char)转成大写

 * char toLowerCase(char)转成小写

 */

public class CharacterFunction {

public static void main(String[] args) {

//判断字符是不是大写

boolean b=Character.isUpperCase('A');

System.out.println(b);

//判断字符是不是小写

boolean b1=Character.isLowerCase('a');

System.out.println(b1);

//判断字符是不是数字

boolean b2=Character.isDigit('0');

System.out.println(b2);

//字符转成小写

char c=Character.toLowerCase('A');

System.out.println(c);

//字符转成大写

char c1=Character.toUpperCase('t');

System.out.println(c1);

}

}

运行结果：

 

4. 练习：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数

package datatype;

public class CharacterTest {

public static void main(String[] args) {

String s = "geHDveSew43Gd32";

// 定义三个变量,计数器

int upper = 0;

int lower = 0;

int digit = 0;

// 转成字符数组

char[] ch = s.toCharArray();

for (int x = 0; x < ch.length; x++) {

if (Character.isUpperCase(ch[x]))

upper++;

else if (Character.isLowerCase(ch[x]))

lower++;

else if (Character.isDigit(ch[x]))

digit++;

}

System.out.println("大写字母有:" + upper + " 个");

System.out.println("小写字母有:" + lower + " 个");

System.out.println("数字有:" + digit + " 个");

}

}

运行结果：

 

三、正则表达式

(一)正则表达式概述及基本使用

1. 概述：正则表达式是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

2. 特点：用于一些特定的符号来表示一些代码操作，这样可以简化书写。所以学习正则表达式，就是在学习一些特殊符号的使用。

3. 好处与弊端

好处：可以简化对字符串的复杂操作

弊端：符合定义越多，正则越长，阅读性越差

4. 正则表达式的组成规则

规则字符在java.util.regex.Pattern类中

常见组成规则：字符、字符类、预定义字符类、边界匹配器、数量词。

演示案例：校验qq号码.，要求必须是5-15位数字，0不能开头

package regex;

import java.util.Scanner;

public class RegexQQ {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入QQ号码");

String number = sc.nextLine();

boolean b = number.matches("[1-9][0-9]{4,10}");

System.out.println(b);

}

}

运行结果：

 

5. 正则表达式的应用

(1)判断功能：public boolean matches(String regex)：正则表达式的匹配功能

(2)分割功能：public String[] split(String regex)

(3)替换功能：public String replaceAll(String regex,String replacement)

(4)获取功能：Pattern和Matcher类的使用

正则表达式匹配功能的案例演示：

package regex;

public class RegexMatches {

public static void main(String[] args) {

method();

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

method1();

}

//匹配数量词

public static void method(){

//字符串出现的次数匹配

String s="abbbbb";

boolean b=s.matches("ab{3,5}");

System.out.println(b);

}

// 匹配字符类

public static void method1(){

//中间的字符必须是元音字母

String s="beb";

boolean b=s.matches("b[^lsgkfg]b");

System.out.println(b);

//中间的字符只能是数字

String s1="b0b";

b=s1.matches("b[\\d]b");

System.out.println(b);

//中间的字符是字母就行

String s2="0~0";

b=s2.matches("0[a-zA-Z]");

System.out.println(b);

}

}

运行结果：

 

正则表达式分割功能案例演示

package regex;

public class RegexSplit {

public static void main(String[] args) {

String path = "F:\\javalianxi\\lianxi3\\键盘录入";

// 路径中的 \ 对字符串进行切割

// F: avalianxi lianxi3 存储到数组中

String[] str = path.split("\\\\");

for (int x = 0; x < str.length; x++) {

System.out.println(str[x]);

}

}

}

运行结果：

 

正则表达式替换功能案例演示

package regex;

/*

 * 正则表达式替换功能

 *   String类方法replaceAll(String , String)

 *   第一个参数,写正则规则

 *   第二个参数,被替换后的字符串

 * 凡是字符串中符合规则的内容,都会被替换

 */

public class RegexReplaceAll {

public static void main(String[] args) {

String s = "he345llo332worte4w234ld";

// 所有数字,替换成*

s = s.replaceAll("[0-9]", "*");

System.out.println(s);

}

}

运行结果：

 

正则表达式获取功能案例演示

package regex;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/*

 * 实现步骤：

 * 1.Pattern类静态方法compile(正则规则)

 * 含义，方法将正则规则进行预编译

 * 静态方法compile返回值是本类类型Pattern

 * 返回的是Pattern类的对象

 * 2.调用Pattern非静态方法matcher(查找的字符串)

 * 含义，将字符串和预先编译的正则规则，进行匹配

 * matcher返回值是Matcher类类型

 * 返回Matcher类的对象(Matcher类，叫做匹配器)

 * 3.Matcher类对象find进行匹配后的查找，找的是规则和字符串匹配后的结果

 * find返回布尔类型

 * 4.Matcher类方法group获取查找后的结果

 * 方法返回String

 */

public class RegexPattern {

public static void main(String[] args) {

//1.静态方法compile，预编译规则,获取出三个字母的单词

Pattern p=Pattern.compile("\\b[a-zA-Z]{3}\\b");//\b表示单词边界匹配

//2.Pattern类非静态方法matcher，传递字符串，进行匹配

Matcher m=p.matcher("da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi le,da jia gao xing ma?");

//3.Matcher对象方法find找匹配后的结果

while (m.find()) {

//Matcher类方法group获取查找后的结果

System.out.println(m.group());

}

}

}

运行结果：

 

6. 正则规则写法

常见符号

       说明：X表示字符X或者匹配的规则。

(1)字符

        x                  字符 x

        \\                 反斜线字符

        \t                 制表符 ('\u0009')

        \n                 新行（换行）符 ('\u000A')

        \r                 回车符 ('\u000D')

        \f                 换页符 ('\u000C')

        \a                 报警 (bell) 符 ('\u0007')

(2)字符类

        [abc]                    a、b或 c（简单类）

        [^abc]                 任何字符，除了 a、b或 c（否定）

        [a-zA-Z]               a到 z或 A 到 Z，两头的字母包括在内（范围）

        [a-d[m-p]]            a到 d或 m 到 p：[a-dm-p]（并集）

        [a-z&&[def]]               d、e或 f（交集）

        [a-z&&[^bc]]        a到 z，除了 b和 c：[ad-z]（减去）

        [a-z&&[^m-p]]     a到 z，而非 m到 p：[a-lq-z]（减去）

(3)预定义字符类

        .                         任何字符（与行结束符可能匹配也可能不匹配）

        \d                        数字：[0-9]

        \D                       非数字： [^0-9]

        \s                        空白字符：[ \t\n\x0B\f\r]

        \S                       非空白字符：[^\s] 

        \w                       单词字符：[a-zA-Z_0-9]

        \W                      非单词字符：[^\w]

(4)边界匹配器

        ^                         行的开头

        $                         行的结尾

        \b                        单词边界

        \B                       非单词边界

        \A                       输入的开头

        \G                       上一个匹配的结尾

        \Z                       输入的结尾，仅用于最后的结束符（如果有的话）

        \z                        输入的结尾

5、Greedy数量词

        X?                       X，一次或一次也没有

        X*                       X，零次或多次

        X+                       X，一次或多次

        X{n}                    X，恰好 n次

        X{n,}                   X，至少 n次

        X{n,m}                X，至少 n次，但是不超过 m 次

7. 正则表达式的练习

(1)校验邮箱

package regex;

import java.util.Scanner;

public class Mailbox {

public static void main(String[] args) {

checkEmail();

}

public static void checkEmail(){

Scanner sc=new Scanner(System.in);

System.out.println("请输入邮箱：");

String email=sc.nextLine();

//String email="my@sina.com";

boolean b=email.matches("[a-zA-Z0-9]+@+[a-zA-Z0-9]+(\\.[a-z]+)+");

System.out.println(b);

}

}

运行结果：

 

(2)我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

package regex;

public class StringSort {

public static void main(String[] args) {

sort();

}

public static void sort(){

String s="91 27 46 38 50";

System.out.println("原字符串为："+s);

//s对象调用方法split将字符串切割，返回字符串数组

String[] str=s.split(" +");

//定义一个长度为str长度的int型数组

int[] arr =new int[str.length];

for (int i = 0; i < str.length; i++) {

//Integer类的静态方法parseInt将数字格式的字符串转成基本类型int，存储到int型数组

arr[i]=Integer.parseInt(str[i]);

}

//运用选择排序将数组中的元素进行排序

for (int i = 0; i < arr.length; i++) {

for (int j =i+1 ; j < arr.length; j++) {

if (arr[i]>arr[j]) {

int t=arr[i];

arr[i]=arr[j];

arr[j]=t;

}

}

}

//将int型数组转成字符串输出

StringBuffer buffer=new StringBuffer();

for (int j = 0; j < arr.length; j++) {

if (j!=arr.length-1) {

buffer.append(arr[j]+" ");

}

else buffer.append(arr[j]);

}

System.out.println("最终结果为："+buffer);

}

}

运行结果：

 

四、Math类

(一)Math类概述

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

(二)成员方法

public static int abs(int a)：计算绝对值

public static double ceil(double a)：返回最小的double值，该值大于等于参数，并等于某个整数

public static double floor(double a)：返回最大的double值，该值小于等于参数，并等于某个整数。

public static int max(int a,int b) ：传递两个参数，返回较大的一个

public static double pow(double a,double b)：计算的是a的b次幂

public static double random()：返回带正号的double值，该值大于等于0.0且小于1.0。

public static int round(float a)：对参数进行四舍五入，取整

案例演示：

package math;

public class MathDemo {

public static void main(String[] args) {

method5();

method4();

method3();

method2();

method1();

method();

}

public static void method5(){

//计算的是a的b次幂

double d = Math.pow(2,3);

System.out.println("2的3次方为："+d);

}

public static void method4(){

//对参数进行四舍五入,取整

double d = Math.round(5.58); 

System.out.println("5.58四舍五入后为："+d);

}

public static void method3(){

//返回小于或者等于参数的最大Double数

double d = Math.floor(-11.56);

System.out.println("-11.56求floor后为："+d);

}

public static void method2(){

//返回大于或者等于参数的最小Double数

double d = Math.ceil(11.56);

System.out.println("11.56求ceil后为："+d);

}

public static void method1(){

//求最大值,传递两个参数,返回较大的一个

int x = Math.max(15, 19);

System.out.println("两个数中的大数为："+x);

}

public static void method(){

//abs计算绝对值

int x = Math.abs(-3);

System.out.println("-3的绝对值为："+x);

}

}

运行结果：

 

五、Random类

(一)Random类概述

此类用于产生随机数

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

(二)构造方法

public Random()

public Random(long seed)

(三)成员方法

public int nextInt()

public int nextInt(int n)

(四)案例演示

package random;

import java.util.*;

public class RandomDemo {

public static void main(String[] args) {

Random r = new Random();

for (int x = 0; x < 5; x++) {

int number = r.nextInt(100);

System.out.println(number);

}

}

}

运行结果：

 

六、System类

(一)System类概述

System 类包含一些有用的类字段和方法。它不能被实例化。 

(二)成员方法

public static void gc()：可用于垃圾回收

public static void exit(int status)：退出虚拟机，所有的程序全部停止

public static long currentTimeMillis()：返回的是自1970年1月1日午夜零时，到升序运行的那一时刻.所经过的毫秒值

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：复制数组，Object src 复制数组数据源，int srcPos 复制数组数据源开始下标，Object dest 复制目的数组，int destPos 复制目的数组开始索引，int length 复制几个

(三)案例演示

package system;

import java.util.Arrays;

public class SystemDemo {

public static void main(String[] args) {

method3();

method2();

method1();

//method();

}

/*

 * static void arrayCopy 复制数组

 * (Object src, int srcPos, Object dest, int destPos, int length)

 * Object src 复制数组数据源

 * int srcPos 复制数组数据源开始下标

 * Object dest 复制目的数组

 * int destPos 复制目的数组开始索引

 * int length 复制几个

 */

public static void method3(){

//定义数组数据源

int[] src = {11,22,33,44,55};

//定义数据目的

int[] dest = new int[src.length+2];

//复制数组

System.arraycopy(src, 0, dest, 0, src.length);

//输出目的

System.out.println(Arrays.toString(dest));

}

/*

 * static Properties getProperties

 * 返回当前操作系统的属性

 */

public static void method2(){

System.out.println(System.getProperties());

}

/*

 * static long currentTimeMillis()

 * 返回值是一个long参数,int不够了

 * 返回的是自1970年1月1日午夜零时,到升序运行的那一时刻.所经过的毫秒值

 * 1000毫秒=1秒

 * 1970年1月1日午夜零时 JAVA语言的时间零点,毫秒值0

 */

public static void method1(){

long time = System.currentTimeMillis();

System.out.println(time);

}

/*

 * static exit(int i)

 * 退出虚拟机,所有的程序全部停止

 */

public static void method(){

while(true){

System.exit(0);

System.out.println("死循环");

}

}

}

七、BigInteger类

(一)BigInteger类概述

可以让超过Integer范围内的数据进行运算

(二)构造方法

public BigInteger(String val)

(三)成员方法

public BigInteger add(BigInteger val)：加法运算，两个BigInteger类的对象进行相加

public BigInteger subtract(BigInteger val)：减法计算，两个BigInteger类的对象进行相减

public BigInteger multiply(BigInteger val)：乘法计算，两个BigInteger类的对象进行乘法

public BigInteger divide(BigInteger val)：除法计算，两个BigInteger类的对象进行除法

public BigInteger[] divideAndRemainder(BigInteger val)

(四)案例演示

package bigdata;

import java.math.*;

public class BigIntegerDemo {

public static void main(String[] args) {

BigInteger bi= new BigInteger("314830481406489259458");

System.out.println(bi);

add();

sub();

mul();

div();

}

public static void add(){

BigInteger b1= new BigInteger("314830481406489259458");

BigInteger b2= new BigInteger("314830481406489259458");

System.out.println(b1.add(b2));

}

public static void sub(){

BigInteger b1= new BigInteger("314830481406489259458");

BigInteger b2= new BigInteger("314830481406489259458");

System.out.println(b1.subtract(b2));

}

public static void mul(){

BigInteger b1= new BigInteger("314830481406");

BigInteger b2= new BigInteger("314830481406");

System.out.println(b1.multiply(b2));

}

public static void div(){

BigInteger b1= new BigInteger("31483048140");

BigInteger b2= new BigInteger("31483048140");

System.out.println(b1.divide(b2));

}

}

运行结果：

 

八、BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

(一)BigDecimal类概述

不可变的、任意精度的有符号十进制数。

(二)构造方法

public BigDecimal(String val) 

(三)成员方法

public BigDecimal add(BigDecimal augend)：两个BigDeimal对象加法运算

public BigDecimal subtract(BigDecimal subtrahend)：两个BigDeimal对象减法运算

public BigDecimal multiply(BigDecimal multiplicand)：两个BigDeimal对象乘法运算

public BigDecimal divide(BigDecimal divisor)

public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)

(四)案例演示

package bigdata;

import java.math.*;

public class BigDecimalDemo1 {

public static void main(String[] args) {

method3();

method2();

method1();

method();

}

/*

 * BigDeimal的除法运算

 * divide

 * 两个BigDeimal对象除法

 * Non-terminating decimal expansion; no exact representable decimal result

 * 除法运算,出现了无限不循环的小数结果

 * divide(BigDecimal divisor, int scale, int roundingMode) 

 * int scale 保留位数

 * int roundingMode 舍入模式

 *   1.412345

                 舍入模式 , 看BigDeimal类的静态成员变量

          ROUND_UP 0.02 向上+1

          ROUND_DOWN 0.01 直接舍去

          ROUND_HALF_UP  四舍五入

          ROUND_HALF_DOWN 舍去部分>0.5向上

 */

public static void method3(){

//创建2个BigDeimal类的对象,封装小数,写字符串

BigDecimal b1 = new BigDecimal("1.500");

BigDecimal b2 = new BigDecimal("100");

//b1对象,调用divide,传递b2  b1/b2

//保留2位小数  0.01501 0.01500

BigDecimal b3 = b1.divide(b2,2,BigDecimal.ROUND_HALF_DOWN);

System.out.println(b3);

}

/*

 * BigDeimal的乘法运算

 * multiply

 * 两个BigDeimal对象乘法

 */

public static void method2(){

//创建2个BigDeimal类的对象,封装小数,写字符串

BigDecimal b1 = new BigDecimal("1.015");

BigDecimal b2 = new BigDecimal("100");

//b1对象,调用multiply,传递b2  b1*b2

BigDecimal b3 = b1.multiply(b2);

System.out.println(b3);

}

/*

 * BigDecimnal的减法运算

 * subtract

 * 两个BigDeimal对象减法

 */

public static void method1(){

//创建2个BigDeimal类的对象,封装小数,写字符串

BigDecimal b1 = new BigDecimal("1.0");

BigDecimal b2 = new BigDecimal("0.32");

//b1对象,调用subtract,传递b2  b1-b2

BigDecimal b3 = b1.subtract(b2);

System.out.println(b3);

}

/*

 * BigDecimal对象加法计算

 * add

 * 两个BigDeimal对象加法

 */

public static void method(){

//创建2个BigDeimal类的对象,封装小数,写字符串

BigDecimal b1 = new BigDecimal("456.76543245");

BigDecimal b2 = new BigDecimal("543.6788");

//b1对象,调用add,传递b2  b1+b2

BigDecimal b3 = b1.add(b2);

System.out.println(b3);

}

}

运行结果：

 

九、Date类

(一)Date类概述

类Date表示特定的瞬间，精确到毫秒。 

(二)构造方法

public Date()：返回当前操作系统上的时间和日期

public Date(long date)：将日期设置到毫秒值指定的日期上

案例演示

package date;

import java.util.Date;

public class DateDemo {

public static void main(String[] args) {

//创建日期对象，空参构造方法

//获取运行时候，操作系统上的时间和日期

Date d=new Date(); 

System.out.println(d);

//调用Date类的构造方法，传递毫秒值

//将毫秒值转成日期对象

Date d1=new Date(0);

System.out.println(d1);

}

}

运行结果：

 

(三)成员方法

public long getTime()：将毫秒值转成日期对象

public void setTime(long time)：返回long参数,将日期对象转成毫秒值

案例演示

package date;

import java.util.*;

public class Get_SetTime {

public static void main(String[] args) {

get();

set();

}

public static void get(){

//创建日期对象

Date d=new Date();

//d对象调用Date类方法getTime将当前日期变成毫秒值，返回long参数

long time=d.getTime();

System.out.println(time);

}

public static void set(){

//创建Date对象

Date d=new Date();

//d对象调用Date类方法setTime,将毫秒值转成日期对象，传递long参数

d.setTime(0);

System.out.println(d);

}

}

运行结果：

 

十、DateFormat类

(一)DateFormat类概述

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

是抽象类，所以使用其子类SimpleDateFormat

1. SimpleDateFormat构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

(二)成员方法

public final String format(Date date)：格式化日期

public Date parse(String source)：传递字符串,变成日期对象

1. DateFormat案例演示

package date;

import java.text.*;

import java.util.*;

public class DateFormatDemo {

public static void main(String[] args) {

//DateFormat类的静态方法getDateTimeInstance获取格式化类对象

DateFormat df=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);

//df对象调用本类方法format格式化日期

String time=df.format(new Date());//new Date()获取的是当前操作系统的时间和日期

System.out.println(time);

}

}

运行结果：

 

2. SimpleDateFormat案例演示

package date;

import java.text.*;

import java.util.*;

public class SimpleDateFormatDemo {

public static void main(String[] args) {

//创建SimpleDateFormat对象

SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日   HH:mm:ss");

//sdf对象调用父类Format的方法format，传递Date类对象，返回字符串类型

String date=sdf.format(new Date());

System.out.println(date);

}

}

运行结果：

 

3. 算一下你来到这个世界多少天?

package date;

import java.text.*;

import java.util.*;

public class DateTest {

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

//从键盘接收你的生日

System.out.println("请输入你的生日,我来计算你来这个世界多少天了？");

String birthday=new Scanner(System.in).nextLine();

//DateFormat类的子类对象

DateFormat df=DateFormat.getDateInstance();

//df对象调用DateFormat类的方法parse将字符串birthday转成日期对象

Date birthdayDate=df.parse(birthday);

//创建Date对象，获取当前操作系统的时间和日期

Date todayDate=new Date();

//birthdayDate对象调用Date类方法getTime将日期对象变成毫秒值

long birthdayTime=birthdayDate.getTime();

//todayDate对象调用Date类方法getTime将日期对象变成毫秒值

long todayTime=todayDate.getTime();

if (todayTime//判断这个人是否出生

System.out.println("你还没出生呢？？？");

}

else{

//相减得到毫秒值，然后将毫秒值转成天数

long day=(todayTime-birthdayTime)/1000/60/60/24;

System.out.println("你来这个世界"+day+"天了");

}

}

}

运行结果：

 

十一、Calendar类

(一)Calendar类概述

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

(二)成员方法

public static Calendar getInstance()：被类名直接调用，返回值是本类对象，本类是抽象类，返回的是子类对象(GregorianCalendar)

public int get(int field)：传递日历字段，返回这个日历字段对应的数字

public void add(int field,int amount)：要偏移的日历字段,偏移具体数据,正数向后偏移,负数向前偏移

public final void set(int year,int month,int date)：传递参数,写int类型的,年月日

(三)练习

1. GetInstance方法案例演示

package date;

import java.util.*;

public class CalendarGetInstance{

public static void main(String[] args) {

//Calendar类静态方法getInstance获取子类对象

Calendar c = Calendar.getInstance();

System.out.println(c);

}

}

2. get方法案例演示

package date;

import java.util.*;

public class CalendarGetDemo {

public static void main(String[] args) {

Calendar c = Calendar.getInstance();// 系统日历

printCalendar(c);

}

public static void printCalendar(Calendar c) {

// 输出日历 2015年07月29日 星期三 XX点XX分XX秒 字符串的拼接作用

System.out.println(c.get(Calendar.YEAR) + "年"

+ getDay((c.get(Calendar.MONTH) + 1)) + "月"

+ getDay(c.get(Calendar.DAY_OF_MONTH)) + "日 "

+ getWeek((c.get(Calendar.DAY_OF_WEEK) - 1)) + " "

+ c.get(Calendar.HOUR_OF_DAY) + "点 " + c.get(Calendar.MINUTE)

+ "分 " + c.get(Calendar.SECOND) + "秒");

}

/*

 * 定义方法,将月份和天数,不足2位数 补齐2位数 07 01 -- String

 */

private static String getDay(int day) {

if (day < 10)

return "0" + day;

return day + "";

}

/*

 * 定义方法,数组查表法,还原星期

 */

private static String getWeek(int week) {

String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };

return weeks[week];

}

}

运行结果：

 

3. 日历类的设置方法

package date;

import java.util.*;

public class CalendarSetDemo {

public static void main(String[] args) {

method();

method1();

method2();

method3();

}

/*

 * setTimeInMillis(毫秒值)

 * 设置日历到指定毫秒值上

 */

public static void method3(){

Calendar c = Calendar.getInstance();

c.setTimeInMillis(0);

CalendarGetDemo.printCalendar(c);

}

/*

 * setTime方法设置日历

 * 传递Date对象(系统日期)

 */

public static void method2(){

Calendar c = Calendar.getInstance();

//设置日历,和Date对象是一样的

c.setTime(new Date());

CalendarGetDemo.printCalendar(c);

}

/*

 * set方法设置日历

 *  同时指定年月日

 */

public static void method1(){

Calendar c = Calendar.getInstance();

//设置到2008年的8月8日

c.set(2008, 7, 8);

CalendarGetDemo.printCalendar(c);

}

/*

 * set方法设置日历

 *  指定设置的字段,指定具体数

 */

public static void method(){

Calendar c = Calendar.getInstance();

//日历设置到,月份,12月

c.set(Calendar.MONTH,11);

CalendarGetDemo.printCalendar(c);

}

}

运行结果：

 

4. add方法案例演示

package date;

import java.util.*;

public class CalendarAddDemo {

public static void main(String[] args) {

Calendar c = Calendar.getInstance();

//日历进行偏移,年份,向后偏移5年

c.add(Calendar.YEAR, -5);

CalendarGetDemo.printCalendar(c);

}

}

运行结果：

 

5. 判断任意一年的二月是不是闰年，从键盘接收年份

package date;

import java.util.*;

import java.text.*;

public class CalendarTest {

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

Scanner sc = new Scanner(System.in);

System.out.println("请输入年份：");

String year = sc.nextLine();

test1(year);

}

//计算闰年,3月1日,偏移1天

public static void test1(String year){

Calendar c = Calendar.getInstance();

int y = Integer.parseInt(year);

//日历设置到这一年的3月1日

c.set(y, 2, 1);

CalendarGetDemo.printCalendar(c);

c.add(Calendar.DAY_OF_MONTH, -1);

CalendarGetDemo.printCalendar(c);

int day = c.get(Calendar.DAY_OF_MONTH);

if(day==29)

System.out.println("闰年");

else

System.out.println("平年");

}

}

运行结果：

 

 

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------