javaSE（六）

最新推荐文章于 2022-03-27 20:09:10 发布

YooFale

最新推荐文章于 2022-03-27 20:09:10 发布

阅读量259

点赞数

分类专栏： javase 文章标签： javase

博主原创，转发请私信。

本文链接：https://blog.csdn.net/YooFale/article/details/82900444

版权

javase 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.StringBuffer类

提供一个可变的字符串序列

StringBuffer线程安全

StringBuffer，StringBuilder，String的区别：

String是不可变的字符序列

StringBuffer是线程安全的，可变字符序列，线程安全效率低

StringBuilder是非线程安全的，可变字符序列，线程不安全，效率高。JDK1.5才出现

构造方法：

  StringBuffer的构造方法：
             public StringBuffer():无参构造方法
             public StringBuffer(int capacity):指定容量的字符串缓冲区对象
             public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
             public int capacity()：返回当前容量。   理论值
             public int length():返回长度（字符数）。实际值
案例代码：

// StringBuffer sb = new StringBuffer();
		// StringBuffer sb = new StringBuffer(15);
		StringBuffer sb = new StringBuffer("明天回家");
		System.out.println(sb.length());
		System.out.println(sb.capacity());

默认的capacity是16，如果构造方法中的参数列表是字符串的话，那么就是字符串长度直接加上16。

添加功能：

  public StringBuffer append(String str):
          可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):
          在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

案例代码：

public static void main(String[] args) {
		// demo1();
		StringBuffer sb = new StringBuffer();
		StringBuffer insert = sb.insert(0, "爱我中华");
		System.out.println(insert);
	}

	public static void demo1() {
		StringBuffer sb = new StringBuffer();
		StringBuffer sb1 = sb.append("黑马");
		System.out.println(sb1);
		StringBuffer sb2 = sb.append(true);
		StringBuffer sb3 = sb.append(100);
		StringBuffer sb4 = sb.append('我');
		System.out.println(sb.toString());
		System.out.println(sb2);
		System.out.println(sb3);
		System.out.println(sb4);
	}

首先可以发现： StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组
当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符。所以sb1，sb2,sb3,sb4都只是索引，最后指向的堆中的对象在不断改变，他们输出的结果都是一样的。

在调用insert方法的时候，如果偏移量给出一个不存在的值，会报索引越界的错误。

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 1

删除功能：
  public StringBuffer deleteCharAt(int index):
           删除指定位置的字符，并返回本身
  public StringBuffer delete(int start,int end):
           删除从指定位置开始指定位置结束的内容，并返回本身（包含头不包含尾，所以清空缓冲区用(0,length())）

案例代码：

StringBuffer sb1 = new StringBuffer();
		StringBuffer sb = sb1.append("heima");
		// sb.deleteCharAt(3);
		// StringBuffer delete = sb.delete(0, 2); 				//包含头不包含尾
		sb.delete(0, sb.length());										//清空缓冲区
		System.out.println(sb);

替换和反转功能：
StringBuffer的替换功能
             public StringBuffer replace(int start,int end,String str):
    从start开始到end用str替换(同样是包含头不包含尾)
      StringBuffer的反转功能
public StringBuffer reverse():
               字符串反转

截取功能：
StringBuffer的截取功能
   public String substring(int start):
从指定位置截取到末尾
         public String substring(int start,int end):
             截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

注意:返回值类型不再是StringBuffer本身

String和StringBuffer的转换：
A:String -- StringBuffer
         a:通过构造方法
         b:通过append()方法
   B:StringBuffer -- String
         a:通过构造方法
         b:通过toString()方法
         c:通过subString(0,length);

案例代码：

public static void demo2() {
		StringBuffer sb1 = new StringBuffer("好日子");                   // 构造方法，StringBuffer转String
		String string = new String(sb1);
		System.out.println(string);

		StringBuffer sb2 = new StringBuffer("今天国庆");			
		String string2 = sb2.toString();												//toString方法，StringBuffer转String

		StringBuffer sb3 = new StringBuffer("haorizi");		      
		String string3 = sb3.substring(0, sb3.length());					//subString方法，StringBuffer转String
	}

	public static void demo1() {
		StringBuffer sb = new StringBuffer("heima"); // 构造方法，String转StringBuffer
		StringBuffer sb1 = new StringBuffer();
		StringBuffer sb2 = sb1.append("hao");
		System.out.println(sb2); // append，String转StringBuffer
	}

数组转换成字符串(通过StringBuffer实现)：

public class Test1 {
	/*
	 * 利用StringBuffer实现数组转换成字符串
	 * 好处是String在不断拼接字符串，以前的就会成为垃圾，浪费。但是StringBuffer不会这样。
	 */
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4 };
		System.out.println(arrayToString(arr));
		System.out.println("数字转换字符串完成");
	}

	public static StringBuffer arrayToString(int[] arr) {
		StringBuffer sb = new StringBuffer();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == (arr.length - 1)) {
				sb.append(arr[i] + "]");
			} else {
				sb.append(arr[i] + ",");
			}
		}
		return sb;
	}
}

好处是String在不断拼接字符串，以前的就会成为垃圾，浪费。但是StringBuffer不会这样

字符串反转：

public class Test2 {
	/*
	 * 对键盘输入的内容进行字符串反转
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入要转换的字符串：");
		String line = sc.nextLine();
		System.out.println(revString(line));
	}

	public static String revString(String line) {
		StringBuffer sb = new StringBuffer(line);
		return sb.reverse().toString();
	}

}

基本类似于String下实现

String和StringBuffer分别作为参数传递：

public class Demo7 {
	/**
	 * * A:形式参数问题
			* String作为参数传递
			* StringBuffer作为参数传递 
		* B:案例演示
			* String和StringBuffer分别作为参数传递问题
	基本数据类型的值传递,不改变其值
	引用数据类型的值传递,改变其值
	
	String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
	 */
	public static void main(String[] args) {
		String s = "heima";
		System.out.println(s);
		change(s);
		System.out.println(s);
		StringBuffer sb = new StringBuffer("国庆");
		System.out.println(sb);
		change(sb);
		System.out.println(sb);
	}

	public static void change(StringBuffer sb) {
		sb.append("快乐");
	}

	public static void change(String s) {
		s += "!";
	}

}

基本数据类型的值传递,不改变其值
引用数据类型的值传递,改变其值
String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的

2.排序

冒泡排序：轻的上浮，重的下沉

每个数都和下一个数比较，大的后移。所以第一轮循环过后，最大的在在后面，第二次比较的时候，就不带最后一个，第二大在第二次的最后一个，下一次就不带这个，以此类推。

选择排序：

第一个数和后面每个数都进行比较。如果后面的数字比第一个数字小，那么交换位置，这样一次循环下来，最小的数字就排在了第一位。第二次循环，除过第一个，从第二个开始与后面的数字进行比较，以此类推。

案例代码：

public class SortDemo {
	/*
	 * 两种排序
	 */
	public static void main(String[] args) {
		int[] arr = { 108, 66, 52, 44, 88 };
		// bubbleSort(arr);
		selectSort(arr);
		show(arr);
	}

	/*
	 * 选择排序 1,返回值类型void 2,参数列表int[] arr
	 * 
	 * 第一次:arr[0]分别与arr[1-4]比较,比较4次 第二次:arr[1]分别与arr[2-4]比较,比较3次
	 * 第三次:arr[2]分别与arr[3-4]比较,比较2次 第四次:arr[3]与arr[4]比较,比较1次
	 */
	public static void selectSort(int[] arr) {
		System.out.println("调用的是选择排序");
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[i]) {
					swap(arr, i, j);
				}
			}
		}
	}

	public static void show(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
	}

	/*
	 * 冒泡排序 1,返回值类型,void 2,参数列表,int[] arr
	 * 
	 * 第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
	 * 第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
	 * 第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次 第四次:arr[0]与arr[1]比较1次
	 */
	public static void bubbleSort(int[] arr) {
		System.out.println("调用的是冒泡排序");
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
				}
			}
		}
	}

	/*
	 * 换位操作 1,返回值类型,void 2,参数列表int[] arr.int i,int j
	 * 
	 * 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
	 */
	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

}

3.二分法查找

必须是有序排列的

public class FindDemo {
	/*
	 * 二分查找
	 */
	public static void main(String[] args) {
		int[] arr = { 11, 22, 33, 44, 55, 66 };
		System.out.println(getIndex(arr, 77));
	}

	public static int getIndex(int[] arr, int value) {
		int max = arr.length - 1;
		int min = 0;
		int mid = (max + min) / 2;
		while (arr[mid] != value) {
			if (arr[mid] < value) {
				min = mid + 1;
			} else {
				max = mid - 1;
			}
			mid = (max + min) / 2;
			if (min > max) {
				return -1;
			}
		}
		return mid;
	}

}

二分查找的核心思路如图所示：

不断改变中值，通过比较中值和目的值来进行比较。

4.Arrays类

public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

工具类方法的掌握及原理的了解

5.基本类型包装类

好处：将基本数据类型封装成对象的好处在于可以定义更多的功能方法操作该数据。

常用操作：用于基本数据类型和字符串之间的转换。

八种六种是直接首字母大写。int的包装类是Integer，char的包装类是Character

除了Character没有parse✘✘✘。其余七个类都有parse✘✘✘来把String对象转换成基本数据类型。

JDK5的新特性

自动拆箱装箱

装箱：基本数据类型变为包装类类型

拆箱：包装类类型变为基本数据类型

案例代码：

int i = 1;
		Integer i1 = new Integer(i); // 手动装箱
		int intValue = i1.intValue(); // 手动拆箱
		Integer i2 = 200;
		int a = i2 - 100;
		System.out.println(a);
		Integer i3 = null;
		int a1 = i3 - 100;
		System.out.println(a1);

Integer x =null的时候，不能自动拆箱，会报错：

java.lang.NullPointerException

所以先判断是否为null再使用

6.Integer类

构造方法：

public Integer(int value)
public Integer(String s)

案例代码：

Integer i1 = new Integer("12345");
		System.out.println(i1);
		Integer i2 = new Integer(123);
		System.out.println(i2);
		// Integer i3 = new Integer("wo");
		// System.out.println(i3);

int和字符串的转换。

输入的字符串不是数字会报错：

java.lang.NumberFormatException: For input string: "wo"

7.String和Int之间的转换

A:int -- String
             a:和""进行拼接
             b:public static String valueOf(int i)
             c:int -- Integer -- String(Integer类的toString方法())
             d:public static String toString(int i)(Integer类的静态方法)
       B:String -- int
             a:String -- Integer -- int
               public static int parseInt(String s)
案例代码：

	int i = 2;
		String s1 = i + "";
		System.out.println(s1);
		String s2 = String.valueOf(i);
		System.out.println(s2);
		Integer integer = new Integer(i);
		String s3 = integer.toString();
		System.out.println(s3);
		Integer integer2 = new Integer(i);
		String s4 = Integer.toString(i);
		System.out.println(s4);
		System.out.println("---------------");
		String s = "12345";
		Integer integer3 = new Integer(s);
		int int1 = integer3.intValue();
		System.out.println(int1);
		int int2 = Integer.parseInt(s);
		System.out.println(int2);

8.Integer面试题

		Integer i1 = new Integer(97);
		Integer i2 = new Integer(97);
		System.out.println(i1 == i2);				//false
		System.out.println(i1.equals(i2));			//true
		System.out.println("-----------");
	
		Integer i3 = new Integer(197);
		Integer i4 = new Integer(197);
		System.out.println(i3 == i4);				//false
		System.out.println(i3.equals(i4));			//true
		System.out.println("-----------");
	
		Integer i5 = 127;
		Integer i6 = 127;
		System.out.println(i5 == i6);				//true
		System.out.println(i5.equals(i6));			//true
		System.out.println("-----------");
	
		Integer i7 = 128;
		Integer i8 = 128;
		System.out.println(i7 == i8);				//false
		System.out.println(i7.equals(i8));			//true

分析：

equals方法是两个Integer的值相等就相等，所以都为true。

==因为前两个都是不同的new，索引指向的不是同一个对象，所以都为false。

后两个运用到了自动装箱：

-128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
如果超过了byte取值范围就会再新创建对象，那么两个索引指向的对象就不是同一个。

9.正则表达式

在API中查询Pattern。

字符类
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]	a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]	d、e 或 f（交集）
[a-z&&[^bc]]	a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]	a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]

需要说明的是，空白字符包括空格和Tab等。但是几个空格不算，什么都没有也不行。

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

有空格不算什么都没有，什么都没有算零个。

[x]{n}需要字符串正好长度为n并且都是x中的字符。

正则表达式的切分功能

`String[]`	`split(String regex)` 根据给定正则表达式的匹配拆分此字符串。
`String[]`	`split(String regex, int limit)` 根据匹配给定的正则表达式来拆分此字符串。

String类的方法，但是参数列表是正则表达式

在此方法中，有一个特例。需要用.切分的，实际需要的切分条件是“\\.”。因为需要转义字符

将给定的数字组合字符串进行排序并输出：

public static void main(String[] args) {
		String s = "12 86 99 25 71";
		// 先把字符串中的数字切分出来
		String[] strings = s.split(" ");
		// 建立长度相等的int数组
		int[] arr = new int[strings.length];
		// 将对应位置的值依次传过去
		for (int i = 0; i < strings.length; i++) {
			arr[i] = Integer.parseInt(strings[i]);
		}
		// 进行排序
		Arrays.sort(arr);
		// 将排序好的进行输出
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arr.length; i++) {
			if (i == (arr.length - 1)) {
				sb.append(arr[i]);
			} else {
				sb.append(arr[i] + " ");
			}
		}
		System.out.println(sb);

	}

如果直接排序80>100，因为8>1。所以，需要把原来的字符串转化成int数组，转化成数组前面需要切分。

正则表达式的替换功能

`String`	`replaceAll(String regex, String replacement)` 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
`String`	`replaceFirst(String regex, String replacement)` 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

案例代码：

	String a = "ai2w0ozhong9hu1a";
		String regex = "\\d";
		String string = a.replaceAll(regex, "");
		System.out.println(string);

需要去除掉字符串中的某些东西，用正则条件限定，再用空字符串替换即可。

正则表达式的分组功能

此处主要是对叠词的处理，匹配，切割，替换等

案例代码：

	public static void main(String[] args) {
		// demo1();
		// demo2();
		/*
		 替换
		 * 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程 将字符串还原成:“我要学编程”。
		 */
		String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
		String s1 = s.replaceAll("\\.+", "");
		String s2 = s1.replaceAll("(.)\\1+", "$1");
		System.out.println(s2);
	}

	public static void demo2() {
		// 需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
		String s = "sdqqfgkkkhjppppkl";
		String regex = "(.)\\1+";
		String[] split = s.split(regex);
		for (int i = 0; i < split.length; i++) {
			System.out.print(split[i] + " ");
		}
	}

	public static void demo1() {
		// 快快乐乐，高高兴兴
		String s1 = "快快乐乐";
		String regex = "(.)\\1(.)\\2";
		System.out.println(s1.matches(regex));
		System.out.println("高兴快乐".matches(regex));
		// 高兴高兴
		String s2 = "高兴高兴";
		String regex1 = "(..)\\1";
		System.out.println(s2.matches(regex1));
		System.out.println("高高兴兴".matches(regex1));
	}

（.）代表的是取第一个数（..)代表取的是取前两个数字 \\1代表在第一组出现 \\2代表在第二组出现

$代表取出位置的值

10.Pattern和Matcher

一般格式：

Pattern p = Pattern.compile("regex");
Matcher m = p.matcher("String");
boolean b = m.matches();

案例代码：

String s = "我用过很多手机号，有15735658888，还有17344407888等等";
		String regex = "1[357]\\d{9}";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(s);
		boolean matches = m.matches();
		// boolean find = m.find();
		// String group = m.group();
		// System.out.println(matches);
		// System.out.println(find);
		// System.out.println(group);
		while (m.find()) {
			String s1 = m.group();
			System.out.println(s1);
		}

可以用于从指定字符串中获取符合格式的内容

必须要先调用find方法，再调用group输出find的内容，不然会报错

Exception in thread "main" java.lang.IllegalStateException: No match found

11.Math类

案例代码：

System.out.println(Math.PI);
		// 绝对值
		System.out.println(Math.abs(-8));
		// ceil天花板，取上面的值
		System.out.println(Math.ceil(12.3));
		System.out.println(Math.ceil(12.99));
		// floor，地板，取下面的值
		System.out.println(Math.floor(12.3));
		System.out.println(Math.floor(12.99));
		// 取两个数之间的最大值
		System.out.println(Math.max(12, 8));
		// 取两个数之间的最小值
		System.out.println(Math.min(12, 8));
		// 前面的是底数，后面的是指数。下面这个2.0的3.0次方
		System.out.println(Math.pow(2, 3));
		System.out.println(Math.pow(3, 2));
		// 生成0-1随机数
		System.out.println(Math.random());
		// 四舍五入
		System.out.println(Math.round(12.3f));
		System.out.println(Math.round(12.6f));
		// 开平方
		System.out.println(Math.sqrt(2));
		System.out.println(Math.sqrt(4));

12.Random类

案例代码：

	Random r = new Random();
		int nextInt = r.nextInt(100);
		System.out.println(nextInt);

nextint里面输入100，实际是0-99.

13.System类

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)

案例代码：

public static void main(String[] args) {
		// demo1();
		int[] arr = { 11, 22, 33, 44, 55, 66 };
		int[] arr1 = new int[7];
		System.arraycopy(arr, 0, arr1, 0, arr.length);
		for (int i = 0; i < arr1.length; i++) {
			System.out.println(arr1[i]);
		}
	}

	public static void demo1() {
		long start = System.currentTimeMillis();
		for (int i = 0; i < 10; i++) {
			System.out.println("aaaaa");
		}
		long end = System.currentTimeMillis();
		long time = end - start;
		System.out.println(time);
		System.out.println(end);
	}

}

class Demo {
	@Override
	protected void finalize() {
		System.out.println("垃圾已经清理");
		System.exit(0);
	}

}

14.BigInteger

用于存放超大整数

案例代码：

BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("3");
		//比较两个BigInteger，大1，等于0，小于-1
		System.out.println(bi1.compareTo(bi2));
		BigInteger bi3 = new BigInteger("100");
		System.out.println(bi1.compareTo(bi3));
//		加
		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[] result = bi1.divideAndRemainder(bi2);
		for (int i = 0; i < result.length; i++) {
			System.out.println(result[i]);
		}

15.BigDecimal类

案例代码：

public static void method3() {
		BigDecimal bd1 = BigDecimal.valueOf(2);
		BigDecimal bd2 = BigDecimal.valueOf(1.1);
		BigDecimal bd3 = bd1.subtract(bd2);
		System.out.println(bd3);
	}

	public static void method2() {
		BigDecimal bd1 = new BigDecimal("2");
		BigDecimal bd2 = new BigDecimal("1.1");
		BigDecimal bd3 = bd1.subtract(bd2);
		System.out.println(bd3);
	}

	public static void method1() {
		BigDecimal bd1 = new BigDecimal(2);
		BigDecimal bd2 = new BigDecimal(1.1);
		BigDecimal bd3 = bd1.subtract(bd2);
		System.out.println(bd3);
	}

推荐使用2方法或者3方法进行创建，这样运算精确。

16.Date类

案例代码：

public static void main(String[] args) {
		//demo1();
		//demo2();
		Date d1 = new Date();	
		d1.setTime(1000);								//设置毫秒值,改变时间对象
		System.out.println(d1);
	}

	public static void demo2() {
		Date d1 = new Date();	
		System.out.println(d1.getTime());				//通过时间对象获取毫秒值
		System.out.println(System.currentTimeMillis());	//通过系统类的方法获取当前时间毫秒值
	}

	public static void demo1() {
		Date d1 = new Date();					//如果没有传参数代表的是当前时间
		System.out.println(d1);
		
		Date d2 = new Date(0);					//如果构造方法中参数传为0代表的是1970年1月1日
		System.out.println(d2);					//通过毫秒值创建时间对象
	}

有参构造，设置为0，实际上是1970年，0点。因为我们在东八区，所以输出的是8点。

getTime是获取时间对象的毫秒值，与System里面的从currentTimeMillis效果是一样的。

setTime相当于设置时间偏移量。

DateFormat是个抽象类，不允许实例化。实际应用注重SimpleDateFormat

17.SimpleDateFormat类

案例代码：

public static void demo3() throws ParseException {
		String d = "2018年10月02日 15:23:55";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		Date parse = sdf.parse(d);
		System.out.println(parse);
	}

	public static void demo2() {
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		System.out.println(sdf.format(d));
	}

	public static void demo1() {
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat();
		System.out.println(sdf.format(d));
	}

简而言之：format用于对象转字符串，可以自己设置格式。parse用于字符串转对象，需要找对格式

求出你至今已经出生多少天？

	// 将日期格式字符串输入
		String birthday = "1995年12月31日";
		String today = "2018年10月02日";
		// 设置字符串转日期的格式
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
		// 将日期格式字符串转化为日期对象
		Date d1 = sdf.parse(birthday);
		Date d2 = sdf.parse(today);
		// 获取中间时间
		long time = d2.getTime() - d1.getTime();
		// 将中间时间转化为天数
		System.out.println(time / 1000 / 60 / 60 / 24);

18.Calendar类

B:成员方法
   public static Calendar getInstance() //获取实例
   public int get(int field) //标准的输出格式Calendar.getInstance().get(Calendar.字段名)
C:成员方法
   public void add(int field,int amount) //对指定的数据进行加减操作
   public final void set(int year,int month,int date) //对位置上对应的数据进行设置

输出当前时间代码：

public class Demo8_Calendar {
	/**
	 * * A:Calendar类的概述
	 * Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR
	 * 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
	 * B:成员方法
	 * public static Calendar getInstance()
	 * public int get(int field)
	 * * C:成员方法
	 * public void add(int field,int amount)
	 * public final void set(int year,int month,int date)
	 */
	public static void main(String[] args) {
		// demo();
		Calendar c = Calendar.getInstance();
		System.out.println("当前日期为:" + c.get(Calendar.YEAR) + "年" + getNum(c.get(Calendar.MONTH)) + "月"
				+ getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
		c.add(Calendar.YEAR, 1);
		c.set(Calendar.MONTH, 8);
		c.set(2000, 8, 8);
		System.out.println("当前日期为:" + c.get(Calendar.YEAR) + "年" + getNum(c.get(Calendar.MONTH)) + "月"
				+ getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}

	public static void demo() {
		Calendar c = Calendar.getInstance();
		System.out.println(c.get(Calendar.YEAR));
		System.out.println(c.get(Calendar.MONTH));
		System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println(c.get(Calendar.DAY_OF_WEEK));
		System.out.println("当前日期为:" + c.get(Calendar.YEAR) + "年" + getNum(c.get(Calendar.MONTH)) + "月"
				+ getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}

	public static String getWeek(int week) {
		String[] arr = { "", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		return arr[week];
	}

	public static String getNum(int num) {
		return num > 9 ? "" + num : "0" + num;
	}

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

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入年份,判断该年份是闰年还是平年:");
		//int year = sc.nextInt();
		
		String line = sc.nextLine();				//录入数字字符串
		int year = Integer.parseInt(line);			//将数字字符串转换成数字
		boolean b = getYear(year);
		System.out.println(b);
	}

	private static boolean getYear(int year) {
		//2,创建Calendar c = Calendar.getInstance();
		Calendar c = Calendar.getInstance();
		//设置为那一年的3月1日
		c.set(year, 2, 1);
		//将日向前减去1
		c.add(Calendar.DAY_OF_MONTH, -1);
		//判断是否是29天
		return c.get(Calendar.DAY_OF_MONTH) == 29;
	}

通过判断2月份是不是29天来确定是否是闰年。无法直接确定是哪一年,只能通过设定3月第一天减一天的方式来确定。

YooFale

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
javaSE（六）

1.StringBuffer类提供一个可变的字符串序列StringBuffer线程安全StringBuffer，StringBuilder，String的区别：String是不可变的字符序列StringBuffer是线程安全的，可变字符序列，线程安全效率低StringBuilder是非线程安全的，可变字符序列，线程不安全，效率高。JDK1.5才出现构造方法：...
复制链接

扫一扫

专栏目录