java基础8-CSDN博客

本文链接：https://blog.csdn.net/wyx542813672/article/details/70740072

常用API
一：基本数据类型包装类
1.1
如何完成以下需求：
需求1：我有一个数据，请问如何判断是否是int范围内的呢?
int范围 -2^31 ~ 2^31-1
需求2：我有一个数据，我要得到该数据的二进制，八进制，十六进制如何实现呢?
按照以前讲过规律进行计算，但是比较麻烦。
为了方便基本类型的数据做更多的操作，java就针对每种基本类型的数据给出了对应的类类型。
这就是我们说的基本类型的包装类。
基本类型类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

1.2 学习Integer类型（查看api进行学习）
可以完成以上需求的所要用到的方法：

1.2.1
字段：
最大值：MAX_VALUE
最小值：MIN_VALUE

1.2.2
构造方法：
Integer(int value)
Integer(String s)
注意：这里的字符串必须是由数字组成的字符串
1.2.3
各种成员方法：
转换为二进制：toBinaryString(int i)
转换为八进制：toOctalString(int i)
转换为十六进制：toHexString(int i)

1.2.4
int和String类型的相互转换：

int -- String
方式1：
String s = 100 +"";
方式2:
String.valueOf(int)
方式3：
Integer.toString(100);

String -- int
方式1：
Integer.parseInt(String)

1.2.5
JDK5的新特性：
自动装箱：基本类型 -- 包装类类型
Integer.valueOf(100)
自动拆箱：包装类类型 -- 基本类型
i.intValue()

---------------------------------------------------------------------------------------------------------------------------
2:Character类的讲解
2.1
Character:Character 类在对象中包装一个基本类型 char 的值
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
构造方法：
public Character(char value)

2.2
成员方法
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) 转成小写

2.3
需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
请把以前的代码复制过来，修改成功即可。

----------------------------------------------------------------------------------------------------------------------------
3. Math：用于执行数学运算的类。
3.1
成员方法：
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) min自学
public static double pow(double a,double b) a的b次方
public static double random()
public static int round(float a) 参数为double的自学

3.2
案例：猜数字小游戏
----------------------------------------------------------------------------------------------------------------------------
4.Object:是所有类的根类。所有的类都直接或者间接的继承自该类
4.1
创建学生对象打印学生对象的地址值（本质上是将地址通过哈希算法算出的哈希值）
同一个对象的哈希值肯定是一样的。
哈希值相同的对象的地址值未必一样。
新华字典,zhu -- 456(哈希值) -- 猪(第三个)，朱(第5个)，珠(第9个)

4.2
为什么重写toString()方法
默认情况下，打印的是对象的字符串表示，意义不大。
包名...类名+@+该对象的哈希值的十六进制
所以，我们建议，所有子类重写该方法。
至于如何重写，你就不要问了，自动生成即可。
表示该对象的数据：
[类名成员变量1=数据值1,成员变量2=数据值2,...]

4.3
equals():
默认情况下，比较的是地址值。没有意义。
所以，建议子类重写该方法。
至于如何重写，你就不要问了，自动生成即可。
这个生成的方法作用是比较对象的成员变量值是否相同。

4.4
面试题：
==和equals()的区别?
A:==的作用
a:基本类型数据值
b:引用类型地址值
B:equals()
只能比较引用类型。默认比较地址值。
如果重写后，是按照重写后的规则进行的。

-------------------------------------------------------------------------------------------------------------------------------
5.
5.1
Scanner:帮助我们从键盘获取数据。
构造方法：
Scanner(InputStream source)

Scanner sc = new Scanner(System.in);

System.in in是System类下面的一个静态的成员变量。
现在我们并不知道in这个成员变量的数据类型。
请看一下伪代码：
Scanner {
public Scanner(InputStream in){}
}

System {
public static final InputStream in;
}
InputStream System.in

成员方法：
int nextInt():获取int类型的数据
String nextLine():获取String类型的数据

InputMismatchException：输入的数据和最终的结果类型不匹配。
建议：要什么类型，你就输入什么类型。反正将来也不用。

5.2
当为同一个Scanner对象，数据的输入顺序问题：
String,String
String,int
int,int
int,String

出现的问题：
先int再String就出现了问题。

解决：
A:我把所有的数据都按照String来拿。
String s1
String s2
String s3
将来你要什么，我就把String的数据转换为什么类型。(明天就可以实现)
B:重新创建一个新的对象。

-------------------------------------------------------------------------------------------------------------------------
6.
Random：用于产生随机数的类。和种子相关（种子其实可以把它看成一个产生随机数的定义的规则）。

构造方法：
Random():没有指定种子，采用的是默认种子。
Random(long seed):可以指定种子。种子相同，产生的随机数就相同。

需求：利用有无种子的方式创建对象，使用for循环产生十个随机数
成员方法：
public int nextInt():返回int范围内的数据
public int nextInt(int n):返回[0,n)之间的数据

得到1-100之间的随机数：
new Random().nextInt(100) + 1

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

成员方法：
public static void exit(int status):终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。
public static long currentTimeMillis():获取当前时间的毫秒值。
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):复制数组
参数一：要复制的源数组
参数二：从源数组那个索引开始复制
参数三：需要复制到哪个数组中
参数四：从哪个索引开始进行覆盖
参数五：需要覆盖几个元素
-------------------------------------------------------------------------------------------------------------------------
8.Date
Date:类 Date 表示特定的瞬间，精确到毫秒。

构造方法：
Date():默认获取的是当前的日期时间
Date(long date):把当前日期按照指定的毫秒值进行设定

成员方法：
public long getTime()：获取日期对象的毫秒值
public void setTime(long time):设置日期对象的毫秒值
------------------------------------------------------------------------------------------------------------------------
9.DateFormat(格式化和解析日期对象)
9.1
格式化：
Date -- String
2015年9月27日 15:14:23

String format(Date d)

解析：
String -- Date
"2015-12-12"

Date parse(String s)

构造：
SimpleDateFormat()用默认的模式格式化日期对象
SimpleDateFormat(String pattern):用给定的模式格式化日期对象
例如：
yyyy年MM月dd日 HH:mm:ss
yyyy-MM-dd HH:mm:ss

成员方法：
public final String format(Date date)将一个 Date 格式化为日期/时间字符串
public Date parse(String source)throws ParseException从给定字符串的开始解析文本，以生成一个日期对象

9.2
日期工具类DateUtils
需求：
1.让外界无法创建这个类的对象
2.设置的方法直接可以通过类名调用
3.可以获取 yy年MM月dd日
4.可以获取 HH:mm:ss
5.可以获取 yy-MM-dd HH:mm:ss

9.3
案例：
键盘录入出生日期，算一下你来到这个世界多少天?

---------------------------------------------------------------------------------------------------------------------------
10.
10.1
Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法

Calendar(日历类) -- 获取年，获取月，获取日，获取时，获取分，获取秒。
public int get(int field):返回给定日历字段的值

10.2
需求：获取当前时间的5年后的3个月前的7天后。
public void add(int field,int amount):根据amount修改field的值
public void set(int year,int month,int date):设置当前日历的年月日

10.3
键盘录入年份，获取任意一年的二月有多少天
--------------------------------------------------------------------------------------------------------------------------
11. 正则表达式：
11.1
正则表达式：符合一定规则的字符串

案例：（用正则和代码两种方式实现）
键盘录入qq号码，校验QQ号码。
需求：
1:要求必须是5-15位数字
2:0不能开头

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

A:字符
x 字符x(举例：a,1)
\\ 反斜线字符

B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[0-9] 0-9字符

C:预定义字符类
. 任何字符
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]

D:Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

结论：以后需要匹配的正则表达式怎么写呢？
答：不用写，直接网上百度

11.3
判断功能:
public boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
需求1：找出规则，写出正则(1[38][0-9]{9})，校验电话号码
13245678901 13332345678 13456789012 18812345678 18999999999
18666666666 18786868686

需求2：找出规则，写出正则(String reg = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,8}(\\.[comnet]{2,3})+")，校验邮箱
sunmeng@163.com zhangsan@126.com lisi@sina.com wxd1221@sina.com.cn
csf@gmail.com 1512345@qq.com

11.4
分割功能
public String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
需求1：
分割如下字符串：
String s = "aa,bb,cc";
String s2 = "aa.bb.cc";
String s3 = "aa bb cc";
String s4 = "aa bb cc";
String s5 = "D:\\baidu\\20150826\\day14";

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

11.5
替换功能
public String replaceAll(String regex,String replacement):把符合regex的用replacement替换
需求：字符串中的数字使用*代替

代码实例演示：

packagecom.edu.integer;

public classIntegerDemo {

public static voidmain(String[] args) {

字段：

最大值：MAX_VALUE

最小值：MIN_VALUE

System.out.println(Integer.MAX_VALUE);

System.out.println(Integer.MIN_VALUE);

/**

* 需求1：我有一个数据，请问如何判断是否是int范围内的呢?

int范围-2^31 ~ 2^31-1

int num =100000000;

if(num>Integer.MIN_VALUE&&num<Integer.MAX_VALUE) {

System.out.println("数据在int范围内");

}

packagecom.edu.integer;

public classIntegerDemo2 {

public static voidmain(String[] args) {

/**

*1.2.2

构造方法：

Integer(int value)

Integer(String s)

注意：这里的字符串必须是由数字组成的字符串

Integer i = newInteger(100);

System.out.println(i);

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

//java.lang.NumberFormatException,当字符串给成非数字的字符串的时候会报如下异常

Integer i2 = new Integer("abc");

System.out.println(i2);

}

packagecom.edu.integer;

public classIntegerDemo3 {

public static voidmain(String[] args) {

/**

* 各种成员方法：

转换为二进制：toBinaryString(inti)

转换为八进制：toOctalString(inti)

转换为十六进制：toHexString(inti)

System.out.println(Integer.toBinaryString(100));

System.out.println(Integer.toOctalString(100));

System.out.println(Integer.toHexString(100));

}

packagecom.edu.integer;

public classIntegerDemo4 {

public static voidmain(String[] args) {

/**

*1.2.4

int和String类型的相互转换：

int -- String

方式1：

String s = 100+"";

方式2:

String.valueOf(int)

方式3：

Integer.toString(100);

String -- int

方式1：

Integer.parseInt(String)

方式2：

Integer i = new Integer(100);

int ii = i.intValue();

// int -- String

//方式1：

int i = 100;

String s = i+"";

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

//方式2：

String s2 = String.valueOf(i);

System.out.println(s2);

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

//方式3：

String s3 = Integer.toString(100);

System.out.println(s3);

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

//String -- int

String ss = "100";

int ii =Integer.parseInt(ss);

System.out.println(ii);

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

Integer integer = newInteger(ss);

int intValue= integer.intValue();

System.out.println(intValue);

}

packagecom.edu.integer;

public classIntegerDemo5 {

public static voidmain(String[] args) {

/**

*JDK5的新特性：

自动装箱：基本类型--包装类类型

Integer.valueOf(100)

自动拆箱：包装类类型--基本类型

// 自动装箱：基本类型 -- 包装类类型

//我们之前创建Integer对象全部是new出来的

//Integer i = new Integer(100);

Integer i = 100;//jdk5之后会进行一个装箱操作，就是直接将你的int数值自动封装成Integer对象

i+=200;

/**

* 理论上我们只有当两种数据类型一致的时候才能进行运算

* ，此时一个数据类型是int,一个是Integer,这两个数据进行

* 相加的时候，Integer类型的数据会自动转变成int类型的数据，

* 这就叫拆箱

System.out.println(i);

}

packagecom.edu.character;

public classCharaterDemo {

public static voidmain(String[] args) {

/**

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

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

构造方法：

public Character(char value)

Character c = newCharacter('a');

System.out.println(c);

}

packagecom.edu.character;

public classCharaterDemo2 {

public static voidmain(String[] args) {

/**

* 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)

System.out.println(Character.isUpperCase('a'));

System.out.println(Character.isUpperCase('A'));

System.out.println(Character.isUpperCase('0'));

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

System.out.println(Character.isLowerCase('a'));

System.out.println(Character.isLowerCase('A'));

System.out.println(Character.isLowerCase('0'));

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

System.out.println(Character.isDigit('a'));

System.out.println(Character.isDigit('A'));

System.out.println(Character.isDigit('0'));

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

System.out.println(Character.toUpperCase('a'));

System.out.println(Character.toUpperCase('A'));

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

System.out.println(Character.toLowerCase('a'));

System.out.println(Character.toLowerCase('A'));

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

}

packagecom.edu.character;

importjava.util.Scanner;

public classCharaterDemo3 {

public static voidmain(String[] args) {

/**

*2.3

需求：键盘录入一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

请把以前的代码复制过来，修改成功即可。

Scanner sc = newScanner(System.in);

String s = sc.nextLine();

//判断里面的大小写字母和数字

int bigCount= 0;

intsmallCount = 0;

int numCount= 0;

//将字符串转换成字符数组

char[] chs =s.toCharArray();

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

if(Character.isUpperCase(chs[i])) {

bigCount++;

}else if(Character.isLowerCase(chs[i])) {

smallCount++;

}else if(Character.isDigit(chs[i])) {

numCount++;

}

System.out.println("大写字符："+bigCount);

System.out.println("小写字符："+smallCount);

System.out.println("数写字符："+numCount);

}

packagecom.edu.math;

public class MathDemo{

public static voidmain(String[] args) {

/**

* 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) min自学

public static double pow(double a,double b) a的b次方

public static double random()

public static int round(float a) 参数为double的自学

}

packagecom.edu.math;

importjava.util.Scanner;

public class MathDemo2{

public static voidmain(String[] args) {

//案例：猜数字小游戏 (1-100的随机数)

//随机生成一个随机数

int random =(int) (Math.random()*100+1);

//System.out.println(random);

Scanner sc = newScanner(System.in);

while (true) {

System.out.println("请输入你猜测的数字");

int guessNum= sc.nextInt();

if(guessNum<random) {

//猜的小了

System.out.println("小了");

}else if(guessNum>random) {

System.out.println("大了");

}else if(guessNum==random) {

System.out.println("答对了");

break;

}

packagecom.edu.object;

class Student{

private String name;

private int age;

public Student(){}

public Student(String name,int age) {

super();

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Student[name=" + name + ", age=" + age + "]";

}

/**

* 创建学生对象打印学生对象的地址值（本质上是将地址通过哈希算法算出的哈希值）

同一个对象的哈希值肯定是一样的。

哈希值相同的对象的地址值未必一样。

新华字典,zhu-- 456(哈希值) --猪(第三个)，朱(第5个)，珠(第9个)

* toString():

* 因为打印的对象时候打印的是对象的哈希吗值

* ，这个对于我们来说，没有意义，我们需要看到的是对象内部的成员变量值。。

* 这个时候我们就需要重写toString()方法，自动生成即可

* equals()：

* 默认比较的是地址值，但是==已经可以比较对象的地址值，这个方法如果默认比较对象的地址值对我们来数意义也不大。

* 所以我们需要重写一下，equals()方法，可以用来比较对象的成员变量是否相同

* 面试题：

==和equals()的区别?

A:==的作用

a:基本类型数据值

b:引用类型地址值

B:equals()

只能比较引用类型。默认比较地址值。

如果重写后，是按照重写后的规则进行的。

public classStudentDemo {

public static voidmain(String[] args) {

Student s = new Student("刘德华",20);

System.out.println(s);//com.edu.object.Student@69123787,其实是对象的哈希吗值

}

importjava.util.Scanner;

public classScannerDemo {

public static voidmain(String[] args) {

/**

Scanner:帮助我们从键盘获取数据。

构造方法：

Scanner(InputStreamsource)

Scannersc = new Scanner(System.in);

System.in in是System类下面的一个静态的成员变量。

现在我们并不知道in这个成员变量的数据类型。

请看一下伪代码：

Scanner{

publicScanner(InputStream in){}

}

System{

publicstatic final InputStream in;

}

InputStreamSystem.in

成员方法：

int nextInt():获取int类型的数据

String nextLine():获取String类型的数据

InputMismatchException：输入的数据和最终的结果类型不匹配。

建议：要什么类型，你就输入什么类型。反正将来也不用。

//创建对象

Scanner sc = newScanner(System.in);

//获取键盘录入的int值

int int1 =sc.nextInt();

System.out.println(int1);

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

Scanner sc2 = newScanner(System.in);

String s = sc2.nextLine();

System.out.println(s);

}

packagecom.edu.scanner;

importjava.util.Scanner;

public classScannerDemo2 {

public static voidmain(String[] args) {

/**

*String,String

*String,int

* int,int

* int,String

//创建键盘录入对象

// Scanner sc = new Scanner(System.in);

// //String,String

// System.out.println("请输入第一个字符串");

// String s1 = sc.nextLine();

// System.out.println("请输入第二个字符串");

// String s2 = sc.nextLine();

// System.out.println(s1);

// System.out.println(s2);

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

//String,int

// Scanner sc = new Scanner(System.in);

// //String,String

// System.out.println("请输入第一个字符串");

// String s1 = sc.nextLine();

// System.out.println("请输入第二个数字");

// int i = sc.nextInt();

// System.out.println(s1);

// System.out.println(i);

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

//int,int

// Scanner sc = new Scanner(System.in);

// //String,String

// System.out.println("请输入第一个数字");

// int i1 = sc.nextInt();

// System.out.println("请输入第二个数字");

// int i2 = sc.nextInt();

// System.out.println(i1);

// System.out.println(i2);

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

//int,String

Scanner sc = newScanner(System.in);

//String,String

System.out.println("请输入第一个数字");

int i1 =sc.nextInt();

System.out.println("请输入第二个字符串");

String i2 = sc.nextLine();

System.out.println(i1);

System.out.println(i2);

/**

* 当第一个赋值数字第二个赋值字符串的时候出现问题？

* 解决办法：

* A：获取字符串的时候重新创建一个Scanner对象

* B：全部按照字符串进行获取，再将字符串的数据通过基本数据类型包装类中的方法转换成你需要的类型

* 例如：String--int

*Integer.parseInt("100") 将字符串100转换成int数据100

}

packagecom.edu.random;

importjava.util.Random;

/**

* 构造方法：

Random():没有指定种子，采用的是默认种子。

Random(longseed):可以指定种子。种子相同，产生的随机数就相同。

需求：利用有无种子的方式创建对象，使用for循环产生十个随机数

成员方法：

public int nextInt():返回int范围内的数据

public int nextInt(int n):返回[0,n)之间的数据

得到1-100之间的随机数：

new Random().nextInt(100) + 1

public classRandomDemo {

public static voidmain(String[] args) {

//无种子创建随机数产生对象

//Random r = new Random();

//有种子创建random对象,同一个种子产生的随机数是相同的

Random r = newRandom(17);

//如何产生1-100之间的随机数

//r.nextInt(100)+1;

//使用for循环产生十个随机数

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

System.out.println(r.nextInt(100)+1);

}

packagecom.edu.system;

importjava.util.Arrays;

* System:

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

* 成员方法：

* public static void exit(int status):终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。

* public static long currentTimeMillis():获取当前时间的毫秒值。

* public static void arraycopy(Object src,intsrcPos,Object dest,int destPos,int length):复制数组

public classSystemDemo {

public static voidmain(String[] args) {

//public static void exit(intstatus):终止当前正在运行的 Java 虚拟机。根据惯例，非 0 的状态码表示异常终止。

System.out.println("hello");

//System.exit(100);//异常终止java虚拟机

//System.exit(0);//正常终止虚拟机

System.out.println("world");

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

//public static longcurrentTimeMillis():获取当前时间的毫秒值。

//主要用在测试程序的执行时间

//获取循环执行前的时间

long start = System.currentTimeMillis();

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

System.out.println(i);

}

//结束时间

long end = System.currentTimeMillis();

//程序执行使用时间

long time = end - start;

System.out.println("使用"+time+"毫秒");

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

// public static void arraycopy(Objectsrc,int srcPos,Object dest,int destPos,intlength):复制数组

/**

* 参数一：要复制的源数组

* 参数二：从源数组那个索引开始复制

* 参数三：需要复制到哪个数组中

* 参数四：从哪个索引开始进行覆盖

* 参数五：需要覆盖几个元素

//复制一个数组

int[] arr ={1,2,3,4,5};

int[] arr2 ={6,7,8,9,10};

System.arraycopy(arr, 1, arr2, 2,2);

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

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

}

packagecom.edu.date;

importjava.util.Date;

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

* 构造方法：

* Date():默认获取的是当前的日期时间

* Date(longdate):把当前日期按照指定的毫秒值进行设定

* 成员方法：

* publiclong getTime()：获取日期对象的毫秒值

* publicvoid setTime(long time):设置日期对象的毫秒值

public class DateDemo{

public static voidmain(String[] args) {

//Date():默认获取的是当前的日期时间

Date d = new Date();

System.out.println(d);//Fri Jan06 16:39:45 CST 2017

//Date(long date):把当前日期按照指定的毫秒值进行设定

//public long getTime()：获取日期对象的毫秒值

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

System.out.println(System.currentTimeMillis());//这两种方式获取当前事件毫秒值，效果是等价的

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

Date d2 = newDate(d.getTime());

//将第一个创建的日期对象的毫秒值赋值给这个日期对象的构造方法，

//其实创建的就是上个日期对应的日期对象，因为两次的毫秒值相同

System.out.println(d2);

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

Date d3 = new Date();

//给日期对象重新赋值之前获取的时间毫秒值

d3.setTime(d.getTime());

System.out.println(d3);

}

package com.edu.dateformat;

import java.text.ParseException;

importjava.text.SimpleDateFormat;

import java.util.Date;

public class DateFormatDemo {

publicstatic void main(String[] args) throws ParseException {

* DateFormat:

* 格式化：

* Date -- String

* 2015年9月27日 15:14:23

* Stringformat(Date d)

* 解析：

* String -- Date

* "2015-12-12"

* Date parse(String s)

* 构造：

SimpleDateFormat()用默认的模式格式化日期对象

SimpleDateFormat(String pattern):用给定的模式格式化日期对象

例如：

yyyy年MM月dd日 HH:mm:ss

yyyy-MM-dd HH:mm:ss

成员方法：

public final String format(Date date)将一个 Date 格式化为日期/时间字符串

public Date parse(String source)throwsParseException从给定字符串的开始解析文本，以生成一个日期对象

//格式化

Dated = new Date();

System.out.println(d);//FriJan 06 17:02:07 CST 2017

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

//使用simpleDateFormat进行格式化

//默认的格式进行格式化

SimpleDateFormatsdf = new SimpleDateFormat();

StringdStr = sdf.format(d);

System.out.println(dStr);

//默认的格式似乎还无法满足我们的需求

//我们需要自定义格式（查看定义的时间字段）

//SimpleDateFormat(String pattern):用给定的模式格式化日期对象

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

Stringd2Str = sdf2.format(d);

System.out.println(d2Str);

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

//解析日期，将一个日期字符串解析成一个日期对象

StringdateStr = "2017-01-06 17:08:54";

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

//注意创建这个对象的参数格式一定要和解析的字符串的格式相匹配

Datedate = sdf3.parse(dateStr);

System.out.println(date);

}

package com.edu.dateformat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

//键盘录入出生日期，算一下你来到这个世界多少天?

/**

* 1.键盘录入年月日

* 2.将年月日封装成日期对象

* 3.获取你出生日期对象的毫秒值

* 4.获取当前时间的毫秒值

* 5.算出差值

* 6.求出来到世界多少天

public class DateFormatTest {

publicstatic void main(String[] args) throws ParseException {

//1.键盘录入年月日

Scannersc = new Scanner(System.in);

System.out.println("请输入你的出生日期：yyyy-MM-dd");

//获取键盘录入数据

StringstartDate = sc.nextLine();

//2.将年月日封装成日期对象

SimpleDateFormatsdf = new SimpleDateFormat("yyyy-MM-dd");

DatestartD = sdf.parse(startDate);

//4.获取当前时间的毫秒值

longnowTime = new Date().getTime();

//5.算出差值

longtime = nowTime - startD.getTime();

//算出天数

longday = time /1000/60/60/24;

System.out.println("你已经来到世间"+day+"天了");

}

importjava.text.SimpleDateFormat;

import java.util.Date;

public abstract class DateUtils {

//可以获取yy年MM月dd日

publicstatic String getDate() {

Dated = new Date();

SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日");

StringdateStr = sdf.format(d);

returndateStr;

}

//可以获取HH:mm:ss

publicstatic String getTime() {

Dated = new Date();

SimpleDateFormatsdf = new SimpleDateFormat("HH:mm:ss");

StringdateStr = sdf.format(d);

returndateStr;

}

//获取yy-MM-dd HH:mm:ss

publicstatic String getDateTime() {

Dated = new Date();

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

StringdateStr = sdf.format(d);

returndateStr;

}

packagecom.edu.dateformat;

public classDateUtilsTest {

public static voidmain(String[] args) {

System.out.println(DateUtils.getDate());

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

System.out.println(DateUtils.getDateTime());

}