第十一章总结Java

最新推荐文章于 2024-07-22 22:58:19 发布

继承家业的小破烂一枚

最新推荐文章于 2024-07-22 22:58:19 发布

阅读量27

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_73086324/article/details/130885881

版权

11.1包装类

Java是一种面向对象语言，但在Java中不能定义基本数据类型的对象，为了你将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本类型数据类型密封在包装类中

11.1.1 Integer类
Java.lang包中的Integer类、Byte类、Short类和long类，分别将基本数据类型int、byte、short和long封装成一个类，由于这些类都是Number类的子类，区别就是封装不同的数据类型，其包含的方法基本相同

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法

public class IntegerDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       int num = Integer.parseInt("456"); //将字符串转换为int类型
           Integer iNum = Integer.valueOf("456"); //创建一个intefer对象
           System.out.println("int数据与Integer对象的比较：；"+iNum.equals(num));
           String str2 = Integer.toBinaryString(num); //获取数字的二进制表示
           String str3 = Integer.toHexString(num); //获取数字的十六进制表示
           String str4 = Integer.toOctalString(num); //获取数字的八进制表示
           String str5 = Integer.toString(num,15); //获取数字的十五进制
           System.out.println("456的二进制表示为："+str2);
           System.out.println("456的十六进制表示为："+str3);
           System.out.println("456的八进制表示为："+str4);
           System.out.println("456的十五进制表示为："+str5);

   }

}

a、MAX--VALUE：表示int类型可取的最大值，即2的31次方-1

b、MIN--VALUE:表示int类型可取的最小值，即-2的31次方

c、SIZE:用来以二进制补码形式表示int值得位数

d、TYPE:表示基本类型int的Class实例

例题11.2

public class GetCon {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       int maxint = Integer.MAX_VALUE; //获取Integer类的常量值
       int minint = Integer.MIN_VALUE;
       int intsize = Integer.SIZE;
       System.out.println("int类型可取的最大值是："+maxint); //将常量值输出
       System.out.println("int类型可取的最小值是："+minint);
       System.out.println("int类型的二进制位数是："+intsize);
   }

}

11.1.2 Double类
Double类和Float类是对double、float基本类型的封装，它们都是Number类的子类，都是对浮点数进行操作，所以和常用方法基本相同

Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段，此外，该类还提供多个方法，可以将double类型转换为String类型，将String类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。

表 11.3 Double类的常用方法
方法   功能描述
valueOf（String str）   返回保存用参数字符串str表示的double值的Double对象
parseDouble（String s）   返回一个新的double值，该值初始化为用指定String表示的值，这与Double类的valueOf方法一样
doubleValue（）   以double形式返回此Double对象
isNaN（）   如果此doouble值是非数字（NaN)值，则返回true；否则返回false
intValue（）   以int形式返回double值
byteValue（）   以byte形式返回double对象值（通过强制转换）
longValue（）   以long形式返回此double的值（通过强制转换为long类型）
compareTo（Double d）   两个Double对象进行数值比较，如果两个值相等，则返回0；如果调用对象的数值小于d的数值，则返回负值；如果调用对象的数值大于d的值，则返回正值
equals（object ojk）   将此对象与指定的对象相比较
to String ()   返回此double对象的字符串表示形式
toHexString（double b）   返回double参数的十六进制字符串表示形式
例题11.3

public class DoubleDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Double dNum = Double.valueOf("3.14"); //创建一个Double类型
       //判断是否为非数值
       System.out.println("3.14是否为非数字值："+Double.isNaN(dNum.doubleValue()));
       System.out.println("3.14转换为int值为："+dNum.intValue());
       //判断大小

       System.out.println("值为3.14的Double对象与3.14的比较结果："+dNum.equals(3.14));
       //转换为十六进制
       System.out.println("3.14的十六进制表示为："+Double.toHexString(dNum));
   }

}

Double类主要提供了以下常量：
☑MAX EXPONENT:返回 int 值,表示有限 double 变量可能具有的最大指数。
☑MIN EXPONENT:返回 int 值,表示标准化 double 变量可能具有的最小指数。
☑NEGATIVE INFINITY:返回 double 值,表示保存 double 类型的负无穷大值的常量。
☑POSITIVE INFINITY:返回 double 值,表示保存 double 类型的正无穷大值的常量

11.1.3 Boolean类
Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean 类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String 类型的相互转换提供了许多方法，并提供了处理boolean 类型时非常有用的其他一些常量和方法。Boolean类的常用方法如表11.4 所示。

public class BooleanDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Boolean b1 = Boolean.valueOf("true"); //创建Boolean对象
       Boolean b2 = Boolean.valueOf("ok");
       System.out.println("b1:"+b1.booleanValue());
       System.out.println("b2:"+b2.booleanValue());
   }

}

11.1.4 Character类
Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作，常用的方法如表11.5所示。

例题11.5

public class UpperOrLower {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Character mychar1 = Character.valueOf('A');
       Character mychar2 = Character.valueOf('a');
       if(Character.isUpperCase(mychar1)) { //判断是否为大写字母
           System.out.println(mychar1 + "是大写字母");
           //转换为小写并输出
           System.out.println("转换为小写字母的结果" +Character.toLowerCase(mychar1));
       }
       if(Character.isLowerCase(mychar2)) {
           System.out.println(mychar2+ "是小写字母");
           //转换为大写并输出
           System.out.println("转换为大写字母的结果" +Character.toUpperCase(mychar2));
       }

   }

}

Character类提供了大量表示特定字符的常量，例如：
☑CONNECTOR_PUNCTUATION:返回 byte 型值,表示 Unicode 规范中的常规类别“ Pc ”。
☑ UNASSIGNED:返回byte 型值,表示Unicode规范中的常规类别“Cn”。
☑TITLECASE_LETTER:返回 byte 型值,表示 Unicode 规范中的常规类别“ Lt ”。

11.2 数字处理
11.2.1 数字格式化
在Java中，没有格式化的数据遵循以下原则：

1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。

2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。

DecimalFormat中的特殊字符及其所代表的含义如下：

import java.text.DecimalFormat;

public class DecimalFormatSimpleDemo {


           //使用实例化对象时设置格式
                   static public void SimgleFormat(String pattern,double value) {
                       DecimalFormat myFormat =new DecimalFormat(pattern);
                       String output =myFormat.format(value);
                       System.out.println(value+""+pattern+""+output);
                   }
                       //使用applyPattern（）方法对数字进行格式化
                   static public void UseApplyPatternMethodFormat(String pattern,double value) {
                   DecimalFormat myFormat =new DecimalFormat();
                       myFormat.applyPattern(pattern);
                           System.out.println(value+""+pattern+""+myFormat.format(value));

                       }
                       public static void main(String[] args) {
                           SimgleFormat("###,###,###",123456.789);
                           SimgleFormat("00000000.###",123456.789);
                           //按照格式化模板格式化数字，不存在的位以0显示
                           SimgleFormat("000000.000",123.78);
                           //调用静态   UseApplyPatternMethodFormat（）方法
                           UseApplyPatternMethodFormat("#.###%", 00.789);
                           UseApplyPatternMethodFormat("###.##", 123456.789);
                           UseApplyPatternMethodFormat("0.00\u2030", 0.789);


   }

}

11.2.2 Math类
Math类提供了众多数学函数方法，这些方法都被定义为static形式

形式调用如下：Math.数学方法

在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E。

形式调用如下：

Math.PI

Math.E

1.三角函数方法

Math类中包含的三角函数方法如下：

☑ _ public static double sin(double a);返回角的三角正弦。
☑ public static double cos(double a);返回角的三角余弦。
☑ public static double tan(double a);返回角的三角正切。
☑ public static double asin(double a):返回一个值的反正弦。
☑ public static double acos(double a):返回一个值的反余弦。
☑ public static double atan(double a):返回一个值的反正切。
☑ public static double toRadians(double angdeg):将角度转换为弧度。
☑ public static double toDegrees(double angrad):将弧度转换为角度。

例题11.7

public class TrigonometricFunction {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

System.out.println("90度的正弦值为："+Math.sin(Math.PI/2));
System.out.println("0度的余弦值："+Math.cos(0));
System.out.println("90度的正弦值为："+Math.tan(Math.PI/3));

//取2的平方根与2商的反正弦
System.out.println("取2的平方根与2商的反正弦"+Math.asin(Math.sqrt(2)/2));

//取2的平方根与2商的反余弦
System.out.println("取2的平方根与2商的反余弦"+Math.asin(Math.sqrt(2)/2));
System.out.println("1的反正切值"+Math.atan(1));
System.out.println("120度的弧度制"+Math.toRadians(120.0));
System.out.println("Π/2的角度值"+Math.toDegrees(Math.PI/2));

   }

}

2.指数函数方法

Math类中与指数相关的函数方法如下。
☑ public static double exp(double a):用于获取e的a次方,即取eᵃ。
☑ public static double log(double a):用于取自然对数,即取lna的值。
☑ public static double log10(double a);用于取底数为10的a的对数。
☑ public static double sqrt(double a):用于取a的平方根,其中a 的值不能为负值。
☑ public static double cbrt(double a):用于取a的立方根。
☑ public static double pow(double a, double b):用于取a的b次方。
例题11.8

public class ExceponentFunction {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

System.out.println("e的平方值"+Math.exp(2));
System.out.println("以e为底的2的对数值"+Math.log(2));
System.out.println("以10为底2的对数值"+Math.log10(2));
System.out.println("4的平方根值"+Math.sqrt(4));
System.out.println("8的立方根值"+Math.cbrt(8));
System.out.println("2的2次方值"+Math.pow(2, 2));


   }

}

3.取整函数方法

　　在具体的问题中，取整操作使用也很普遍，所以Java 在Math类中添加了数字取整方法。Math类中主要包括以下几种取整方法：
☑ public static double ceil(double a):返回大于等于参数的最小整数。
☑ public static double floor(double a):返回小于等于参数的最大整数。
☑ public static double rint(double a):返回与参数最接近的整数,如果存在两个同样接近的整数,则结果取偶数。
☑ public static int round(float a):将参数加上0.5后返回与参数最近的整数。
☑ public static long round(double a):将参数加上0.5 后返回与参数最近的整数,然后强制转换为长整型。

例题11.9

public class InFunction {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       System.out.println("使用ceil（）方法取整"+Math.ceil(5.2));
       System.out.println("使用floor（）方法取整"+Math.floor(2.5));
       System.out.println("使用rint（）方法取整"+Math.rint(2.7));
       System.out.println("使用rint（）方法取整"+Math.rint(2.5));
       //将参数加上0.5后返回最接近的整数
       System.out.println("使用round（）方法取整"+Math.round(3.4f));
       //将参数加上0.5后返回最接近的整数，并且将结果强制转换为长整型

   }

}

4. 取最大值、最小值、绝对值函数方法
在程序中最常用的方法就是取最大值、最小值、绝对值等，Math类中包括的操作方法如下：public static double max(double a,double b):取a与b之间的最大值。
public static int min(int a,int b):取a与b之间的最小值，参数为整型。
public static long min(long a,long b):取a与b之间的最小值，参数为长整型。public static float min(float a,float b):取a与b之间的最小值，参数为单精度浮点型。public static double min(double a,double b):取a与b之间的最小值，参数为双精度浮点型。public static int abs(int a)：返回整型参数的绝对值。
public static long abs(long a)：返回长整型参数的绝对值。
public static float abs(float a):返回单精度浮点型参数的绝对值。
public static double abs(double a)：返回双精度浮点型参数的绝对值。

例题10.10

public class AnyFunction {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

       System.out.println("4和8较大者"+Math.max(4, 8));
       System.out.println("4.4和4较小者"+Math.min(0, 0));
       System.out.println("-7的绝对值"+Math.abs(-7));

   }

}

11.2.3 Random类
Random对象创建一个随机数生成器语法如下：

Random r = new Random;

设置随机数生成器的种子语法如下：

Random r = new Random(seedValue);

r: Random类对象。
seedValue：随机数生成器的种子。
在Random类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：
public int nextInt):返回一个随机整数。
public int nextInt(int n):返回大于等于0且小于n的随机
public long nextLong()：返回一个随机长整型值。
public boolean nextBoolean):返回一个随机布尔型值。
public float nextFloat()：返回一个随机单精度浮点型值。
public double nextDouble()：返回一个随机双精度浮点型应
public double nextGaussian):返回一个概率密度为高斯分布的双精度浮点型值

例题11.11

import java.util.Random;

public class RandomDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

               Random r = new Random();
               //随机产生一个整数
               System.out.println("随机产生一个整数"+r.nextInt());
               //随机产生一个大于等于0且小于10的整数
               System.out.println("随机产生一个大于等于0且小于10的整数"+r.nextInt(10));
               //随机产生一个布尔型的值
               System.out.println("随机产生一个布尔型的值"+r.nextBoolean());
               //随机产生一个双精度浮点型的值
               System.out.println("随机产生一个双精度浮点型的值"+r.nextDouble());
               //随机产生一个单精度浮点型的值
               System.out.println("随机产生一个单精度浮点型的值"+r.nextFloat());
               //随机产生一个概率密度为高斯分布的双精度浮点型的值
               System.out.println("随机产生一个概率密度为高斯分布的双精度浮点型的值"+r.nextGaussian());

   }

}

11.2.4 BigInteger 类
在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。
使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作：

Biglnteger twolnstance =new Biglnteger("2");

注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。

一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。下面列举了Biglnteger类中常用的几种运算方法：public BigInteger add(BigInteger val)：做加法运算。
public BigInteger subtract(BigInteger val)：做减法运算。
public BigInteger multiply(BigInteger val)：做乘法运算。
public BigInteger divide(BigInteger val)：做除法运算。
public BigInteger remainder(BigInteger val)：做取余操作。
public BigIntegerl] divideAndRemainder(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(int exponent):进行取参数的exponent次方操作。
public BigInteger negate()：取相反数。
public Biglnteger shiftLeft(int n)：将数字左移n位，如果n为负数，做右移操作。public BigInteger shiftRight(int n)：将数字右移n位，如果n为负数，做左移操作。public BigInteger and(BigInteger val)：做与操作。
public BigInteger or(BigInteger val)：做或操作。
public int compareTo(BigInteger val):做数字比较操作。
public boolean equals(Object x)：当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。
public BigInteger min(BigInteger val)：返回较小的数值。
public BigInteger max(Biglnteger val)：返回较大的数值。
例题11.12

import java.math.BigInteger;

public class BigIntegerDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       BigInteger b1 =new BigInteger("987654321987654321");
       BigInteger b2 =new BigInteger("123456789123456789");
       System.out.println("加法操作："+b1.add(b2));
       System.out.println("减法操作："+b1.subtract(b2));
       System.out.println("乘法操作："+b1.multiply(b2));
       System.out.println("除法操作："+b1.divide(b2));
       System.out.println("取商："+b1.divideAndRemainder(b2)[0]);
       System.out.println("取余数："+b1.divideAndRemainder(b2)[1]);
       System.out.println("做2次方操作："+b1.pow(2));
       System.out.println("取相反数操作："+b1.negate());

   }

}

11.2.5 BigDecimal类

在BigDecimal类，常用的两个构造方法如下：

BigDecimal类实现的加减乘除的方法如下：

BigDecimal类中divide（）方法有多种设置，用于但会商小数点后的末尾的处理，名称和含义如下：

例题11.13

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

               //11.2.4 BigDecimal
               BigDecimal b1=new BigDecimal("0.728382834535");
               BigDecimal b2=new BigDecimal("0.00045353");
               System.out.println("两个数字相加结果："+b1.add(b2));
                   System.out.println("两个数字相减结果："+b1.subtract(b2));
                   System.out.println("两个数字相乘结果："+b1.multiply(b2));
               //除法运算，商小数点后保留9位，并将结果进行四舍五入操作
               System.out.println("两个数字相除，保留小数点后9位："+b1.divide(b2,9,RoundingMode.HALF_UP));
   }

}

System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。Svstem类提供
服多系线层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如下：

11.3.1 控制台输出字符

1.不会自动换行的print()方法
printO方法的语法如下：

System.out.print("Hello!");

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
2. 可以自动换行的 println()方法

printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下：

System.out.println(”书籍是人类进步的阶梯！”)；

此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。

print()方法与println()方法输出的对比效果如下：

综上所述，Java输出换行的方法有以下两种：

System.out.print("\n"); //利用换行符\n 实现奂行
System.out.println(); //空参数即可实现换行

误区警示：
使用这两个输出方法时还要注意以下两点：
(1)“System.out.println("n")；”会打印两个空行。
(2)“System.out.print);”无参数会报错。

11.3.2 计时
例题11.14

public class SystemTimeDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       long start = System.currentTimeMillis(); //程序开始记录时间
       String str = null; //创建null字符串
       for(int i = 0;i<10000;i++) { //循环一万次
           str+=1; //字符串与循环变量拼接
       }
       long end = System.currentTimeMillis(); //记录循环结束时间
       System.out.println("循环用时："+(end-start)+"毫秒");
   }

}

11.4 Scanner 类

Scanner类首先要引入该类，语法如下：

import java.util.Scanner; //引入Scanner类

下表所示的常用的方法，通过这些方法可以获取控制台中输入的不同类型的值

使用Scanner类扫描控制台的代码如下：

Scanner sc = new Scanner(System.in);

例题11.15

import java.util.Random;
import java.util.Scanner;

public class ScannerDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Random r = new Random(); //随机数对象
       int num = r.nextInt(100); //从1~99取值
       int input = -1; //记录用户输入的值
       Scanner sc = new Scanner(System.in); //扫描器扫描控制台输入
       while(true) {
           System.out.println("猜一猜随机数是多少?");
           input = sc.nextInt(); //获取用户输入的一个整数
           if(input>num) { //如果大于随机数
               System.out.println("你输入的数字大了!");
           }else if(input<num) { //如果小于随机数
               System.out.println("你输入的数字小了!");
           }else if(input==num) { //如果等于随机数
               break; //结束循环
           }else {
               System.out.println("您的输入有误！");
           }
       }
       System.out.println("恭喜你答对了！");
       sc.close(); //关闭扫描器

   }

}

11.5 日期时间类

11.5.1 Date类

例题11.16

import java.util.Date;

public class Datedemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

       Date date = new Date(); // 创建现在的日期
       long value = date.getTime(); // 获得毫秒数
       System.out.println("日期：" + date);
       System.out.println("到现在所经历的毫秒数为： " + value);

   }

}

11.5.2 日期时间格式化
DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化。DateFormat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
SHORT：完全为数字，如12.13.52或3：30pm。
MEDIUM：较长，如Jan 12,1952。
LONG:更长，如January 12,1952或3：30：32pm。
FULL：完全指定，如Tuesday、April 12、1952AD或3：30:42pm PST。
另外，使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态方法 getDateInstance()进行创建，语法如下：

DateFormat df =DateFormat.getDatelnstance();

DateFormat 类的常用方法及其说明如下：

例如，将当前日期按照DateFormat类默认格式输出：

DateFormat df = DateFormat. getinstance();
system.out.printin(df.format(new Date());

结果如下：

2021/2/19上午9:59

输出长类型格式的当前时间：

DateFormat df =DateFormat.getTimelnstance(DateFormat.LONG);
System.out.printn(df.format(new Date());

结果如下：

CST 上午10:00:33

输出长类型格式的当前日期：

DateFormat df=DateFormat.getDate/nstance(DateFormat.LONG);
System.out.printin(df.format(new Date());

结果如下：

2021年2月19日

输出长类型格式的当前日期和时间：

DateFormat df = DateFormat.getDate Timelnstance(DateFormat.LONG, DateFormat.LONG);System,out.println(df.format(new Date()));

结果如下：

2021年2月19日CST上午10:01:12

SimpleDateFormat类提供了19个格式化字符，如下：

一些常用的日期时间格式如下

例题11.17

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

       DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 EEEE HH时mm分ss秒");
       System.out.print("各位观众大家好，现在是");
       System.out.print(df.format(new Date()));
       System.out.println("，欢迎收看新闻。");

   }

}

11.5.3 Calecdar 类
Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下：

Calendar rightNow =Calendar.getlnstance();

说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。
Calendar类提供的常用字段及其说明如下：

Calendar类提供的常用方法及其说明如下：

例题11.18

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class CountDown {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       System.out.println("————————————中华人民共和国成立100周年倒计时————————————————");
       Date date = new Date(); //当前时间
       //创建SimpleDateFormat对象，指定目标格式
       SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");
       //调用format方法，格式化时间，转换为指定格式
       String today = simpleDateFormat.format(date);
       System.out.println("今天是"+today); //输出当前日期
       //获取自1970年1月1日至当前时间所经过的毫秒数
       long time1 = date.getTime();
       //使用默认时区和语言环境获得一个日历calendar
       Calendar calendar = Calendar.getInstance();
       //设置日历calendar中的年月日的值，因为从月份是从0开始计算的，所以这里要减一
       calendar.set(2049,10-1,1); //所以这里是十月，
       //计算自1970年1月1日至2049年10月1日所经过的毫秒数
       long time2 = calendar.getTimeInMillis();
       //计算2049年10月1日距离当前时间相差天数
       long day = (time2-time1)/(1000*60*60*24);
       System.out.println("距离2049年10月1日还有"+day+"天!");

   }

}

11.6 Runtime 类
Runtime类的常用方法如下11.6.1 执行本地命令
本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。
Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如：

Process exec(String command)
Process exec(String， cmdarray)

command：要执行的系统命令，字符串类型。
cmdarray：要执行的命令和相应的命令参数，字符串数组类型。
其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：

Runtime.getRuntime().exec("javac hello.java");

使用第二种重载方式的代码如下：

String command，=("javac","hello.java"];
Runtime.getRuntime().exec(command);

exec)方法会返回一个 Process对象。Process类是Java中进程类，该类是抽象类，不能使用new关键字创建实例。Process类的常用方法如表11.22所示，开发可以使用getlnputStream)方法获取进程返回的信息。

例题11.19

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class RuntimeExecDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Runtime r = Runtime.getRuntime(); //获取本地对象Runtime对象
       try {
           Process p = r.exec("help"); //执行help命令，获取进程对象
           InputStream is = p.getInputStream(); //获取进程的字节输入流
           //将字节输入流转换为字符输入流
           BufferedReader br = new BufferedReader(new InputStreamReader(is));
           String str = null; //创建null字符串
           while((str = br.readLine())!=null) { //如果字符流中可获取非空内容
               System.out.println(str); //打印获取的内容
           }
           }catch(IOException e) {
               e.printStackTrace();
           }
   }

}

11.6.2 查看内存
例题11.20

public class MemoryDemo {

   public static void main(String[] args) {
       // TODO Auto-generated method stub
       Runtime r = Runtime.getRuntime(); //获取本地Runtime对象
       Integer ints[] = new Integer[10000]; //创建长度为10000的整型数组
       long before = r.freeMemory(); //获取当前空闲内存数
       System.out.println("赋值前空闲内存字节数："+before);
       for(int i =0,length = ints.length;i<length;i++) { //循环为整数数组赋值
           ints[i] = i; //赋值
       }
       long after = r.freeMemory(); //获取当前空闲内存数
       System.out.println("赋值后空闲内存字节数："+after);
       System.out.println("数组用掉的内存字节数："+(before-after)); //输出数组用掉的内存量
   }

}

继承家业的小破烂一枚

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十一章总结Java

Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段，此外，该类还提供多个方法，可以将double类型转换为String类型，将String类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段，此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。
复制链接

扫一扫