javase

day01

1.     MS-DOS

       命令提示符（cmd）

       启动：                        Win+R，输入cmd回车

       切换盘符：               盘符名称：

       进入文件夹：          cd 文件夹名称

       进入多级文件夹：  cd 文件夹1\文件夹2\文件夹3

       返回上一级：          cd ..

       直接回根路径：      cd \

       查看当前内容：      dir

       清屏：                        cls

       退出：                        exit

2.     标识符：程序中自己定义的内容（类的名称（大驼峰式）、方法、变量的名字（小驼峰式）……）

3.     关键字特点：完全小写的字母，有特殊颜色

4.     java的数据类型分为两大类：

                  基本数据类型：四类八种

         字节型（byte）                      一个字节                 -128~127

         短整型（short）                     两个字节                 -32768~32767

         整形（int）                              四个字节                 -21亿~21亿

         长整型（long）                       八个字节                 

         单精度浮点数（float）         四个字节                 1.4013E-45~3.4028E+38

         双精度浮点数（double）     八个字节                 4.9E-324~1.7977E+38

         字符型（char）                      两个字节                 0~65535

         布尔类型（boolean）           1个字节                  true，false

                  引用数据类型：类，数组，接口

5.     float：需在数字后加F          long：需在数字后加L

day02

1.     “+”特殊用法：对于char类型，计算前会被提升为int，然后计算。

2.     char类型字符、int类型数字关系对照表：ASCLL、Unicode

3.     0--48  A--65  a--97

4.     常量优化：short sum=5+8； 13没有超出short范围，不会报错，即编译器的常量优化。（但是一旦有变量参与，就不能进行这种优化了）

5.      一元运算符：只需一个数据就可以进行操作的运算符。例如：取反！、自增++……

6.     二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=……

7.     三元运算符：需要三个数据才可以进行操作的运算符。

8.     三元运算符格式：数据类型 变量名称=条件判断？表达式A：表达式B

9.     复合赋值运算符：(其中隐含了一个强制类型转换)

+=         a+=3        a=a+3

%=         b%=4       b=b%4

10.   逻辑运算符：

    与（并且） &&、或（或者）||  二者具有短路效果，左边若可得到结果，右边不执行        非（取反） ！   true变false，false变true

    （与、或：如果有多个条件可以连写）  

11.  数据类型转换：

自动类型转换（隐式）：自动完成，由小到大

强制类型转换（显示）：double a=(double)10;(不推荐使用：数据溢出，精度损失)

day03

1.break：switch中，一旦执行，整个switch语句立刻结束。

循环语句中，一旦执行，循环结束

（循环次数确定多用for循环，否则while）

 continue:一旦执行，跳过当前次循环剩余内容，马上开始下一次循环

2.                     do while循环：

 j=0

do{

循环体

j++

}  while(j<10)

3.switch:前后可以颠倒，匹配到那个case就从那个位置向下执行，直到遇到break或整体结束为止。

4.死循环标准格式：

while(true){

循环体

}

day04

1.      IDEA常用快捷键：

Alt+Enter                                     导入包，自动修正代码

Ctrl+Y                                           删除光标所在行

Ctrl+D                                          复制光标所在行内容，插入到光标位置下面

Ctrl+Alt+L                                    格式化代码

Ctrl+/                                           单行注释，再按取消注释

Ctrl+SHIft+/                                选中代码多行注释，再按取消

Alt+Shift+上下箭头                  移动当前代码行

2.方法的三种调用：

单独调用：方法名称（参数）；        “无返回值只能单独调用”

打印调用：System.out.println(方法名称（参数）)；

赋值调用：数据类型 变量名称=方法名称（参数）；

3.     重载：一个方法名称，实现多个类似功能

与下列因素有关：参数个数不同；参数类型不同；参数多类型顺序不同

Day05

1.     java的内存划分（5个部分）：

栈（stack）：方法运行在栈中；

堆（Heap）：new出来的东西在堆中；

方法区（Method Area）：存储.class相关信息，包含方法信息；

本地方法栈（Native Method Stack）：与操作系统相关

寄存器（pc Register）:与CPU相关。

2.     动态初始化数组：数据类型[] 数据名称=new 数据类型[数据长度]；

（初始化时有默认值：

整数类型：0

浮点类型：0.0

字符类型：‘\u0000’

布尔类型：false

引用类型：null）

3.     静态初始化数组：数据类型[] 数据名称=new 数据类型[] {元素1，元素2......}   

（内容确定用静态初始化）

（初始化时系统马上将默认值替换为大括号中的数值）

4.     数组名称.Length     代表数组长度

Day06

1.     间接访问private成员变量，就是定义一对Getter/Setter方法             （Alt+Insert）

2.     根据类创建对象：

导包：import 包名称.类名称；（与类属于同一个包，可省略导包语句）

创建：类名称 对象名 = new 类名称（）；

使用：对象名.成员方法名（参数）/对象名.成员变量名

3.     面向对象三大特征：封装、继承、多态。 （方法、关键字private都是一种封装）

Day07

1.     数组长度不可以发生变化，ArrayList<E>集合的长度可以随意变化。

2.     <E>泛型：只能是引用类型，不能是基本类型。

3.     向ArrayList中存储基本数据类型，必须使用对应的“包装类”

Byte(Byte)  short(Short)   long(Long)  float(Float)  double(Double)

Boolean(Boolean)  特殊的：char(Character)  int(Integer) 

4.     ArrayList直接打印得到的不是地址值，而是内容。无内容得到[]

5.     对于引用类型，==进行的是地址值的比较。

6.     Scanner类：实现键盘输入数据到程序中。

Day08

1.     Java.util.Arrays工具类：

public static String toString(数组)：将参数数组变成字符串[元素1，元素2......]

Public static void sort(数组)：升序排序数组元素。

2.     Java.util.Math 工具类：

Math.abs(double num):获取绝对值

Math.ceil(double num):向上取整

Math.floor(double num):向下取整

Math.round(double num):四舍五入

Math.PI代表近似圆周率

3.     一旦用了static关键字，那么这样的内容不再属于自己，而属于类。凡是本类的对象，都共享同一份。

4.     创建字符串3+1种方式：

三种构造方法：

Public String()  创建一个空白字符串

Public String(char[] array)  根据字符数组的内容创建

Public String(byte[] array)  根据字节数组的内容创建

一种直接创建：

String str = “Hello”;

5.     静态代码块的格式：

public class 类名称{

static{

//静态代码块的内容

}

}

6.     ==是进行字符串的地址值比较，

7.     字符串内容比较：a.equals(b)  b.equals(a)效果相同

8.     字符串与常量比较  “ABC”.equals(str)  不推荐：str.equals(“abc”)

9.     String当中与获取相关的常用方法：

str.Length()      获取字符个数；

str.concat(str1)    拼接；

str.charAt(int index)获取索引位置的单个字符

str.indexOf(str1)  str1在str中首次出现的位置，没有返回-1

Day09

1.     面向对象的三大特征：封装性、继承性、多态性。

2.     继承是多态的前提，没有继承就没有多态。

3.     Java是单继承的，可以多级继承，子类只有一个父类，父类可有多个子类

4.     @Override可写在前面检查覆盖重写

5.     父子类方法名称、参数列表必须相同（java.lang.Object类是祖宗类）

6.     子类方法的返回值必须<=父类方法的返回值范围

7.     子类方法的权限必须>=父类方法的权限修饰符。

（public>protected>()>private）

8.     抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束

9.     抽象类：抽象方法所在的类，必须是抽象类。在class之前写上abstract即可。

注意：不能直接创建new抽象类对象，必须用子类继承抽象父类，子类必须覆盖重写所有抽象方法。 

             覆盖重写（实现）：子类去掉抽象方法的abstract关键字，补上方法体大括号

10.  super关键字用来访问父类内容，而this关键字用来访问本类内容。

       super与this调用必须是构造方法的第一个且唯一一个语句.

day10

1.      接口格式：

public interface 接口名称{

          //接口内容

}

2.      接口中可包含：常量、抽象方法、默认方法、静态方法、私有方法

3.      接口中的抽象方法，修饰符必须是两个固定的关键字，[public] [abstract]

4.      抽象方法没有方法体，所在的类必须是抽象类，且必须被覆盖重写

5.      接口使用步骤：

1.public class 实现类名称 implements 接口名称{

   //…

}

        2.覆盖重写接口中所有抽象方法

         3.创建实现类的对象，进行使用。

5.     接口的默认方法会被实现类自动继承；格式：

         [public] default 返回值类型 方法名称（参数列表）{

         方法体

}

6.     静态方法格式：

         [public] static 返回值类型 方法名称（参数列表）{

         方法体

}

         （静态方法必须通过接口名称直接调用）

7.     普通私有方法：

         private 返回值类型 方法名称（参数列表）{

         方法体

}

静态私有方法：

private 返回值类型 方法名称（参数列表）{

         方法体

}

8.     接口中的常量：[public] [static] [final] 数据类型 常量名称 = 数据值；       

         (常量名称用完全大写的字母且用下划线分隔)

9.  一个类直接父类只能有一个，但接口可以有很多个。

10. 多态性（左父右子）：

         父类名称 对象名 = new 子类名称（）；

         接口名称 对象名 = new 实现类名称（）；               

11. 访问成员变量的两种方式：（编译看左边，运行看左边）

         直接通过对象名称访问成员变量，等号左边是谁优先用谁，没有则向上找；

         间接通过成员方法访问成员变量，方法属于谁优先用谁，没有则向上找

12. 访问成员变量：（编译看右边，运行看右边）

        new的是谁优先用谁，没有则向上找；

13. 对象的向上转型（其实就是多态写法）：父类名称 对象名 = new 子类名称（）；

day11

1.      final类没有子类，格式：

public final class 类名称（）{

          …

}

2.      final方法不能被覆盖重写，格式：

修饰符 final 返回值类型 方法名称（）{

          //方法体

}

3.      final修饰局部变量，赋值后不可改变；

final 变量类型 变量名

对于基本类型，不可变为变量中的数据不可变

对于引用类型，不可变为变量中的地址值不可变

4.      java中四种权限修饰符：

                                                    public  protected  private

同一个类（我自己）                      YES          YES          YES          YES

同一个包（我邻居）                      YES          YES          YES           

不同包子类（我儿子）                    YES          YES                             

不同包不子类（陌生人）                YES                                             

5.      权限修饰符规则：

外部类：public/（）；

成员内部类：四种都可；

局部内部类：什么都不能写。

6.      成员内部类的定义格式：

修饰符 class 外部类名称（）{

          修饰符 class 内部类名称（）{

                  //…

              }

//….                                                                       

}

7.      内用外，随便用；外用内，需要内部类对象

8.      成员内部类的使用：

间接方法：在外部类的方法当中，使用内部类，然后main调用外部类方法；

直接方法：公式：（外.内）

外部类名称.内部类名称 方法名 = new外部类名称().new 内部类名称()

9.      访问重名的外部类成员变量：外部类名称.this.外部类成员变量名

10.   局部内部类：定义在方法内部的类

修饰符 class 外部类名称{

修饰符 返回值类型 方法名（参数列表）{

class 局部内部类名称{

//…

}

}

}

局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必是有效final的

11.   匿名内部类（接口的实现类或父类的子类只需要用唯一一次）：

接口名称 对象名 = new 接口名称（）{

    //覆盖重写所有抽象方法

}；

day12

1.      直接打印对象的名字，就是调用toString方法 p=p.toString();

2.      toString方法：重写前打印对象的 包名类名@地址值（默认）；

重写后打印对象中的 属性值

3.      equals方法默认比较的是地址值，调用空指针会抛出空指针异常  s1.equals(s2)

4.      Objects.equals(s1,s2)  则可以防止空指针异常

5.      Date类：表示特定的瞬间，精确到毫秒

Date(): 获取当前系统的日期和时间；

Date(Long date):  传递毫秒值，转化为日期

成员方法Long getTime():把日期转化为自1970.1.1到Date的毫秒数

6.      DateForma类&SimpleDateFormat类：

SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

成员方法：String format(Date date) 格式化

                       Date parse(String source) 把符合模式的字符串，解析为Date日期

7.      Calendar类（日历类）：为一个抽象类，其中有一个静态方法叫getInstance()

成员方法：

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对象。

8.      System类：

Long currentTimeMillis()  获取当前系统毫秒值

System.arraycopy(src,0,dest,0,3)  从源数组src的0号元素复制到dest的0号到3号

9.      StringBilder类：字符串缓冲区，提高字符串效率

成员方法：

StringBuilder append(..)  返回自身，无需接受返回值，可连续写

StringBuilder reverse();  反转内容

String toString();        将缓冲区内容转换为字符串

10.   自动装箱、自动拆箱：基本类型与包装类可自动相互转换

11.   基本类型转String： 例如：  34+“”

String转基本类型： 包装类.parse基本类型（String s） 

day13

1.      Collection (单列集合最顶层的接口)：

     List（单列集合的一种）：（有索引，可以保证存取顺序，可以存储重复元素）

           ArrayList（重点）：底层是数组实现的，查询快，增删慢

           LinkedList（次之）：底层是链表实现的，查询慢，增删快

           Vector（了解）

  Set（单列集合的一种）：（无索引，存取无序，不可以存储重复元素）

           HashSet（重点）：底层是哈希表+（红黑树）实现的

           LinkedHashSet（次之）：底层是哈希表+链表实现的，<可以保证存取顺序>

           TreeSet（了解）：底层是二叉树实现的，一般用于排序 

boolean add(E e);                        向集合中添加元素

boolean remove(E e);        删除集合中某个元素

void clear();                                      清空集合中所有元素

boolean contains(E e);                    判断集合中是否包含某个元素

boolean isEmpey();                        判断集合是否为空

int size();                                          获取集合的长度

object[] toArray();                          将集合转成一个数组

2.      java.util.Iterator接口：迭代器（遍历集合）

获取迭代器：Iterator<String> it = coll.iterator();

成员方法：  boolean hasNext();  判断还有没有下一个元素

                          String next();    取出下一个元素

3.      增强for循环（foreach）：用来遍历集合和数组

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

                      sout（变量名）；

}

4.      泛型类和泛型方法：  类名<泛型>   方法名（泛型）

5.      泛型接口和泛型方法：接口名<泛型> 方法名（泛型）

实现类格式1：public class 实现类名 implements 接口名<任意类型>{

                              覆盖重写；

                          }

调用1：实现类名 g = new 实现类名();

                  g.method();

实现类格式2：public class 实现类名<I> implements 接口名<I>{

                              覆盖重写；

                          }

调用2：实现类名<任意类型> g = new 实现类名<>();

                  g.method();

6.     泛型通配符：

day14

1.      数据结构-数组：查询快，增删慢

（在堆内存中频繁创建数组，复制其中元素，销毁原数组，效率低下）

2.      数据结构-链表：查询慢，增删快

3.      红黑树：趋近于平衡树，查询速度非常快，查询叶子节点最大最小次数不超过两倍

（根节点、叶子节点为黑色，每个红色节点的子节点都为黑色，一个节点到其每一个 叶子节点的所有路径上黑色节点数相同）

4.      List集合方法：

void add(int index,E element)；  将指定元素添加到指定位置

E remove(int index);            移除指定元素

E get(int index);                返回指定元素

E set(int index, E element);        用指定元素替换指定位置的元素     

5.      Linkedlist集合：（包含了大量操作首尾元素的方法）

void addFirst(E e) / void push(E e) :          将指定元素插入到列表开头

void addLast(E e)                          将指定元素添加到列表结尾

E getFirst() / E getLast :                    返回第一个/最后一个元素

E removeFirst() / E pop()                    移除并返回第一个元素

E removeLast()                                                        移除并返回最后一个元素

6.      HashSet集合：无序（存储和取出顺序可能不同），查询速度特别快

7.      哈希值：是一个十进制整数，由系统随机给出，是一个逻辑地址，不是物理地址

int hasCode()  返回该对象的哈希值

8.      HashSet存储的元素必须重写hasCode和equals方法

9.      可变参数：当参数列表数据类型已经确定，参数个数不确定时，可使用可变参数

格式：修饰符 返回值类型 方法名（数据类型…变量名）{}

如果有多个类型的参数，可变参数必须写到结尾：

                      修饰符 返回值类型 方法名（数据类型 变量名，数据类型…变量名）{}

10.   Collections集合工具类：

boolean addAll(Collections<T> c ,T…elements):往集合中添加元素

void shuffle(List<?> list):打乱集合顺序

void sort (List<T> list):将集合中的元素按默认规则（升序）排序

  注意：必须实现Comparable,重写接口的方法compare to定义排序规则

          升序：自己（this）-参数

void sort (List<T> list,Comparator<? super T>):将集合中的元素按指定规则排序

                              升序：o1-12

全是静态方法，可直接调用（Collection.方法名）

day15

1.      Map集合的特点：双列集合，一个元素包含两个值（一个key，一个value），key与value    数据类型无关；key不能重复，value可以重复；key与value一一对应

2.      Map集合的方法： V put（K key，V value）：把指定的键和值添加到Map集合中。

                       返回值V：存储键值对的时候，key不重复，返回null；

                                              key重复，会使用新的value替换Map中重复的，返回旧的value

V remove（Object key）：把指定的键值对删除，返回对应的值；若没有返回null

V get(Object key)：根据指定的键返回值

boolean containskey(object key)：判断集合是否包含指定key

3.      Map的两种遍历方式：

Set<k> keySet() / Set<Map.Entry<k,v>> entrySet()：将键都取出来放到set集合

4.      Hashtable集合：（单线程，速度慢；不能存储null键、null值）

HashMap集合：（多线程，速度快；能存储null键、null值）

5.      of方法（静态）：List<E> of(E…elements)

JDK9中List接口、Set接口、Map接口增加的，可以给集合一次性添加多个元素

Set、Map方法调用时不能有重复元素

6.      Debug调试程序：让代码逐行执行，查看执行过程中出现的bug

使用方法：添加断点，右键选择Debug，程序会停在第一个断点处

执行程序：

F8：逐行执行程序

F7：进入方法

shift+F8：跳出方法，并将方法执行完

F9：跳到下一个断点，若没有下一个断点则结束程序

Ctrl+F2：退出Debug模式，停止程序

Console：切换到控制台

day16

1.      Throwable类：是所有异常或错误的超类

                       Exception类（小病）：编译期异常

                               RuntimeException：运行期异常，java程序运行过程中出现的问题

                       Error类（绝症）：错误，必须修改源代码，程序才能继续执行

2.      throw关键字：作用（抛出指定异常）

使用格式：throw new XXXException(“产生异常的原因”)

3.      throws关键字：异常处理的第一种方式，交给别人处理，最终交给JVM处理，中断程序

使用格式：

修饰符 返回值类型 方法名（参数列表） throws AAAException，throw BBBException…{

                      throws new AAAException（“产生原因”）；

                      throws new BBBException（“产生原因”）；

                      …

}

4.      try…catch：处理异常的第二种方式，自己处理

格式：

try{

可能产生异常的代码

}catch（异常类名 变量名（接收try中抛出异常的对象））{

异常的处理逻辑

}

…

catch（异常类名 变量名）{

异常的处理逻辑

}

（try中可能抛出多个异常，可用多个catch处理，若异常有父子类关系，子类必写上面）

5.      finally代码块：

try{

可能产生异常的代码

}catch（异常类名 变量名（接收try中抛出异常的对象））{

异常的处理逻辑

}

…

catch（异常类名 变量名）{

异常的处理逻辑

}finally{

无论是否异常都会执行 

}

（如果finally中有return语句，永远返回finally中的结果，应避免该情况）

6.      父类有异常，子类异常必须<=父类

7.      多线程：并发（同一时段交替执行）、并行（同时执行）

8.      进程：点击应用程序执行，进入到内存中的程序

线程：通向CPU的执行路径

线程调度：java为抢占式调度，若优先级相同则随机

（一个程序可以有多个进程，进程包含多个线程）

9.      主线程：执行主方法（main）的线程

10.   创建多线程程序的第一种方式：创建Thread类的子类

实现步骤：

1.      创建一个Thread类的子类

2.      子类中重写Thread类的run方法，设置线程任务

3.      创建子类对象

4.      调用Thread类中的start方法，开启新线程，执行run方法。

结果：两个线程并发执行：当前线程（main线程）和另一个线程（创建的新线程）

day17

1.      Thread类常用方法：

String getName()                              返回该线程的名称

static Thread currentThread()    返回当前正在执行的线程

static void sleep(long millis)              使当前执行的线程以指定毫秒数暂停

2.      创建多线程程序的第二种方式（推荐）：实现Runnable接口

实现步骤：

1.      创建一个Runnable接口的实现类

2.      在实现类中重写Runnable接口的run方法，设置线程任务

3.      创建实现类对象

4.      创建Thread类对象，构造方法中传递Runnable接口的实现类对象

5.      调用Thread类中的start方法，开启新线程，执行run方法

3.      匿名内部类方法实现线程：格式：

new 父类/接口（）{

          重写父类/接口的方法

}.start();

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

格式：

synchronized（锁对象）{

  可能出现线程安全问题的代码（访问共享数据的代码）

}

锁对象（任意创建的）：把同步代码块锁住，只让一个线程在同步代码块中执行

5.      解决线程安全问题的第二种方案：使用同步方法

格式：

修饰符 synchronized 返回值类型 方法名（参数列表）{

  可能出现线程安全问题的代码（访问共享数据的代码）

}

6.      解决线程安全问题的第三种方案：使用Lock锁

Lock接口中的方法：void lock（） 获取锁  ；  void unlock（） 释放锁

使用步骤：

1.      成员位置创建对象：Lock l = new ReentrantLock();

2.      在可能出现线程安全问题的代码前  l.Lock();

3.      在可能出现线程安全问题的代码前  l.unlock();

day18

1.      Executors：线程池的工厂类，用来生产线程池

Executors类中的静态方法：

Executors.newFixedThreadPool(int nThreads) 创建一个可重用线程数固定的线程池

2.      线程池的使用步骤：

1.      使用Executors的方法newFixedThreadPool生存一个线程池

2.      创建一个类，实现Runnable接口，重写run方法，设置线程任务

3.      调用ExecutorService中的方法submit，传递线程任务，开启线程，执行run方法

（4. 调用ExecutorService中的方法shutdown销毁线程池）

3.      Lambda标准格式：   （参数列表）-> {一些重写方法的代码}；

4.      Lambda省略格式：   

1)      参数列表的数据类型可省略

2)      若参数只有一个，（）可以省略

3)      若{}中的代码只有一行，{}、；、return可一起省略（无论是否有返回值）

5.      Lambda使用前提：                

1）  必须有函数式接口（有且仅有一个抽象方法的接口）

2）  方法的参数或局部变量类型必须为Lambda变量接口的类型

day19

1.      File类： static String pathSeparator 路径分隔符 Windows；  Linux：

static String Separator 文件名分隔符  Windows\  Linux/

2.      绝对路径：完整的     相对路径：简化的    （路径不区分大小写）

3.      File类

构造方法：

File（String pathname）：通过给定的路径字符串转化为抽象路径名创建一个新的File实例

File（String parent，String child）：父子路径都可以随意变化

File（FIle parent，String child）

获取功能的方法：

String getAbsolutePath（）：返回此File的绝对路径

String getPath()：返回路径

String getName（）：返回路径的结尾部分

Long Length（）：以字节为单位返回文件大小，不存在返回0

判断功能的方法：

boolean extsis（）：判断路径是否存在

boolean isDirectory()：判断是否以文件夹结尾                    （路径不存在返回false）

boolean isFile()：判断是否以文件结尾                （路径不存在返回false）

创建删除的方法：

boolean createNewFile()：若该文件不存在，创建一个新文件

boolean mkdir()：创建单级文件夹

boolean mkdirs()：创建单级或多级文件夹 

boolean delete()：删除文件或文件夹

遍历方法：

String[] List()：遍历文件夹

File[] listFiles()：遍历文件夹（带路径）

day20

1.      顶级父类们：

字节流：字节输入流InputStream        字节输出流OutputStream

字符流：字符输入流Reader                  字符输出流Writer

2.      OutputStream：此抽象类是所有字节输出流类的超类

成员方法：

void write(byte b) // void write(byte[] b) // void write(byte[] b,int off,int len)数组的一部分off开始，len长度

byte[] getBytes()  把字符串转化为字节数组（String类的方法）

追加写/续写（true：可在文件后续写  false：创建新文件覆盖原文件）

FileOutputStream（String name，boolean append）

FileOutputStream（File file, boolean append）

换行：

Windows：\r\n Linux: /n          mac: /r

3.      InputStream：

int read（byte bytes） // int read(byte[] bytes)  //int read(byte[] bytes, int offset ,int length)         

4.      Reader:

int read()  //  int read（char[] cbur）

5.      Writer:

void write(int c)  //  void write(char[] cbuf)  //  abstract void write(char[] cbuf,int offset,int count)  //

void write(String str)  //  void write(String str, int off,int len)

void flush()  刷新该流的缓冲 

void close()  关闭此流（但是会先刷新缓冲）

注意：write方法是先把数据写入缓冲区中（字符-->字节），再用flush刷新到文件中

6.      Properties双列集合（唯一与IO流相结合的集合）：

Object setProperty(String key,String value)  往集合中添加数据

String getProperty(String key)  通过key找value         

Set<String> stringPropertyNames()  返回键集

将集合中的临时数据写入硬盘

void store(OutputStream out, String comments) 

void store(Writer writer,String comments)

读取硬盘中的键值对

void load(InputStream inStream)

void load(Reader reader)

day21

1.      缓冲流：提高四个基本FileXXX流的效率

BufferedOutputStream：字节缓冲输出流

2.      转换流（编码，解码）：

OutputStreamWriter（编码）:字符通向字节的桥梁

构造方法：

OutputStreamWriter(OutputStream out)创建默认字符表的OutputStreamWriter

OutputStreamWriter(OutputStream out,String charsetName)创建指定编码表的OutputStreamWriter

参数charsetName：指定编码表，可以是utf-8,gbk……不指定默认utf-8

InputStreamReader（解码）：字节流向字符的桥梁

3.      对象的序列化流（把对象以流的方式写入文件中）：

ObjectOutputStream特有的成员方法：

void writeObject(Object obj)  

        反序列化流（读取）：

                  ObjectInputStream特有的成员方法：

                  void readObject(Object obj)

          注意：

1）序列化和反序列化的类必须实现Serializable接口

2）被transient关键字（瞬态关键字）和static关键字（静态关键字）修饰的成员变量，不能序列化

3）解决序列化异常：在类中Private static final long serialVersionUID = 1L；

4.      打印流PrentStream（extends OutputStream）：

ps.write(97) à a

ps.print(97) à 97

day22

1.      TCP通信：客户端Client和服务器Server之间的通信，这个连接中包含IO对象

2.      Socket类：

构造方法：Socket(String host,int port) 创建套接字并连接到指定主机的端口号（port）

                                            （host 服务器主机名称/服务器的IP地址）

成员方法：OutputStream getOutputStream() 返回此套接字的输出流

                    InputStream getInputStream() 返回此套接字的输入流

3.      ServerSocket类：

构造方法：ServerSocket(int port) 创建绑定到特定端口的服务器套接字

成员方法：Socket accept() 监听并接收此套接字的连接

day23 

1.      函数式接口：有且只有一个抽象方法的接口

@FunctionalInterface注解：检测接口是不是一个函数是接口

2.      常用的函数式接口

1）  Supplier<T> （生产型接口）接口中的get方法生产泛型类型的数据

2）  Consumer<T>（消费型接口）使用accept方法消费泛型执行类型的数据 

3）  Predicate<T> 判断T类型的数据

抽象方法：boolean test(T t);  符合条件返回true，否则false  

表示“与”关系：pre1.test(s) && pre2.test(s) 等价于 pre1.and(pre2).test(s)  

“或”:or         “非”:negate  (同上)

4）  Function<T,R> 用抽象方法R apply(T t)  将T类型的参数转化为R类型

fun1.andThen(fun2)

day24

1.      Stream流：Stream<T>接口不是函数式接口

Collection集合可以通过stream默认方法转为流： Stream<E> stream

Stream接口的静态方法of可以获取数组对应的流：Stream<T> of(T…values)

Stream流为管道流，只能用一次

2.      常用方法：（除了终结方法就是延迟方法）

forEach: 遍历流中的数据（终结方法：调用后不能继续调用Stream流中的其他方法）

                            void forEach(Consumer<? super T> action)

filter：过滤数据  Stream<T> filter(Predicate<? super T> predicate)

                                                      boolean test(T t);

map：映射  Stream<R>  map(Function<? super T , ? extends R> mapper)

                                                      Function方法R apply(T t)

count：元素个数（终结方法）  Long count()；

limit: 截取元素  Stream<T> limit(long maxsize)

skpi：跳过前几个元素 Stream<T> skip(long n);

concat：合并两个流（静态方法）Stream<T> concat(Stream<? extends t> a,Stream<? extends T> b);

3.      方法引用优化Lambda：

对象和成员方法都存在：s-> system.out.println(s)  ==  system.out::println

静态方法引用：Math::abs

父类：super::父类成员方法

本类：this::成员方法

类的构造器：Person::new

数组的构造器：int[]::new

基础加强

1.      Junit单元测试（白盒测试）：

步骤：1） 定义一个测试类（测试用例）    测试类名：CalculatorTest  包名：xxx.xxx.test

                    2） 定义测试方法      方法名：testAdd()  返回值：void  参数：空参

                    3） 给方法加@Test

                    4） 导入Junit依赖环境

        判定结果：断言：Assert.assertEquals(期望的结果，实际的结果)

        @Before：修饰的方法会在测试方法之前自动执行，用于申请资源

        @After： 修饰的方法会在测试方法之后自动执行，用于释放资源

2.      反射：框架设计的灵魂

a)       框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

b)       反射机制：将类的各个组成部分封装为其他对象

  好处：

1.        可以在程序运行过程中，操作这些对象

2.        可以解耦，提高程序的可扩展性

3.      注解：@Override覆盖重写父类方法 @Deprecated已过时 @SuppressWarnings(“all”)压制（所有）警告

自定义注解：

* 格式：

            元注解

            public @interface 注解名称{

                属性列表;

            }

        * 本质：注解本质上就是一个接口，该接口默认继承Annotation接口

            * public interface MyAnno extends java.lang.annotation.Annotation {

        * 属性：接口中的抽象方法

            * 要求：

                1. 属性的返回值类型有下列取值

                   * 基本数据类型

                   * String

                   * 枚举

                   * 注解

                   * 以上类型的数组

                2. 定义了属性，在使用时需要给属性赋值

                   1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。

                   2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。

                   3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略

        * 元注解：用于描述注解的注解

            * @Target：描述注解能够作用的位置

                * ElementType取值：

                   * TYPE：可以作用于类上

                   * METHOD：可以作用于方法上

                   * FIELD：可以作用于成员变量上

            * @Retention：描述注解被保留的阶段

                * @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到

            * @Documented：描述注解是否被抽取到api文档中

            * @Inherited：描述注解是否被子类继承