学习Java的第二周

前言

本篇文章仅记录自己学习Java的内容。作为小白知识浅薄等原因可能有错误的内容，待后续学习再更正。

Object类

java.lang.Object Java默认将Java.lang包下的所有类都导入程序中，不需要手动导包。
任何类都直接或者间接的继承object类，所以所有类都可以调用Object类的非私有的属性和方法

1.Object类的构造方法

public void Object(){}

2.Object类的常用方法

1>protected Object clone() 创建并返回此对象的副本。
2>boolean equals(Object obj) 比较2个对象是否相等
public boolean equals(Object obj) { return (this == obj);} 观察父类的equals方法还是比较的地址，所以子类觉得不合理的情况可以进行重写制定比较规则
重写了equals方法，必须重写hashCode方法
== 如果是基本数据类型，则比较值是否相等 如果是引用数据类型，则比较地址是否相等
3>int hashCode() 返回对象的哈希码值。
hashcode就是通过hash函数f(x)计算出来的一个值， hashCode就是在hash表中对应的位置.若两个对象调用equals相等，但是他们hashCode值不相等，则也不是同一个对象
4>Class getClass() 返回此 Object 的运行时类。

Scanner sc=new Scanner(System.in);
System.out.println(sc.getClass());//class java.util.Scanner 返回这个类所在的包名和类名

5>String toString() 返回对象的字符串表示形式。

public String toString() {
 		return getClass().getName() + "@" + Integer.toHexString(hashCode());
  }
//使用一个字符串来表示这个对象 格式： 包名.类名@哈希码值16进制数 
//当输出一个对象的时候，默认调用toString()方法，输出的是地址，子类可以改写方法输出值

String类

1.String类的概述

java.lang.String
public final class String extends Object implements Serializable, Comparable, CharSequence{}
String类代表字符串，例如"ABC"都是此类的对象
String对象代表一组不可改变的Unicode字符序列
java有三种常量池：字符串常量池(全局字符串池)，class文件常量池，运行时常量池

2.String类的构造方法

String() 初始化新创建的 String对象，使其表示空字符序列。
String(byte[] bytes) 通过字节数组来创建字符串
String(byte[] bytes, String charsetName) 指定字符编码集
String(char[] value) 通过字符数组来创建字符串
String(String original) 通过一个字符串来创建一个新的字符串

3.Sring类的常用方法

1.char charAt(int index) 返回 char指定索引处的值

String s="abcd";
char c=s.charAt(0);
System.out.println(s);//a 索引从0开始

2.int compareTo(String anotherString) 按字典顺序比较两个字符串。

int a="a".compareTo("b");
System.out.println(a);//-1
int a1="a".compareTo("d");
System.out.println(a1);//-3
//0代表相等  <0代表比字符串参数小  >0代表比字符串参数大

3.int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写。

int a = "a".compareToIgnoreCase("A");
        System.out.println(a);

4.String concat(String str) 将指定的字符串连接到该字符串的末尾。
static String join(CharSequence delimiter, CharSequence… elements) 使用指定分隔符对将多个字符序拼接并返回一个新的字符串

  String s="hello";
  String s1=s.concat("world!");
  System.out.println(s);//hello 
  System.out.println(s1);//hello world!
  String s2=String.join("*","1","2","3","4");
  System.out.println(s2);//1*2*3*4

5.boolean contains(CharSequence s) 字符串是否包含另一个字符串

String s="poiduiayuhdjk";
boolean b=s.contains("yu");//字符串是否包含 “yu”子字符串
System.out.println(b);//true

6.boolean endsWith(String suffix) 字符串是否以指定的字符串开头或者结尾
boolean startWith(String prefix)

 String s="C:/aaa/a.java";
boolean b=s.startsWith("C:");//判断是否以给定字符串开头
System.out.println(b)//true
boolean b1=s.endsWith(".java");//判断是否以给定字符串结尾
System.out.println(b1)//true

7.boolean equals(Object anObject) 将此字符串与指定对象进行比较
boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略大小写

String s1="aAaAa";
String s2="AaAAA";
booolean b1=s1.equals(s2);
System.out.println(b1);//false
boolean b2=s1.equalsIgnoreCase(s2);
System.out.println(b2);//true

8.byte[] getBytes() 将此字符串转换为新的字节数组。
char[] toCharArray() 将此字符串转换为新的字符数组。

String s="hehe";
char []c=s.toCharArray();
System.out.println(Arrays.toString(c));//[h,e,h,e]
byte[]b=s.getByte();
System.out.println(Arrays.toString(b));//[104,101,104,101]

9.int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引 ,从前往后搜索。
int indexOf(String str, int fromIndex) 返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。
int lastIndexOf(String str, int fromIndex) 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。

String s="Masaaki kishibe"; 
int index= s.indexOf("ki"); //不存在则返回-1 
System.out.println("从前往后搜索，ki在s中第1次出现的索引值:"+ index); // 5 
int index2=s.lastIndexOf("ki");//不存在则返回-1 
System.out.println("从后往前搜索，ki在s6中第1次出现的索引位置:"+index2); // 8
// 从指定的位置开始从后搜索 ki第一次出现的位置 
int index3= s.indexOf("i",7); 
System.out.println("index3="+index3);//12

10.boolean isEmpty() 判断是否为空字符串

String s=""; 
//String s=new String();length()为 0,则返回true 
//错误的，null不能调用属性和方法 
String s=null; // "" 和 null不是一个意思 
boolean b=s.isEmpty(); 
System.out.println(b); // true

11.int length() 返回此字符串的长度。

//字符串中有多少个字符? 
String s="abc"; 
int l=s.length(); 
System.out.println(l); // 返回的是字符的个数 3

12.String replace(char oldChar, char newChar) 替换一个字符
String replace(CharSequence target, CharSequence replacement) 替换一个字符串
//以下两个方法，支持正则表达式regex
String replaceAll(String regex, String replacement) 替换所有的满足条件的字符串
String replaceFirst(String regex, String replacement) 替换满足条件的第1个字符串

String str="this1 is2 my3 homework4! I5 must6 finish7 it8!"; 
String s1=str.replace('i', '*');
System.out.println(s1);//th*s1 *s2 my3 homework4! I5 must6 f*n*sh7 *t8! 
String s2=str.replace("is", "$"); 
System.out.println(s2); // th$1 $2 my3 homework4! I5 must6 fin$h7 it8! 
//需求：把所有的数字替换成“编号” 
String s3=str.replaceAll("[0-9]", "编号"); 
System.out.println(s3); //this编号 is编号 my编号 homework编号! I编号 must编号 finish编号 it编号! 
String s4=str.replaceFirst("[0-9]", "编号"); 
System.out.println(s4); //this编号 is2 my3 homework4! I5 must6 finish7 it8!

13.String[] split(String regex)将此字符串分割为给定的 regular expression的匹配

//使用String类中的split()函数， 统计出"this is my homework! I must finish it!"中单词的个数。 
//思路： 按照空格拆分
String s="this is my homework! I must finish it!"; 
String[] str=s.split(" "); 
System.out.println(Arrays.toString(str)); //[this,is,my,homework!,I,must,finish,it!]
System.out.println("单词的个数为:"+ str.length);//8

14.String substring(int beginIndex) 获取部分字符串

String s="abcdef";
String s1=s.subString(3);
System.out.println(s1);//def   [3,末尾]
String s2=s.subString(1,4);
System.out.println(s2);//bcd [1,4)

15.String toLowerCase() 转小写
String toUpperCase() 转大写

String s="ABCdef"; 
String s1=s.toLowerCase(); 
System.out.println(s1);// abcdef
String s2=s.toUpperCase(); 
System.out.println(s2);//ABCDEF

16.String trim() 去掉字符串的前后空格，中间的空格不能删除

String s=" www  hhh  yy "; 
System.out.println(s); // www  hhh  yy 
String s1=s.trim();
System.out.println(s1);//www  hhh  yy

4.String对象的不可变

从底层可以看到String被final修饰，并且char[]被final和private修饰，代表String对象不可被更改，这个特性就是String对象的不可变性，即String对象一旦创建成功，就不能对它进行改变。

String s="hello";
System.out.println(s);//hello
s="world";
System.out.println(s);//world

s的值确实改变了，为什么说String对象不可变？
区分：对象“hello” 和对象的引用 String s
s只是String对象的引用，并不是对象的本身。
对象在内存中有一块内存地址，s则是一个指向这个内存地址的引用，所以第一次赋值的时候创建了一个“hello”对象，s引用指向“hello”地址。第二次赋值的时候又重新创建了一个“world”对象，s引用指向了“world”地址，但是“hello”对象依然存在在内存中，s是一个对象的引用，而不是一个对象，真正的对象依然还在内存中没有改变。

5.String不同版本的属性

Java1.6版本
String 中属性 : char[] 偏移量 offset 字符数量 count 哈希值 hash
String 对象通过offset和count两个属性来定位char[]数组，获取字符串 这么做可以高效、快速地共享数组对象，同时节省内存空间，但是这种方式 有可能导致内存泄漏。
Java7/Java8版本
String 中属性: private final char value[];
private int hash;
Java9以后
String 中属性： private final byte[] value;
把char[] 字段修改成 byte[]字段
private final byte coder; 又增加了一个新的属性，它是一个编码格式标 识
private int hash;
为什么工程师需要这样修改？
【原因】一个char字符占16位，2个字节 在这个情况下，存储单字节的编码内的字符(存字母，占一个字节的字符) 就显得非常浪费。于是在JDK1.9版本的String类为了节约内存空间， 于是使用占8位，一个字节的byte数组来存放字符串。 而新的属性coder的作用是，在计算字符串长度或者使用indexOf函数的 时候，我们需要根据这个字段判断如何计算字符串的长度 查看源码发现coder属性有2个值， 1 和 0 0 代表 Latin-1 （单字节编码） 1 代表 UTF-16

StringBuffer StringBuilder类

字符串缓冲区

1.构造方法

StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。

 //初始容量为16个字符
 StringBuffer buffer1 = new StringBuffer();
 //底层数组大小 16+3
 StringBuffer buffer2 = new StringBuffer("abc");
 //指定初始容量为30个字符
 StringBuffer buffer3=new StringBuffer(30);

2.常用方法

1.StringBuffer append(String str) 添加各种类型的数据到字符串末尾

StringBuffer sb1=new StringBuffer();
sb1.append(1);
sb1.append('中');//字符
sb1.append("中午吃什么");//字符串
char[] arr= {'a','b','c'};
buffer.append(arr); //字符数组
sb1.append(3.33);//float
sb1.append(false);//boolean
//将所有的字符串进行了拼接，没有重新创建对象
System.out.println(sb1);

2.StringBuffer insert(int offset, String str) 在指定的位置，插入各种类型的数据
// insert方法也重载，也有很多不同类型的参数值

StringBuffer buffer2=new StringBuffer("123"); 
buffer2.insert(2, 'why'); 
System.out.println(buffer2);//12why3
Student s = new Student("why",29,"男");
sb1.insert(1,s);//将对象以字符串的形式添加到字符串缓存区中
System.out.println(sb1);//1Student{name='why', age=29, sex='男'}2why3

3.StringBuffer delete(int start, int end) 删除此序列的子字符串中的字符。
StringBuffer deleteCharAt(int index) 删除 char在这个序列中的指定位置。

StringBuffer sb=new StringBuffer("abcdefg");
sb.delete(1, 4);// [1,4) 半闭半开区间 
System.out.println(sb); // aefg 
sb.deleteCharAt(0); 
System.out.println(sb);// efg

4.StringBuffer replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的String
void setCharAt(int index, char ch) 指定索引处的字符设置为 ch

StringBuffer sb=new StringBuffer("abcdefg");
sb.replace(1, 3, "$$$$$$"); //[1,3)半闭半开区间 
System.out.println(sb);// a$$$$$$defg 
//设置指定位置的字符
sb.setCharAt(0, 'A'); //记住：(int index, char ch) 
System.out.println(sb);// A$$$$$$defg

5.StringBuffer reverse()将字符串倒序输出

StringBuffer sb=new StringBuffer("abcd"); 
sb.reverse(); 
System.out.println(sb);//dcba

6.substring，求子字符串的方法
注意：append，delete，insert。replace，reverse 方法都是返回当前对象自己 所以StringBuffer是一个可变的字符序列
String substring(int start) 会返回一个新的字符串 ，其中包含此字符序列中当前包含的字符的子序列。
String substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。

StringBuffer sb=new StringBuffer("abcdef"); 
String newSb=buffer.substring(1, 3);//生成一个新的字符串 
System.out.println(sb);//abcdef 原来buffer没有改变 
System.out.println(newSb);//bc [1,3)半闭半开区间

3.String 和 StringBuffer ，StringBuilder的区别

1 运算速度（运算性能，执行效率） StringBuilder > StringBuffer > String
解释： String 是一个不可变的字符序列
StringBuffer ， StringBuilder 是一个可变的字符序列
String 对象一旦创建便不可更改，而StringBuffer，StringBuilder 是可更改的
2 线程安全 (多线程)
StringBuilder （非线程安全）
StringBuffer （线程安全）
String 适用于少量的字符串操作
StringBuilder 适用于单线程的 大量字符串操作
StringBuffer 适用于多线程的 大量字符串操作

基本数据的封装类

1. 在java中8个基本数据类型都有与之对应的封装类 因为基本数据类型不能调用方法和属性 通过它的封装类可以访问属性和方法。
   byte Byte
   short Short
   int Integer
   long Long
   float Float
   double Double
   boolean Boolean
   char Character

1.String 和基本数据类型之间的转换

//parseXXX(String s);其中XXX表示基本类型，参数为可以转成基本类型的字符串，
//如果字符串无法转成基本类型，将会发生数字转换的问题 NumberFormatException
System.out.println(Integer.parseInt("123") + 2);//打印结果为 125
System.out.println("123"+2);//打印结果为 1232
String s="3.14";
double  num=Double.parseDouble(s);

2.基本数据类型转换成字符串

1> 直接与"“连接 34+”" 就会变成字符串
2> 调用String类中有重载 valueOf方法
static String valueOf(boolean b) 返回 boolean参数的字符串 boolean形式。
static String valueOf(char c) 返回 char参数的字符串 char形式。
static String valueOf(char[] data) 返回 char数组参数的字符串 char形式。
static String valueOf(char[] data, int offset, int count) 返回char数组参数的特 定子阵列的字符串
static String valueOf(double d) 返回 double参数的字符串 double形式。
static String valueOf(float f) 返回 float参数的字符串 float形式。
static String valueOf(int i) 返回 int参数的字符串 int形式。
static String valueOf(long l) 返回 long参数的字符串 long形式。
static String valueOf(Object obj) 返回 Object参数的字符串 Object形式。
3> 调用对应包装类方法，static String toString(xxx 变量名)
Integer 类 static String toString(int i)
Byte 类 static String toString(byte b)
Short 类 static String toString(short s)
Long 类 static String toString(long l)
Float 类 static String toString(float f)
Double 类 static String toString(double d)
Character 类 static String toString(char c)
Boolean 类 static String toString(boolean b)

3.int 和 Integer转换

1>int ---- > Integer
方式1： 通过Integer构造方法可以将int转换成
Integer Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。
Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数。
示例： Integer x=new Integer(10);
Integer y =new Integer(“10”);
方式2： 调用Integer类静态方法 valueOf方法
static Integer valueOf(int i) 返回一个 Integer指定的 int值的 Integer实例。
static Integer valueOf(String s) 返回一个 Integer对象，保存指定的值为 String 。
static Integer valueOf(String s, int radix) 返回一个 Integer对象，保存从指定的String 中 String的值，当用第二个参数给出的基数进行解析时。
示例： Integer m =Integer.valueOf(4); Integer n=Integer.valueOf(“4”);
2> Integer ----> int
int intValue() 将Integer转换成int

4.Integer类

① 常量
static int BYTES 用于表示二进制补码二进制形式的 int值的字节数。
static int MAX_VALUE 最大值
static int MIN_VALUE 最小值
static int SIZE 用于表示二进制补码二进制形式的 int值的位数。
static 类 TYPE 类原始类型 int的 类实例。
② 构造方法
Integer x=new Integer(7);
Integer y=new Integer(“7”);//只能写能够转换int类型的字符串

5.自动装箱和自动拆箱

自动装箱： int ------------valueOf(int n)--------> Integer
自动拆箱: Integer ------intValue()---------> int

6. == 和equals的区别

Math类

1.概述

Math类是包含了用于执行基本数学运算的方法的数学工具类,比如:指数,对数,平方根,三角函数等
类似这样的工具类,所有的方法都是静态方法,所以我们一般不会创建对象,使用类名直接调用。

2.常量和方法

3.考点

rint 接近 返回最接近参数的整数，若 出现xxx.5则取偶数， 返回值类型是 double （记住整数后 面要加.0）
floor 地板 返回<=参数的最大整数， 返回值类型是 double
ceil 天花板 返回>=参数的最小整数， 返回值类型是 double
round 四舍五入 返回值类型 参数是double类型则返回 long 或者 参数是float类型则返回 int，如果是在中间就去大值例如-9.5就是-9,9.5就是10.

System类

1.概述

System代表系统，发现构造函数私有化，我们也不能创建System对象
System类中的方法和变量也是static修饰的，使用类名进行直接访问使用类名进行直接访问

2.方法

3.获取系统变量

System.getProperty(“属性名”);
os.version 操作系统的版本
user.name 用户名
os.arch操作系统的架构
user.home用户的主目录
user.dir当前工作目录

File类

1.概述

回顾之前我们写过的程序，数据是存储在内存中，一旦程序停止，这这些数据就没有啦。 等下一次再想使用的这些数据的时候，只能重新运行？
问题： 能不能把运算完的数据保存下来，下次程序启动的时候，再把这些数据读出来继续使用？
要把数据持久化存储，就需要把内存中的数据存储到另外的位置(磁盘，网络中)
内存 -----> 磁盘 称为 输出操作 Output (写)
磁盘 -----> 内存 称为 输入操作 Input (读)
因此把 读写操作(IO操作)
File 既可以表示文件，也可以表示为目录

2.构造方法

File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname) 《*最常用的》 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri) 通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

3.常用方法

1> 获取信息的方法
long length() 1.文件就返回内容的字节个数 2目录 返回0
String getPath() 返回相对路径 例如： src\hehe.txt
String getAbsolutePath() 返回绝对路径，带盘符的路径 例如： D:\code\hehe.txt
String getName() 获取文件或者目录的名称
String getParent() 获取文件或者目录的父目录
File getParentFile() √ 返回值类型不一样
long lastModified() 返回文件最后修改时间的 毫秒数
2> 判断
boolean canExecute() 是否可以执行
boolean canRead() 是否可读
boolean canWrite() 是否可写(向文件中写内容)
boolean exists() 是否存在
boolean isAbsolute() 是否是绝对路径
boolean isDirectory() 是否是一个目录
boolean isFile() 是否是一个文件
boolean isHidden() 是否是一个隐藏文件
3> 创建、删除
boolean createNewFile() 注意:1, 只能创建文件 2,文件所在的父路径必须存在，如果不存在则报错创建不成功
boolean delete() 删除文件和目录 注意:1 可以直接删除一个文件 2,删除一个目录，必须这个目录是一个空目录(里面没有存储任何东西) 若需要删除一个有内容的目录，则必须递归删除
boolean mkdir() 只能创建1级目录
boolean mkdirs() 可以创建多级目录
4> 重命名
boolean renameTo(File dest) 重命名由此抽象路径名表示的文件。
作用1> 可以修改文件或者目录名称 作用2> 可以将文件移动到指定的位置
5> 遍历目录
String[] list() 如果仅仅只是输出这个目录下文件和目录的路径就用这个方法
File[] listFiles() 如果还需要对子目录或者文件进行操作，例如获取修改时间，长度等等
6> 文件过滤
listFiles() 可以遍历一个目录下子文件和子目录，但是我们能不能进行筛选
满足条件的输出，不满足条件的不输出
File[] listFiles(FileFilter filter)
File[] listFiles(FilenameFilter filter)

命令行参数

1.概述

命令行参数就是给main函数的参数赋值

2.使用方法

BigInteger类(超过long范围)

1.概述

在java中超过了 long 的取值范围的数值，我们不能称它为整数啦。它会被封装成一个对象 BigInteger对象
则不能使用 + - * /等算术运算符，只能使用BigInteger提供的方法进行运算

BigDecimal类(做金融项目)

1.概述

double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算

Properties类

1.概述

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串String。
特点：
Properties类继承Hashtable实现了Map接口
1、Hashtable的子类，Map<K,V>集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
属性名的数据类型 String 属性值的数据类型 String
注释 属性名1=属性值 属性名2=属性值
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。

2.方法

void load(InputStream) 把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中
void load(Reader)
void store(OutputStream,commonts)把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息
void stroe(Writer,comments);

3. 把Properties对象中数据 --> 存到磁盘文件 xxxx.properties文件中

//步骤1：创建一个空的属性列表 
Properties pros=new Properties(); 
//存值 
pros.put("张三", "123");
pros.put("zhangsan", "666"); 
pros.put("lisi", "258258"); 
pros.setProperty("wangwu", "258258"); 
//属性名不能相同，相同的话，后面会覆盖前面的,属性值可以相同，没有要求 
pros.list(System.out); 
//步骤2：创建一个文件(不建议写中文) //写中文也会变成unicode编码 
File file=new File("d:/user.properties"); 
//步骤3：调用store方法 
//参数1： OutputStream抽象类 //若文件不存在，可以自动创建 
OutputStream os=new FileOutputStream(file);//每次会覆盖掉前面 
//OutputStream os=new FileOutputStream(file,true);//true代表追加 
//参数2：注释
pros.store(os, "user list");

4.把磁盘文件xxxx.properties中内容—> Properties对象中

//将磁盘上的demo.properties文件的内容，存入Properties对象中 
File file=new File("d:/demo.properties");
//创建一个没有默认值的空属性列表。 
Properties pros=new Properties();//空的属性列表 
pros.list(System.out); //空的 
InputStream is=new FileInputStream(file); //输入流，读数据 
pros.load(is); //这个方法作用就是将文件的内容存入对象中 
pros.list(System.out); //查看是否有值

递归

1.递归思想

以此类推 是递归的基本思想 具体点：就是把规模大的问题转换成规模小的相似的子问题来解决， 在函数实现时，因为解决大问题的方法和解决小问题的方法 往往是同一个方法，所以就产生了函数调用它自身的情况。 另外这个解决问题的函数必须有明显的结束条件，这样就不 会无限递归(死递归)的情况。

2.递归的2个条件

1.可以通过递归调用来缩小问题的规模，且新的问题与原来的问题有相同的形式
2. 存在一种特殊的情况，递归退出的情况，也就是递归的出口

3.递归3要素

在使用递归做题目的时候一定要有这三个要素：
1 要有结束条件
2 要有分支 （前进段，返回段）
3 方法自己调用自己

4.递归算法一般形式

public 返回值类型 fun(参数){ 
	if(递归出口条件){ 
		return 结果; //再回归 
	}else{
		fun(); //调用本身 (先递推) 
	} 
}

Date类

1.概述

Date类表示特定的瞬间时间，精确到毫秒
System类的静态方法，我们可以获取当前系统时间毫秒数
long t=System.currentTimeMillis();
Date类有很多构造方法，但是大多数都过时
Date() 获取当前系统时间 Date(long date) // long类型的时间 -----》 Date类型
//文件
File file = new File(“D:/code/a.txt”);
//文件的最后修改时间
long mod = file.lastModified();
System.out.println(mod);
//使用Date(long t)
Date date=new Date(mod);
System.out.println(date);

2.long <—> Date 转换

//将 long --> Date 
long t=System.currentTimeMillis(); 
Date date=new Date(t); 
//将 Date --> long 
long t2=date.getTime();//将日期对象转换成时间的毫秒值 
System.out.println(t2);

3. 日期比较的方法

boolean after(Date when) 测试此日期是否在指定日期之后。
boolean before(Date when) 测试此日期是否在指定日期之前。
int compareTo(Date anotherDate) 比较两个日期进行订购。
compareTo方法，返回0代表两个日期一样，返回<0代表调用方法的日期在参数日期之前 返回>0 代表调用方法日期在参数日期的后面

DateFormat类

1.概述

DateFormat 是日期/时间格式化的抽象类
子类 SimpleDateFormat 简单日期格式化器
作用： Date --格式化— > String （按照你想要的格式进行格式化）
String --解析---- > Date

2.日期格式化Date —>String

SimpleDateFormat(String pattern) //参数是一种规则
SimpleDateFormat(String pattern, Locale locale)

//步骤1：创建一个简单日期格式化器 
String pattern="yyyy年MM月dd日 HH:mm:ss E"; 
SimpleDateFormat sdf=new SimpleDateFormat(pattern); 
String t1=sdf.format(new Date()); 
System.out.println(t1); // 2021年07月11日 22:45:42 星期日

3 解析日期 String—> Date

我们在网页中注册信息，填写的数据都是String
此时我们需要将String—> Date
Date parse(String source) 从给定字符串的开始解析文本以生成日期

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 
Date date=sdf.parse(s); 
System.out.println(date);

Calendar类

1.Calendar类的概述

Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。
Calendar是一个抽象类通过静态方法创建
static Calendar getInstance()

2.Calender类常见方法

1.public int get(int field) 返回指定字段的值
方法的参数：
Calendar.YEAR 年
Calendar.MONTH 月 从0开始-11
Calendar.DATE 日
Calendar.HOUR 小时
Calendar.MONUTE 分钟
Calendar.SECOND 秒
Calendar.DAY_OF_WEEK 星期几 // SUNDAY ， MONDAY ， TUESDAY ， WEDNESDAY ， THURSDAY ， ///FRIDAY,SATURDAY
Calendar.DAY_OF_MONTH 几号
Calendar.DAY_OF_YEAR 一年的第几天

Calendar c1=Calendar.getInstance(); 
int v1=c1.get(Calendar.DAY_OF_YEAR); 
System.out.println(v1); 
int year=c1.get(Calendar.YEAR); 
System.out.println(year);

2.public void add(int field,int amount) 在指定字段增减值
参数1：就是刚刚学习的日历字段
参数2: 正数 增 负数 减

//当前时间 
Calendar c1=Calendar.getInstance(); 
//酸奶5天后过期，需要输出5天后的日期 
c1.add(Calendar.DATE, 5); 
System.out.println(c1); 
//输出日历对象不是我们想要的格式 
Date date=c1.getTime(); //将Calendar--->Date 
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); 
System.out.println(sdf.format(date));

3.public final void set(int field,int value)//设置指定字段的值
void set(int year, int month, int date)
void set(int year, int month, int date, int hourOfDay, int minute)
void set(int year, int month, int date, int hourOfDay, int minute, int second)

//计算自己活了多少天?
//当前系统时间 
Calendar c1=Calendar.getInstance(); 
//设置你的生日 
Calendar c2=Calendar.getInstance(); c2.set(1992, 7, 20); //月份从0开始 
//在Calendar类中月份 0-11表示的 
// 日期大小，时间越靠后，越大 
// 西方每周开始的时间周天，中国为周一 
long t1=c1.getTimeInMillis(); 
long t2=c2.getTimeInMillis(); 
long day= (t1-t2)/1000/60/60/24; 
System.out.println(day);
//设置时间为1992年8月20日
c.set(Calendar.YEAR, 1992);
c.set(Calendar.MONTH, 7);
c.set(Calendar.DATE, 20);

4.public final Date getTime() //获取该日历对象转成的日期对象

Calendar c = Calendar.getInstance();
Date d = c.getTime();