常用JavaAPI详解

发表于 | 更新于 | 分类于 | 阅读次数： | 字数： 2,617 | 阅读时长： 12

Java日期与时间的处理

Date类：

在 JDK 1.1 之前，类 Date 有两个其他的函数。它允许把日期解释为年、月、日、小时、分钟和秒值。它也允许格式化和解析日期字符串。不过，这些函数的 API 不易于实现国际化。从 JDK 1.1
开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和解析日期字符串。Date 中的相应方法已废弃。

在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式：

  • 年份 y 由整数 y - 1900 表示。
  • 月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。
  • 日期（一月中的某天）按通常方式由整数 1 至 31 表示。
  • 小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。
  • 分钟按通常方式由 0 至 59 的整数表示。
  • 秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

在所有情形中，针对这些目的赋予方法的参数不需要在指定的范围内；例如，可以把日期指定为 1 月 32 日，并把它解释为 2 月 1 日的相同含义。

Calendar类：

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化： 

1
2
> Calendar rightNow = Calendar.getInstance();
>

程序示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package 常用JavaAPI;

import java.sql.Date;
import java.util.Calendar;

public class TimeDame {

	public static void main(String[] args) {
		long now = System.currentTimeMillis();
		System.out.println("now = " + now);
		
		Date d1 = new Date(now);
		System.out.println("d1 = " + d1);
		
		Calendar c1 = Calendar.getInstance();
		System.out.println("c1 = " + c1.getTime().toString());
	}

}

时间和日期的基本操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package 常用JavaAPI;

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

public class DateDame {
	public static void main(String[] args) throws ParseException {
		Date d1 = new Date(System.currentTimeMillis());
		
		Calendar c1 = Calendar.getInstance();
		
		//格式化
		SimpleDateFormat sdf  = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		System.out.println("格式化前的d1 = " + d1.toString());
		System.out.println("格式化后的d1 = " + sdf.format(d1));
		
		//String和Date的转换
		String date = "2018-04-30";
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
		
		java.util.Date d2 = sdf1.parse(date);
		System.out.println("Sting转化为Date， d2 = " + d2.toString());
		
		
		//由Date类型转换为String类型
		String s1 = sdf1.format(d2);
		System.out.println("Date转换为String，s1 = " + s1);
	
		//Date和Calendar转换
		c1.setTime(d2);//Date转换到Calendar类
		c1.getTime();//Calendar转换到Date类
	}

}

//程序执行结果：
格式化前的d1 = 2018-04-30
格式化后的d1 = 2018-04-30 05:39:00
Sting转化为Date， d2 = Mon Apr 30 00:00:00 CST 2018
Date转换为String，s1 = 2018-04-30

日期应用小示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package 常用JavaAPI;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Date {

	public static void main(String[] args) throws ParseException {
		//程序示例：
		//设定女朋友的生日，并在提前两个星期的星期六提醒
		
		//1.设定生日，String
		String birthday = "2018-4-30";
		
		//2.将String类型转换为日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		java.util.Date date = sdf.parse(birthday);
		
		//3.对日期进行计算
		java.util.Date spec = preapareBirthdayDay(date);
		
		//4.将计算后的结果，转换为String类型输出
		String s2 = sdf.format(spec);
		System.out.println(birthday + "提前两周的周六为 : " + s2);
	}
	
	/*
	 * 传入1个日期，计算出该日期的2个星期前的 周六的日期
	 * @param birthdayDate 传入的日期
	 * @return 2周前的周六的日期
	 */
	public static java.util.Date  preapareBirthdayDay(java.util.Date birthdayDate) {
		//GregorianCalendar是 Calendar 的一个具体子类，
		//提供了世界上大多数国家/地区使用的标准日历系统。
		//父类声明，创建子类对象
		Calendar calendar = new GregorianCalendar();
		//接收传入的date日期，转换为Calendar类
		calendar.setTime(birthdayDate);
		calendar.add(Calendar.WEEK_OF_MONTH, -2);//提前两周
		//调整为当前日期的周六
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);//调整为当前日期的周六
		return calendar.getTime();
		
	}
}

//程序运行结果：
2018-4-30提前两周的周六为 : 2018-04-21

日期计算示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package 常用JavaAPI;

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

public class Time {

	public static void main(String[] args) throws ParseException {
		String s1 = "2018-5-1 ";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar c1 = Calendar.getInstance();
		
		//计算一个日期加指定天数
		c1.set(2018, 5, 1);
		c1.add(Calendar.DAY_OF_WEEK, 20);
		System.out.println(c1.getTime());
		
		//计算两日期之差
		String  s2 = "2018-5-5";
		java.util.Date d1 = sdf.parse(s1);
		java.util.Date d2 = sdf.parse(s2);
		long diff = d1.getTime() - d2.getTime();
		long days = diff / (1000 * 60 * 60 * 24);
		System.out.println(days);
	}
}

高精度加法：

问题描述

　　输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。

算法描述

　　由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
　　定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
　　计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
　　最后将C输出即可。

输入格式

　　输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。

输出格式

　　输出一行，表示a + b的值。

样例输入

20100122201001221234567890
2010012220100122

样例输出

20100122203011233454668012

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class 高精度加法 {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s1 = br.readLine();
		String s2 = br.readLine();
		br.close();
		int[] a = new int [100];
		int[] b = new int [100];
		int len1 = s1.length();
		int len2 = s2.length();
		for(int i = 0; i < len1; i++)
			//Character.getNumericValue(s1.charAt(i))
			//返回指点字符的int值。
			a[len1-1-i] = Character.getNumericValue(s1.charAt(i));
		for(int i = 0; i < len2; i++)
			b[len2-1-i] = Character.getNumericValue(s2.charAt(i));
		int max = len1 > len2 ? len1 : len2;
		int[] c = new int[max+1];
		int r = 0; 
		for(int i = 0; i < max; i++) {
			c[i] = a[i] + b[i] + r;
			r = 0; //回溯，r归0
			if(c[i] > 9) {
				r = c[i] / 10;
				c[i] = c[i] % 10;
			}
		}
		for(int i = max-1; i>=0; i--) {
			System.out.print(c[i]);
		}
	}
}

Huffuman树：

问题描述

　　Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
　　给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
　　1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
　　2. 重复步骤1，直到{pi}中只剩下一个数。
　　在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
　　例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
　　1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
　　2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
　　3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
　　4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
　　5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。

输入格式

　　输入的第一行包含一个正整数n（n<=100）。
　　接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。

输出格式

　　输出用这些数构造Huffman树的总费用。

样例输入

5
5 3 8 2 9

样例输出

59

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Arrays;
import java.util.Scanner;

public class Huffuman树 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int [] pi = new int[n];
		for(int i = 0; i < n; i++)
			pi[i] = sc.nextInt();
		int sum = 0, num = 0;
		for(int i = 0; i < n-1; i++) {
			Arrays.sort(pi);
			num = pi[i] + pi[i+1];
			pi[i+1] = num;
			sum += num;
		}
		System.out.println(sum);
	}
}
坚持原创技术分享，您的支持将鼓励我继续创作！