java常见对象_4-java常见对象-常用类的介绍及使用

最新推荐文章于 2022-07-04 17:14:19 发布

思简

最新推荐文章于 2022-07-04 17:14:19 发布

阅读量138

点赞数

文章标签： java常见对象

本文链接：https://blog.csdn.net/weixin_30030437/article/details/114471528

版权

14.11_常见对象(Math类概述和方法使用)

A:Math类概述

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

B:成员方法

public static int abs(int a)

public static double ceil(double a)

public static double floor(double a)

public static int max(int a,int b)

public static double pow(double a,double b)

public static double random()

public static int round(float a)

public static double sqrt(double a)

/**

* @param args

* * A:Math类概述

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

* B:成员方法

* public static int abs(int a)

* public static double ceil(double a)

* public static double floor(double a)

* public static int max(int a,int b)

* public static double pow(double a,double b)

* public static double random()

* public static int round(float a)

* public static double sqrt(double a)

public static void main(String[] args) {

System.out.println("//打印结果是：");

System.out.println(Math.PI);

System.out.println(Math.abs(-10)); //取绝对值

//ceil天花板

* 13.0

* 12.3

* 12.0

System.out.println(Math.ceil(12.3));//向上取整,但是结果是一个double

System.out.println(Math.ceil(12.99));

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

//floor地板

* 13.0

* 12.3

* 12.0

System.out.println(Math.floor(12.3));//向下取整,但是结果是一个double

System.out.println(Math.floor(12.99));

//获取两个值中的最大值

System.out.println(Math.max(20, 30));

//前面的数是底数,后面的数是指数

System.out.println(Math.pow(2, 3));//2.0 ^ 3.0

//生成0.0到1.0之间的所以小数,包括0.0,不包括1.0

System.out.println(Math.random());

//四舍五入

System.out.println(Math.round(12.3f));

System.out.println(Math.round(12.9f));

//开平方

System.out.println(Math.sqrt(4));

System.out.println(Math.sqrt(2));

System.out.println(Math.sqrt(3));

}

//打印结果是：

3.141592653589793

13.0

-----------

12.0

8.0

0.5499534369777632

2.0

1.4142135623730951

1.7320508075688772

14.12_常见对象(Random类的概述和方法使用)

A:Random类的概述

此类用于产生随机数如果用相同的种子创建两个 Random 实例，

则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

B:构造方法

public Random()

public Random(long seed)

C:成员方法

public int nextInt()

public int nextInt(int n)

/**

* * A:Random类的概述

* 此类用于产生随机数如果用相同的种子创建两个 Random 实例，

* 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

* B:构造方法

* public Random()

* public Random(long seed)

* C:成员方法

//返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

* public int nextInt()

//返回一个伪随机数，它是取自此随机数生成器序列的、在 0(包括)和指定值(不包括)之间均匀分布的 int 值。

* public int nextInt(int n)

public static void main(String[] args) {

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

Random r1 = new Random();

//返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

int x = r1.nextInt();

System.out.println(x);

System.out.println("------Random----nextInt(int n) ------------");

Random r2 = new Random();

for(int i = 0; i < 10; i++) {

//System.out.println(r.nextInt());

System.out.println(r2.nextInt(100));//要求掌握,生成在0到n范围内的随机数,包含0不包含n

}

* -1244746321

1060493871

-1244746321

1060493871

System.out.println("------Random(long seed)----nextInt(int n) ------------");

Random r3 = new Random(1001);//使用单个 long 种子创建一个新的随机数生成器。

int a = r3.nextInt();

int b = r3.nextInt();

System.out.println(a);

System.out.println(b);

}

//打印结果如下：

------------Random--nextInt()----------

562474177

------Random----nextInt(int n) ------------

------Random(long seed)----nextInt(int n) ------------

-1245131070

-2078988849

14.13_常见对象(System类的概述和方法使用)

A:System类的概述

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

B:成员方法

public static void gc()

public static void exit(int status)

public static long currentTimeMillis()

pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

C:案例演示

System类的成员方法使用

public class DemoSystem {

@Test

public void testSystemGc(){

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

for(int i= 0;i<2;i++){

new Person();

System.gc();//运行垃圾回收器,相当于呼喊保洁阿姨

}

@Test

public void testSystemExit(){

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

System.exit(1);//非0状态是异常终止,退出jvm

System.out.println("11111111111");

}

@Test

public void testSystemCurrentTime(){

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

long time = System.currentTimeMillis();

System.out.println(String.valueOf(time));

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String currentTime = sdf.format(new Date(time));

System.out.println(currentTime);

}

@Test

public void testSystemCopyArray(){

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

int [] array1 = {12,9,4,1,55,76};

System.out.println("数组1："+Arrays.toString(array1));

int [] array2 = new int [array1.length];

System.out.println("数组2："+Arrays.toString(array2));

/**

* src - 源数组。

srcPos - 源数组中的起始位置。

dest - 目标数组。

destPos - 目标数据中的起始位置。

length - 要复制的数组元素的数量。

System.arraycopy(array1, 0, array2, 0, array1.length);

System.out.println("拷贝后的数组："+Arrays.toString(array2));

}

class Person{ //在一个源文件中不允许定义两个用public修饰的类

@Override

protected void finalize() throws Throwable {

// TODO Auto-generated method stub

System.out.println("资源被销毁了");

}

//打印结果如下：

--------System.gc()----------

资源被销毁了

--------System.currentTimeMillis()----------

1470032925284

2016-08-01 14:28:45

-------System.exit(1)-----------

14.14_常见对象(BigInteger类的概述和方法使用)

A:BigInteger的概述

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

B:构造方法

public BigInteger(String val)

C:成员方法

public BigInteger add(BigInteger val)

public BigInteger subtract(BigInteger val)

public BigInteger multiply(BigInteger val)

public BigInteger divide(BigInteger val)

public BigInteger[] divideAndRemainder(BigInteger val)

public static void main(String[] args) {

//long num = 123456789098765432123L;

//String s = "123456789098765432123";

BigInteger bi1 = new BigInteger("100");

BigInteger bi2 = new BigInteger("2");

System.out.println(bi1.add(bi2)); //+

System.out.println(bi1.subtract(bi2));//-

System.out.println(bi1.multiply(bi2)); //*

System.out.println(bi1.divide(bi2)); ///(除)

BigInteger[] arr = bi1.divideAndRemainder(bi2);//取除数和余数

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

System.out.println(arr[i]);

}

//打印结果如下：

102

200

14.15_常见对象(BigDecimal类的概述和方法使用)

A:BigDecimal的概述

由于在运算的时候，float类型和double很容易丢失精度，演示案例。

所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

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

B:构造方法

public BigDecimal(String val)

C:成员方法

public BigDecimal add(BigDecimal augend)

public BigDecimal subtract(BigDecimal subtrahend)

public BigDecimal multiply(BigDecimal multiplicand)

public BigDecimal divide(BigDecimal divisor)

D:案例演示

BigDecimal类的构造方法和成员方法使用

/**

* * A:BigDecimal的概述

* 由于在运算的时候，float类型和double很容易丢失精度，演示案例。

* 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

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

* B:构造方法

* public BigDecimal(String val)

* C:成员方法

* public BigDecimal add(BigDecimal augend)

* public BigDecimal subtract(BigDecimal subtrahend)

* public BigDecimal multiply(BigDecimal multiplicand)

* public BigDecimal divide(BigDecimal divisor)

* D:案例演示

* BigDecimal类的构造方法和成员方法使用

十进制表示1/3

0.3333333333333333333333333333333333333333

public static void main(String[] args) {

System.out.println(2.0 - 1.1);

BigDecimal bd1 = new BigDecimal(2.0);//这种方式在开发中不推荐,因为不够精确

BigDecimal bd2 = new BigDecimal(1.1);

System.out.println(bd1.subtract(bd2));

BigDecimal bd3 = new BigDecimal("2.0");//通过构造中传入字符串的方式,开发时推荐

BigDecimal bd4 = new BigDecimal("1.1");

System.out.println(bd3.subtract(bd4));

BigDecimal bd5 = BigDecimal.valueOf(2.0);//这种方式在开发中也是推荐的

BigDecimal bd6 = BigDecimal.valueOf(1.1);

System.out.println(bd5.subtract(bd6));

}

//打印结果如下：

0.8999999999999999

0.899999999999999911182158029987476766109466552734375

0.9

14.16_常见对象(Date类的概述和方法使用)

A:Date类的概述

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

B:构造方法

public Date()

public Date(long date)

C:成员方法

public long getTime()

public void setTime(long time)

@Test

public void testDate1(){

Date d1 = new Date();//如果没有传参数代表的是当前时间

System.out.println(d1);

Date d2 = new Date(0);//如果构造方法中参数传为0代表的是1970年1月1日

System.out.println(d2);//通过毫秒值创建时间对象

}

@Test

public void testDate2(){

Date d1 = new Date();

// 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

System.out.println(d1.getTime());

// 当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量)。

System.out.println(System.currentTimeMillis());

}

@Test

public void testDate3(){

Date d1 = new Date();

d1.setTime(1000);

System.out.println(d1);

}

//打印结果如下：

Mon Aug 01 15:22:32 CST 2016

Thu Jan 01 08:00:00 CST 1970

1470036152585

1470036152586

Thu Jan 01 08:00:01 CST 1970

14.17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)

A:DateFormat类的概述

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

B:SimpleDateFormat构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

C:成员方法

public final String format(Date date)

public Date parse(String source)

@Test

public void demo4() {

//demo1();

//demo2();

//demo3();

//将时间字符串转换成日期对象

String str = "2000年08月08日 08:08:08";

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

Date d;

try {

d = sdf.parse(str);

System.out.println(d);

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}//将时间字符串转换成日期对象

}

@Test

public void demo3() {

Date d = new Date();//获取当前时间对象

SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//创建日期格式化类对象

System.out.println(sdf.format(d));//将日期对象转换为字符串

}

@Test

public void demo2() {

Date d = new Date();//获取当前时间对象

SimpleDateFormat sdf = new SimpleDateFormat();//创建日期格式化类对象

System.out.println(sdf.format(d)); //88-6-6 下午9:31

}

@Test

public void demo1() {

//DateFormat df = new DateFormat();//DateFormat是抽象类,不允许实例化

//DateFormat df1 = new SimpleDateFormat();

DateFormat df1 = DateFormat.getDateInstance();//相当于父类引用指向子类对象,右边的方法返回一个子类对象

}

//打印结果如下：

16-8-1 下午4:43

2016/08/01 16:43:20

Tue Aug 08 08:08:08 CST 2000

14.18_常见对象(你来到这个世界多少天案例)

A:案例演示

需求：算一下你来到这个世界多少天?

@Test

public void testMyLifeDays(){

String birthday= "1990-02-12 05:30:00";

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");

try {

Date date = sdf.parse(birthday);

long timeBegin = date.getTime();

System.out.println("出生时间："+timeBegin);

long timeEnd = System.currentTimeMillis();

System.out.println("当前时间："+timeEnd);

long time = timeEnd - timeBegin;

System.out.println("时间差："+time);

long day = time / (1000*60*60*24);

System.out.println(day);

//837907200000

//837948780537

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

//打印结果如下：

出生时间：632093400000

当前时间：1470043577804

时间差：837950177804

9698

14.19_常见对象(Calendar类的概述和获取日期的方法)

A:Calendar类的概述

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

B:成员方法

public static Calendar getInstance()

public int get(int field)

@Test

public void testCalendar(){

Calendar c = Calendar.getInstance();

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH)+1;//月份是从0开始

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

System.out.println(year+"-"+month+"-"+day);

//打印结果如下：

//2016-8-2

}

@Test

public void testCalendar2(){

Calendar c = Calendar.getInstance();

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH)+1;

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

int day_of_week = c.get(Calendar.DAY_OF_WEEK);

//****年**月**日星期*

System.out.println(year+"年"+month+"月"+getNum(day_of_month)+"日 "+getWeek(day_of_week));

//打印结果如下：

//2016年8月02日星期三

}

private String getWeek(int day_of_week) {

String [] arr_week = {

"星期日",

"星期一",

"星期二",

"星期三",

"星期四",

"星期五",

"星期六"

};

return arr_week[day_of_week];

}

private String getNum(int day_of_month) {

return day_of_month > 9 ? ""+day_of_month:"0"+day_of_month;

}

14.20_常见对象(Calendar类的add()和set()方法)(掌握)

A:成员方法

public void add(int field,int amount)

public final void set(int year,int month,int date)

B:案例演示

Calendar类的成员方法使用

@Test

public void testCalendarAdd() {

//demo1();

Calendar c = Calendar.getInstance();//父类引用指向子类对象

c.add(Calendar.MONTH, -1);//对指定的字段进行向前减或向后加

c.set(Calendar.YEAR, 2000);//修改指定字段

System.out.println(c.get(Calendar.YEAR)+"-"+c.get(Calendar.MONDAY));

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

Calendar c2 = Calendar.getInstance();

c2.set(2016, 8, 2);

System.out.println(c2.get(Calendar.YEAR)+"-"+c2.get(Calendar.MONTH)+"-"+c2.get(Calendar.DAY_OF_MONTH));

}

//打印结果如下：

2000-6

-------------------------

2016-8-2

14.21_常见对象(如何获取任意年份是平年还是闰年)(掌握)

A:案例演示

需求：键盘录入任意一个年份，判断该年是闰年还是平年

/**

* 1.键盘录入Scanner

* 2.获取Calendar实例

* 3.设置为那一年的3月1日

* 4.将日期向前减去1

* 5.判断日期是多少天，如果等于29就返回true否则返回false

* @param args

public static void main(String [] args){

Scanner sc = new Scanner(System.in);

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

String line = sc.nextLine();

int year = Integer.parseInt(line);

System.out.println(year);

boolean b= getYear(year);

System.out.println("---是否是闰年---"+b);

}

/**

* 判断当前年份是否是闰年

* @param year

* @return

private static boolean getYear(int year) {

//1.创建Calendar实例

Calendar c = Calendar.getInstance();

//2.设置为那一年的3月1日

c.set(year, 2, 1);

//3.将日期向前减去1

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

return c.get(Calendar.DAY_OF_MONTH) == 29;

}

//打印结果如下：

请输入年份:

2016

---是否是闰年---true

思简

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常见对象_4-java常见对象-常用类的介绍及使用

14.11_常见对象(Math类概述和方法使用)A:Math类概述Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。B:成员方法public static int abs(int a)public static double ceil(double a)public static double floor(double a)public static int max(...
复制链接

扫一扫