[TOC]

String 类使用

1.Scanner 详解于使用

Scanner的概述:一个简单的文本扫描器,可以使用正则表达式解析原始类型和字符串,以默认空格作为分割。
Scanner的构造方法原理:

1
2
3
4
5
6
7
8
#由于是final修饰Scanner类不能被继承
public final class Scanner
extends Object
implements Iterator<String>, Closeable

#常用方法
Scanner(InputStream source)
Scanner(System.in)

System类下有一个静态的字段:public static final InputStream in; 标准的输入流,对应着键盘录入。

一般方法

  • hasNextXxx() #判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串则可以省略Xxx
  • nextXxx() #获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下,Scanner使用空格,回车等作为分隔符
  • public int nextInt():获取一个int类型的值,当我们录入10的时候键盘上录入的是10和\r\n
  • public String nextLine():获取一个String类型的值,可以接收任意类型,只要通过\r\n就证明一行结束;

Scanner获取数据出现的小问题及解决方案

  • 第一种:先获取一个数值后,在创建一个新的键盘录入对象获取字符串。(会占用内存空间)
  • 第二种:把所有的数据都先按照字符串获取,然后要什么,你就对应的转换为什么。(后面讲)

基础示例:

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
package com.weiyigeek;
import java.util.Scanner;
public class ScannerClass {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);

//示例1:输入格式判断
System.out.print("请输入一个整数:");
if (sc.hasNextInt()) {
System.out.println("整数:"+sc.nextInt());
}else {
System.out.println("格式错误!");
}

//示例2.NextInt域nextLine联用的问题
System.out.print("请输入第二个1数字:");
int integer = sc.nextInt();
System.out.println("请输入第二个字符串:");
String line = sc.nextLine();
System.out.println("Integer 整数:"+integer+","+line);
//解决方法1:创建两次对象
int i = sc.nextInt();
Scanner lineStr = new Scanner(System.in);
String line1 = lineStr.nextLine();
System.out.println("解决方法: 整数="+ i +", 字符串=" + line1);
}
}

//#执行结果
请输入一个整数:1024
整数:1024
请输入第二个1数字:2048
请输入第二个字符串:
Integer 整数:2048,
4096
I love Study Java
解决方法: 整数=4096, 字符串=I love Study Java


2.String类

String类的概通过JDK提供的API,查看String类的说明,只要是java.lang里面的类都不用导包;

  • 字符串Java程序中的所有字符串文字(例如”abc” )都被实现为此类的实例。
  • 字符串常量即它们的值在创建后不能被更改(一旦被赋值就不能被改变)
  • 字符串缓冲区支持可变字符串因为String对象是不可变的,它们可以被共享

Java语言为字符串连接运算符(+)提供特殊支持,并为其他对象转换为字符串。

  • 字符串连接是通过StringBuilder (或StringBuffer )类及其append方法实现的。
  • 字符串转换是通过方法来实现toString

常见构造方法:

1
2
3
4
5
6
* public String():空构造
* public String(byte[] bytes):把字节数组转成字符串
* public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
* public String(char[] value):把字符数组转成字符串
* public String(char[] value,int index,int count):把字符数组的一部分转成字符串
* public String(String original):把字符串常量值转成字符串

String类的常见面试题:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#* 1.判断定义为String类型的s1和s2是否相等
* String s1 = "abc";
* String s2 = "abc";
* System.out.println(s1 == s2); #T
* System.out.println(s1.equals(s2)); #T
#* 2.下面这句话在内存中创建了几个对象?
* String s1 = new String("abc"); #// 2 个对象 ,常量池一份(正本),堆内存一份(副本);
#* 3.判断定义为String类型的s1和s2是否相等
* String s1 = new String("abc");
* String s2 = "abc";
* System.out.println(s1 == s2); #F
* System.out.println(s1.equals(s2)); #T
#* 4.判断定义为String类型的s1和s2是否相等
* String s1 = "a" + "b" + "c";
* String s2 = "abc";
* System.out.println(s1 == s2); #T JAVA中的常量优化机制
* System.out.println(s1.equals(s2)); #T
#* 5.判断定义为String类型的s1和s2是否相等
* String s1 = "ab";
* String s2 = "abc";
* String s3 = s1 + "c";
* System.out.println(s3 == s2); #F
* System.out.println(s3.equals(s2)); #T

基础示例:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.weiyigeek;
public class StringDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//#示例1.字符串是不可更改的,除了 字符串缓冲区支持可变字符串
String str = "abcdefg"; //字符串对象
System.out.println(str); //输出字符串
System.out.println(str.toString()); //String类重写了toString方法返回的是该对象本身;

//#示例2.字符串是常量一旦被赋值将不能被改变
str = "重新赋值,原来的字符串就变成垃圾等待被回收!";
System.out.println(str);

//#示例3.String类的构造方法
byte[] arr1 = {48, 65, 97};
String s1 = new String(arr1); //通过使用平台的默认字符集解码指定的字节数组来构造新的 String
System.out.println(s1);

byte[] arr2 = {97,98,99,100,101,102};
String s2 = new String(arr2,2,3); //从arr2数组中第三个元素开始解码转换3个
System.out.println(s2);

char[] arr3 = {'a','b','c','d','e'}; //字符数组转换成为字符串
String s3 = new String(arr3);
System.out.println(s3);

String s4 = new String(arr3,2,2); //字符数组从指定位置开始转多少个
System.out.println(s4);

String s5 = new String("WeiyiGeek");
System.out.println(s5);

//示例3.面试题
extracted();
stackFinal();
diffrenent();
}

//常量池中没有这个字符串对象就创建,如果有就直接引用即可(相同地址)
private static void extracted() {
String a1 = "abc";
String b1 = "abc";
System.out.println("方式1:"+(a1 == b1)); //我们前面知道 == 号默认比较的是对象地址,这里由于字符串是常量实际a1与b1指向同一个;
System.out.println("方式2:"+b1.equals(a1));
}

//常量池中的地址与堆内存中的地址是不一样的;
private static void stackFinal() {
String s1 = new String("abc"); //记录的是堆内存的地址值
String s2 = "abc"; //记录是常量池中的地址值
System.out.println(s1 == s2); // == 比较的是地址
System.out.println(s1.equals(s2)); //比较的是字符串
}

//字符串串联符号+以及将其他对象转换为字符串
private static void diffrenent() {
String s1 = "ab";
String s2 = "abc";
String s3 = s1 + "c"; //经过StringBuffer 再使用toString转换成String ; 所以地址是不同的
System.out.println("方式1:" + (s3 == s2));
System.out.println("方式2:" + s3.equals(s2));
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
abcdefg
abcdefg

重新赋值,原来的字符串就变成垃圾等待被回收!

0Aa
cde
abcde
cd
WeiyiGeek

方式1:true
方式2:true

false
true
方式1:false
方式2:true

WeiyiGeek.javaString类

WeiyiGeek.javaString类


String类的判断功能:

  • boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
  • boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  • boolean contains(String str):判断大字符串中是否包含小字符串(当且仅当此字符串包含指定的char值序列时才返回true)
  • boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
  • boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
  • boolean isEmpty():判断字符串是否为空,注意null不能被该方法判断;

空串””和null的区别

  • “”是字符串常量,同时也是一个String类的对象,既然是对象当然可以调用String类中的方法
  • null是空常量,不能调用任何方法否则会出现空指针异常,null常量可以给任意的引用数据类型赋值;

基础示例:

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 com.weiyigeek;
public class StringJudge {
public static void main(String[] args) {
// TODO Auto-generated method stub
//示例1.判断是否为空以及内容是否相同区分大小
String s1 = "";
String s2 = "abc";
String s3 = "ABC";
System.out.println("isEmpty: " + s1.isEmpty()); //是为空返回TRUE
System.out.println("equals: " + s2.equals(s3)); //返回FALSE由于区分大小写
System.out.println("equalsIgnoreCase: " + s2.equalsIgnoreCase(s3)); //返回TRUE由于不区分大小写

//示例2.判断字符串中是否包含另一个字符串以及匹配开头可结尾
String s4 = "ABC is capital,then lowercase is abc";
System.out.println("contains: " + s4.contains(s2)); // 返回为true由于S4确实包含s2字符串
System.out.println("startsWith: " + s4.startsWith(s3)); //返回为True由于s3字符串是s4字符串的开头
System.out.println("endsWith: " + s4.endsWith(s2)); //返回为TRUE由于s2字符串是s4字符的结尾
}
}

//执行结果:
isEmpty: true
equals: false
equalsIgnoreCase: true
contains: true
startsWith: true
endsWith: true


String类的获取功能

1
2
3
4
5
6
7
8
9
* int length():获取字符串的长度(其实是获取每一个字符的个数)
* char charAt(int index):获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。(不存再返回-1)
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
* lastIndexOf
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

基础示例:

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
51
52
53
54
55
56
57
58
59
60
package com.weiyigeek;

public class StringIndexSub {
public static void main(String[] args) {
//示例1.字符串长度length()其实是获取每一个字符的个数,不管中英文
String s1 = "WeiyiGeek";
String s2 = "我是一名java开发者";
System.out.println("English Text is "+s1+", Length = " +s1.length());
System.out.println("Chinese Text is "+s2+", Length = " +s2.length());


//示例2.获取指定索引的字符或者记录字符出现的索引(+ 如果不加""默认是将字符解码成为ascii序号并进行相加)
System.out.println(s1.charAt(0)+""+s1.charAt(1)+""+s1.charAt(2)+""+s1.charAt(3)+""+s1.charAt(4));
System.out.println("Index : " + s2.indexOf('j')); //参数接收的是int类型,传递char类型会自动提升;
System.out.println("Index : " + s2.indexOf("java")); //如果不存在则返回 -1
System.out.println("Index : " + s2.indexOf("开发者",5)+"\n"); //指定位置开始从前向后找

System.out.println("lastIndex : " + s2.lastIndexOf('j')); //从后向前找第一次出现的字符串
System.out.println("lastIndex : " + s1.lastIndexOf("e", 7)); //从指定位置向前找(注意这里是指定的位置任然是从字符开头到结尾数)
System.out.println("lastIndex : " + s2.lastIndexOf("java",4)+"\n"); //从第4个位置进行查找匹配


//示例3.指定截取字符串
System.out.println("My Name is " + s1.substring(0, 5) + ", I am is " + s1.substring(5)); //指定位置截取到末尾
//关键点:注意字符串有些方法会在字符串上进行操作,有的不在字符串本身进行操作(substring)不会改变源字符串;


//示例4.字符串的遍历,通过for循环获取到字符串中每个字符的索引;
String Demo = "Hacker";
for(int i = 0; i < Demo.length(); i++)
{
System.out.println(Demo.charAt(i));
}

//实际案例
countNumber();
}

//统计字符串中大小写,字符串字符以及数字字符出现此时
public static void countNumber() {
String s = "[email protected]#$%%^";
int cap = 0;
int small = 0;
int num = 0;
int other = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if( c >= 'a' && c <= 'z'){
small++;
}else if(c >= 'A' && c <= 'Z'){
cap++;
}else if(c >= '0' && c <= '9'){
num++;
}else {
other++;
}
}
System.out.println("大写字母个数: " + cap + ", 小写字母个数: " + small + ", 数字个数: " + num + ", 其他字符数量" + other);
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
English Text is WeiyiGeek, Length = 9
Chinese Text is 我是一名java开发者, Length = 11

Weiyi

Index : 4
Index : 4
Index : 8

lastIndex : 4
lastIndex : 7
lastIndex : 4

My Name is Weiyi, I am is Geek
H
a
c
k
e
r

大写字母个数: 5, 小写字母个数: 6, 数字个数: 6, 其他字符数量7


String类的转换功能

1
2
3
4
5
6
7
8
9
10
* byte[] getBytes():把字符串转换为字节数组。
* char[] toCharArray():把字符串转换为字符数组。

#注意:String类的valueOf方法可以把任意类型的数据转成字符串
* static String valueOf(char[] chs):把字符数组转成字符串。
* static String valueOf(int i):把int类型的数据转成字符串
* static String valueOf(Object obj): 返回 Object参数的字符串 Object形式。
* String toLowerCase():把字符串转成小写。
* String toUpperCase():把字符串转成大写。
* String concat(String str):把字符串拼接。 (重点)

注意事项:

  • gbk码表表示一个中文代表两个字节,gbk码表特点中文的第一个字节肯定是负数(由于康熙字典有十二万多)所以有时后面是为正数;
  • copyValueOf 与 valueOf() 实现的功能是一致的
    1
    2
    static String copyValueOf(char[] data)  #相当于 valueOf(char[]) 。
    static String copyValueOf(char[] data, int offset, int count) #相当于 valueOf(char[], int, int) 。
  • 用+拼接与从concat()方法拼接的区别:前者非常强大任意字符串拼接,后者只能字符串类型进行拼接;
  • 链式编程:只要保证每次调用完方法返回的是对象就可以继续调用;

基础案例:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package com.weiyigeek;
public class StringConversion {
public static void main(String[] args) {
//示例1.探究字符串默认转换的码表,编码把我们看的懂转换为计算机看的懂的;
demo1();

//示例2.将字符串转换成为字符数组
demo2();

//示例3.将valueof任意类型的数据转换成为字符串
char[] arr4 = {'a','b','c'}; //底层都是采用 new String() 构造方法来进行的
String s = String.valueOf(arr4);
System.out.println("\n" + s + ", 整形转换成为字符串 : " + String.valueOf(1024));

//示例4.字符串的大小写转换并且进行拼接
String lower = "abcd";
String upper = "ABCD";
System.out.println("Lower -> Upper :" + lower.toUpperCase());
System.out.println("Upper -> Lower :" + upper.toLowerCase());

System.out.println("字符串拼接1:" + lower + upper); //任意字符串拼接
System.out.println("字符串拼接2:" + lower.concat(upper)); //只能字符串类型进行拼接

//示例5.非常值得学习 把一串字符串首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
String ori = "iLOveStudyJavaPrograminG";
String dst = ori.substring(0, 1).toUpperCase().concat(ori.substring(1).toLowerCase()); //链式编程
System.out.println("示例5:" + dst);

}

public static void demo2() {
String s3 = "This";
char[] arr = s3.toCharArray();
System.out.println("\n字符串转换成为字符数组 ");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}

public static void demo1() {
String s1 = "abc";
String s2 = "你好,JAVA";

System.out.println("英文字符:" + s1);
byte[] arr1 = s1.getBytes();
byte[] arr2 = s2.getBytes();
for(int i = 0; i < arr1.length; i++)
{
System.out.print(arr1[i] + " ");
}

System.out.println("\n中文字符:" + s2);
//gbk码表表示 一个中文代表两个字节 ,gbk码表特点中文的第一个字节肯定是负数
for(int i = 0; i < arr2.length; i++)
{
System.out.print(arr2[i] + " ");
}
//注意这里是统计的数组个数所以是length (特殊中文字符串)
System.out.println("\n特殊中文字符:琲");
byte[] arr3 = "琲".getBytes();
for( int i = 0; i < arr3.length; i++)
{
System.out.print(arr3[i] + " ");
}
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
英文字符:abc
97 98 99

中文字符:你好,JAVA
-60 -29 -70 -61 44 74 65 86 65

特殊中文字符:琲
-84 105

字符串转换成为字符数组
T h i s

abc, 整形转换成为字符串 : 1024

Lower -> Upper :ABCD
Upper -> Lower :abcd

字符串拼接1:abcdABCD
字符串拼接2:abcdABCD

示例5:Ilovestudyjavaprograming


String类的其他功能

1
2
3
4
5
6
7
8
9
10
#字符串替换
String replace(char old,char new)
String replace(String old,String new)

#去除字符串两空格
String trim()

#String的按字典顺序比较两个字符串
int compareTo(String str)(暂时不用掌握)
int compareToIgnoreCase(String str)(了解)

注意事项:

  • Jave再进行查找的时候是将中文汉字转换成为10位UNICODE编码再进行比较;

基础案例:

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
package com.weiyigeek;

public class StringReplace {

public static void main(String[] args) {
//示例1.字符串替换replace
String s = "I love Java Programing!";
String s1 = s.replace("o", "A");
String s2 = s.replace("Java", "PHP"); //如果没有找到替换字符则保留原字符串不改变;
System.out.println("o -> A : " + s1);
System.out.println("Java -> PHP : " + s2);

//示例2.除去字符串两边的空格
String s3 = " Weiyi Geek ";
String s4 = s3.trim();
System.out.println("两边 blank space 去除 : " + s4);


//示例3.比较两个字符串实际将ascii码进行比较相减,如果第一个字符相减为0则,第二个字符进行相减操作直到字符串末尾;
String s5 = "abc";
String s6 = "bcd";
int num = s5.compareTo(s6); //是按照码表值进行比较
System.out.println("s5 < s6 = " + num); // 97(a) - 98(b) = -1
//不区分大写比较
int num2 = "weiyigeek".compareToIgnoreCase("WeiyiGeek");
System.out.println("CompareToIgnoreCase 不区分大小写: " + num2);
//java默认是utf-8码表
int num1 = "唯".compareTo("一");
System.out.println('唯'+0);
System.out.println('一'+0);
System.out.println("unicode(唯) - unicode(一) = " + num1);
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
o -> A : I lAve Java PrAgraming!
Java -> PHP : I love PHP Programing!

两边 blank space 去除 : Weiyi Geek

s5 < s6 = -1
CompareToIgnoreCase 不区分大小写: 0

21807
19968
unicode(唯) - unicode(一) = 1839


StringBuffer类使用

StringBuffer概述

描述:线程安全可变的字符序列,字符串缓冲区就像一个String但可以修改(长度会随着字符串变长而变长)。

1
2
3
4
5
6
7
8
public final class StringBuffer  //不能被继承
extends Object
implements Serializable, CharSequence

StringBuffer() #构造一个没有字符的字符串缓冲区,初始容量为16个字符。
StringBuffer(CharSequence seq) #构造一个包含与指定的相同字符的字符串缓冲区 它包含与指定CharSequence相同的字符
StringBuffer(int capacity) #构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer(String str) #构造一个初始化为指定字符串内容的字符串缓冲区。


StringBuffer获取长度的方法:

  • public int capacity() : 返回当前容量理论值(16个字符)
  • public int length() : 返回实际字符的长度值

StringBuffer两个添加方法:append 和 insert 方法;

  • public StringBuffer append(String str) 把任意类型数据添加到字符串缓冲区中并返回字符串缓冲区本身。(重载的方法-拥有不同的参数)
  • public StringBuffer insert(int offset, String str) 指定位置把任意类型的数据插入到字符串缓冲区中并返回字符串区本身 (重载的方法)

StringBuffer的删除功能:

  • public StringBuffer deleteCharAt(int index); 删除指定位置的字符并返回本身(如果指定索引不存在的时候则会导致缓冲区字符串异常)
  • public StringBuffer delete(int start,int end); 删除指定范围的内容并返回本身

StringBuffer的替换反转功能:

  • public StringBuffer replace(int start, int end, String str) 从start开始到end用str替换;
  • public StringBuffer reverse() 字符串反转;

StringBuffer的截取功能:

  • public StringBuffer substring(int start); 从指定位置截取到末尾
  • public StringBuffer substring(int start, int end); 截取从指定位置开始到结束位置,包括开始位置不包括结束位置;
  • 注意事项: 不会更改StringBuffer中的字符串,而是重新将截取字符串生成一个字符串对象;

实际案例:

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
51
52
53
54
55
56
57
58
59
60
61
62
/**
* @Filename: Demo1_StringBufeer.java
* @Author: WeiyiGeek
* @Function:
* @CreateTime: 下午10:12:22
*/
package com.weiyigeek.stringbuffer;

public class Demo1_StringBufeer {

public static void main(String[] args) {
//示例1.StringBuffer的三种构造方法
StringBuffer sb1 = new StringBuffer();
System.out.println("空参构造 理论长度 : "+sb1.capacity() +", 实际长度 : "+sb1.length());

StringBuffer sb2 = new StringBuffer(10); //设置一个缓冲区初始量
System.out.println("有参构造 理论长度 : "+sb2.capacity() +", 实际长度 : "+sb2.length());

StringBuffer sb3 = new StringBuffer("Java");
System.out.println("有参构造 理论长度 : "+sb3.capacity() +", 实际长度 : "+sb3.length()); //capacity() = 初始量(16) + 字符串长度(4)


//示例2.StringBuffer的增加字符串
StringBuffer sb4 = new StringBuffer();
StringBuffer sb5 = sb4.append(true);
StringBuffer sb6 = sb4.append("WeiyiGeek");
//后面的多个引用其实指向同一个对象,并且该类中重写了toString方法
System.out.println("append方法 理论长度 : "+sb5.capacity() +", 实际长度 : "+sb5.length() + ", 值为 " + sb5.toString()); //capacity() = 初始量(16) + 字符串长度(4)
System.out.println("append方法 理论长度 : "+sb6.capacity() +", 实际长度 : "+sb6.length() + ", 值为 " + sb6.toString()); //capacity() = 初始量(16) + 字符串长度(4)


//示例3.StringBuffer的指定位置添加字符元素
StringBuffer sb7 = new StringBuffer("Iloveprogramming!"); //注意这里缓冲区初始量是 16 + 17个字符 = 33
sb7.insert(5, "java"); //索引是从0开始,在指定位置添加字符串元素,如果没有指定位置的索引便会报索引越界异常;
System.out.println("insert方法 理论长度 : "+sb7.capacity() +", 实际长度 : "+sb7.length() + ", 值为 " + sb7.toString()); //capacity() = 初始量(16) + 字符串长度(4)


//示例4.StringBuffer删除功能
sb7.deleteCharAt(16); //删除sb7字符串中的一个m
System.out.println("deleteCharAt 方 法 : " + sb7);
sb7.delete(0, 5); //删除字符Ilove,删除时候是包含头但不包含尾0~5
System.out.println("delete 方法 : " + sb7);
sb7.delete(0,sb7.length()); //清空缓存区
System.out.println("delete 方法 理论长度 : "+sb7.capacity() +", 实际长度 : "+sb7.length() + ", 值为 空" + sb7.toString()); //capacity() = 初始量(16) + 字符串长度(4)

sb7 = new StringBuffer(); //不要用,原来的变成垃圾浪费内存
System.out.println("[不推荐这种方式清空缓冲区]理论长度 : "+sb7.capacity() +", 实际长度 : "+sb7.length());


//示例5.StringBuffer的替换与反转功能
StringBuffer sb8 = new StringBuffer("My Name is Weiyi");
sb8.replace(sb8.length()-5, sb8.length(), "Geek");
System.out.println("replace 方法: " + sb8.toString());
System.out.println("reverse 方法: " + sb8.reverse());

//实例6.StringBuffer字符串截取功能呢
StringBuffer sb9 = new StringBuffer("I'am weiyigeek!");
String subdemo1 = sb9.substring(5); //截取从第六个字符到末尾
String subdemo2 = sb9.substring(5,10); //截取从第6个字符开始截取直到底十的字符结束;
System.out.println("SubDemo1 = " + subdemo1 + ", SubDemo2 = " + subdemo2);
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
空参构造 理论长度 : 16, 实际长度 : 0
有参构造 理论长度 : 10, 实际长度 : 0
有参构造 理论长度 : 20, 实际长度 : 4

append方法 理论长度 : 16, 实际长度 : 13, 值为 trueWeiyiGeek
append方法 理论长度 : 16, 实际长度 : 13, 值为 trueWeiyiGeek

insert方法 理论长度 : 33, 实际长度 : 21, 值为 Ilovejavaprogramming!

deleteCharAt 方 法 : Ilovejavaprograming!
delete 方法 : javaprograming!
delete 方法 理论长度 : 33, 实际长度 : 0, 值为 空
[不推荐这种方式清空缓冲区]理论长度 : 16, 实际长度 : 0

replace 方法: My Name is Geek
reverse 方法: keeG si emaN yM

SubDemo1 = weiyigeek!, SubDemo2 = weiyi


StringBuffer与String类差异

描述:StringBuffer与String类的区别?

  • String 是一个不可变的字符序列
  • StringBuffer 是一个可变的字符序列缓冲区,当new时候是在堆内存创建一个对象,底层是一个长度为16的字符数组;当调用添加的方法时,不会重新创建对象再不断向原缓冲区添加字符;


StringBuffer与String进行转换:

  • String -> StringBuffer : 通过构造方法 或者 append() 方法;
  • StringBuferr -> String : 通过构造方法 或者 toString() 方法 或者 subString(0, length)


String和Stringbuffer分别作为参数传递问题;

  • 基本数据类型 的值传递,不改变其值;
  • 引用数据类型 的值传递,改变其值;
  • String类虽然是引用数据类型但是它当作参数传递时候和基本数据类型是一样(由于String一旦被初始化将不可变的性质)
  • StringBuffer是引用数据类型在作为参数传递的时候将会被改变

基础实例:

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
package com.weiyigeek.stringbuffer;
public class Demo2_StringBuffer {
public static void main(String[] args) {
//实例1.StringBuffer类与String类相互转换
//String -> StringBuffer对象 : 通过构造方法 或者 append() 方法;
StringBuffer sb1 = new StringBuffer("initialize 初始化"); //通过String对象转换成为StringBuffer对象;
StringBuffer sb2 = new StringBuffer();
sb2.append("initialize append");
System.out.println("方法1 : " + sb1);
System.out.println("方法2 : " + sb2);

//StringBuferr -> String : 通过构造方法 或者 toString() 方法 或者 subString(0, length)
String s1 = new String(sb1);
String s2 = sb1.toString();
String s3 = sb1.substring(0, 10);
System.out.println("方法1 = " + s1);
System.out.println("方法2 = " + s2);
System.out.println("方法3 = " + s3);


//实例2.String和Stringbuffer分别作为参数传递问题
String s4 = "String parma";
System.out.println("源字符串 : " + s4);
changeStr(s4); //一弹栈就内部的s4就变成了垃圾,也由于String一旦初始化将不会被改变(类似于C中的局部变量)
System.out.println("changeStr 方法外: " + s4);

StringBuffer sb3 = new StringBuffer(); //两个引用指向同一个对象(类似于C指针);
sb3.append("append 1");
System.out.println("第一次引用 : " + sb3);
changeStrBuf(sb3);
System.out.println("第二次引用(经过changeStrBuf) : " + sb3);
}

private static void changeStrBuf(StringBuffer sb3) {
sb3.append(",append 2");
}
private static void changeStr(String s4) {
s4 += "add";
System.out.println("changeStr 方法内 : " + s4);
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
方法1 : initialize 初始化
方法2 : initialize append
方法1 = initialize 初始化
方法2 = initialize 初始化
方法3 = initialize

源字符串 : String parma
changeStr 方法内 : String parmaadd
changeStr 方法外: String parma

第一次引用 : append 1
第二次引用(经过changeStrBuf) : append 1,append 2

注意事项:

  • 线程安全是以消耗效率为代价,可将线程安全比作是一把锁,当有人使用的时候外部将无法使用(原理类似于操作系统中的信号锁);

基础实例:

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
51
52
53
54
55
56
57
58
59
60
61
package com.weiyigeek.stringbuffer;

import java.util.Scanner;

public class Demo3_Stringbuffer {
public static void main(String[] args) {
//实例1. 利用StringBuffer将数组转换成为字符串; "[1,2,3]"形式
int[] arr = {1,2,3};
System.out.println(arrayToString(arr));


//实例2.键盘录入反转
Scanner sc = new Scanner(System.in); //创建一个键盘录入对象
System.out.print("请输入一串字符: ");
String line = sc.nextLine(); //将键盘录入的字符串存储到line中
StringBuffer sb = reverseStr(line);
System.out.println("缓存区的内容反转 : " + sb);

//实例3.反转字符串数组并输出特定格式
String[] arr1 = {"Study","Java","Programming"};
System.out.println(changeStrReverse(arr1));

}

//实例1.抽取方法
private static String arrayToString(int[] arr) {
StringBuffer sb1 = new StringBuffer(); //创建缓冲区对象(节省内存-不需要重复的申请对象提高效率)
sb1.append("[");
for(int i = 0; i < arr.length; i++) //遍历数组
{
if( i == arr.length-1 ){
sb1.append(arr[i]).append("]"); //[推荐形式]
}else {
sb1.append(arr[i] + ","); //只有这种形式不推荐(底层还是new string然后toString()),所以还是建议采用append的方法
}
}
return sb1.toString();
}

//实例2.抽取方法
public static StringBuffer reverseStr(String line) {
StringBuffer sb = new StringBuffer(line); //重点,将输入的字符串放入缓存区之中
sb.reverse(); //注意操作是sb对象本身
return sb;
}

//实例3. 抽取方法 (这里返回方法采用StringBuffer减少一次String对象申请)
private static StringBuffer changeStrReverse(String[] arr1) {
StringBuffer sb2 = new StringBuffer();
sb2.append("{");
for (int i = 0; i < arr1.length; i++) {
if( i == arr1.length - 1)
{
sb2.append(reverseStr(arr1[i])).append("}");
}else {
sb2.append(reverseStr(arr1[i])).append(",");
}
}
return sb2;
}
}

执行结果:
1
2
3
4
[1,2,3]
请输入一串字符: Whoami
缓存区的内容反转 : imaohW
{ydutS,avaJ,gnimmargorP}


StringBuilder类

描述: 一个可变的字符序列。 此类提供与StringBuffer的API,但不保证同步。
此类设计用作简易替换为StringBuffer在正在使用由单个线程字符串缓冲区的地方(如通常是这种情况);在可能的情况下,建议使用这个类别优先于StringBuffer ,因为它在大多数实现中将更快;
StringBuilder的主要StringBuilder是append和insert方法,它们是重载的以便接受任何类型的数据(参数类型不一致);

1
2
3
4
#类结构
public final class StringBuilder
extends Object
implements Serializable, CharSequence


问:String,StringBuffer与StringBuilder的区别

  • StringBuffer是jdk1.0版本的,线程是安全的但是效率低(同步);
  • StringBuilder是jdk1.5版本的,线程是不安全的效率高(不同步);
  • String是一个不可变字符序列,而StringBuffer,StringBuilder是可变字符序列;

Arrays类使用

描述:说到数组类的使用不得说关于数组相关的排序算法,这可是编程中的灵魂;
该类包含用于操作数组的各种方法(如排序和搜索)。 该类还包含一个静态工厂可以将数组视为列表。

1
2
public class Arrays
extends Object


数组高级之冒泡排序
描述:轻的上浮,沉的下降;两个相邻位置比较如果前面的元素大于后面的元素则交互位置;

WeiyiGeek.冒泡排序规律

WeiyiGeek.冒泡排序规律


数组高级之选择排序
描述:用一个索引位置上的元素,依次与其他索引位置上的元素比较小在前面(右) ,大的在后面(左) - 与冒泡排序位置相反

WeiyiGeek.选择排序

WeiyiGeek.选择排序


数组高级之二分查找法
描述:二分查找前提必须是有序的,二分查找 查找元素对应的索引;

WeiyiGeek.二分查找法

WeiyiGeek.二分查找法

基础示例:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package com.weiyigeek.array;

public class Demo1_ArrayMaopao {
public static void main(String[] args) {
//实例1. 冒泡排序(相邻元素比较)
int[] arr = {45,12,89,75,65,17};
for (int i = 0; i < arr.length - 1; i++) { //外循环只需要比较arr.length-1
for(int j = 0; j < arr.length - 1 - i; j++) { // -1为了防止数组越界产生异常, -i 为了提高效率;
if(arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp; //拿取最大值向左边走
}
}
}
extracted("冒泡算法 :",arr);

//实例2. 选择排序
int[] arr1 = {45,12,89,75,65,17};
for (int i = 0; i < arr1.length - 1; i++) { //循环5次
for(int j = i + 1; j < arr1.length; j++) //从 i + 1 次开始
{
if(arr1[i] > arr1[j])
{
int temp = arr1[i]; //将大值存放在temp
arr1[i] = arr1[j]; //循环遍历过滤出最小的
arr1[j] = temp; //将temp给当前[j]
}
}
}
extracted("\n选择排序:", arr1);

//实例3.二分查找
int res = binarySearch(arr1,45);
if(res != -1) {
System.out.println("\n二分查找:\n已经找到该值 : " + arr1[res]+", Index = "+res);
}else {
System.out.println("未找到您要查询的值!");
}

}

private static int binarySearch(int[] arr1, int i) {
int min = 0;
int max = arr1.length - 1;
int mid = (max - min) / 2;
//判断mid索引在数组值是否等于i
while(arr1[mid] != i) {
if(arr1[mid] < i) { //如果当然mid索引值 小于 查找的值 则 最小值 = mid+1;下次就从mid+1处理开始
min = mid + 1;
}else if(arr1[mid] > i) {
max = mid - 1;
}
if( min > max ) {
return -1;
}
mid = (max - min) /2;
}
return mid;
}
//公共方法(输出数组各个元素值)
public static void extracted(String name,int[] arr) {
System.out.println(name);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}

执行结果:
1
2
3
4
5
6
7
8
冒泡算法 :
12 17 45 65 75 89

选择排序:
12 17 45 65 75 89

二分查找:
已经找到该值 : 45, Index = 2


Arrays 类常用方法

描述:Arrays常用的以下方法可以处理上面我们的问题示例;

  • public static String toString(int[] a); //可以将整形数组转换成为字符串Arrays.toString(int[])
  • public static void sort(int[] a); //(dualquick排序)可以将整形数组进行排序会修改原数组
  • public static int BinarySearch(int[] a,int key); //Array类的二分查找方法,注意如果存在则返回数组元素的索引,不存在则返回-(mid+1)

基础示例:

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
import java.util.Arrays;

public class Demo2_ArrayMethod {

public static void main(String[] args) {
//示例1.Arrays类中的toString
int[] arr1 = {20,19,17,1,5,9,95};
System.out.println("示例1 : " + Arrays.toString(arr1));

//示例2.Arrays类中的sort排序
Arrays.sort(arr1);
System.out.println("示例2 : " + Arrays.toString(arr1)); //重点这里输出是采用Arrays.方法

//示例3.Arrays类中的二分法
System.out.println("示例3 : Index = " + Arrays.binarySearch(arr1, 19));
System.out.println("示例3 : Index = " + Arrays.binarySearch(arr1, 2019)); //由于2019大于arr1数组中所有元素则排在索引为7的地方; -(7+1) 及 -插入点 -1
}

}

//执行结果:
示例1 : [20, 19, 17, 1, 5, 9, 95]
示例2 : [1, 5, 9, 17, 19, 20, 95]
示例3 : Index = 4
示例3 : Index = -8


Arrays工具类的asList()方法的使用
描述: Collection中toArray(T[] a)泛型版的集合转数组,而asList()将数组转成集合;

1
2
3
4
5
6
#加入了泛型
java.util.Arrays
static <T> List<T> asList(T... a) #返回由指定数组支持的一个固定大小的列表。

#java.util
<T> T[] toArray(T[] a) #返回包含此集合中所有元素的数组;返回数组的运行时类型是指定的数组的运行时类型

基础示例:
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
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo2_CollectionAsList {
public static void main(String[] args) {
//Arrays工具类的asList()方法的使用
//实例1.数组转成集合(虽然不能可以增加或者删除元素,但是可以利用集合的思想操作数组),
//也就是说使用其他集合的方法
String[] arr = {"a","b","c","d"};
List<String> list = Arrays.asList(arr);
System.out.println(arr + " " + list);
//list.add("不能添加")


//示例2.整形数组转换成为集合
int[] arr1 = {11,222,333}; //基本数据类型
List<int[]> list1 = Arrays.asList(arr1); //基本数据类型的数组转换成为集合.会将整改数组当做一个对象
System.out.println(list1); //返回的是一个地址
//重点
Integer[] arr2 = {11,22,344}; //引用数据类型(数组转集合)
List<Integer> list2 = Arrays.asList(arr2);
System.out.println(arr2 + " " + list2);


//示例3.泛型集合转数组
ArrayList<String> list3 = new ArrayList<String>();
list3.add("demo");
list3.add("YES");
list3.add("this");

String[] arr3 = list3.toArray(new String[0]); //new String[0]当集合转化成数组时候,数组的长度小于等于集合的size,转换后的数组长度等于集合
//new String[10]如果数组长度大于了size,匹配的数组就和您设置长度一致,不存在的以null补齐
for (String param : arr3) {
System.out.print(param + " ");
}
}
}
//#执行结果
[Ljava.lang.String;@15db9742 [a, b, c, d]
[[[email protected]6d06d69c]
[Ljava.lang.Integer;@7852e922 [11, 22, 344]
demo YES this


基本类型包类

描述:将基本数据类型封装成为对象的好处,可以在对象中定义更多的功能方法操作该数据;
常见的操作就是用于基本数据类型之间的转换(进制转换/字符串之间的转换);

基本数据类型和引用数据类型包装类对应表:

1
2
3
4
5
6
7
8
9
基本数据类型   引用数据类型(包名称)
byte Byte
short Short
int Integer #比较特殊
long Long
float Float
double Double
char Character #比较特殊
boolean Boolean

下面以Integer为例来进行学习,其他的基本数据类型与包装类都差不多;

Integer 类使用

描述:Integer类包装一个对象中的原始类型int的值。 类型为Integer的对象包含一个单一字段其类型为int ;提供了一些将int转换为String和String转换为int,以及在处理int时有用的其他常量和方法

1
2
3
4
5
6
7
8
9
10
public final class Integer
extends Number
implements Comparable<Integer>

//自带常量值
static int BYTES 用于表示二进制补码二进制形式的 int值的字节数。
static int MAX_VALUE 一个持有最大值一个 int可以有2^31 -1。
static int MIN_VALUE 的常量保持的最小值的 int可以具有,-(2 ^31)。
static int SIZE 用于表示二进制补码二进制形式的 int值的位数。
static 类<Integer> TYPE 类原始类型 int的 类实例。


Integer类构造方法:

  • public Integer(int value); 构造一个新分配的 Integer对象,该对象表示指定的 int值。
  • public Integer(String s); 构造一个新分配 Integer对象,表示 int由指示值 String参数。

Integer类常用方法:

  • static String toBinaryString(int i) 在基数2中返回整数参数的字符串表示形式为无符号整数。
  • static String toHexString(int i) 返回整数参数的字符串表示形式,作为16位中的无符号整数。
  • static String toOctalString(int i) 在基数8中返回整数参数的字符串表示形式为无符号整数。

Inter类型与String相互转换:

  • 将int转换成为Str的方法:
    • 1.与””进行拼接
    • 2.public static String valueOf(int i); //String类型静态的valueOf方法
    • 3.public static String toString(); //integer类型静态的toString方法
    • 4.public static String toString(int i); //integer类型的静态方法
  • 将str转换成为int的方法:
    • public int intValue(); //以int类型返回该Interger;String -> Integer -> Int
    • public static int parseInt(String s);
  • 字符串到字符的转换通过toCharArray()既就可以把字符串转换成为字符数组(JDK 8 里面取消了);
  • 注意事项:基本数据类型包装类有八种其中七种都有ParseXXX的方法(除了Character类没有),可以将这七种字符串表现形式转换成为基本数据类型;

基础实例:

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
51
52
53
54
55
package com.weiyigeek.integer;

import java.util.Arrays;

public class Demo2_Integer {

public static void main(String[] args) {
//实例1.Integer类的构造方法以及常量
System.out.println("int 类型 Max : " + Integer.MAX_VALUE);
System.out.println("int 类型 Min : " + Integer.MIN_VALUE);

Integer it1 = new Integer(100);
Integer it2 = new Integer("100"); //数字字符串转换成为整形
Integer it3 = new Integer('a'); //注意:这里可以将单个字符转成码表对应的十进制值(但是字符串是不行的比如"abc")
System.out.println(it1);
System.out.println(it2);
System.out.println(it3);

//实例2.Integer类的一些方法(实现十进制转成其他进制)
int src = 255;
System.out.println(src + " -> Binary : " + Integer.toBinaryString(src)); //二进制
System.out.println(src + " -> Octal : " + Integer.toOctalString(src)); //八进制
System.out.println(src + " -> Hex : " + Integer.toHexString(src)); //十六进制


//实例3.int与String之间的相互转换
//整数转成字符串类型
int num = 1024;

String s1 = num + ""; //method1 (推荐)

String s2 = String.valueOf(num); //method2 (推荐)

Integer num2 = new Integer(num);
String s3 = num2.toString();

String s4 = Integer.toString(1024);
System.out.println("四种int 转成 字符串 的 静态方法 :" + s1 + ", " + s2 + ", " + s3 + ", " + s4);

//字符串转成整数
String s5 = "1024";
Integer num3 = new Integer(s5);
int num4 = num3.intValue();

int num5 = Integer.parseInt(s5); // 推荐方法
System.out.println("字符串转换成为整形:");
System.out.print(num4);
System.out.println(num5);


//实例3.ParseXXX的方法,可以将这七种字符串表现形式转换成为基本数据类型;
Boolean b = Boolean.parseBoolean("true");
System.out.println(b);
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int 类型  Max : 2147483647
int 类型 Min : -2147483648
100
100
97

255 -> Binary : 11111111
255 -> Octal : 377
255 -> Hex : ff

四种int 转成 字符串 的 静态方法 :1024, 1024, 1024, 1024

字符串转换成为整形:
1024 1024

true

补充知识:

  • JDK5新的特性(自动装箱和自动拆箱)
    • 自动装箱: 把基本类型转换成为包装类型;
    • 自动拆箱: 把包装类型转换成为基本类型;
  • 注意事项: 在-128到127是Byte的取值范围,如果在这个取值范围内,自动装箱就不会创建对象而是从常量池中获取;但是需要注意如果超过了该范围便会重新创建该对象;

基础实例演示:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
//实例1.JDK5的新特性(面试题会问)
System.out.println("JDK 新特殊 : 自动装箱与拆箱");
//1.5 之前
int x = 1024;
Integer i1 = new Integer(x); //将基本数据类型 包装成为 对象 -> 装箱
int y = i1.intValue(); //将对象 转换成为 基本数据类型 -> 拆箱

//1.5版本之后
Integer i2 = 1024; // 自动装箱(把基本数据类型转换成为对象) - 其实底层还是上面的操作;
int z = i2 + 200; // 自动拆箱(把对象转换成为基本数据类型)
System.out.println(i2 + ", " + z);

//注意Integer 调用intValue但是如果值为null,null调用方法就会出现异常
// Integer i3 = null;
// int a = i3 + 100;
// System.out.println(a); //调用会导致空指针异常 java.lang.NULLPointerException


//面试题 自动装箱拆箱的特性
int number1 = 1024;
int number2 = 1024;
Integer int1 = new Integer(number1);
Integer int2 = new Integer(number2);
System.out.println(int1 == int2); //对象地址之间的比较
System.out.println(int1.equals(int2)); //对象之间的比较
System.out.println("#-----------------------------------------#");

Integer int3 = new Integer(512);
Integer int4 = new Integer(512);
System.out.println(int3 == int4);
System.out.println(int3.equals(int4));
System.out.println("#-----------------------------------------#");

//特殊点来了(如果取值范围在bytes中 -127 ~ 128,将直接从常量中取)
Integer int5 = 97;
Integer int6 = 97;
System.out.println(int5 == int6);
System.out.println(int5.equals(int6));
System.out.println("#-----------------------------------------#");

Integer int7 = 197;
Integer int8 = 197;
System.out.println(int7 == int8);
System.out.println(int7.equals(int8));
System.out.println("#-----------------------------------------#");


//执行结果:
JDK 新特殊 : 自动装箱与拆箱
1024, 1224

false
true
#-----------------------------------------#

false
true
#-----------------------------------------#
//特殊点(-127 ~ 128)
true
true
#-----------------------------------------#

false
true
#-----------------------------------------#


Math类使用

描述: Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数;里面的方法都是静态不用去new Math使用直接类名.方法名称;

1
2
3
4
5
6
7
#lang包里
java.lang.Object
java.lang.Math

#语法结构
public final class Math
extends Object

常用方法和静态属性:

1
2
3
4
5
6
7
8
9
10
11
12
#属性
public static final double E #double值比任何其他的努尔紧密,自然对数的基础。
public static final double PI # double值比其他任何接近零圆周率,圆周和直径的比值。
#部分方法
* public static int abs(int a) #对a取绝对值
* public static double ceil(double a) #向上取值 天花板
* public static double floor(double a) #向下取值 地板
* public static int round(float a) #参数为double的自学
* public static int max(int a,int b) #min自学取最小值
* public static double pow(double a,double b) #求幂次方
* public static double random() #随机数 0~1
* public static double sqrt(double a) #求平方根

基础案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//示例1.常量值
System.out.println("自然对数 : " + Math.E);
System.out.println("圆周率 : " + Math.PI);

//示例2.常用方法
System.out.println(" -2 的绝对值 : " + Math.abs(-2));
System.out.println(" -2 .0的绝对值 : " + Math.abs(-2.0));

System.out.println("向上取整" + Math.ceil(12.3));
System.out.println("向上取整" + Math.ceil(12.99));

System.out.println("向下取整" + Math.floor(12.3));
System.out.println("向上取整" + Math.floor(12.99));

System.out.println("四舍五入 " + Math.round(12.30));
System.out.println("四舍五入 " + Math.round(12.50));

System.out.println("5 8 最大值 = " + Math.max(5, 8));
System.out.println("5 8 最大值 = " + Math.min(5, 8));

System.out.println("2^16 = " + Math.pow(2,16));

System.out.println("随机数 = " + Math.random());

执行结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
自然对数  : 2.718281828459045
圆周率 : 3.141592653589793

-2 的绝对值 : 2
-2 .0的绝对值 : 2.0

向上取整13.0
向上取整13.0
向下取整12.0
向上取整12.0
四舍五入 12
四舍五入 13

5 8 最大值 = 8
5 8 最大值 = 5

2^16 = 65536.0
随机数 = 0.511862521199665


Random 类使用

描述: 这个类的一个实例是用于生成伪随机数流。该类使用一个48位的种子,这是使用线性同余公式的修正。

此类用于产生随机数如果用相同的随机数种子创建两个 Random 实例,对每个实例进行相同的方法调用序列,它们将生成并返回相同的
数字序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//#包
java.util.Random

//#基础语法结构
public class Random
extends Object
implements Serializable

//#构造方法
public Random() //#创建一个新的随机数发生器。此构造函数将随机数发生器的种子设置为一个非常有可能与此) 纳米值构造函数的任何其他调用不同的值。 内部取值System.nanoTime(

public Random(long seed) //#使用一个单一的 long种子创造了一种新的随机数发生器。种子的伪随机数发生器的方法 next(int)保持内部状态的初始值。 相同的种子生成的随机数是一致的;与调用new Random(seed)是等价的:


protected int next(int bits) //#生成下一个随机数。
int nextInt() //#返回下一个伪随机、均匀分布的 int价值从这个随机数生成器的序列。

int nextInt(int bound) //#返回一个随机、均匀分布的 int值在0(含)和指定值(独家),从这个随机数发生器的顺序绘制。值为0<=n<bound

基础示例:

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
package com.weiyigeek.random;
import java.util.Random;
public class Demo1_Random {
public static void main(String[] args) {
//示例1.Random类的使用
//方式1:伪随机数底层种子默认采用系统当前时间的纳秒
Random ra = new Random();
System.out.println("伪随机 = " + ra.nextInt());
System.out.println("伪随机 = " + ra.nextInt());

//方式2
System.out.println("相同的seed种子数,生成的随机数是一致的:");
Random r = new Random(1024); //调用new Random(seed)与r.setSeed(seed)是等价的:
System.out.println(r.nextInt());
System.out.println(r.nextInt());

//方式3
Random r1 = new Random();
r1.setSeed(1024);
System.out.println(r1.nextInt());
System.out.println(r1.nextInt());

//示例2.生成一个范围内的随机数
Random r2 = new Random();
for (int i = 0; i < 10; i++) {
System.out.print(r.nextInt(100) + " "); //生成十次 0 ~ 99 的随机数(注意这里不是100)
}
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
伪随机 = 1656751839
伪随机 = 112905377

相同的seed种子数,生成的随机数是一致的:
-1549467450
1376243983
-1549467450
1376243983

87 33 98 93 9 43 61 69 68 9


System 类使用

描述: 由System类提供的设施包括标准输入、标准输出和错误输出流;访问外部定义的属性和环境变量;加载文件和库的方法;和一种快速复制数组的一部分的实用方法。

注意事项:由于它私有了它的构造方法所以不能采用new System申请对象的形式(即它不能被实例化);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#基础格式
java.lang.System

public final class System
extends Object

#输入输出流成员属性
public static final PrintStream err #“标准”错误输出流。该流已打开,并准备接受输出数据。
public static final PrintStream in #“标准”输入流。该流已打开并准备提供输入数据。通常此流对应于主机环境或用户指定的键盘输入或另一个输入源。 (从终端键盘输入)
public static final PrintStream out #“标准”输出流。该流已打开并准备接受输出数据。通常此流对应于主机环境或用户指定的显示输出或另一个输出目的地。 (最终生成到控制台)

#成员方法
public static void gc() #运行垃圾收集器;调用gc方法表明,java虚拟机消耗的努力回收未使用的对象为了让记忆他们目前占据可以快速重用 它相当于Runtime.getRuntime().gc()
public static void exit(int status) #终止当前正在运行的java虚拟机。该参数作为状态代码;按惯例,一个非零状态码表示异常终止。 类似C和php中的exit(1)作用
public static long currentTimeMillis() #返回当前时间以毫秒为单位。
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) #从指定的源数组中复制一个数组,开始在指定的位置,到目标数组的指定位置。一个后继数组组件从源到目的地的 src数组引用的数组引用的 dest复制

基础示例:

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
package com.weiyigeek.system;

public class Demo1_System {

public static void main(String[] args) {
//示例1.垃圾回收机制(需要用到Object中的)
//protected void finalize()throws Throwable 当垃圾收集确定没有对对象的引用时,由对象上的垃圾收集器调用。
//子类重写 finalize方法配置系统资源或执行其他清理。
for (int i = 0; i < 5; i++) {
System.out.print(i);
new GcDemo();
System.gc(); //运行垃圾回收机制(当数量达到一定限制的时候)
}

//示例2.当前系统时间(毫秒数) 从 1970年1月1日开始
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
System.out.print(i + " ");
}
long endTime = System.currentTimeMillis();
System.out.println("\n循环花费的毫秒数 = " + (endTime - startTime));

//示例3.直接Arraycopy复制拼接目标数组
int[] arr1 = {18,2017,2019,7,1,9};
int[] arr2 = new int[5+arr1.length];
arr2[1] = 1;
arr2[4] = 4;
System.arraycopy(arr1, 0, arr2, 5, arr1.length);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i] + " ");
}

//示例4
System.exit(0); //正常的退出java
}
}


//注意:一个java文件中只有一个public 公共类
class GcDemo {
public int count = 0;
@Override
public void finalize() throws Throwable {
count++;
System.out.println(" - 垃圾正在被回收!");
//super.finalize();
}
}

执行结果:
1
2
3
4
5
6
7
8
9
10
012 - 垃圾正在被回收!
3 - 垃圾正在被回收!
4 - 垃圾正在被回收!
- 垃圾正在被回收!
0 - 垃圾正在被回收!

1 ~ ~ ~ 99
循环花费的毫秒数 = 2

0 1 0 0 4 18 2017 2019 7 1 9

注意事项:

  • 避免使用 finalize()由于finalize()的行为不可预期,而且没有任何保证提及 finalize()会被及时和最终会执行。
  • System.gc()和 System.runFinalization()仅仅能够增加 finalize()执行的可能性,但还是不能确保肯定会执行。

BigInteger 类使用

描述:可以让超过Integer范围内的数据进行运算;可变的任意精度整数,BigInteger提供类似java的所有原始的整数商,从java.lang.math所有相关的方法。此外BigInteger提供操作的模运算,GCD计算,素性测试,原代、位操作,和其他一些杂项作业。

1
2
3
4
5
6
7
#包
java.math.BigInteger

#语法结构
public class BigInteger
extends Number
implements Comparable<BigInteger>

常用方法描述:

1
2
3
4
5
6
7
8
9
#构造方法
public BigInteger(String val) #翻译BigInteger的十进制字符串表示为BigInteger。

#成员方法
* public BigInteger add(BigInteger val) #//加
* public BigInteger subtract(BigInteger val) # //减
* public BigInteger multiply(BigInteger val) # //乘
* public BigInteger divide(BigInteger val) #//除法
* public BigInteger[] divideAndRemainder(BigInteger val) #//将除法所得 与取模所得 放入数组之中

基础示例:

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 com.weiyigeek.bigInteger;
import java.math.BigInteger;
public class Demo1_BigInteger {
public static void main(String[] args) {
//示例1.将比long大的字符串转换成为可被计算的整形
String val = new String("3141592600000000000");
BigInteger bi = new BigInteger(val);
System.out.println(bi);

//示例2.大整数计算(注意会生成新值不会再远值上改变)
BigInteger bi1 = new BigInteger("256");
BigInteger bi2 = new BigInteger("2");
BigInteger[] bi3 = bi1.divideAndRemainder(bi2);
System.out.println("add = " + bi1.add(bi2)); //加
System.out.println("subtract = " + bi1.subtract(bi2)); //减
System.out.println("multiply = " + bi1.multiply(bi2)); //乘
System.out.println("divide = " + bi1.divide(bi2)); //除
System.out.println("div = " + bi3[0] + ", Remainder = " + bi3[1]);
}
}
//###执行结果######
3141592600000000000
add = 258
subtract = 254
multiply = 512
divide = 128
div = 128, Remainder = 0


BigDecimal 类使用

描述:该类出现为了更加精确的处理小数部分,由于在运算的时候,float类型和double很容易丢失精度,所以为了能精确的表示、计算浮点数,Java提供了BigDecimal不可变的、任意精度的有符号十进制数。

BigDecimal类的算术,尺度操纵,圆、比较、散列提供的操作,和格式转换。的toString()方法提供的一个典型代表,一个BigDecimal。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#包
java.math.BigDecimal

#语法结构
public class BigDecimal
extends Number
implements Comparable<BigDecimal>


#构造方法
public BigDecimal(BigInteger val) //#BigInteger值被转换为 BigDecimal
public BigDecimal(double val) //BigDecimal doubledouble二进制浮点值的小数表示。
public BigDecimal(String val) //将一个字符串表示一个 BigDecimal

#成员方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)

基本案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.weiyigeek.BigDecimal;

import java.math.BigDecimal;

public class Demo1_BigDecimal {
public static void main(String[] args) {
//示例1.BigDecimal 精确计算的几种方法
BigDecimal bd1 = new BigDecimal(2.0); //方式1 传入double类型参数
BigDecimal bd2 = new BigDecimal(1.1);
System.out.println("Demo1 - 开发中不推荐此种方式 2.0 - 1.1 = " + bd1.subtract(bd2));

BigDecimal bd3 = new BigDecimal("2.0"); //方式2 传入字符串的方式
BigDecimal bd4 = new BigDecimal("1.1");
System.out.println("Demo2 - 通过构造中传入字符串的方式 开发时候推荐 2.0 - 1.1 = " +bd3.subtract(bd4));

BigDecimal bd5 = BigDecimal.valueOf(2.0); //方式3
BigDecimal bd6 = BigDecimal.valueOf(1.1);
System.out.println("Demo3 - 在开发中也是推荐的 2.0 - 1.1 = " + bd5.subtract(bd6));
System.out.println(bd5.add(bd6));
System.out.println(bd5.multiply(bd6));
System.out.println(bd5.divide(bd6,1)); //注意除法 有其他参数
}
}

执行结果:
1
2
3
4
5
6
7
8
9
Demo1 - 开发中不推荐此种方式  2.0 - 1.1 = 0.899999999999999911182158029987476766109466552734375

Demo2 - 通过构造中传入字符串的方式 开发时候推荐 2.0 - 1.1 = 0.9

Demo3 - 在开发中也是推荐的 2.0 - 1.1 = 0.9

3.1
2.20
1.8


Date 类方法

描述:类 Date 表示特定的瞬间,精确到毫秒。里面大多方法都失效了我只关注没有没替代的;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#包
java.util.Date

#语法结构
public class Date
extends Object
implements Serializable, Cloneable, Comparable<Date>

#构造方法
public Date() #分配一个 Date对象并将它初始化,它代表的时间分配给它,测量精确到毫秒。 == System.currentTimeMillis()
public Date(long date) #分配一个 Date对象并将它初始化为代表指定的毫秒数自基准时间被称为“时代”,即1970年1月1日,00:00:00 GMT

#成员方法
public long getTime() #返回毫秒数自1970年1月1日以来,该 Date对象表示00:00:00 GMT。 == System.currentTimeMillis()

public void setTime(long time) #集代表一个时间点是1970年1月1日00:00:00 GMT time毫秒后这 Date对象

实际案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.weiyigeek.Date;
import java.util.Date;
public class Demo_Date {
public static void main(String[] args) {
//示例1.
Date d1 = new Date(); //没有传入参数代表的是当前时间
System.out.println("当前时间 = " + d1);
Date d2 = new Date(0); //代表的是1970年1月1日,通过毫秒值创建时间对象
System.out.println("格林GMT起始时间 = " + d2); //需要注意时区的影响

//示例2.
Date d3 = new Date();
System.out.println("通过时间对象获取当前毫秒值 :" + d3.getTime());
System.out.println("通过类方法获取当前毫秒值 :" + System.currentTimeMillis());

//示例3.设置毫秒值改变时间对象 从1970年一月一日开始 (与示例 d2 有一定的关联)
Date d4 = new Date();
d4.setTime(1000);
System.out.println("与示例 d2 有一定的关联" + d4);
}
}

执行结果:
1
2
3
4
5
当前时间 = Sun Aug 25 21:51:27 CST 2019
格林GMT起始时间 = Thu Jan 01 08:00:00 CST 1970
通过时间对象获取当前毫秒值 :1566741087306
通过类方法获取当前毫秒值 :1566741087306
与示例 d2 有一定的关联 : Thu Jan 01 08:00:01 CST 1970

注意事项:

  • 导包的时候注意是在 java.util.Date 包下
  • 在new Date(0) 获取的是1970年1月1日,但是获取的小时数与您所在的时区有关;


DateFormat 类使用

描述:DateFormat类是抽象类(无法直接new创建对象实例化),所以使用其子类SimpleDateFormat; DateFormat 是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。

日期时间格式的子类SimpleDateFormat,允许的格式(例如,日期→文本),分析(文本→日期),和归一化。

1
2
3
4
5
6
7
8
9
10
11
12
#包
java.text.DateFormat

#语法结构
public abstract class DateFormat #DateFormat是一个抽象类的子类格式的日期/时间格式化和解析日期或独立于语言的方式时间
extends Format

#构造与方法
protected Format() //唯一的构造函数。(用于调用子类构造函数,通常是隐式的。
public static final DateFormat getDateInstance() //#获取与默认格式样式为默认 FORMAT本地化的日期格式。
public static final DateFormat getDateInstance(int style) //#获取与给定的格式设置样式为默认 FORMAT本地化的日期格式。
//相当于调用getDateInstance(style, Locale.getDefault(Locale.Category.FORMAT))。

DateFormat子类:

1
2
3
4
5
6
7
8
9
10
11
12
13
#包
java.text.SimpleDateFormat
#语法结构
public class SimpleDateFormat
extends DateFormat

//#SimpleDateFormat构造方法
public SimpleDateFormat()
public SimpleDateFormat(String)

//#子类方法
public final String format(Date date); //格式化日期转换成为字符串显示
public Date parse(String source); //字符串日期解析为日期对象

下面的例子显示的日期和时间模式
1
2
3
4
5
6
7
8
9
10
11
12
Date and Time Pattern  Result  
"yyyy.MM.dd G 'at' HH:mm:ss z" 2001.07.04 AD at 12:08:56 PDT
"EEE, MMM d, ''yy" Wed, Jul 4, '01
"h:mm a" 12:08 PM
"hh 'o''clock' a, zzzz" 12 o'clock PM, Pacific Daylight Time
"K:mm a, z" 0:08 PM, PDT
"yyyyy.MMMMM.dd GGG hh:mm aaa" 02001.July.04 AD 12:08 PM
"EEE, d MMM yyyy HH:mm:ss Z" Wed, 4 Jul 2001 12:08:56 -0700
"yyMMddHHmmssZ" 010704120856-0700
"yyyy-MM-dd'T'HH:mm:ss.SSSZ" 2001-07-04T12:08:56.235-0700
"yyyy-MM-dd'T'HH:mm:ss.SSSXXX" 2001-07-04T12:08:56.235-07:00
"YYYY-'W'ww-u" 2001-W27-3

WeiyiGeek.

WeiyiGeek.

实际案例:

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
//SimpleDateFormat类实现日期和字符串的相互转换
package com.weiyigeek.DateFormat;

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

public class Demo1_DateFormat {

public static void main(String[] args) throws ParseException {
//示例1
//DateFormat df = new DateFormat(); //注意 : DateFormat是抽象类不允许实例化
//态工厂方法之一:
DateFormat df1 = DateFormat.getDateInstance();//默认格式YYYY/MM/dd 相当于父类引用指向子类对象,右边的方法返回一个子类
System.out.println("示例1 " + df1.format(new Date()));
DateFormat df2 = new SimpleDateFormat(); //效果同上


//示例2
Date d = new Date(); //时间对象
SimpleDateFormat sdf = new SimpleDateFormat(); //创建日期格式化对象
System.out.println("当前时间默认格式化: " + sdf.format(d)); //将日期转换字符串
//自定义输出格式
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss");
System.out.println("当前时间自定义格式化: " + sdf1.format(d));


//示例3
String str = "2019 年 08 月 25 日 22:09:25"; //将时间字符串转换成日期对象
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss");
Date d1 = sdf2.parse(str);
System.out.println("转换结果 : " + d1);


//示例4:生日当前时间生活了多少天
String birthDay = "1995年01月10日";
String currentDay = "2019年08月25日";
//定义日期格式化对象
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年mm月dd日");
//将日期字符串转换成为日期对象
Date bir = sdf3.parse(birthDay);
Date cur = sdf3.parse(currentDay);
//通过日期对象获取时间毫秒值
long res = cur.getTime() - bir.getTime();
//之间差毫秒值除以1天的毫秒值 1000 / 3600 / 24
System.out.println("我已经生活了 " + (res / 1000 / 3600 / 24) + " 天");
}
}

执行结果:
1
2
3
4
当前时间默认格式化:  19-8-25 下午10:35
当前时间自定义格式化: 2019 年 08 月 25 日 22:35:18
转换结果 : Sun Aug 25 22:09:25 CST 2019
我已经生活了 8781 天


Calendar 类使用

描述Calendar类的概述是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。

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
//包
java.util.Calendar

//类
public abstract class Calendar
extends Object
implements Serializable, Cloneable, Comparable<Calendar>

//成员方法
public static Calendar getInstance() //CalendargetInstance方法返回的对象Calendar日历领域已与当前的日期和时间初始化
public int get(int field) //获取一个静态变量的值
public final void set(int year,int month,int day) //修改年月日

//#######常用的field#####
调用方法:Calendar.AM
static int AM //指示在中午之前从午夜的日期 AM_PM字段值。
static int DATE //场数 get和 set显示该月的一天。
static int YEAR //对于 get和 set指示年场数。
static int MONTH //对于 get和 set指示的月数。
static int DAY_OF_MONTH //对于 get和 set显示该月的一天场数。
static int DAY_OF_WEEK //对于 get和 set显示星期日期字段数。
static int DAY_OF_WEEK_IN_MONTH //对于 get和 set指示当前月的星期序号字段数目。
static int HOUR //#对于 get和 set表示上午或下午场的小时数。
static int HOUR_OF_DAY //对于 get和 set指示小时的一天场数。
static int MINUTE //对于 get和 set指示在小时分钟的场数。
static int MILLISECOND //对于 get和 set指示在第二毫秒字段数目。

public void add(int field,int amount) //年月日时分秒 向前减向后加amout


基础实例:

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
51
52
53
54
55
56
57
58
59
60
61
62
63
//Calendar类的概述和获取日期的方法
package com.weiyigeek.calendar;
import java.util.Calendar;
import java.util.Scanner;
public class Demo_Calendar {

public static void main(String[] args) {
// 实例1.Calendar使用
Calendar c = Calendar.getInstance();
System.out.println("当前详细时间 : " + c);
//获取指定的年月日周
System.out.println(c.get(Calendar.YEAR)); //字段静态成员年
System.out.println(c.get(Calendar.MONTH)+1); //字段获取月主要是从年开始 (注意是从0开始的)
System.out.println(c.get(Calendar.DAY_OF_MONTH)); //月中的的第几天
System.out.println(c.get(Calendar.DAY_OF_WEEK)); //周中第几天 周日是第一天,周六是最后一天

//实例2.获取当前星期几
System.out.println(getWeek(c.get(Calendar.DAY_OF_WEEK)));

//实例3.个数前进行补0
System.out.println("当前月中的天数 : " + getDay(c.get(Calendar.DAY_OF_MONTH)));

//实例4.常用方法
Calendar c1 = Calendar.getInstance(); //父类引用指向子类对象
c1.add(Calendar.YEAR, -1); //当前年份-1; 我们可以对字段进行向前减或者向后加 2018
c1.set(Calendar.DAY_OF_MONTH,29); // 设置当前月中的天数为29号
System.out.println(c1.get(Calendar.YEAR) + "年" + (c1.get(Calendar.MONTH)+1) +"月" +c1.get(Calendar.DAY_OF_MONTH)+"日");

//实例5.平年闰年判断
System.out.print("请输入一个年份判断是闰年还是平年: ");
Scanner sc = new Scanner(System.in);
String year = sc.nextLine();
int y = Integer.parseInt(year); //将数字字符串转换成为数字
Calendar c2 = Calendar.getInstance();
c2.set(y, 2, 1); //设置年3月1日
c2.add(Calendar.DAY_OF_MONTH, -1);
String flag = (c2.get(Calendar.DAY_OF_MONTH) == 29) ? "润年":"平年";
System.out.println(year+"年是"+flag);
}

private static String getWeek(int i) {
String[] week = {"","星期天","星期一","星期二","星期三","星期四","星期五","星期六"}; //注意这里week[0] 为空
return week[i];
}

private static String getDay(int i) {
return i > 9 ? "" + i:"0" + i; //非两位数补0
}
}


//#######执行结果############
当前详细时间 : java.util.GregorianCalendar[time=1566785857554,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=7,WEEK_OF_YEAR=35,WEEK_OF_MONTH=5,DAY_OF_MONTH=26,DAY_OF_YEAR=238,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=10,HOUR_OF_DAY=10,MINUTE=17,SECOND=37,MILLISECOND=554,ZONE_OFFSET=28800000,DST_OFFSET=0]

2019 8 26 2
星期一

当前月中的天数 : 26
2018829

请输入一个年份判断是闰年还是平年: 2088
2088年是润年
`