学习笔记-Java进阶

各类的使用方法

object类

类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类

重要方法：

　　public String toString() ：返回该对象的字符串表示。
　　public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。

public static boolean equals(Object a, Object b) :判断两个对象是否相等。

  toString

　　toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
　　由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
小贴士： 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

equals

　　如果没有覆盖重写equals方法，那么Object类中默认进行== 运算符的对象地址比较，只要不是同一个对象，结果必然为false。

　　如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。

时间类

date类的构造函数：

　　public Date() ：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
　　public Date(long date) ：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

重要方法：

　　public long getTime() 把日期对象转换成对应的时间毫秒值。

注意:
    中国属于东八区,会把时间增加8个小时
dateformat类：

　　java.text.DateFormat:是日期/时间格式化子类的抽象类
　　　作用:
    　　　　格式化（也就是日期 -> 文本）、解析（文本-> 日期）
　　成员方法:
 　　   String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
   　　 Date parse(String source)  把符合模式的字符串,解析为Date日期
DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类SimpleDateFormat

构造方法:
    SimpleDateFormat(String pattern)
      用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
    参数:
         String pattern:传递指定的模式
    模式:区分大小写的

y	M	d	H	m	s
年	月	日	时	分	秒

写好对应的模式,会把模式替换为对应的日期和时间："yyyy-MM-dd HH:mm:ss"

    注意:
        模式中的字母不能更改,连接模式的符号可以改变："yyyy年MM月dd日 HH时mm分ss秒"

使用DateFormat类中的方法parse,把文本解析为日期
　　使用步骤:
  　　 1.创建SimpleDateFormat对象,构造方法中传递指定的模式
   　　2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期

使用DateFormat类中的方法format,把日期格式化为文本
　　使用步骤:
　　    1.创建SimpleDateFormat对象,构造方法中传递指定的模式
 　　   2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)。

日期类

日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

Calendar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。

Calendar类的常用成员方法:
    public int get(int field)：返回给定日历字段的值。
    public void set(int field, int value)：将给定的日历字段设置为给定值。
    public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
    public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
成员方法的参数:
    int field:日历类的字段,可以使用Calendar类的静态成员变量获取

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

小贴士：

　　西方星期的开始为周日，中国为周一。
　　在Calendar类中，月份的表示是以0-11代表1-12月。
　　日期是有大小关系的，时间靠后，时间越大。

System

类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
　　public static long currentTimeMillis() ：返回以毫秒为单位的当前时间。
　　public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将数组中指定的数据拷贝到另一个数组中。

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

StringBuilder类

StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。

构造方法:
    StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
    StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

常用方法：

　　public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。
　　public String toString() ：将当前StringBuilder对象转换为String对象。

StringBuilder和String可以相互转换:
    String->StringBuilder:可以使用StringBuilder的构造方法
        StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
    StringBuilder->String:可以使用StringBuilder中的toString方法
        public String toString()：将当前StringBuilder对象转换为String对象。

包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
    构造方法:
        Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
        Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
            传递的字符串,必须是基本类型的字符串,否则会抛出异常 "100" 正确  "a" 抛异常。
    静态方法:
        static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
        static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)。
    成员方法:
        int intValue() 以 int 类型返回该 Integer 的值。

自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换 JDK1.5之后出现的新特性。

基本类型与字符串类型之间的相互转换
基本类型->字符串(String)
    1.基本类型的值+""  最简单的方法(工作中常用)
    2.包装类的静态方法toString(参数),不是Object类的toString() 重载
        static String toString(int i) 返回一个表示指定整数的 String 对象。
    3.String类的静态方法valueOf(参数)
        static String valueOf(int i) 返回 int 参数的字符串表示形式。
字符串(String)->基本类型
    使用包装类的静态方法parseXXX("字符串");
        Integer类: static int parseInt(String s)

collection集合

集合：集合是java中提供的一种容器，可以用来存储多个数据。

数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List 和java.util.Set 。其中， List 的特点是元素有序、元素可重复。Set 的特点是元素无序，而且不可重复。List 接口的主要实现类有java.util.ArrayList 和java.util.LinkedList ， Set 接口的主要实现类有java.util.HashSet 和java.util.TreeSet 。

关系图：

java.util.Collection接口
    所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法。
    任意的单列集合都可以使用Collection接口中的方法。
共性的方法:
  　　public boolean add(E e)：  把给定的对象添加到当前集合中 。
  　　public void clear() :清空集合中所有的元素。
　　  public boolean remove(E e): 把给定的对象在当前集合中删除。
　　  public boolean contains(E e): 判断当前集合中是否包含给定的对象。
　　  public boolean isEmpty(): 判断当前集合是否为空。
　　  public int size(): 返回集合中元素的个数。
　　  public Object[] toArray(): 把集合中的元素，存储到数组中。

迭代器

java.util.Iterator接口:迭代器(对集合进行遍历)

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

有两个常用的方法：
    boolean hasNext() 如果仍有元素可以迭代，则返回 true。
        判断集合中还有没有下一个元素,有就返回true,没有就返回false。
    E next() 返回迭代的下一个元素。
        取出集合中的下一个元素
Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象。

　　Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

迭代器的使用步骤:
    1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)。
    2.使用Iterator接口中的方法hasNext判断还有没有下一个元素。
    3.使用Iterator接口中的方法next取出集合中的下一个元素。

1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)。
注意:
    Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型。

增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写，不能对集合中的元素进行增删操作。
所有的单列集合都可以使用增强for。
增强for循环:用来遍历集合和数组。

  for(集合/数组的数据类型 变量名: 集合名/数组名){
        sout(变量名);

泛型

含有泛型的方法,在调用方法的时候确定泛型的数据类型。
传递什么类型的参数,泛型就是什么类型。

创建集合对象,使用泛型。

好处:
    1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型。
    2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)。
 弊端:
    泛型是什么类型,只能存储什么类型的数据。

创建集合对象,不使用泛型。

修饰符 class 类名<代表泛型的变量> { }

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

修饰符 interface接口名<代表泛型的变量> { }

型泛型通配符

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

    ?:代表任意的数据类型。
使用方式:
    不能创建对象使用。
    只能作为方法的参数使用。

注意:
    泛型没有继承概念的。

泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身。
泛型的下限限定: ? super E    代表使用的泛型只能是E类型的父类/本身。

List集合

List接口的特点:
    1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
    2.有索引,包含了一些带索引的方法
    3.允许存储重复的元素

 List接口中常用方法：

　　public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
　　public E get(int index) :返回集合中指定位置的元素。
　　public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
　　public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

注意:
    操作索引的时候,一定要防止索引越界异常
    IndexOutOfBoundsException:索引越界异常,集合会报
    ArrayIndexOutOfBoundsException:数组索引越界异常
    StringIndexOutOfBoundsException:字符串索引越界异常

List的子类：

　　java.util.LinkedList集合 implements List接口
　　　　LinkedList集合的特点:
  　　  1.底层是一个链表结构:查询慢,增删快
  　　  2.里边包含了大量操作首尾元素的方法
   　　 注意:使用LinkedList集合特有的方法,不能使用多态
    　　　　  public void addFirst(E e):将指定元素插入此列表的开头。
      　　　　public void addLast(E e):将指定元素添加到此列表的结尾。
      　　　　public void push(E e):将元素推入此列表所表示的堆栈。
      　　　　public E getFirst():返回此列表的第一个元素。
      　　　　public E getLast():返回此列表的最后一个元素。
      　　　　public E removeFirst():移除并返回此列表的第一个元素。
      　　　　public E removeLast():移除并返回此列表的最后一个元素。
      　　　　public E pop():从此列表所表示的堆栈处弹出一个元素。
      　　　　public boolean isEmpty()：如果列表不包含元素，则返回true。

Set接口

java.util.Set接口 extends Collection接口
Set接口的特点:
    1.不允许存储重复的元素
    2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口
HashSet特点:
     1.不允许存储重复的元素
     2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
     3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
     4.底层是一个哈希表结构(查询的速度非常的快)

　　HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与equals 方法。

　　HashSet存储自定义类型元素：　　　

　　　　给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

LinkedHashSet集合特点:
    底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序

哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)
在Object类有一个方法,可以获取对象的哈希值     int hashCode() 返回该对象的哈希码值。

 可变参数

使用前提:
    当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
使用格式:定义方法时使用
    修饰符 返回值类型 方法名(数据类型...变量名){}
可变参数的原理:
    可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
    传递的参数个数,可以是0个(不传递),1,2...多个

 Collections

常用功能：

　　public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
　　public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
　　public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
　　public static <T> void sort(List<T> list，Comparator<? super T> ) :将集合中元素按照指定规则排序。

注意:
     sort(List<T> list)使用前提
     被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则
Comparable接口的排序规则: 自己(this)-参数:升序

 Comparator和Comparable的区别：
    Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
    Comparator:相当于找一个第三方的裁判,比较两个
Comparator的排序规则:  o1-o2:升序

 Map集合

java.util.Map<k,v>集合
 　　Map集合的特点:
   　　  1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
   　　  2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
  　　   3.Map集合中的元素,key是不允许重复的,value是可以重复的
 　　    4.Map集合中的元素,key和value是一一对应
 java.util.HashMap<k,v>集合 implements Map<k,v>接口
　　 HashMap集合的特点:
  　　   1.HashMap集合底层是哈希表:查询的速度特别的快
     　　    JDK1.8之前:数组+单向链表
       　　  JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
    　　 2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
　　LinkedHashMap的特点:
   　　  1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
   　　  2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

Map集合的第一种遍历方式:通过键找值的方式
　　Map集合中的方法:
   　　  Set<K> keySet() 返回此映射中包含的键的 Set 视图。
　　实现步骤:
 　　   1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
 　　   2.遍历set集合,获取Map集合中的每一个key
  　　  3.通过Map集合中的方法get(key),通过key找到value

Map集合遍历的第二种方式:使用Entry对象遍历
　　Map集合中的方法:
  　　  Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
　　实现步骤:
  　　  1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
   　　 2.遍历Set集合,获取每一个Entry对象
　　    3.使用Entry对象中的方法getKey()和getValue()获取键与值

HashMap存储自定义类型键值
　　Map集合保证key是唯一的:
    　　作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一

java.util.LinkedHashMap<K,V> entends HashMap<K,V>
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
底层原理:
    哈希表+链表(记录元素的顺序)

java.util.Hashtable<K,V>集合 implements Map<K,V>接口
Hashtable:底层也是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢
HashMap:底层是一个哈希表,是一个线程不安全的集合,是多线程的集合,速度快
HashMap集合(之前学的所有的集合):可以存储null值,null键
Hashtable集合,不能存储null值,null键
Hashtable和Vector集合一样,在jdk1.2版本之后被更先进的集合(HashMap,ArrayList)取代了
Hashtable的子类Properties依然活跃在历史舞台
Properties集合是一个唯一和IO流相结合的集合

JDK9的新特性:
    List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素
    static <E> List<E> of​(E... elements)
    使用前提:
        当集合中存储的元素的个数已经确定了,不在改变时使用
 注意:
    1.of方法只适用于List接口,Set接口,Map接口,不适用于接接口的实现类
    2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
    3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常

Debug调试程序:

    可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug
使用方式:
    在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里)
    右键,选择Debug执行程序
    程序就会停留在添加的第一个断点处
执行程序:
    f8:逐行执行程序
    f7:进入到方法中
    shift+f8:跳出方法
    f9:跳到下一个断点,如果没有下一个断点,那么就结束程序
    ctrl+f2:退出debug模式,停止程序
    Console:切换到控制台

 异常处理

java.lang.Throwable:类是 Java 语言中所有错误或异常的超类。
    Exception:编译期异常,进行编译(写代码)java程序出现的问题
    RuntimeException:运行期异常,java程序运行过程中出现的问题
        异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉,程序可以继续执行
    Error:错误
        错误就相当于程序得了一个无法治愈的毛病.必须修改源代码,程序才能继续执行

throw关键字

作用:
    可以使用throw关键字在指定的方法中抛出指定的异常

 throw new xxxException("异常产生的原因");

注意:
    1.throw关键字必须写在方法的内部
    2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
    3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
        throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
        throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch

Obects类中的静态方法
public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

throws关键字:异常处理的第一种方式,交给别人处理

作用:
    当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
    可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理

修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
        throw new AAAExcepiton("产生原因");
        throw new BBBExcepiton("产生原因");
        ...
    }

 注意:
    1.throws关键字必须写在方法声明处
    2.throws关键字后边声明的异常必须是Exception或者是Exception的子类
    3.方法内部如果抛出了多个异常对象,那么throws后边必须也声明多个异常
        如果抛出的多个异常对象有子父类关系,那么直接声明父类异常即可
    4.调用了一个声明抛出异常的方法,我们就必须的处理声明的异常
        要么继续使用throws声明抛出,交给方法的调用者处理,最终交给JVM
        要么try...catch自己处理异常

try...catch:异常处理的第二种方式,自己处理异常

    try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,异常异常对象之后,怎么处理异常对象
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){
    }

注意:
    1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
    2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码
      如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码

finally代码块

    try{
        可能产生异常的代码
    }catch(定义一个异常的变量,用来接收try中抛出的异常对象){
        异常的处理逻辑,异常异常对象之后,怎么处理异常对象
        一般在工作中,会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名 变量名){

    }finally{
        无论是否出现异常都会执行
    }

 注意:
    1.finally不能单独使用,必须和try一起使用
    2.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

　3.如果finally有return语句,永远返回finally中的结果,避免该情况.

多个异常使用捕获又该如何处理呢？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。

子父类的异常:

    - 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
    - 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
注意:
    父类异常时什么样,子类异常就什么样

自定义异常类:

    java提供的异常类,不够我们使用,需要自己定义一些异常类

public class XXXExcepiton extends Exception | RuntimeException{
        添加一个空参数的构造方法
        添加一个带异常信息的构造方法
    }

 注意:
    1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
    2.自定义异常类,必须的继承Exception或者RuntimeException
        继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
        继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)

 进程线程

主线程:执行主(main)方法的线程。
单线程程序:java程序中只有一个线程。
执行从main方法开始,从上到下依次执行。JVM执行main方法,main方法会进入到栈内存，JVM会找操作系统开辟一条main方法通向cpu的执行路径cpu就可以通过这个路径来执行main方法，而这个路径有一个名字,叫main(主)线程

创建多线程程序的第一种方式:创建Thread类的子类
java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类
实现步骤:
    1.创建一个Thread类的子类
    2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)
    3.创建Thread类的子类对象
    4.调用Thread类中的方法start方法,开启新的线程,执行run方法
         void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
         结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
         多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行

创建多线程程序的第二种方式:实现Runnable接口

java.lang.Runnable ：Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的 Thread 对象。
    Thread(Runnable target, String name) 分配新的 Thread 对象。
实现步骤:
    1.创建一个Runnable接口的实现类
    2.在实现类中重写Runnable接口的run方法,设置线程任务
    3.创建一个Runnable接口的实现类对象
    4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    5.调用Thread类中的start方法,开启新的线程执行run方法
实现Runnable接口创建多线程程序的好处:
    1.避免了单继承的局限性
        一个类只能继承一个类,类继承了Thread类就不能继承其他的类
        实现了Runnable接口,还可以继承其他的类,实现其他的接口
    2.增强了程序的扩展性,降低了程序的耦合性(解耦)
        实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
        实现类中,重写了run方法:用来设置线程任务
        创建Thread类对象,调用start方法:用来开启新线程

获取线程的名称:
    1.使用Thread类中的方法getName()
        String getName() 返回该线程的名称。
    2.可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称
        static Thread currentThread() 返回对当前正在执行的线程对象的引用。

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。毫秒数结束之后,线程继续执行

匿名内部类方式实现线程的创建（匿名:没有名字。内部类:写在其他类内部的类）
匿名内部类作用:简化代码
    把子类继承父类,重写父类的方法,创建子类对象合一步完成
    把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

   new 父类/接口(){
        重复父类/接口中的方法
    };

解决线程安全问题的一种方案:使用同步代码块

    synchronized(锁对象){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

注意:
    1.通过代码块中的锁对象,可以使用任意的对象
    2.但是必须保证多个线程使用的锁对象是同一个
    3.锁对象作用:
        把同步代码块锁住,只让一个线程在同步代码块中执行

解决线程安全问题的二种方案:使用同步方法
使用步骤:
    1.把访问了共享数据的代码抽取出来,放到一个方法中
    2.在方法上添加synchronized修饰符

修饰符 synchronized 返回值类型 方法名(参数列表){
    可能会出现线程安全问题的代码(访问了共享数据的代码)

Obejct类中的方法

void wait()
      在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void notify()
      唤醒在此对象监视器上等待的单个线程。
      会继续执行wait方法之后的代码

进入到TimeWaiting(计时等待)有两种方式
　　1.使用sleep(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
　　2.使用wait(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态
唤醒的方法:
     void notify() 唤醒在此对象监视器上等待的单个线程。
     void notifyAll() 唤醒在此对象监视器上等待的所有线程。

设置线程的名称:
    1.使用Thread类中的方法setName(名字)
        void setName(String name) 改变线程名称，使之与参数 name 相同。
    2.创建一个带参数的构造方法,参数传递线程的名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
        Thread(String name) 分配新的 Thread 对象。 

线程池:

JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
    static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
    参数:
        int nThreads:创建线程池中包含的线程数量
    返回值:
        ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.ExecutorService:线程池接口
    用来从线程池中获取线程,调用start方法,执行线程任务
        submit(Runnable task) 提交一个 Runnable 任务用于执行
    关闭/销毁线程池的方法
        void shutdown()
线程池的使用步骤:
    1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
    2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
    3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
    4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

Lambda表达式的标准格式:
    由三部分组成:
        a.一些参数
        b.一个箭头
        c.一段代码

(参数列表) -> {一些重写方法的代码};

    解释说明格式:
        ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
        ->:传递的意思,把参数传递给方法体{}
        {}:重写接口的抽象方法的方法体

Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
    1.(参数列表):括号中参数列表的数据类型,可以省略不写
    2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
    3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
        注意:要省略{},return,分号必须一起省略

递归

递归:方法自己调用自己
递归的分类:
    递归分为两种，直接递归和间接递归。
    直接递归称为方法自身调用自己。
    间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
注意事项：
    递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
    在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
    构造方法,禁止递归
递归的使用前提:
    当调用方法的时候,方法的主体不变,每次调用方法的参数不同,可以使用递归

文件处理

资源回收

java.io.File类

java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作
File类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法

static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
static char pathSeparatorChar 与系统有关的路径分隔符。
static String separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
static char separatorChar 与系统有关的默认名称分隔符。

操作路径:路径不能写死了
　　C:developaa.txt  windows
　　C:/develop/a/a.txt  linux
　　"C:"+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt"

路径分隔符 windows:分号;  linux:冒号:

文件名称分隔符 windows:反斜杠  linux:正斜杠/

路径:
    绝对路径:是一个完整的路径， 以盘符(c:,D:)开始的路径
    相对路径:是一个简化的路径
        相对指的是相对于当前项目的根目录
        如果使用当前项目的根目录,路径可以简化书写
    注意:
        1.路径是不区分大小写的
        2.路径中的文件名称分隔符：windows使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠

File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
参数:把路径分成了两部分
    File parent:父路径
    String child:子路径
好处:
     父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化
     父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象

File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
参数:
    String pathname:字符串的路径名称
    路径可以是以文件结尾,也可以是以文件夹结尾
    路径可以是相对路径,也可以是绝对路径
    路径可以是存在,也可以是不存在
    创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况

File类获取功能的方法
     public String getAbsolutePath() ：返回此File的绝对路径名字符串。获取的构造方法中传递的路径，无论路径是绝对的还是相对的,getAbsolutePath方法返回的都是绝对路径
     public String getPath() ：将此File转换为路径名字符串。获取的构造方法中传递的路径
     public String getName()  ：返回由此File表示的文件或目录的名称。获取的就是构造方法传递路径的结尾部分(文件/文件夹)
     public long length()  ：返回由此File表示的文件的长度。获取的是构造方法指定的文件的大小,以字节为单位

注意:
    文件夹是没有大小概念的,不能获取文件夹的大小
    如果构造方法中给出的路径不存在,那么length方法返回0

toString方法调用的就是getPath方法 

File类判断功能的方法
     public boolean exists() ：此File表示的文件或目录是否实际存在。用于判断构造方法中的路径是否存在
     public boolean isDirectory() ：此File表示的是否为目录。用于判断构造方法中给定的路径是否以文件夹结尾
     public boolean isFile() ：此File表示的是否为文件。用于判断构造方法中给定的路径是否以文件结尾

注意:
    电脑的硬盘中只有文件/文件夹,两个方法是互斥
    这两个方法使用前提,路径必须是存在的,否则都返回false

File类创建删除功能的方法
     public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。创建文件的路径和名称在构造方法中给出(构造方法的参数)
     public boolean delete() ：删除由此File表示的文件或目录。此方法,可以删除构造方法路径中给出的文件/文件夹
     public boolean mkdir() ：创建由此File表示的目录。
     public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。创建文件夹的路径和名称在构造方法中给出(构造方法的参数)

注意:
    delete方法是直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎

　createNewFile声明抛出了IOException,我们调用这个方法,就必须的处理这个异常,要么throws,要么trycatch

File类遍历(文件夹)目录功能
     public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
     public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。遍历构造方法中给出的目录,会获取目录中所有的文件/文件夹,把文件/文件夹封装为File对象,多个File对象存储到File数组中
注意:
    list方法和listFiles方法遍历的是构造方法中给出的目录
    如果构造方法中给出的目录的路径不存在,会抛出空指针异常
    如果构造方法中给出的路径不是一个目录,也会抛出空指针异常

 在File类中有两个和ListFiles重载的方法,方法的参数传递的就是过滤器

File[] listFiles(FileFilter filter)

java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器。
    作用:用来过滤文件(File对象)
    抽象方法:用来过滤文件的方法
        boolean accept(File pathname) 测试指定抽象路径名是否应该包含在某个路径名列表中。
        参数:
            File pathname:使用ListFiles方法遍历目录,得到的每一个文件对象

File[] listFiles(FilenameFilter filter)

java.io.FilenameFilter接口:实现此接口的类实例可用于过滤器文件名。
    作用:用于过滤文件名称
    抽象方法:用来过滤文件的方法
        boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中。
        参数:
            File dir:构造方法中传递的被遍历的目录
            String name:使用ListFiles方法遍历目录,获取的每一个文件/文件夹的名称
注意:
    两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法accept,在方法中自己定义过滤的规则

public String[] list() ：

返回一个String数组，表示该File目录中的所有子文件或目录。
遍历构造方法中给出的目录,会获取目录中所有文件/文件夹的名称,把获取到的多个名称存储到一个String类型的数组中

java.io.OutputStream:字节输出流

    此抽象类是表示输出字节流的所有类的超类。
定义了一些子类共性的成员方法:
      public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
      public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
      public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
      public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
      public abstract void write(int b) ：将指定的字节输出流。

FileOutputStream:文件字节输出流

java.io.FileOutputStream extends OutputStream
作用:把内存中的数据写入到硬盘的文件中
构造方法:
    FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
    FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    参数:写入数据的目的
        String name:目的地是一个文件的路径
        File file:目的地是一个文件
    构造方法的作用:
        1.创建一个FileOutputStream对象
        2.会根据构造方法中传递的文件/文件路径,创建一个空的文件
        3.会把FileOutputStream对象指向创建好的文件
写入数据的原理(内存-->硬盘)
    java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中
字节输出流的使用步骤(重点):
    1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
    2.调用FileOutputStream对象中的方法write,把数据写入到文件中
    3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

一次写多个字节的方法:
      public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

　　　　    如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
    　　 　  如果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
      public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

写入字符的方法:可以使用String类中的方法把字符串,转换为字节数组
    byte[] getBytes()  把字符串转换为字节数组

追加写/续写:使用两个参数的构造方法
    FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
    FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    参数:
       String name,File file:写入数据的目的地
       boolean append:追加写开关
        true:创建对象不会覆盖源文件,继续在文件的末尾追加写数据
        false:创建一个新文件,覆盖源文件

java.io.InputStream:字节输入流

此抽象类是表示字节输入流的所有类的超类。
定义了所有子类共性的方法:
     int read()从输入流中读取数据的下一个字节。
     int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
     void close() 关闭此输入流并释放与该流关联的所有系统资源。

FileInputStream:文件字节输入流

java.io.FileInputStream extends InputStream
作用:把硬盘文件中的数据,读取到内存中使用
构造方法:
    FileInputStream(String name)
    FileInputStream(File file)
    参数:读取文件的数据源
        String name:文件的路径
        File file:文件
    构造方法的作用:
        1.会创建一个FileInputStream对象
        2.会把FileInputStream对象指定构造方法中要读取的文件
读取数据的原理(硬盘-->内存)
    java程序-->JVM-->OS-->OS读取数据的方法-->读取文件
字节输入流的使用步骤(重点):
    1.创建FileInputStream对象,构造方法中绑定要读取的数据源
    2.使用FileInputStream对象中的方法read,读取文件
    3.释放资源

超重点：

　　布尔表达式(len = fis.read())!=-1
   　　 1.fis.read():读取一个字节
    　　2.len = fis.read():把读取到的字节赋值给变量len
   　　 3.(len = fis.read())!=-1:判断变量len是否不等于-1

字节输入流一次读取多个字节的方法:
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
明确两件事情:
    1.方法的参数byte[]的作用?
        起到缓冲作用,存储每次读取到的多个字节
        数组的长度一把定义为1024(1kb)或者1024的整数倍
    2.方法的返回值int是什么?
        每次读取的有效字节个数
String类的构造方法
    String(byte[] bytes) :把字节数组转换为字符串
    String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数

文件复制的步骤:
    1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
    2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
    3.使用字节输入流对象中的方法read读取文件
    4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
    5.释放资源 

java.io.Reader:字符输入流

是字符输入流的最顶层的父类,定义了一些共性的成员方法,是一个抽象类
共性的成员方法:
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。

FileReader:文件字符输入流

java.io.FileReader extends InputStreamReader extends Reader
作用:把硬盘文件中的数据以字符的方式读取到内存中
构造方法:
    FileReader(String fileName)
    FileReader(File file)
    参数:读取文件的数据源
        String fileName:文件的路径
        File file:一个文件
    FileReader构造方法的作用:
        1.创建一个FileReader对象
        2.会把FileReader对象指向要读取的文件
字符输入流的使用步骤:
    1.创建FileReader对象,构造方法中绑定要读取的数据源
    2.使用FileReader对象中的方法read读取文件
    3.释放资源

java.io.Writer:字符输出流

是字符输出流的最顶层的父类,定义了一些共性的成员方法,是一个抽象类
共性的成员方法:

　　void write(String str) 写入字符串。
　　void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。

　　void flush() 刷新该流的缓冲。
　　void close() 关闭此流，但要先刷新它。

FileWriter:文件字符输出流

java.io.FileWriter extends OutputStreamWriter extends Writer
作用:把内存中的数据以字符的方式写到硬盘文件中
构造方法:

　　FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。
　　FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称。

flush ：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

IO异常处理

在jdk1.7之前使用try catch finally 处理流中的异常

    try{
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }finally{
        一定会指定的代码
        资源释放
    }

JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally

   try(定义流对象;定义流对象....){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以释放掉,不用写finally

    A a = new A();
    B b = new B();
    try(a,b){
        可能会产出异常的代码
    }catch(异常类变量 变量名){
        异常的处理逻辑
    }

Properties 类表示了一个持久的属性集。

java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>

Properties 可保存在流中或从流中加载。
Properties集合是一个唯一和IO流相结合的集合
    可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
    可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
属性列表中每个键及其对应值都是一个字符串。
    Properties集合是一个双列集合,key和value默认都是字符串

可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用

void load(InputStream inStream)
void load(Reader reader)
参数:
    InputStream inStream:字节输入流,不能读取含有中文的键值对
    Reader reader:字符输入流,能读取含有中文的键值对
使用步骤:
    1.创建Properties集合对象
    2.使用Properties集合对象中的方法load读取保存键值对的文件
    3.遍历Properties集合
注意:
    1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
    2.存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取
    3.存储键值对的文件中,键与值默认都是字符串,不用再加引号

可以使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储

void store(OutputStream out, String comments)
void store(Writer writer, String comments)
参数:
    OutputStream out:字节输出流,不能写入中文
    Writer writer:字符输出流,可以写中文
    String comments:注释,用来解释说明保存的文件是做什么用的
            不能使用中文,会产生乱码,默认是Unicode编码
            一般使用""空字符串
使用步骤:
    1.创建Properties集合对象,添加数据
    2.创建字节输出流/字符输出流对象,构造方法中绑定要输出的目的地
    3.使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储
    4.释放资源

使用Properties集合存储数据,遍历取出Properties集合中的数据
Properties集合是一个双列集合,key和value默认都是字符串
Properties集合有一些操作字符串的特有方法
    Object setProperty(String key, String value) 调用 Hashtable 的方法 put。
    String getProperty(String key) 通过key找到value值,此方法相当于Map集合中的get(key)方法
    Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串,此方法相当于Map集合中的keySet方法

缓冲

BufferedOutputStream:字节缓冲输出流

java.io.BufferedOutputStream extends OutputStream
继承自父类的共性成员方法:
      public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
      public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
      public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
      public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
      public abstract void write(int b) ：将指定的字节输出流。
 构造方法:
    BufferedOutputStream(OutputStream out)  创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
    BufferedOutputStream(OutputStream out, int size)  创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
    参数:
       OutputStream out:字节输出流
            我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
       int size:指定缓冲流内部缓冲区的大小,不指定默认
 使用步骤
    1.创建FileOutputStream对象,构造方法中绑定要输出的目的地
    2.创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象对象,提高FileOutputStream对象效率
    3.使用BufferedOutputStream对象中的方法write,把数据写入到内部缓冲区中
    4.使用BufferedOutputStream对象中的方法flush,把内部缓冲区中的数据,刷新到文件中
    5.释放资源(会先调用flush方法刷新数据,第4部可以省略)

BufferedInputStream:字节缓冲输入流

java.io.BufferedInputStream extends InputStream
继承自父类的成员方法:
    int read()从输入流中读取数据的下一个字节。
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    void close() 关闭此输入流并释放与该流关联的所有系统资源。
构造方法:
    BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    参数:
        InputStream in:字节输入流
            我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的读取效率
        int size:指定缓冲流内部缓冲区的大小,不指定默认
使用步骤:
    1.创建FileInputStream对象,构造方法中绑定要读取的数据源
    2.创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高FileInputStream对象的读取效率
    3.使用BufferedInputStream对象中的方法read,读取文件
    4.释放资源

 BufferedWriter:字符缓冲输出流

java.io.BufferedWriter extends Writer
继承自父类的共性成员方法:
      void write(int c) 写入单个字符。
      void write(char[] cbuf)写入字符数组。
      abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
      void write(String str)写入字符串。
      void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
      void flush()刷新该流的缓冲。
      void close() 关闭此流，但要先刷新它。
构造方法:
    BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
    BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
    参数:
        Writer out:字符输出流
            我们可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
        int sz:指定缓冲区的大小,不写默认大小
特有的成员方法:
    void newLine() 写入一个行分隔符。会根据不同的操作系统,获取不同的行分隔符
 使用步骤:
    1.创建字符缓冲输出流对象,构造方法中传递字符输出流
    2.调用字符缓冲输出流中的方法write,把数据写入到内存缓冲区中
    3.调用字符缓冲输出流中的方法flush,把内存缓冲区中的数据,刷新到文件中
    4.释放资源

 BufferedReader:字符缓冲输入流

java.io.BufferedReader extends Reader
继承自父类的共性成员方法:
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。
 构造方法:
    BufferedReader(Reader in)  创建一个使用默认大小输入缓冲区的缓冲字符输入流。
    BufferedReader(Reader in, int sz)     创建一个使用指定大小输入缓冲区的缓冲字符输入流。
    参数:
        Reader in:字符输入流
            我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区,提高FileReader的读取效率
 特有的成员方法:
    String readLine() 读取一个文本行。读取一行数据
        行的终止符号:通过下列字符之一即可认为某行已终止：换行 (' ')、回车 (' ') 或回车后直接跟着换行( )。
    返回值:
        包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
 使用步骤:
    1.创建字符缓冲输入流对象,构造方法中传递字符输入流
    2.使用字符缓冲输入流对象中的方法read/readLine读取文本
    3.释放资源

编码问题

FileReader可以读取IDE默认编码格式(UTF-8)的文件
FileReader读取系统默认编码(中文GBK)会产生乱码���

java.io.OutputStreamWriter extends Writer

OutputStreamWriter: 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。(编码:把能看懂的变成看不懂)
继续自父类的共性成员方法:
      void write(int c) 写入单个字符。
      void write(char[] cbuf)写入字符数组。
      abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
      void write(String str)写入字符串。
     void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
      void flush()刷新该流的缓冲。
      void close() 关闭此流，但要先刷新它。
构造方法:
    OutputStreamWriter(OutputStream out)创建使用默认字符编码的 OutputStreamWriter。
    OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。
    参数:
        OutputStream out:字节输出流,可以用来写转换之后的字节到文件中
        String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,...不指定默认使用UTF-8
使用步骤:
    1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称
    2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储缓冲区中(编码)
    3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)
    4.释放资源

java.io.InputStreamReader extends Reader

InputStreamReader:是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。(解码:把看不懂的变成能看懂的)
继承自父类的共性成员方法:
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。
构造方法:
    InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
    InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。
    参数:
        InputStream in:字节输入流,用来读取文件中保存的字节
        String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,...不指定默认使用UTF-8
 使用步骤:
    1.创建InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称
    2.使用InputStreamReader对象中的方法read读取文件
    3.释放资源
 注意事项:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

 序列化

ObjectOutputStream:对象的序列化流

java.io.ObjectOutputStream extends OutputStream
作用:把对象以流的方式写入到文件中保存
构造方法:
    ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
    参数:
        OutputStream out:字节输出流
特有的成员方法:
    void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
使用步骤:
    1.创建ObjectOutputStream对象,构造方法中传递字节输出流
    2.使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
    3.释放资源

 ObjectInputStream:对象的反序列化流

java.io.ObjectInputStream extends InputStream
作用:把文件中保存的对象,以流的方式读取出来使用
构造方法:
    ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
    参数:
        InputStream in:字节输入流
特有的成员方法:
    Object readObject() 从 ObjectInputStream 读取对象。
使用步骤:
    1.创建ObjectInputStream对象,构造方法中传递字节输入流
    2.使用ObjectInputStream对象中的方法readObject读取保存对象的文件
    3.释放资源
    4.使用读取出来的对象(打印)
 readObject方法声明抛出了ClassNotFoundException(class文件找不到异常)
 当不存在对象的class文件时抛出此异常
 反序列化的前提:
    1.类必须实现Serializable
    2.必须存在类对应的class文件

Serializable 接口

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
Serializable接口也叫标记型接口
    要进行序列化和反序列化的类必须实现Serializable接口,就会给类添加一个标记
    当我们进行序列化和反序列化的时候,就会检测类上是否有这个标记
        有:就可以序列化和反序列化
        没有:就会抛出 NotSerializableException异常
static关键字:静态关键字
    静态优先于非静态加载到内存中(静态优先于对象进入到内存中)
    被static修饰的成员变量不能被序列化的,序列化的都是对象
transient关键字:瞬态关键字
    被transient修饰成员变量,不能被序列化

 打印流

java.io.PrintStream:打印流
    PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
PrintStream特点:
    1.只负责数据的输出,不负责数据的读取
    2.与其他输出流不同，PrintStream 永远不会抛出 IOException
    3.有特有的方法,print,println
构造方法:
    PrintStream(File file):输出的目的地是一个文件
    PrintStream(OutputStream out):输出的目的地是一个字节输出流
    PrintStream(String fileName) :输出的目的地是一个文件路径
PrintStream extends OutputStream
继承自父类的成员方法:
      public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
      public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
      public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
      public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
      public abstract void write(int b) ：将指定的字节输出流。
注意:
    如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
    如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

可以改变输出语句的目的地(打印流的流向)：
　　输出语句,默认在控制台输出
　　使用System.setOut方法改变输出语句的目的地改为参数中传递的打印流的目的地
    　　static void setOut(PrintStream out)  重新分配“标准”输出流。

网络编程入门

客户端

TCP通信的客户端:向服务器发送连接请求,给服务器发送数据,读取服务器回写的数据
表示客户端的类:
    java.net.Socket:此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
    套接字:包含了IP地址和端口号的网络单位
构造方法:
    Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。
    参数:
        String host:服务器主机的名称/服务器的IP地址
        int port:服务器的端口号
成员方法:
    OutputStream getOutputStream() 返回此套接字的输出流。
    InputStream getInputStream() 返回此套接字的输入流。
    void close() 关闭此套接字。
实现步骤:
    1.创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
    2.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    3.使用网络字节输出流OutputStream对象中的方法write,给服务器发送数据
    4.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    5.使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
    6.释放资源(Socket)
 注意:
    1.客户端和服务器端进行交互,必须使用Socket中提供的网络流,不能使用自己创建的流对象
    2.当我们创建客户端对象Socket的时候,就会去请求服务器和服务器经过3次握手建立连接通路
        这时如果服务器没有启动,那么就会抛出异常ConnectException: Connection refused: connect
        如果服务器已经启动,那么就可以进行交互了

 服务端

TCP通信的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据
表示服务器的类:
    java.net.ServerSocket:此类实现服务器套接字。
构造方法:
    ServerSocket(int port) 创建绑定到特定端口的服务器套接字。
服务器端必须明确一件事情,必须的知道是哪个客户端请求的服务器
所以可以使用accept方法获取到请求的客户端对象Socket
成员方法:
    Socket accept() 侦听并接受到此套接字的连接。
服务器的实现步骤:
    1.创建服务器ServerSocket对象和系统要指定的端口号
    2.使用ServerSocket对象中的方法accept,获取到请求的客户端对象Socket
    3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
    4.使用网络字节输入流InputStream对象中的方法read,读取客户端发送的数据
    5.使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
    6.使用网络字节输出流OutputStream对象中的方法write,给客户端回写数据
    7.释放资源(Socket,ServerSocket)

①客户端

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/*
    文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器回写的数据

    明确:
        数据源:c:\1.jpg
        目的地:服务器

    实现步骤:
        1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
        3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
        4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
        5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
        6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        8.释放资源(FileInputStream,Socket)
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        //1.创建一个本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\1.jpg");
        //2.创建一个客户端Socket对象,构造方法中绑定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);
        //3.使用Socket中的方法getOutputStream,获取网络字节输出流OutputStream对象
        OutputStream os = socket.getOutputStream();
        //4.使用本地字节输入流FileInputStream对象中的方法read,读取本地文件
        int len = 0;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes))!=-1){
            //5.使用网络字节输出流OutputStream对象中的方法write,把读取到的文件上传到服务器
            os.write(bytes,0,len);
        }

        /*
            解决:上传完文件,给服务器写一个结束标记
            void shutdownOutput() 禁用此套接字的输出流。
            对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。
         */
        socket.shutdownOutput();

        //6.使用Socket中的方法getInputStream,获取网络字节输入流InputStream对象
        InputStream is = socket.getInputStream();



        //7.使用网络字节输入流InputStream对象中的方法read读取服务回写的数据
        while((len = is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


        //8.释放资源(FileInputStream,Socket)
        fis.close();
        socket.close();
    }
}
②服务器端

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

/*
    文件上传案例服务器端:读取客户端上传的文件,保存到服务器的硬盘,给客户端回写"上传成功"

    明确:
        数据源:客户端上传的文件
        目的地:服务器的硬盘 d:\upload\1.jpg

    实现步骤:
        1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象
        3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
        4.判断d:\upload文件夹是否存在,不存在则创建
        5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
        6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件
        7.使用本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
        8.使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
        9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
        10.释放资源(FileOutputStream,Socket,ServerSocket)
 */
public class TCPServer {
    public static void main(String[] args) throws IOException {
        //1.创建一个服务器ServerSocket对象,和系统要指定的端口号
        ServerSocket server = new ServerSocket(8888);
        //2.使用ServerSocket对象中的方法accept,获取到请求的客户端Socket对象

        /*
            让服务器一直处于监听状态(死循环accept方法)
            有一个客户端上传文件,就保存一个文件
         */
        while(true){
            Socket socket = server.accept();

            /*
                使用多线程技术,提高程序的效率
                有一个客户端上传文件,就开启一个线程,完成文件的上传
             */
            new Thread(new Runnable() {
                //完成文件的上传
                @Override
                public void run() {
                   try {
                       //3.使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
                       InputStream is = socket.getInputStream();
                       //4.判断d:\upload文件夹是否存在,不存在则创建
                       File file =  new File("d:\upload");
                       if(!file.exists()){
                           file.mkdirs();
                       }

                    /*
                        自定义一个文件的命名规则:防止同名的文件被覆盖
                        规则:域名+毫秒值+随机数
                     */
                       String fileName = "itcast"+System.currentTimeMillis()+new Random().nextInt(999999)+".jpg";

                       //5.创建一个本地字节输出流FileOutputStream对象,构造方法中绑定要输出的目的地
                       //FileOutputStream fos = new FileOutputStream(file+"\1.jpg");
                       FileOutputStream fos = new FileOutputStream(file+"\"+fileName);
                       //6.使用网络字节输入流InputStream对象中的方法read,读取客户端上传的文件


                       int len =0;
                       byte[] bytes = new byte[1024];
                       while((len = is.read(bytes))!=-1){
                           //7.使用本地字节输出流FileOutputStream对象中的方法write,把读取到的文件保存到服务器的硬盘上
                           fos.write(bytes,0,len);
                       }


                       //8.使用Socket对象中的方法getOutputStream,获取到网络字节输出流OutputStream对象
                       //9.使用网络字节输出流OutputStream对象中的方法write,给客户端回写"上传成功"
                       socket.getOutputStream().write("上传成功".getBytes());
                       //10.释放资源(FileOutputStream,Socket,ServerSocket)
                       fos.close();
                       socket.close();
                   }catch (IOException e){
                       System.out.println(e);
                   }
                }
            }).start();


        }

        //服务器就不用关闭
        //server.close();
    }
}

package com.itheima.demo04.BSTCP;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/*
    创建BS版本TCP服务器
 */
public class TCPServerThread {
    public static void main(String[] args) throws IOException {
        //创建一个服务器ServerSocket,和系统要指定的端口号
        ServerSocket server = new ServerSocket(8080);
        /*
            浏览器解析服务器回写的html页面,页面中如果有图片,那么浏览器就会单独的开启一个线程,读取服务器的图片
            我们就的让服务器一直处于监听状态,客户端请求一次,服务器就回写一次
         */
        while(true){
            //使用accept方法获取到请求的客户端对象(浏览器)
            Socket socket = server.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        //使用Socket对象中的方法getInputStream,获取到网络字节输入流InputStream对象
                        InputStream is = socket.getInputStream();
                        //使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
                        /*byte[] bytes = new byte[1024];
                        int len = 0;
                        while((len = is.read(bytes))!=-1){
                            System.out.println(new String(bytes,0,len));
                        }*/

                        //把is网络字节输入流对象,转换为字符缓冲输入流
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        //把客户端请求信息的第一行读取出来 GET /11_Net/web/index.html HTTP/1.1
                        String line = br.readLine();
                        System.out.println(line);
                        //把读取的信息进行切割,只要中间部分 /11_Net/web/index.html
                        String[] arr = line.split(" ");
                        //把路径前边的/去掉,进行截取 11_Net/web/index.html
                        String htmlpath =arr[1].substring(1);

                        //创建一个本地字节输入流,构造方法中绑定要读取的html路径
                        FileInputStream fis = new FileInputStream(htmlpath);
                        //使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
                        OutputStream os = socket.getOutputStream();

                        // 写入HTTP协议响应头,固定写法
                        os.write("HTTP/1.1 200 OK
".getBytes());
                        os.write("Content-Type:text/html
".getBytes());
                        // 必须要写入空行,否则浏览器不解析
                        os.write("
".getBytes());

                        //一读一写复制文件,把服务读取的html文件回写到客户端
                        int len = 0;
                        byte[] bytes = new byte[1024];
                        while((len = fis.read(bytes))!=-1){
                            os.write(bytes,0,len);
                        }

                        //释放资源
                        fis.close();
                        socket.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        //server.close();
    }
}

 函数式接口

函数式接口

函数式接口:有且只有一个抽象方法的接口,称之为函数式接口。
当然接口中可以包含其他的方法(默认,静态,私有)
@FunctionalInterface注解
作用:可以检测接口是否是一个函数式接口
    是:编译成功
    否:编译失败(接口中没有抽象方法抽象方法的个数多余1个)

Lambda的特点:延迟加载
Lambda的使用前提,必须存在函数式接口

如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。

常用的函数式接口

①

java.util.function.Supplier<T>接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。
Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据

①

import java.util.function.Supplier;

/*

 */
public class Demo01Supplier {
    //定义一个方法,方法的参数传递Supplier<T>接口,泛型执行String,get方法就会返回一个String
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    public static void main(String[] args) {
        //调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
        String s = getString(()->{
            //生产一个字符串,并返回
            return "胡歌";
        });
        System.out.println(s);

        //优化Lambda表达式
        String s2 = getString(()->"胡歌");
        System.out.println(s2);
    }
}
②

import java.util.function.Supplier;

/*
    练习：求数组元素最大值
        使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
        提示：接口的泛型请使用java.lang.Integer类。
 */
public class Demo02Test {
   //定义一个方法,用于获取int类型数组中元素的最大值,方法的参数传递Supplier接口,泛型使用Integer
   public static int getMax(Supplier<Integer> sup){
       return sup.get();
   }

    public static void main(String[] args) {
        //定义一个int类型的数组,并赋值
        int[] arr = {100,0,-50,880,99,33,-30};
        //调用getMax方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
        int maxValue = getMax(()->{
            //获取数组的最大值,并返回
            //定义一个变量,把数组中的第一个元素赋值给该变量,记录数组中元素的最大值
            int max = arr[0];
            //遍历数组,获取数组中的其他元素
            for (int i : arr) {
                //使用其他的元素和最大值比较
                if(i>max){
                    //如果i大于max,则替换max作为最大值
                    max = i;
                }
            }
            //返回最大值
            return max;
        });
        System.out.println("数组中元素的最大值是:"+maxValue);
    }
}

 ②

java.util.function.Consumer<T>接口则正好与Supplier接口相反， 它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
 Consumer接口中包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。
Consumer接口是一个消费型接口,泛型执行什么类型,就可以使用accept方法消费什么类型的数据至于具体怎么消费(使用),需要自定义(输出,计算....)

Consumer接口的默认方法andThen
作用:需要两个Consumer接口,可以把两个Consumer接口组合到一起,在对数据进行消费

①

import java.util.function.Consumer;

/*

 */
public class Demo01Consumer {
    /*
        定义一个方法
        方法的参数传递一个字符串的姓名
        方法的参数传递Consumer接口,泛型使用String
        可以使用Consumer接口消费字符串的姓名
     */
    public static void method(String name, Consumer<String> con){
        con.accept(name);
    }

    public static void main(String[] args) {
        //调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,所以可以传递Lambda表达式
        method("赵丽颖",(String name)->{
            //对传递的字符串进行消费
            //消费方式:直接输出字符串
            //System.out.println(name);

            //消费方式:把字符串进行反转输出
            String reName = new StringBuffer(name).reverse().toString();
            System.out.println(reName);
        });
    }
}
②
import java.util.function.Consumer;

/*

   例如:
    Consumer<String> con1
    Consumer<String> con2
    String s = "hello";
    con1.accept(s);
    con2.accept(s);
    连接两个Consumer接口  再进行消费
    con1.andThen(con2).accept(s); 谁写前边谁先消费
*/
public class Demo02AndThen {
    //定义一个方法,方法的参数传递一个字符串和两个Consumer接口,Consumer接口的泛型使用字符串
    public static void method(String s, Consumer<String> con1 ,Consumer<String> con2){
        //con1.accept(s);
        //con2.accept(s);
        //使用andThen方法,把两个Consumer接口连接到一起,在消费数据
        con1.andThen(con2).accept(s);//con1连接con2,先执行con1消费数据,在执行con2消费数据
    }

    public static void main(String[] args) {
        //调用method方法,传递一个字符串,两个Lambda表达式
        method("Hello",
                (t)->{
                    //消费方式:把字符串转换为大写输出
                    System.out.println(t.toUpperCase());
                },
                (t)->{
                    //消费方式:把字符串转换为小写输出
                    System.out.println(t.toLowerCase());
                });
    }
}

③

java.util.function.Predicate<T>接口
作用:对某种数据类型的数据进行判断,结果返回一个boolean值
Predicate接口中包含一个抽象方法： boolean test(T t):用来对指定数据类型数据进行判断的方法

Predicate接口中有一个方法and,表示并且关系,也可以用于连接两个判断条件

Predicate接口中有一个方法or,表示或者关系,也可以用于连接两个判断条件

Predicate接口中有一个方法negate,也表示取反的意思

①

import java.util.function.Predicate;

/*

*/
public class Demo01Predicate {
    /*
        定义一个方法
        参数传递一个String类型的字符串
        传递一个Predicate接口,泛型使用String
        使用Predicate中的方法test对字符串进行判断,并把判断的结果返回
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return  pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcdef";

        //调用checkString方法对字符串进行校验,参数传递字符串和Lambda表达式
        /*boolean b = checkString(s,(String str)->{
            //对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
            return str.length()>5;
        });*/

        //优化Lambda表达式
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);
    }
}
②

import java.util.function.Predicate;

/*
    逻辑表达式:可以连接多个判断的条件
    &&:与运算符,有false则false
    ||:或运算符,有true则true
    !:非(取反)运算符,非真则假,非假则真

    需求:判断一个字符串,有两个判断的条件
        1.判断字符串的长度是否大于5
        2.判断字符串中是否包含a
    两个条件必须同时满足,我们就可以使用&&运算符连接两个条件


    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> this.test(t) && other.test(t);
    }
    方法内部的两个判断条件,也是使用&&运算符连接起来的
 */
public class Demo02Predicate_and {
    /*
        定义一个方法,方法的参数,传递一个字符串
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            两个条件必须同时满足
     */
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        //return pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);//等价于return pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abcdef";
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}
③

import java.util.function.Predicate;

/*
     需求:判断一个字符串,有两个判断的条件
        1.判断字符串的长度是否大于5
        2.判断字符串中是否包含a
    满足一个条件即可,我们就可以使用||运算符连接两个条件


    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    方法内部的两个判断条件,也是使用||运算符连接起来的
 */
public class Demo03Predicate_or {
    /*
            定义一个方法,方法的参数,传递一个字符串
            传递两个Predicate接口
                一个用于判断字符串的长度是否大于5
                一个用于判断字符串中是否包含a
                满足一个条件即可
         */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
        //return pre1.test(s) || pre2.test(s);
        return  pre1.or(pre2).test(s);//等价于return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "bc";
        //调用checkString方法,参数传递字符串和两个Lambda表达式
        boolean b = checkString(s,(String str)->{
            //判断字符串的长度是否大于5
            return str.length()>5;
        },(String str)->{
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}
④

import java.util.function.Predicate;

/*
    需求:判断一个字符串长度是否大于5
        如果字符串的长度大于5,那返回false
        如果字符串的长度不大于5,那么返回true
    所以我们可以使用取反符号!对判断的结果进行取反


    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
 */
public class Demo04Predicate_negate {
    /*
           定义一个方法,方法的参数,传递一个字符串
           使用Predicate接口判断字符串的长度是否大于5
    */
    public static boolean checkString(String s, Predicate<String> pre){
        //return !pre.test(s);
        return  pre.negate().test(s);//等效于return !pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abc";
        //调用checkString方法,参数传递字符串和Lambda表达式
        boolean b = checkString(s,(String str)->{
            //判断字符串的长度是否大于5,并返回结果
            return str.length()>5;
        });
        System.out.println(b);
    }
}
⑤

import java.util.ArrayList;
import java.util.function.Predicate;

/*
    练习：集合信息筛选
    数组当中有多条“姓名+性别”的信息如下，
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
    请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
    需要同时满足两个条件：
        1. 必须为女生；
        2. 姓名为4个字。

    分析:
        1.有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
        2.必须同时满足两个条件,所以可以使用and方法连接两个判断条件
 */
public class Demo05Test {
    /*
        定义一个方法
        方法的参数传递一个包含人员信息的数组
        传递两个Predicate接口,用于对数组中的信息进行过滤
        把满足条件的信息存到ArrayList集合中并返回
     */
    public static ArrayList<String> filter(String[] arr,Predicate<String> pre1,Predicate<String> pre2){
        //定义一个ArrayList集合,存储过滤之后的信息
        ArrayList<String> list = new ArrayList<>();
        //遍历数组,获取数组中的每一条信息
        for (String s : arr) {
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            //对得到的布尔值进行判断
            if(b){
                //条件成立,两个条件都满足,把信息存储到ArrayList集合中
                list.add(s);
            }
        }
        //把集合返回
        return list;
    }

    public static void main(String[] args) {
        //定义一个储存字符串的数组
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
        //调用filter方法,传递字符串数组和两个Lambda表达式
        ArrayList<String> list = filter(array,(String s)->{
            //获取字符串中的性别,判断是否为女
           return s.split(",")[1].equals("女");
        },(String s)->{
            //获取字符串中的姓名,判断长度是否为4个字符
           return s.split(",")[0].length()==4;
        });
        //遍历集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

 ④

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。
Function接口中最主要的抽象方法为：R apply(T t)，根据类型T的参数获取类型R的结果。使用的场景例如：将String类型转换为Integer类型。

Function接口中的默认方法andThen:用来进行组合操作

①
import java.util.function.Function;

/*

 */
public class Demo01Function {
    /*
        定义一个方法
        方法的参数传递一个字符串类型的整数
        方法的参数传递一个Function接口,泛型使用<String,Integer>
        使用Function接口中的方法apply,把字符串类型的整数,转换为Integer类型的整数
     */
    public static void change(String s, Function<String,Integer> fun){
        //Integer in = fun.apply(s);
        int in = fun.apply(s);//自动拆箱 Integer->int
        System.out.println(in);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "1234";
        //调用change方法,传递字符串类型的整数,和Lambda表达式
        change(s,(String str)->{
            //把字符串类型的整数,转换为Integer类型的整数返回
            return Integer.parseInt(str);
        });
        //优化Lambda
        change(s,str->Integer.parseInt(str));
    }
}
②

import java.util.function.Function;

/*


    需求:
        把String类型的"123",转换为Inteter类型,把转换后的结果加10
        把增加之后的Integer类型的数据,转换为String类型

    分析:
        转换了两次
        第一次是把String类型转换为了Integer类型
            所以我们可以使用Function<String,Integer> fun1
                Integer i = fun1.apply("123")+10;
        第二次是把Integer类型转换为String类型
            所以我们可以使用Function<Integer,String> fun2
                String s = fun2.apply(i);
        我们可以使用andThen方法,把两次转换组合在一起使用
            String s = fun1.andThen(fun2).apply("123");
            fun1先调用apply方法,把字符串转换为Integer
            fun2再调用apply方法,把Integer转换为字符串
 */
public class Demo02Function_andThen {
    /*
        定义一个方法
        参数串一个字符串类型的整数
        参数再传递两个Function接口
            一个泛型使用Function<String,Integer>
            一个泛型使用Function<Integer,String>
     */
    public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static void main(String[] args) {
        //定义一个字符串类型的整数
        String s = "123";
        //调用change方法,传递字符串和两个Lambda表达式
        change(s,(String str)->{
            //把字符串转换为整数+10
            return Integer.parseInt(str)+10;
        },(Integer i)->{
            //把整数转换为字符串
            return i+"";
        });

        //优化Lambda表达式
        change(s,str->Integer.parseInt(str)+10,i->i+"");
    }
}
③
import java.util.function.Function;

/*
    练习：自定义函数模型拼接
    题目
    请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
        String str = "赵丽颖,20";

    分析:
    1. 将字符串截取数字年龄部分，得到字符串；
        Function<String,String> "赵丽颖,20"->"20"
    2. 将上一步的字符串转换成为int类型的数字；
        Function<String,Integer> "20"->20
    3. 将上一步的int数字累加100，得到结果int数字。
        Function<Integer,Integer> 20->120
 */
public class Demo03Test {
    /*
        定义一个方法
        参数传递包含姓名和年龄的字符串
        参数再传递3个Function接口用于类型转换
     */
    public static int change(String s, Function<String,String> fun1,
                             Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        //使用andThen方法把三个转换组合到一起
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String str = "赵丽颖,20";
        //调用change方法,参数传递字符串和3个Lambda表达式
        int num = change(str,(String s)->{
            //"赵丽颖,20"->"20"
           return s.split(",")[1];
        },(String s)->{
            //"20"->20
            return Integer.parseInt(s);
        },(Integer i)->{
            //20->120
            return i+100;
        });
        System.out.println(num);
    }
}

Stream流

使用Stream流的方式,遍历集合,对集合中的数据进行过滤
关注的是做什么,而不是怎么做

java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：
     所有的Collection集合都可以通过stream默认方法获取流；default Stream<E> stream​()
     Stream接口的静态方法of可以获取数组对应的流。 static <T> Stream<T> of​(T... values)参数是一个可变参数

1、Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤
　　Stream<T> filter(Predicate<? super T> predicate);
filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤

2、Stream流中的常用方法_count:用于统计Stream流中元素的个数
　　long count();
count方法是一个终结方法,返回值是一个long类型的整数
所以不能再继续调用Stream流中的其他方法了

3、Stream流中的常用方法_limit:用于截取流中的元素
limit方法可以对流进行截取，只取用前n个。方法签名：
　　Stream<T> limit(long maxSize);
参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作
limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法

4、Stream流中的常用方法_skip:用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
　　Stream<T> skip(long n);
 如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

5、Stream流中的常用方法_concat:用于把流组合到一起

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

 方法引用

1、通过对象名引用成员方法

①
/*
    通过对象名引用成员方法
    使用前提是对象名是已经存在的,成员方法也是已经存在
    就可以使用对象名来引用成员方法
 */
public class Demo01ObjectMethodReference {
    //定义一个方法,方法的参数传递Printable接口
    public static void printString(Printable p){
        p.print("Hello");
    }

    public static void main(String[] args) {
        //调用printString方法,方法的参数Printable是一个函数式接口,所以可以传递Lambda表达式
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            //调用MethodRerObject对象中的成员方法printUpperCaseString,把字符串按照大写输出
            obj.printUpperCaseString(s);
        });

        /*
            使用方法引用优化Lambda
            对象是已经存在的MethodRerObject
            成员方法也是已经存在的printUpperCaseString
            所以我们可以使用对象名引用成员方法
         */
        //创建MethodRerObject对象
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCaseString);
    }
}
②
public class MethodRerObject {
    //定义一个成员方法,传递字符串,把字符串按照大写输出
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}
③
/*
    定义一个打印的函数式接口
 */
@FunctionalInterface
public interface Printable {
    //定义字符串的抽象方法
    void print(String s);
}

2、通过类名称引用静态方法

①

/*
    通过类名引用静态成员方法
    类已经存在,静态成员方法也已经存在
    就可以通过类名直接引用静态成员方法
 */
public class Demo01StaticMethodReference {
    //定义一个方法,方法的参数传递要计算绝对值的整数,和函数式接口Calcable
    public static int method(int number,Calcable c){
       return c.calsAbs(number);
    }

    public static void main(String[] args) {
        //调用method方法,传递计算绝对值得整数,和Lambda表达式
        int number = method(-10,(n)->{
            //对参数进行绝对值得计算并返回结果
            return Math.abs(n);
        });
        System.out.println(number);

        /*
            使用方法引用优化Lambda表达式
            Math类是存在的
            abs计算绝对值的静态方法也是已经存在的
            所以我们可以直接通过类名引用静态方法
         */
        int number2 = method(-10,Math::abs);
        System.out.println(number2);
    }
}
②

@FunctionalInterface
public interface Calcable {
    //定义一个抽象方法,传递一个整数,对整数进行绝对值计算并返回
    int calsAbs(int number);
}

3、通过super引用成员方法

①
/*
    定义子类
 */
public class Man extends Human{
    //子类重写父类sayHello的方法
    @Override
    public void sayHello() {
        System.out.println("Hello 我是Man!");
    }

    //定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        //调用method方法,方法的参数Greetable是一个函数式接口,所以可以传递Lambda
        /*method(()->{
            //创建父类Human对象
            Human h = new Human();
            //调用父类的sayHello方法
            h.sayHello();
        });*/

        //因为有子父类关系,所以存在的一个关键字super,代表父类,所以我们可以直接使用super调用父类的成员方法
       /* method(()->{
            super.sayHello();
        });*/

      /*
           使用super引用类的成员方法
           super是已经存在的
           父类的成员方法sayHello也是已经存在的
           所以我们可以直接使用super引用父类的成员方法
       */
      method(super::sayHello);
    }

    public static void main(String[] args) {
        new Man().show();
    }
}
②
/*
    定义父类
 */
public class Human {
    //定义一个sayHello的方法
    public void sayHello(){
        System.out.println("Hello 我是Human!");
    }
}
③
/*
    定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
    //定义一个见面的方法
    void greet();
}

4、通过this引用成员方法

①
/*
    使用this引用本类的成员方法
 */
public class Husband {
    //定义一个买房子的方法
    public void buyHouse(){
        System.out.println("北京二环内买一套四合院!");
    }

    //定义一个结婚的方法,参数传递Richable接口
    public void marry(Richable r){
        r.buy();
    }

    //定义一个非常高兴的方法
    public void soHappy(){
        //调用结婚的方法,方法的参数Richable是一个函数式接口,传递Lambda表达式
       /* marry(()->{
            //使用this.成员方法,调用本类买房子的方法
            this.buyHouse();
        });*/

        /*
            使用方法引用优化Lambda表达式
            this是已经存在的
            本类的成员方法buyHouse也是已经存在的
            所以我们可以直接使用this引用本类的成员方法buyHouse
         */
        marry(this::buyHouse);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }
}
②
/*
    定义一个富有的函数式接口
 */
@FunctionalInterface
public interface Richable {
    //定义一个想买什么就买什么的方法
    void buy();
}

5、类的构造器引用

①
/*
    类的构造器(构造方法)引用
 */
public class Demo {
    //定义一个方法,参数传递姓名和PersonBuilder接口,方法中通过姓名创建Person对象
    public static void printName(String name,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //调用printName方法,方法的参数PersonBuilder接口是一个函数式接口,可以传递Lambda
        printName("迪丽热巴",(String name)->{
            return new Person(name);
        });

        /*
            使用方法引用优化Lambda表达式
            构造方法new Person(String name) 已知
            创建对象已知 new
            就可以使用Person引用new创建对象
         */
        printName("古力娜扎",Person::new);//使用Person类的带参构造方法,通过传递的姓名创建对象
    }
}
②

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
③
/*
    定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    //定义一个方法,根据传递的姓名,创建Person对象返回
    Person builderPerson(String name);
}

6、数组的构造器引用

①

import java.util.Arrays;

/*
    数组的构造器引用
 */
public class Demo {
    /*
        定义一个方法
        方法的参数传递创建数组的长度和ArrayBuilder接口
        方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
     */
    public static int[] createArray(int length, ArrayBuilder ab){
        return  ab.builderArray(length);
    }

    public static void main(String[] args) {
        //调用createArray方法,传递数组的长度和Lambda表达式
        int[] arr1 = createArray(10,(len)->{
            //根据数组的长度,创建数组并返回
            return new int[len];
        });
        System.out.println(arr1.length);//10

        /*
            使用方法引用优化Lambda表达式
            已知创建的就是int[]数组
            数组的长度也是已知的
            就可以使用方法引用
            int[]引用new,根据参数传递的长度来创建数组
         */
        int[] arr2 =createArray(10,int[]::new);
        System.out.println(Arrays.toString(arr2));
        System.out.println(arr2.length);//10
    }
}
②
/*
    定义一个创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
    //定义一个创建int类型数组的方法,参数传递数组的长度,返回创建好的int类型数组
    int[] builderArray(int length);
}

好