1.java初级

1.1.java运行环境

• JDK：JDK(Java SE Development Kit)，Java标准开发包，它提供了编译、运行Java程序所需的各种工具和资源，包括Java编译器、Java运行时环境，以及常用的Java类库等
• JRE：JRE( Java Runtime Environment) 、Java运行环境，用于解释执行Java的字节码文件。
• JVM：JVM是JRE的一部分。它是整个java实现跨平台的最核心的部分，负责解释执行字节码文件，是可运行java字节码文件的虚拟计算机。所有平台的上的JVM向编译器提供相同的接口，而编译器只需要面向虚拟机，生成虚拟机能识别的代码，然后由虚拟机来解释执行。
• 三者区别与联系：JDk包含JRE,JDK和JRE 中都包含 JVM，JDK 用于开发，JRE 用于运行java程序，JVM 是 java 编程语言的核心并且具有平台独立性。

1.2.Java数据类型

1.2.1基本数据类型

• 基本数据类型共有8种，整型：byte，shot，int，long 浮点型：float，double 字符型：char 布尔型：boolea

  /**声明方法*/public boolean bool;public byte by;public char ch;public double d;public float f;public int i;public long l;public short sh;public String str;/**默认值*/Bool :falseByte :0Character: Double :0.0Float :0.0Integer :0Long :0Short :0String :null
  

1.2.2引用数据类型

• 引用数据类型包括自定义对象等

/**声明自定义类型*/
public class user {private String name;private int age;public user() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}/**调用对象*/public void test01(){user user =new user();/**user=null*/System.out.println("user="+user);}

1.3.Java运算符

1.3.1算数运算符

操作符	描述
+	加法 - 相加运算符两侧的值
-	减法 - 左操作数减去右操作数
*	乘法 - 相乘操作符两侧的值
/	除法 - 左操作数除以右操作数
%	取余- 左操作数除以右操作数的余数
++	自增 - 操作数的值增加1
–	自减 - 操作数的值减少1

/**代码演示*/
public class Test {public static void main(String[] args) {int a = 10;int b = 20;int c = 25;int d = 25;System.out.println("a+b="+(a+b));System.out.println("a-b="+(a-b));System.out.println("a*b="+(a*b));System.out.println("b/a="+(b/a));System.out.println("b%a="+(b%a));System.out.println("c%a="+(c%a));/**重点在于理解x++，x--，++x，--x的区别*/System.out.println("a++="+(a++));System.out.println("a--="+(a--));System.out.println("d++="+(d++));System.out.println("++d="+(++d));}
}
/**运行结构*/a+b=30a-b=-10a*b=200b/a=2b%a=0c%a=5a++=10a--=11d++=25++d=27

1.3.2关系运算符

操作符	描述
==	两个值相等，条件为真
!=	两个值不相等，返回为真
>	左值大于右值，返回为真
<	左值小于右值，返回为真
>=	左值大于或等于右值，返回为真
<=	左值小于或等于右值，返回为真

/**代码演示*/
public class Test {public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a==b="+(a==b));System.out.println("a!=b="+(a!=b));System.out.println("a>b="+(a>b));System.out.println("a<b="+(a<b));System.out.println("b>=a="+(b>=a));System.out.println("b<=a="+(b<=a));}
}
/**运行结果*/a==b  falsea!=b  truea>b   falsea<b   trueb>=a  trueb<=a  false

1.3.3逻辑运算符

操作符	描述
&&	两个操作数都为真，条件才为真。
II	有任何一个为真，条件为真。
!	用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

/**代码演示*/
public class Test {public static void main(String[] args) {boolean a = true;boolean b = false;System.out.println("a&&b="+(a&&b));System.out.println("a||b="+(a||b));System.out.println("!(a&&b)="+!(a&&b));}}
/**运行结果*/a&&b=falsea||b=true!(a&&b)=true

1.3.4赋值运算符

赋值符	描述
=	简单的赋值运算符，将右操作数的值赋给左侧操作数
+=	加和赋值操作符，将左操作数和右操作数相加赋值给左操作数
-	减和赋值操作符，将左操作数和右操作数相减赋值给左操作数
*=	乘和赋值操作符，将左操作数和右操作数相乘赋值给左操作数
/=	除和赋值操作符，将左操作数和右操作数相除赋值给左操作数
％=	取模和赋值操作符，将左操作数和右操作数取模后赋值给左操作数
<<=	左移位赋值运算符，
>>=	右移位赋值运算符
＆=	按位与赋值运算符
^=	按位异或赋值操作符
	=

/**代码演示*/
public class Test {public static void main(String[] args) {int a =10;int b =20;int c =0;c=a+b;System.out.println("c=a+b="+c);c+=a ;System.out.println("c+=a="+c);c-=a;System.out.println("c-=a="+c);c*=a;System.out.println("c*=a="+c);a=10;c=15;c/=a;System.out.println("c/=a="+c);a=10;c=15;c%=a;System.out.println("c%=a="+c);c<<=2 ;System.out.println("c<<=2="+c);c>>=2 System.out.println("c>>=2="+c);c>>=2 ;System.out.println("c>>=2="+c);c&=a;System.out.println("c&=a="+c);c^=a;System.out.println("c^=a="+c);c|=a;System.out.println("c|=a="+c);}
}
/**运行结果*/c=a+b=30c+=a=40c-=a=30c*=a=300c/=a=1c%=a=5c<<=2=20c>>=2=5c>>=2=1c&=a=0c^=a=10c|=a=10

1.3.4三元运算符

/**代码演示*/
public class Test {public static void main(String[] args){int a , b;a=10;b=(a==1)?20:30;System.out.println("b="+b);b=(a==10)?20:30;System.out.println("b="+b);}}/**运行结果*/b=30b=20

1.4.分支结构

分支符	说明
if(判断语句){}	布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。
if(判断语句){}else{}	if 语句的布尔表达式值为 false 时，else 语句块会被执行。

/**代码演示*/
public static void main(String args[]){int x=10;int b=22;if(x<20 ){System.out.print("这是单独if语句");}if(b<20){System.out.print("这是if,else中的if语句");}else{System.out.print("这是if,else的else语句语句");}}/**运行结果*/这是单独if语句这是if,else的else语句语句}

1.5.循环结构

循环符	说明
while(布尔表达式){循环内容}	只要布尔表达式为 true，循环就会一直执行下去。
do {代码语句}while(布尔表达式);	布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false
for(初始化; 布尔表达式; 更新) {代码语句}

public class Test {
/**while循环演示*/@Testpublic void t1(){int x = 10;while( x < 12 ) {System.out.println("while循环x=" + x );x++;}}/**do..while循环演示*/@Testpublic void t1(){int x = 10;do{System.out.println("do..while循环x= " + x );x++;}while( x < 12 );}/**for循环演示*/@Testpublic void t3(){for(int x = 10; x < 12; x++) {System.out.println("for循环x=" + x );}}/**运行结果*/while循环x=10while循环x=11do..while循环x=10do..while循环x=11for循环x=10for循环x=11
}

2.java中级

2.1类与对象

• 类：类是一个模板，它描述一类对象的行为和状态。

• 对象：对象是类的一个实例，有状态和行为。

  类包括有：
  1.局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
  2.成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  3.类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

• 构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的无参构造方法。

2.2this与static

• this：this 是自身的一个对象，代表对象本身。用法为：

     1.普通的直接引用
     2.形参与成员名字重名，用 this 来区分

//声明一个自定义对象
public class emp {private String name;public emp(String name) {//this 同名时，用来区别方法形参与成员变量this.name = name;}public String getName() {return name;}public void setName(String name) {//this 同名时，用来区别方法形参与成员变量this.name = name;}
}
//测试类
public class test {public void t1（）{emp emp = new emp("gui");System.out.println(emp.getName());}
}
//运行结果gui

• static：在类中，用static声明的成员变量为静态成员变量，也成为类变量，方法称为静态方法，代码快称为静态代码块类变量的生命周期和类相同，在整个应用程序执行期间都有效
• 静态方法与非静态方法区别
  1.静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化
  2.非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响
• static修饰的方法的调用： 类名.方法();

2.3面向对象三个特性

2.3.1封装

• 封装：将抽象性函式接口的实现细节部分包装、隐藏起来的
• 封装的优点： 1. 封装能够减少耦合
                         2.类内部的结构可以自由修改。
                         3.可以对成员变量进行更精确的控制。

/**封装自定义对象*/
public class Person{//将属性的访问修饰符改为私有private String name;private int age;
​  //添加对外界访问的方法public int getAge(){return age;}public String getName(){return name;}public void setAge(int age){this.age = age;}public void setName(String name){this.name = name;}}/**测试自定义对象*/public class Test {@Testpublic void t1(){Person  person = new  Person();person.setName("gui");person.setAge(20);System.out.print("Name:"+person.getName()+"，  Age : "+person.getAge());}}/**运行结果*/Name:gui，Age:20

2.3.2继承

• 继承：子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• 继承的特点：1.子类拥有父类非 private 的属性、方法。
                         2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展
                         3.子类可以用自己的方式实现父类的方法(方法重写)
• 继承关键字：extends，implements，因为Java继承是单继承，使用implements关键字可以变相的达到多继承效果

/**父类user*/
public class user {private String name;private int age;public user() {}public user(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void eat(){System.out.println(name+"正在吃");}
}
/**接口emp*/
public interface emp {public void sleep(String name);
}
/**user02继承user类并且引用emp接口*/
public class user02 extends  user implements emp {public user02(String name, int age) {super(name, age);}@Overridepublic void sleep(String name) {System.out.println(name+"在睡觉");}
}
/**测试类*/public class Test {@Testpublic void test02(){user02 user =new user02("gui",20);user.eat();user.sleep(user.getName());}}/**运行结果*/gui正在吃gui在睡觉

2.3.3多态

• 多态就是同一个接口，使用不同的实例而执行不同操作，当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

/**父类*/
public abstract class Animal {  abstract void eat();  
}  
/**子类*/ 
public class Cat extends Animal {  public void eat() {  System.out.println("吃鱼");  }  public void work() {  System.out.println("抓老鼠");  }  
}  /**子类*/ 
public class Dog extends Animal {  public void eat() {  System.out.println("吃骨头");  }  public void work() {  System.out.println("看家");  }  
}
/**测试代码*/ public class Test {@Testpublic void test01(){Animal a = new Cat(); a.eat();               Cat c = (Cat)a;       c.work();        /}  /**运行结果*/ 吃鱼抓老鼠

2.4内部类

• 内部类大致分为四种

内部类名称	说明
成员内部类	最普通的内部类，即在类中在定义一个类
局部内部类	即定义在一个类的方法或者一个作用域里面的类
匿名内部类	即不定义名字的内部类
静态内部类	修饰符为static的成员内部类

成员内部类：成员内部类访问外部类时可以无条件访问外部类的所有成员属性和成员方法，外部类访问访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问;

//内部类访问外部类演示
public class user {public static age=10class emp {     //内部类public void getage() {//打印结果为10，可以直接调用System.out.println(age);}}}//外部类访问内部类演示public class user {//使用emp里面的内容时调用t1()方法public emp t1(){return new emp;}class emp {     //内部类public void haha() {System.out.println("哈哈");}}}

局部内部类：局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

3.java高级

day01

• 代码执行顺序
  ①类被加载的时候优先执行静态代码块并且只执行一次
  ② 执行顺序静态代码块>构造代码块>构造方法
• 匿名对象
  优点：用完即毁，节省内存
  缺点：多次使用时，不停创建,毁灭cpu压力大
• 重载与重写
  重载：同类中参数列表不同，方法相同为方法重载
  重写：子类重写父类的方法为方法重写
  重载看参数，重写看类型
• 方法重写
  ①toString()方法重写 2
  原方法代码返回的是String型的数据：类名+@+哈希值的16进制形式，可根据项目要求重写toString()方法
  ②hashCode()与equale()方法重写
  项目中为了达到想要判断原则，需要重写hashCode()与equale()方法
  ③clone()方法重写
  当克隆的对象的类没有引用Cloneable接口，调用的clone()方法克隆的为浅克隆，堆内存指向的是同一个地址
  当克隆的对象的类引用Cloneable接口，调用的clone()方法克隆的，堆内存指向的是不同的地址

day02

包装类作用：通过包装类可以让基本数据类型获取对象一样的特征，行使对象相关的权力。（jdk 1.5 出现自动装拆箱，不用new）

• 类的调用
  1.成员内部类的调用：
  静态成员内部类：类名.内部类名.方法名
  非静态成员内部类：new类名.new内部类名.方法名称，在类中添加方法，通过方法访问非静态成员内部类

//类声明
public class test01 {//静态成员内部类的声明static class test001{public static void h1(){System.out.println("静态成员内部类的方法");}}//非静态成员内部类的声明class test002{public  void h2(){System.out.println("非静态成员内部类的方法");}}
}
//测试代码
public class test01Test {@Testpublic void h1Test(){test01.test001.h1();}@Testpublic void h2Test(){test01 test01 = new test01();test01.test002 test002 = test01.new test002();test002.h2();}
}

2.局部内部类的调用：
①静态方法中的局部内部类的调用：在方法中new内部类.方法名。外部类名.点方法名称调用
②非静态方法中的局部内部类的调用：new 局部内部的类名(){方法体}.方法名();
③方法体内增加调用局部内部类的方法：
局部内部的类名 变量名 = new 局部内部类名(){方法体 };
new 局部内部的类名(){方法体}.方法名();
这种方法需要有个局部内部类，局限性大故new Object(){方法体}.方法名()

//演示代码
public class hh {  /*** 静态方法中的局部内部类*/
public static void h1(){class  s1{public void sleep(){System.out.println("睡觉");}}new s1().sleep();
}/***非静态方法中的局部内部类*/public  void h2(){class  s1{public void sleep(){System.out.println( "睡觉");}}new s1().sleep();}
}
//测试代码
public class test {//静态方法中的局部内部的调用@Testpublic void t1(){hh.h1();}//非静态方法中的局部内部的调用@Testpublic void t2(){hh hh=new hh();hh.h2();}
}

• java8接口新特性
  ①.default，static修饰符

修饰符	继承	重写
default	✔	✔
static	✖	✖

//演示代码
public interface test {default void  t1(){System.out.println("default的方法");}static void  t2(){System.out.println("static的方法");}
}

②.函数式接口的使用（接口有且只有一个抽象方法并且使用@FunctionalInterface注解）
接口名 变量名 = new 接口名 { 重写接口的方法体； };
简写即lamba表达式：接口名 变量名 =（参数列表） ->{方法体内的方法};

//接口
public interface test01 {public int sum(int a,int b);
}
//演示代码
public class test01Test {//普通写法@Testpublic void t1(){test01 test01= new test01(){@Overridepublic int sum(int a, int b) {return a+b;}};int sum = test01.sum(1, 2);System.out.println(sum);}//简写 即lamda表达式@Testpublic void t2(){test01 test01=(a,b)->{return a+b;};
}}

③lamda表达式
1.UnaryOperator<>,方法为apply（）(一个参数 一个返回)
2.BinaryOperator<>,方法为apply()(两个参数 一个返回)
3.Consumer<> ,方法为accept()(一个参数 无返回)
4.Supplier<>,方法为get(无参数 一个返回)

//演示代码@Testpublic void test01(){// 一个参数 有返回 方法为applyUnaryOperator<Integer> unaryOperator = (a) -> {return a + 3;};Integer apply = unaryOperator.apply(6);System.out.println(apply);}@Testpublic void test02() {// 两个参数 有返回 方法为applyBinaryOperator<Integer> binaryOperator = (a, b) -> {return a + b;};Integer n = binaryOperator.apply(10, 20);System.out.println(n);}@Testpublic void test03() {// 一个参数 无返回 方法为acceptConsumer<String> consumer = (hh) -> {System.out.println("你好 >>> " + hh);};consumer.accept("明天");}@Testpublic void test04() {// 无参数 有返回 方法为getSupplier<String> supplier = () -> {return "hello word";};String slogan = supplier.get();System.out.println(slogan);}@Testpublic void test05() {// 数据类型转换 方法applyFunction<String, Integer> function = (str) -> {return Integer.parseInt(str);};Integer num = function.apply("200");System.out.println(num instanceof Integer);}

day03

手写arrayList

• arrayList底层
  集合arraylist底层是一个object类型的数组，故对该集合的操作本质上是对数组的操作

• 数组的拷贝
  ①arrayCopy(Object[] src, int srcPos,Object[] dest, int destPos,int length)
  通过源数组src,源数组指定下标:srcPos 目标数组:dest,目标数组指定下标destPos,拷贝长度length这几个参数实现数组的拷贝
  注意： 要备份源数组中欲被拷贝的元素的值,通过源数组src，新数组长度newLength两个参数以及循环实现数组的拷贝

  ②copyOf(Object[] src, int newLength)
  通过源数组src，新数组长度newLength两个参数以及调用arraycopy()方法实现数组的拷贝

• 底层实现相关方法：
  ①size()返回集合数据个数->返回size的大小
  ②add(Object object)向集合添加数据->通过size值向指定网站插入数据
  ③ensureCapacity(int minCapacity)用于底层数组的扩容->当数组长度不够时，数组长度扩大一半
  ④get(int index)返回集合下标的数据->返回底层数组指定位置的值
  ⑤checkRang(int index)判断下标的书是否符合规范->用于判断操作的下标是否符合标准
  ⑥remove(int index)去除集合中指定下标的数据->删除数组指定下标数据，后面的数据需要网前面移动
  注意： 拷贝元素的长度size - index -1

day04

• List （有序可重复）
  ①.Arraylist：
  特点：底层数组，线性存储
  优点：查询和修改速递快
  缺点：新增删除比较慢
  相关方法：add()集合添加数据
  集合遍历：普通for循环增强for循环迭代器遍历
  hasNext()判断下一个指针是否有值，next()取值
  ②.Linkedlist：
  特点：底层数组，双向链表结构
  优点：新增数据和删除数据比较快
  缺点：查询和修改速度慢
  相关方法：add()集合添加数据
  集合遍历：普通for循环,增强for循环迭代器遍历
  ③.Vector:
  特点:Vector采用了加锁机制，适合用于多线程的情况下
• Set （无序不重复）
  ① HashSet：
  特点:输出数据的顺序不是按照存储的顺序显示
  相关方法:方法使用与其他集合无多大全部
  集合遍历:迭代器遍历
  ②LinkedHashSet：
  特点：HashSet的有序版，输出顺序按输入顺序打印
  ③TreeSet：
  特点：TreeSet基于TreeMpa实现，TreeMap本质就是红黑树。所以TreeSet其实于是基于红黑树的
  相关方法使用TreeSet存储自定义数据类型时，对象必须使用Comparable接口，重写compareTo()方法
  集合遍历:迭代器遍历
• Map
  （key不可重复）
  ①HashMap：
  特点:底层是基于 数组 + 链表，key，value结构存储数据
  相关方法:
  get()返回某一键对应的value值
  keySet()获取所有的key的集合
  entrySet()获取entrySet entrySet中存储的是key 和 value的集合
  values()获取所有value的集合
  ②LinkHashMap：（继承与HashMap）
  特点:HashMap的有序版输出数据的顺序按照存储的顺序打印
  使用方法与Hashmap集合无太大区别
  ③HashTable
  特点:Hashtable是线程安全的，它的每个方法中都加入了Synchronize方法。在多线程并发的环境下，可以直接使用Hashtable，不需要自己为它的方法实现同步
  集合遍历:Enumeration遍历
  ④ConcurrentHashMap
  特点:引入了一个“分段锁”的概念,把Map分成了N个Segment，put和get的时候，都是现根据key.hashCode()算出放到哪个Segment中：

day05

规范属性值方法：
1.接口（jdk1.5前面）使用接口静态常量规范变量时，不足的是可以通过set方法进行修改
2.枚举（jdk1.5出现）推荐使用枚举规范属性值
随机数的生成
1.Math.random()，Math.random()随机返回一个0到1之间的浮点型数据
2.ThreadLocalRandom
nextInt()随机整数
nextInt(整数值) 生成0到该整数值但不包含该整数值之间的一个随机整数
nextInt(origin,bound) 生成origin到bound但不包含bound之间的一个随机整数
date时间的生成
1.过时用法
getYear()返回年份（注意：年份从1900开始）
getMonth()（注意：月份从0开始）
getDate()某月的第几天
getMinutes()分钟
getSeconds()多少秒
getDay()星期几
getTime()获取从1970年开始至今的时间毫秒数
toGMTString()返回世界标准时间
通过setTimeZone可以格式化时区
2.推荐用法
通过 SimpleDateFormat格式化日期，获得我们需要格式的日期

//代码演示@Testpublic void test01(){//通过定义时间模板生成日期SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date date = new Date();String format = simpleDateFormat.format(date);System.out.println(format);}

BaseDate工具类：
getDateString()：格式化date，方法重载参数为传入日期，或者日期与字符串模板
parse(String source)：字符串转日期，方法重载，传入字符串或者字符串与字符串的模板

流Stream的生成方式
(jdk1.8新特性)

①stream() :为集合创建串行流
②stream.forEach遍历
③Arrays.stream()数组生成流数据源
④Stream.of()数组生成流数据源
⑤Files.lines(Paths.get())通过nio获得数据源
⑥filter()数据筛选
⑦sorted()数据排序，默认升序
⑧stream.map()类型转换

//代码演示
//注意：Stream类似与迭代器，使用即没，故使用stream需要多次创建流，下面仅用于演示public void test01(){List<Integer> list = new ArrayList<Integer>();for(int i=0;i<5;i++){list.add(i);}//stream遍历数组Stream<Integer> stream = list.stream();stream.forEach( i -> {System.out.println(i);});
//        stream排序（默认升序）stream.sorted().forEach( n -> {System.out.println(n);});// 使用map进行类型转换stream.map((n) -> {if (n < 2) {return "不及格";} else {return "恭喜成功通过";}}).forEach(n -> {System.out.println(n);});}  

2.parallelStream() 为集合创建并行流,该流的操作是并发的

//parallelStreamStream并行流演示
@Testpublic void test02(){List<Integer> list = new ArrayList<Integer>();for(int i=0;i<5;i++){list.add(i);}
//        parallelStream创建并行流Stream<Integer> stream = list.parallelStream();stream.forEach( i -> {System.out.println(i);});}

day06

java8新增管理时间类

• LocalDate(日期工具类)

public class LocalDateTest {@Testpublic void test01(){//演示代码LocalDate now = LocalDate.now();System.out.println("获得当前日期："+now);LocalDate of = LocalDate.of(2020, 5, 23);System.out.println("感觉传入的参数获得的日期："+of);System.out.println("当前月的第几天："+now.getDayOfMonth());System.out.println("当前日期的星期几："+now.getDayOfWeek());System.out.println("当前日期是该年的第几天："+now.getDayOfYear());System.out.println("当前日期所在的月份(英文)："+now.getMonth());System.out.println("当前日期所在的月份(数字)："+now.getMonthValue());System.out.println("当前日期所在年的总天数："+now.lengthOfYear());System.out.println("当前年是否闰年："+now.isLeapYear());//with根据传入的参数更改日期System.out.println("正常日期："+now);System.out.println("更改当前日期的参数日"+now.withDayOfMonth(1));System.out.println("根据天数获得日期"+now.withDayOfMonth(1));System.out.println("更改当前日期的参数月"+now.withMonth(1));System.out.println("更改当前日期的参数年"+now.withYear(1));//minus根据参数与当前日期做减法运算System.out.println("当前日期减去1天"+now.minusDays(1));System.out.println("当前日期减去1周"+now.minusWeeks(1));System.out.println("当前日期减去1月"+now.minusMonths(1));System.out.println("当前日期减去1年"+now.minusMonths(1));//minus根据参数与当前日期做加法运算System.out.println("当前日期加去1天"+now.plusDays(1));System.out.println("当前日期加去1周"+now.plusWeeks(1));System.out.println("当前日期加去1月"+now.plusMonths(1));System.out.println("当前日期加去1年"+now.plusMonths(1));
}}//运行代码获得当前日期：2020-05-03感觉传入的参数获得的日期：2020-05-23当前月的第几天：3当前日期的星期几：SUNDAY当前日期是该年的第几天：124当前日期所在的月份(英文)：MAY当前日期所在的月份(数字)：5当前日期所在年的总天数：366当前年是否闰年：true正常日期：2020-05-03更改当前日期的参数日2020-05-01根据天数获得日期2020-05-01更改当前日期的参数月2020-01-03更改当前日期的参数年0001-05-03当前日期减去1天2020-05-02当前日期减去1周2020-04-26当前日期减去1月2020-04-03当前日期减去1年2020-04-03当前日期加去1天2020-05-04当前日期加去1周2020-05-10当前日期加去1月2020-06-03当前日期加去1年2020-06-03

• LocalTime(时间工具类)

//演示代码
public class LocalTimeTest {@Testpublic void test01(){LocalTime now = LocalTime.now();System.out.println("当前时间："+now);//根据参数获得时间System.out.println("根据参数获得时间:"+LocalTime.of(8,8,8));System.out.println("获得当前时间小时数："+now.getHour());System.out.println("获得当前时间分钟数："+now.getMinute());System.out.println("获得当前时间秒数："+now.getSecond());//with根据参数改变获得的时间System.out.println("更改当前时间参数小时："+now.withHour(1));System.out.println("更改当前时间参数分钟："+now.withMinute(1));System.out.println("更改当前时间参数秒："+now.withSecond(1));//minus将当前日期与参数进行减法运算System.out.println("小时减1："+now.minusHours(1));System.out.println("分钟减1："+now.minusMinutes(1));System.out.println("秒减1："+now.minusSeconds(1));//plus将当前日期与参数进行加法运算System.out.println("小时减1："+now.plusHours(1));System.out.println("分钟减1："+now.plusMinutes(1));System.out.println("秒减1："+now.plusSeconds(1));}}//运行结果当前时间：18:08:21.297根据参数获得时间:08:08:08获得当前时间小时数：18获得当前时间分钟数：8获得当前时间秒数：21更改当前时间参数小时：01:08:21.297更改当前时间参数分钟：18:01:21.297更改当前时间参数秒：18:08:01.297小时减1：17:08:21.297分钟减1：18:07:21.297秒减1：18:08:20.297小时减1：19:08:21.297分钟减1：18:09:21.297秒减1：18:08:22.297

• LocalDateTime（时间日期二合一工具类）

public class LocalDateTimeTest {@Testpublic  void test01(){LocalDateTime now = LocalDateTime.now();System.out.println("LocalDateTime默认格式："+now);//因为LocalDateTime默认格式的时间不好看，故需要DateTimeFormatter优化格式DateTimeFormatter dateTF = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String format = dateTF.format(now);System.out.println("DateTimeFormatter优化后的时间："+format);String d1="2020-05-03 18:27:15";//把字符串按格式转化成日期LocalDateTime parse= LocalDateTime.parse(d1, dateTF);System.out.println("字符串转化的日期："+parse);System.out.println("判断now是否在parse时间之前："+now.isBefore(parse));System.out.println("判断now是否在parse时间之后："+now.isAfter(parse));System.out.println("判断now是与parse时间是否相等："+now.isEqual(parse));}}//运行结果LocalDateTime默认格式：2020-05-03T18:33:16.242DateTimeFormatter优化后的时间：2020-05-03 18:33:16字符串转化的日期：2020-05-03T18:27:15判断now是否在parse时间之前：false判断now是否在parse时间之后：true判断now是与parse时间是否相等：false

• String
  ==比较的是内存地址，equals比较的是字符

public class StringTest02 {
//演示代码@Testpublic void test01(){char[] a1={'l','o','v','e'};int []  a2={1,2,3,4};String s1=new String(a1);String s2 = String.valueOf(a1);String s3 = String.valueOf(a2);System.out.println("String构造方法char数组转字符串:"+s1);System.out.println("String的valueof方法数组转字符串:"+s2);System.out.println("String的valueof方法数组转字符串:"+s3);System.out.println("判断字符串s1是否包含某个参数："+s1.contains("a"));System.out.println("返回参数在字符串s1的下标："+s1.indexOf("l"));System.out.println("返回参数在字符串s1最后一次出现的下标："+s1.lastIndexOf("e"));System.out.println("返回字符串s1参数下标的字符："+s1.charAt(0));System.out.println("判断两个字符串是否相同："+s1.compareTo(s2));System.out.println("字符转大写："+s1.toUpperCase());System.out.println("字符转小写："+s1.toLowerCase());//截取时：一个参数截取参数及后面所有内容，两个参数是截取内容包前不包后System.out.println("字符串截取："+s1.substring(2));System.out.println("字符串截取："+s1.substring(2,3));System.out.println("字符串替换："+s1.replace('l','o'));String s4="111-111";//字符串截取,参数为截取规则String[] split = s4.split("-");Stream<String> stream = Arrays.stream(split);stream.forEach(i->{System.out.println(i);});}}//运行结果String构造方法char数组转字符串:loveString的valueof方法数组转字符串:loveString的valueof方法数组转字符串:[I@ba8a1dc判断字符串s1是否包含某个参数：false返回参数在字符串s1的下标：0返回参数在字符串s1最后一次出现的下标：3返回字符串s1参数下标的字符：l判断两个字符串是否相同：0字符转大写：LOVE字符转小写：love字符串截取：ve字符串截取：v字符串替换：oove111111

• StringBuilder与StringBuffer

  String 类型每次进行改变的时候都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，每次生成对象都会对系统性能产生影响当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，速度就会变慢
  StringBuilder 字符串变量（线程不安全）
  StringBuffer 字符串变量（线程安全）

public class StringBuilderTest {//演示代码@Testpublic void test01(){StringBuilder sb = new StringBuilder();sb.append("l");sb.append("o");sb.append("v");sb.append("e");System.out.println(sb.toString());}
}
//运行结果
love