Java第十一章总结

已于 2023-06-16 15:41:58 修改
阅读量94 收藏
点赞数
文章标签： java
于 2023-05-26 14:45:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75710189/article/details/129997281
版权

一，包装类
1，Java 是一种面向对象语言，但在 Java 中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java 提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如 int 型的包装类 Integer、 boolean 型的包装类 Boolemn 等。

2，Integer类

        1.Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含int类型的字段。

        2.Integer类的常用方法

例题1

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");//创建对象
		System.out.println("int数据与integet对象比较："+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);
	}
 
}

​

 运行结果

Integer类提供了以下4个常量:

MAX_VALUE:表示int类型可取的最大值，即231-1。
MIN_VALUE:表示int类型可取的最小值，即-23。
SIZE:用来以二进制补码形式表示int值的位数。
TYPE:表示基本类型int的Class 实例。 

例题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);
	}
 
}

 3，Double类
        1.Double类和Float 类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于Float类，可以参考 Double类的相关内容。

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

        3.Double类的常用方法

 

例题3

public class DoubleDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Double dNum = Double.valueOf("3.14");//创建对象
		//判断是否为非数字值
		System.out.println("3.14是否为非数字值："+Double.isNaN(dNum.doubleValue()));
		System.out.println("3.14转换为int类型："+dNum.intValue());
		//intvalue直接取整    转换为int类型
		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变量可能具有的最小指数

QNEGATIVE_INFINITY:返回 double值，表示保存 double 类型的负无穷大值的常量图区

POSITIVE_INFINITY:返回 double值，表示保存 double类型的正无穷大值的常量

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

        2.Boolean类的常用方法 

例题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());
	}
}

运行结果

Boolcan 提供了以下3个常量

TRUE:对应基值true的 Boolean 对象

 FALSE对应基值false 的 Boolcan 对象
TYPE:基本类型boolean的Class对象

5，Character类

        1.在对象中包装一个基本类型为 har 的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方地将字符从大写转换成小写，反之亦然。

        2.Character类的常用方法

 例题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 规范中的常规类别“Pe"

UNASSIGNED:返回 byte 型值，表示 Unicode 规范中的常规类别“Cn”

TITLECASE_LETTER:返回 byte型值，表示Unicode规范中的常规类别“Lt”

6，Number类 
        1.前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类一Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。

        2.数值型包装类的共有方法 

二，数字处理
1.数字格式化
        1.数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。

        2.在Java中，没有格式化的数据遵循以下原则:
        如果数据绝对值大于0.001 并且小于 10000000，使以常规小数形式表示。
        如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
        由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在         Java中，可以使用DecimalFormat类进行格式化操作。

        3.DecimalFormat类是NumberFormat的一个子类用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一”情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中applyPattern0方法来实现数字格式化。

        4. DecimalFormat类中的特殊字符及其说明

 

 例题6

import java.text.DecimalFormat;
public class DecimalFormatSimpleDemo {
//使用实例化对象时设置格式化模式
	static public void SimgleFormat(String pattern,double value) {
	DecimalFormat myFormat = new DecimalFormat(pattern);
	//实例化DecimalFormat对象
	String output = myFormat.format(value);
	//将数字化格式化
	System.out.println(value+" "+pattern+" "+output);
	}
	//使用applypattern()方法对数字进行格式化
	static public void UseApplyPatternMethodFormat(String pattern,double value) {
		//实例化DecimalFormat对象
		DecimalFormat myFormat = new DecimalFormat();
		myFormat.applyPattern(pattern);
		//调用applypattern()方法设置格式化模板
		System.out.println(value+" "+pattern+" "+myFormat.format(value));
	}
	public static void main(String[] args) {
		SimgleFormat("###,###.###",123456.789);
		//调用静态SimpleFormat（）方法
		SimgleFormat("000000.###kg", 123456.789);
		//在数字后加上单位
		SimgleFormat("000000.000", 123.78);
		UseApplyPatternMethodFormat("#.###%", 0.789);
		//将数字转换为百分比形式
		UseApplyPatternMethodFormat("###.##", 123456.789);
		//将小数点后格式化为两位
		UseApplyPatternMethodFormat("0.00\u2030", 0.789);
		//将数字转换为千分位数形式
	
	
		
	}
 
}

5.在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字行格式化设置

//实例化DecimalFormat 类对象
DecimalFormat myFormat = new DecimalFormat();
//设置将数字分组的大小
myFormat.setGroupingSize(2);
//设置是否支持分组
myFormat.setGroupingUsed(false);

6.在项目中创建 DecimalMethod类，在类的主方法中调用setGroupingSize0与 setGroupingUsed0方法实现数字的分组。

import java.text.DecimalFormat;
public class DecimalMethod {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DecimalFormat  myFormat = new DecimalFormat();
		myFormat.setGroupingSize(2);//设置将数字分组为2
		String output = myFormat.format(123456.789);
		System.out.println("将数字以每两个数字分组 "+ output);
		myFormat.setGroupingUsed(false);//设置不允许数字进行分组
		String output2 = myFormat.format(123456.789);
		System.out.println("不允许数字分组 "+ output2);
	}
 
}

 6.Math类

        1.Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便

        2.可以使用如下形式调用:

Math.数学方法

3.在 Math 类中，除函数方法外还存在一些常用数学常量，如I、E等。这些数学常量作为Mah的成员变量出现，调用起来也很简单。可以使用如下形式调用

Math.PI
Math.E

三角函数方法
        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):将弧度转换为角度。

public class TrigonometricFunction {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90°的正弦
		System.out.println("0度的余弦值："+Math.cos(0));//取0°的余弦
		System.out.println("60度的正弦值："+Math.tan(Math.PI/3));//取60°的正切
		//取2的平方根与2商的反正弦
		System.out.println("2的平方根与2商的反正弦值："+Math.asin(Math.sqrt(2)/2));
		System.out.println("2的平方根与2商的反余弦值："+Math.acos(Math.sqrt(2)/2));
		System.out.println("1的正切值："+Math.atan(1));//取1的反正切
		System.out.println("120度的弧度值："+Math.toRadians(120.0));//取120°的弧度值
		System.out.println("Π/2的角度值："+Math.toDegrees(Math.PI/2));//取Π/2的角度
	}
 
}

指数函数方法
        Math类中与指数相关的函数方法如下：

        public static double exp(doublea):用于获取e的a次方，即取e
        public static double log(doublea):用于取自然对数，即取Ina的值

        public static double log10(doublea):用于取底数为10的a的对数。

        public static doublesqrt(doublea):用于取a的平方根，其中a的值不能为负值。
        public static double cbrt(doublea):用于取a的立方根。

         public static double pow(double adouble b):用于取a的b次方

public class ExponentFunction {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("e的平方值："+Math.exp(2));//取e的2次方
		System.out.println("以e为底2的对数值："+Math.log(2));//取以e为底2的对数
		System.out.println("以10为底的2的对数值："+Math.log10(2));//取以10为底的2的对数
		System.out.println("4的平方根值："+Math.sqrt(4));//取4的平方根
		System.out.println("8的立方根值："+Math.cbrt(8));//取8的立方根
		System.out.println("2的2次方值："+Math.pow(2,2));//取2的2次方
		
		
	}
 
}

取整函数方法
在具体的问题中，取整操作使用也很普遍，所以Java在Mah类中添加了数字取整方法。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 后返与参数最近的整数，然后强制转换为长整型。

 public class IntFunction {
	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));
		//返回与参数最接近的整数
		System.out.println("使用round()方法取整："+Math.round(3.4f));
		//将参数加上0.5后返回最接近的整数
		System.out.println("使用round()方法取整："+Math.round(2.5));
		//将参数加上0.5后返回最接近的整数，并强制转换为长整型
		
		
	}
 
}

取最大值、最小值、绝对值函数方法
      在程序中最常用的方法就是取最大值、最小值、绝对值等，Ma 类中包括的操作方法

        public static double max(double a double b):取a与b之间的最大值。

        public static int min(inta.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):返回双精度浮点型参数的绝对值。

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(4.4, 4));
		//取两个参数的最小值
		System.out.println("-7的绝对值："+Math.abs(-7));
		//取参数的绝对值
	}
 
}

 Random类

        1.Random类是JDK中的随机数生成器类，可以通过实例化一个 Random对象创建一个随机数生器，语法如下:

Random r = new Random();

2.用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下:

Random r = new Random(seedValue);

 r:Random类对象
        seedValue:随机数生成器的种子。
在Random 类中，提供了蔬聚各种据类型随机数的方法，下面列举几个常用的方法

        public int nextInt（）:返回一个随机整数。
        public int nextlnt(int n): 返回大于等于0 且小于n的随机整数.

        public long nextLong（）: 返回一个随机长整型值
         public boolean nextBoolean（）: 返回一个随机布尔型值,
        public foat nextFloat（）: 返回一个随机单精度浮点型值.
        public double nextDouble（）: 返回一个随机双精度浮点型值.

        public double nextGaussian（）: 返回一个概率密度为高斯分布的双精度浮点型值

import java.util.Random;
public class RandomDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Random r = new Random();//实例化一个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());
	}
 
}

Biginteger类
        1.BigInterer类的数字截围较 nteger 类的数字范围要大得多。前文介绍过integer 类是int 的最大为 2^31-1，如果要计算更大的数字，使用 nteger 类无法实现了，所 BieInteger 类来处理更大的数字。Biglncger 类支持任意精度的整数，也就是说，在运曾中类可以准确地表示任何大小的整数值而不会丢失信息。

        2.将2转换为 BigInteger 类型，可以使用以下语句进行初始化操作:

Biginteger twolnstance = new Biginteger("2");

3.一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数算和位运算以及一些取相反数、取绝对值等操作。下面列举了 Biglnteger 类中常用的几种运算方

法：

        public BigInteger add(BigInteger val):做加法运算。

        public BigInteger subtract(BigInteger val):做减法运算。
        public BigInteger multiply(BigInteger val): 做乘法运算
        publicBigInteger divide(BigInteger val):做除法运算。
        public BigInteger remainder(BigInteger val):做取余操作。
        public BigInteger[] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中个值为商，第二个值为余数。
        CpublicBigInteger pow(intexponent):进行取参数的exponent 次方操作。
        public BigInteger negate():取相反数。
        public BigInteger shiftLeft(intn):将数字左移n位，如果n为负数，做右移操作            publicBigIntegershiftRight(intn):将数字右移n位，如果n为负数，做左移操作
        public BigIntegerand(BigInteger val):做与操作。
        public BigIntegeror(BigInteger val):做或操作。
        public int compareTo(BigInteger val):做数字比较操作。

        public booleanequals(Objectx):当参数x是BigInteger类型的数字并且数值与对象实例的数
区相等时，返回true。

        public BigInteger min(BigInteger val):返回较小的数值。        

        public BigInteger max(BigIntegerval):返回较大的数值。

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]);
		//2次方运算
		System.out.println("做2次方操作："+b1.pow(2));
		//相反数运算
		System.out.println("取相反数操作："+b1.negate());
	}
 
}

BigDecimal类
         BigDecimal类和BigInteger类都能实现大数字的运算,不同的是BigDecimal类加入了小数的概念般的float型和double型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。
 

import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//第一个大小数
		BigDecimal b1 = new BigDecimal("0.00987654321987654321");
		//第二个大小数
		BigDecimal b2 = new BigDecimal("0.00123456789123456789");
		//加法运算
		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类

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

 控制台输出字符

        1.System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3个静态对象:in、out和err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。

        2.不会自动换行的print（)方法

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

      3.可以自动换行的println()方法

System.outprintln("书籍是人类进步的阶梯!");

Java 输出换行的方法有以下两种:

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

计时
        1.System.currentTimeMillis0方法可以获取自1970年1月1日零点至今的毫秒数。虽然Dae也有类似的方法，但代码会比 System 类多，所以System.currentTimeMillis0方法是为获取当前毫最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

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++) {//循环10000次
			str += i;//将字符串与循环变量拼接
		}
		
		long end = System.currentTimeMillis();
		System.out.println("循环用时："+(end-start)+"毫秒");
	}
 
}

四，Scanner 类
        1.与C语言不同，Java 从控制台中读出用户输入的值，用到的不是一行可以直接使用的代码，而是由一个叫 Scanner 的类来实现的。Scanner 英文直译就是扫描仪，它的用途就和现实生活的扫描仪一样可以把数字化信息流转为人类可识别的文字。控制台输出内容用到了 System.out 就表示向控制台输出Systemin就表示从控制台输入，让Scanner 扫描Systemin就可以获取用户输入的值了。

        2.使用Scanner类首先要引入该类，其语法如下:

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

         3.Scanner类的几个常用方法

         4.使用Scanner类扫描控制台的代码如下:

Scanner sc = new Scanner(System.in);

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();//关闭扫描器
	}
 
}

五，日期时间类

1，Date类

       Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表11.14所示。

使用 Date类的第2种构造方法创建一个 Date类的对象，代码如下:

long timeMillis=System.currentTimeMillis(); 
//当前系统时间所经历的毫秒数
Date date = new Date(timeMillis); 

上述代码中的System类的currentTimeMillis0方法主要用来获取当前系统时间距标准基准时间的毫秒数。另外，这里需要注意的是，创建 Date 对象时使用的是 long 型整数，而不是 double 型，这主要是因为 double类型可能会损失精度。

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);
	}
 
}

 日期时间格式化
        1.DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种:

        SHORT:完全为数字，如12.13.52或3:30pm。
        MEDIUM:较长，如Jan 12,1952。
        LONG:更长，如January12,1952或3:30:32pm。
        FULL:完全指定，如Tuesday、April12、1952AD或3:3042pm PST

     2.可以使用其静态方法getDateInstance(进行创建，语法如下:

DateFormat df = DateFormat.getDatelnstance();

 

3.由于DateFormat类是一个抽象类，不能用 new创建实例对象。因此，除了使用getXXXInstance0方能创健其对象，还可以使用其子类，如 SimpleDateFormat 类，该类是一个以与语言环境相关的方式*花式化和分析日期的具体类，它允许进行格式化 (日期一文本)、分析(文本一日期)和规范化。

4.SimpleDateFormat 类提供了19个格式化字符，可以让开发者随意编写日期格式

 

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.println("各位观众大家好，现在是");
		System.out.println(df.format(new Date()));
		System.out.println(", 欢迎收看新闻。");
		
	}
 
}

Calendar 类
        1.Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF MONTH、HOU等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected

        2.Calendar 提供了一个类方法 getInstance0，以获得此类型的一个通用的对象。Calendar 类的getInstance0方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下:

Calendar rightNow = Calendar.getlnstance();

 

 

add0方法和 roll0方法都用来为给定的日历字段添加或减去指定的时间量它们的主要区别在于:使用 add0方法时会影响大的字段，像数学里加法的进位或错位，而使用 roll0方法设置的日期字段只是进行增加或减少，不会改变更大的字段。

 
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+"天!");
		
		
		
	}
 
}

六，Runtime类
        1.Runtime类是 JDK 提供的运行时类，该类为Ja 提供了与当前运行环境相连接的一个通Java程可以利用设头提的超行环填执行一些简单的操作。Runtime 类不能使用 new 关键字创建看例，只能通过RuntimegetRuntime0方法获取实例。

        2.Runtime类的常用方决知表1121所示，本节将重点讲解利用 Runtime 类执行本地命令和查看虚拟机所占内存这两个操作。
 

执行本地命令

        1.Runtime类提供exec0方法让Java代码可以执行系统的命令，exec0方法有很多重载的形式，例如：

 Process exec(String command)
Process exec(Stringl cmdarray)

        2.Proces 类的常用方法如表 11.22 所示，开发可以使用 getlnputStream0方法获取进返回的信息。

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();
		}
		
	}
 
}

查看内存

        1.Runtime类可以通过freeMemory0方法查看当前Java虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张

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));//输出数组用掉的内存量
	}
 
}

 运行结果

 

夕落辞
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值