java全程学习笔记(持续更新+ing)

day01笔记：
Java开发环境：
       编译运行过程：
       编译期：.java源文件，经过编译，生成.class字节码文件
       运行期：JVM加载.class并运行.class(0和1)
       特点：跨平台、一次编译到处使用
名词解释：
       JVM：java虚拟机
       加载.class并运行.class
       JRE：java运行环境
       除了包含JVM以外还包含了运行java程序所必须的环境
       JRE = JVM+java系统类库(小零件)
       JDK：java开发工具包
       除了包含JRE以外还包含了开发java程序所必须的命令工具
       JDK = JRE+编译、运行等命令工具
说明：
1. 运行java的最小环境为JRE
2. 开发java的最小环境为JDK

day02笔记：
1. 变量：存数的
       声明：相当于开帐户
       初始化：给帐户存钱
       使用：用的是帐户里面的钱
       对变量的使用就是对它所存的那个数的使用
       变量在用之前必须声明并初始化
       命名：给帐户起名
       只能包含字母、数字、_和$符，并且不能以数字开头
       严格区分大小写
       不能使用关键字
       允许中文命名，但不建议，建议"英文的见名知意"、"小驼峰命名法"
2. 八种基本数据类型：byte、short、int、long、float、double、boolean、char
       int：整型，4个字节，-21个多亿到21个多亿
       整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
       两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
       运算时若超范围则发生溢出，溢出不是错误，但需要避免
       long：长整型，8个字节，-900万万亿多到900万万亿多
       表示长整型直接量，需在数字后加L或l
       运算时若有可能溢出，建议在第1个数字后加L
       double：浮点型，8个字节，很大很大很大
       小数直接量默认为double类型，若想表示float需在数字后加F或f
       不能表示精确数据，运算时有可能会发生舍入误差，精确场合不能使用
       boolean：布尔型，1个字节
       只能存储true或false
       char：字符型，2个字节
       采用的是Unicode编码格式，一个字符对应一个码，看到的是字符char，本质上是码
       int(0到65535)，需要记住几个ASCII码（'a'---97 'A'---65 '0'---48）
       字符型直接量必须放在单引号中，只能有一个
       特殊符号需要通过\来转义
3. 类型间的转换：
       数据类型由小到大依次为：byte<short<int<long<float<double
       char<<int<long<float<double
       两种方式：
       自动/隐式类型转换：小类型到大类型
       强制类型转换：大类型到小类型
       语法：(要转换成为的数据类型)变量
       注意：强转有可能发生溢出或丢失精度
       两点规则：
       整数直接量可以直接赋值给byte,short,char，但不能超出范围
       byte,short,char型数据参与运算时，系统一律将其转换为int再运算

day03笔记：
1. 运算符：
       算术：+，-，*，/，%，++，--
       关系：>、<、>=、<=、==、!=
       逻辑：&&、||、!
       赋值：=、+=、-=、*=、/=、%=
       字符串连接：+
       条件：boolean？数1：数2
2. 分支结构(上)：基于条件执行
       if结构：1条路
       if...else结构：2条路
       if...else if结构：多条路


day04笔记：
1. Scanner接收用户输入的数据：------共3步，先背下来，面向对象第5天才能理解
2. 分支结构(下)：
       switch...case结构：多条路
       优点：效率高、结构清晰
       缺点：只能对整数判断相等
       break：跳出switch
       switch中数据的类型：byte,short,int,char,String,枚举
3. 循环：反复多次执行一段相同或相似的代码
4. 循环三要素：------------------------非常重要
       循环变量的初始化
       循环的条件(以循环变量为基础)
       循环变量的改变
       循环变量：在整个循环过程中所反复改变的那个数
5. 循环结构：
       while结构：先判断后执行，有可能一次都不执行
       do...while结构：先执行后判断，至少执行一次
       当第1要素的代码与第3要素的代码相同时，首选do...while
       for结构：应用率最高，适合与次数相关的
6. 三种循环结构如何选择：
       先看循环是否与次数有关：
       若有关--------------------------------------直接上for
       若无关，再看第1要素与第3要素的代码是否相同：
       若相同--------------------------------直接上do...while
       若不同--------------------------------直接上while

day05笔记：
1. for的练习：
2. break：跳出循环
       continue：跳过循环体中剩余语句而进入下一次循环
3. 嵌套循环：
       循环中套循环，常常多行多列时使用，外层控制行，内层控制列
       执行规则：外层循环走一次，内层循环走所有次
       建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
       break默认只能跳出当前一层循环
4. 数组(上)：
       是一种引用数据类型
       相同数据类型元素的集合
定义：
       初始化：初始化数组中的元素
访问：
       通过(数组名.length)可以获取数组的长度(元素个数)
       通过下标/索引来访问元素，下标从0开始，最大到(数组的长度-1)
       遍历/迭代：从头到尾挨个走一遍
排序：


day06笔记：
1. 数组(下)：
复制：
      System.arraycopy(a,1,b,0,4);
      int[] b = Arrays.copyOf(a,6);
      a = Arrays.copyOf(a,a.length+1); //数组的扩容
2. 方法：函数、过程
      作用：用于封装一段特定的业务逻辑功能
      建议：尽可能独立，一个方法只干一件事
      方法可以被反复多次调用
      好处：可以减少代码重复，有利于代码维护
      何时用：只要是一个独立的业务功能，就得封装到一个方法中
3. 方法的定义：五要素
4. 方法的调用：
      无返回值：方法名(有参传参);
      有返回值：数据类型 变量 = 方法名(有参传参);
      int[] arr = new int[3]; //0,0,0
      int[] arr = {2,3,7};
      int[] arr = new int[]{2,3,7};
      arr[0] = 100;
      System.out.println(arr[arr.length-1]);
      for(int i=0;i<arr.length;i++){
      arr[i] = (int)(Math.random()*100);
      System.out.println(arr[i]);
}
      Arrays.sort(arr); //升序
      修饰词 返回值类型 方法名(参数列表){
      方法体---------具体的业务逻辑功能实现
}
5. return：
      return 值; //1)结束方法的执行 2)返回结果给调用方------------用在有返回值的方法中
      return; //1)结束方法的执行------------------------------------------用在无返回值的方法中

1. 形参：形式参数，定义方法时的参数为形参
    实参：实际参数，调用方法时的参数为实参

day07笔记：
精华笔记：
1. 方法的重载(overload/overloading)：
      语法：发生在同一类中，方法名相同，参数列表不同
      绑定：编译器在编译时会根据方法的签名自动绑定方法

方法的签名：方法名+参数列表
在Java中，函数签名包括函数名，参数的数量、类型和顺序。返回值和函数上声明的异常并不属于函数签名的构成部分。
下两个函数签名不同
doSomething(String[] y);
doSomething(String y);
因为他们虽然函数名相同，但是参数类型不同。

下面三个函数的签名相同：
int doSomething(int y) 
String doSomething(int x)
int doSomething(int z) throws java.lang.Exception


ooday01笔记：
1. 什么是类？什么是对象？
      现实生活是由很多很多对象组成的，基于对象抽出了类
      对象：软件中真实存在的单个的个体/东西
      类：类型/类别，代表一类个体
      类是对象的模子/模板，对象是类的具体的实例，可以将类理解为类别/模子/图纸
      类中可以包含：
            对象的属性/特征/数据----------------------成员变量
            对象的行为/动作/功能----------------------方法
            一个类可以创建多个对象
2. 如何创建类？如何创建对象？如何访问成员？
3. this：指代当前对象，哪个对象调用方法它指的就是哪个对象
      只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法：
      this.成员变量名--------------------访问成员变量(必须掌握)
      当成员变量与局部变量同名时，若想访问成员变量，则this不能省略
      this.方法名()-------------------------调用方法(一般不用)
      this()-----------------------------------调用构造方法(一般不用)
4. 构造方法：
      构造函数、构造器、构建器----------好处：复用给成员变量赋初始值的代码
      作用：给成员变量赋初始值
      语法：与类同名，没有返回值类型(连void都没有)
      调用：在创建(new)对象时被自动调用
      若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默
      认提供
      构造方法可以重载
            方法的重载(overload/overloading)：
            发生在同一类中，方法名相同，参数列表不同
            编译器在编译时会根据方法的签名自动绑定调用的方法
      OO:(Object Oriented)面向对象
      OOA:(Object-Oriented Analysis）面向对象分析
      OOD:(Object-Oriented Design)面向对象设计
      OOAD:(Object-oriented Analysis and Design)面向对象分析与设计
      OOP： (object-oriented programming)---------------------------我们所要参与的部分
默认规则:
           byte,short,int,long,char---------------0
           float,double---------------------------0.0
           boolean--------------------------------false
           引用类型---------------------------------null
内存管理：由JVM管理-----------暂时的笔记
           堆：存储new出来的对象(包括成员变量、方法的地址)
           栈：正在调用的方法中的局部变量(包括方法的参数)
           方法区/元空间：.class字节码文件(包括所有方法)


ooday02笔记：
1. 继承：
           作用：代码复用
           通过extends实现继承
           超类/基类/父类：共有的属性和行为
           派生类/子类：特有的属性和行为
           派生类可以访问：超类的+派生类的，超类不能访问派生类的
           一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承具有传递性
           java规定：构造派生类之前必须先构造超类
           在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
           在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
           注意：super()调用超类构造方法，必须位于派生类构造方法中的第1行
2. super：指代当前对象的超类对象
           super.成员变量名-------------------------访问超类的成员变量
           当超类成员变量和派生类成员变量同名时，super指超类的，this指派生类的
           若没有同名现象，则写super和this是一样的
           super.方法名()------------------------------调用超类的方法
           super()----------------------------------------调用超类的构造方法
3. 方法的重写(override/overriding)：重新写、覆盖
           发生在父子类中，方法名相同，参数列表相同
           重写方法被调用时，看对象的类型---------------new谁就调谁的，这是规定
补充：
1. 泛化：从程序设计角度而言叫泛化，从代码实现角度而言叫继承，泛化就是继承
2. 继承要符合is(是)的关系
3. 继承的是超类的成员变量和普通方法，不包括超类的构造方法，超类的构造方法是被派生类通过super()来调用的，而不是继承的
class Aoo{
           int a;
           Aoo(){
           }
           void show(){
           }
}
           class Boo extends Aoo{
           继承了Aoo类的a+show()，并没有继承Aoo类的构造方法
}

静态方法里面没this


ooday03精华笔记：
1. 抽象方法：
           由abstract修饰
           只有方法的定义，没有具体的实现(连{}都没有)
2. 抽象类：
           由abstract修饰
           包含抽象方法的类必须是抽象类，但不包含抽象方法的类也可以声明为抽象类
           抽象类不能被实例化(new对象)
           抽象类是需要被继承的，派生类：
           必须重写所有抽象方法------------------变不完整为完整
           也声明为抽象类----------------------------一般不这么用
           抽象类的意义：
           封装共有的属性和行为------------------代码复用
           可以包含抽象方法，为所有派生类统一入口(名字统一)，强制必须重写
3. 接口：
           是一种引用数据类型
           由interface定义
           只能包含抽象方法(常量、默认方法、静态方法、私有方法------暂时搁置)
           不能被实例化
           接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法
           注意：重写接口中的方法时，必须加public(先记住) 一个类可以实现多个接口，用逗号分隔。
          若又继承又实现时，应先继承后实现
          接口可以继承接口
4. 引用类型数组：------记住它和基本类型数组的两种区别即可
           区别1：给引用类型数组的元素赋值时，需要new个对象
           区别2：访问引用类型数组的元素的属性/行为时，需要打点访问


ooday04笔记：
1. 多态：多种形态
           向上造型/自动类型转换：
           超类型的引用指向派生类的对象
           能点出来什么，看引用的类型--------------这是规定，记住它
           向下转型/强制类型转换，成功的条件只有如下两种：
           引用所指向的对象，就是该类型
           引用所指向的对象，实现了该接口或继承了该类
           强转时若不符合如上条件，则发生ClassCastException类型转换异常
           建议：在强转之前先通过instanceof来判断引用的对象是否是该类型
           注意：instanceof返回boolean结果，它为true的条件就是强转成功的条件
           何时需要强转：若想访问的属性/行为在超类中没有，则需要强制类型转换
2. 成员内部类：应用率低，了解
           类中套类，外面的称为外部类，里面的称为内部类
           内部类通常只服务于外部类，对外不具备可见性
           内部类对象通常在外部类中创建
           内部类可以直接访问外部类的成员，在内部类中有个隐式的引用指向创建它的外部类对象
           隐式的引用：外部类名.this
           何时用：若A类(Baby)只让B类(Mama)用，并且A类(Baby)还想访问B类(Mama)的成员时，可
           以设计成员内部类
3. 匿名内部类：应用率高，掌握
           何时用：若想创建一个派生类的对象，并且对象只创建一次，可以设计为匿名内部类，可以大
           大简化代码
           注意：匿名内部类中不能修改外面局部变量的值
小面试题：
           问：内部类有独立的.class吗?
           答：有
4. package和import：
 package：声明包
           作用：避免类的命名冲突
           规定：同包中的类不能同名，但不同包中的类可以同名。
           类的全称：包名.类名。包名常常有层次结构
           建议：包名所有字母都小写
import：导入类
           同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
           先import导入类，再访问类--------------建议
           类的全称---------------------------------------太繁琐、不建议


ooday05精华笔记：
1. 访问控制修饰符：--------------保护数据的安全(隐藏数据、暴露行为)，实现封装
           public：公开的，任何类
           private：私有的，本类
           protected：受保护的，本类、派生类、同包类
           默认的：什么也不写，本类、同包类--------------------------java不建议
注意：
           1. 访问权限由低到高依次为：private<默认的<protected<public
           2. 类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以。
           2. final：最终的、不能改变的------------单独应用几率低
           修饰变量：变量不能被改变
           修饰方法：方法不能被重写
           修饰类：类不能被继承
3. static：静态的
静态变量：
           由static修饰
           属于类，存储在方法区中，只有一份
           常常通过类名点来访问
           何时用：对象所共享的数据
静态块：
           由static修饰
           属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
           何时用：初始化/加载静态资源/静态变量
静态方法：
           由static修饰
           属于类，存储在方法区中，只有一份
           常常通过类名点来访问
           静态方法中没有隐式this传递，所以静态方法中不能直接访问实例成员(实例变量/实例方法)
           何时用：方法的操作与对象无关(不需要访问对象的属性/行为)
4. static final常量：应用率高
           必须声明同时初始化
           常常通过类名点来访问，不能被改变
           建议：常量名所有字母都大写，多个单词之间用_分隔
           编译器在编译时，会将常量直接替换为具体的数，效率高
           何时用：在程序运行过程中数据永远不变，并且经常使用
5. 枚举：
           是一种引用数据类型
           特点：枚举类型的对象数目是固定的，常常用于定义一组常量
           例如：季节、星期、月份、订单状态、性别......
           所有枚举都继承自Enum类，其中提供了一组方法供我们使用
           枚举的构造方法都是私有的


string笔记：
1. String字符串类型：
       java.lang.String类使用final修饰，不能被继承
       String的底层封装的是一个字符数组
       String在内存中采用Unicode编码格式，每个字符占用2个字节的内存空间
       字符串对象一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)
       String称为不变对象
2. 字符串常量池：是java对String的一个优化措施
       java推荐我们使用字面量/直接量(直接"")的方式来创建字符串对象，并且会将所有以字面量方
       式创建的对象缓存到常量池中，当使用相同字面量再创建字符串对象时将会复用常量池中的对
       象，以减少内存开销。
3. String常用方法：
       length()：获取字符串的长度(字符个数)
       trim()：去除当前字符串两边的空白字符
       toUpperCase()/toLowerCase()：将当前字符串中的英文部分给转换为全大写/全小写
       startsWith()/endsWith()：判断当前字符串是否是以给定的定符串开始/结束的
       charAt()：返回当前字符串指定位置上的字符----根据位置找字符
       indexOf()/lastIndexOf()：检索给定字符串在当前字符串中第一次/最后一次出现的位置----根据字符串找位置
       substring()：截取当前字符串中指定范围的字符串(含头不含尾)
       静态方法valueOf()：将其它数据类型转换为String
              例如:int a=123;
        	    String s1=String.valueOf(a);//将int类型变量a转换为String类型并赋给s1
         	    System.out.println(s1);//123---字符串类型
	    double b=123.456;
        	    String s2=String.valueOf(b);//将double型变量转换为String类型并赋值给s2
        	    System.out.println(s2);//123.456---字符串类型
	    String s3=b+"";//任何类型与字符串相连,结果都会变为字符串类型,效率低
                     System.out.println(s3);//123.456---字符串类型
4. StringBuilder类：
       由于String是不变对象，每次修改内容都会创建新的对象，因此String不适合频繁修改操作，
       为了解决这个问题，java提供了StringBuilder类。
       StringBuilder类是专门用于修改字符串的一个类，内部维护一个可变的char数组，所做操作
       都是在这个数组之上进行的，修改速度、性能优秀，并且提供了修改字符串的常见方式：增、
       删、改、插。
5. StringBuilder的常用方法：
       append()：追加内容---------------------增
       delete()：删除部分内容-----------------删
       replace()：替换部分内容---------------改
       insert()：插入内容------------------------插



regexObject笔记:
1. 正则表达式：
       用于描述字符串的内容格式，使用它通常用于匹配一个字符串是否符合格式要求
       正则表达式的语法：---------------了解，不用纠结、不用深入研究

           1.[]:表示一个字符,该字符可以是[]中指定的内容
              例如:
              [abc]:这个字符可以是a或b或c
              [a-z]:表示任意一个小写字母
              [a-zA-Z]:表示任意一个字母
              [a-zA-Z0-9]:表示任意一个字母数字
              [a-zA-Z0-9_]:表示任意一个数字字母下划线
              [^abc]:该字符只要不是a或b或c
           2.预定义字符:
              .:表示任意一个字符,没有范围限制
              \d:表示任意一个数字,等同于[0-9]
              \w:表示任意一个单词字符,等同于[a-zA-Z0-9_]----单词字符指字母、数字和_
              \s:表示任意一个空白字符
              \D:不是数字
              \W:不是单词字符
              \S:不是空白字符
           3.量词:
              ?:表示前面的内容出现0-1次
              例如: [abc]? 可以匹配:a 或 b 或 c 或什么也不写
              但是不能匹配：m或aaa
              +:表示前面的内容最少出现1次
              例如: [abc]+ 可以匹配:b或aaaaaaaaaa...或abcabcbabcbabcba....
              但是不能匹配:什么都不写 或 abcfdfsbbaqbb34bbwer...
              *:表示前面的内容出现任意次(0-多次)---匹配内容与+一致，只是可以一次都不写
              例如: [abc]* 可以匹配:b或aaaaaaaaaa...或abcabcba....或什么都不写
              但是不能匹配:abcfdfsbbaqbb34bbwer...
              {n}:表示前面的内容出现n次
              例如: [abc]{3} 可以匹配:aaa 或 bbb 或 aab 或abc 或bbc
              但是不能匹配: aaaa 或 aad
              {n,m}:表示前面的内容出现最少n次最多m次
              例如: [abc]{3,5} 可以匹配:aaa 或 abcab 或者 abcc
              但是不能匹配:aaaaaa 或 aabbd
              {n,}:表示前面的内容出现n次以上(含n次)
              例如: [abc]{3,} 可以匹配:aaa 或 aaaaa.... 或 abcbabbcbabcba....
              但是不能匹配:aa 或 abbdaw...
           4.()用于分组,是将小括号里面的内容看做是一个整体
              例如: (abc){3} 表示abc整体出现3次. 可以匹配abcabcabc
              但是不能匹配aaa 或abc 或abcabccba
              (abc|def){3}表示abc或def整体出现3次.
              可以匹配: abcabcabc 或 defdefdef 或 abcdefabc
              但是不能匹配abcdef 或abcdfbdef
2. String支持正则表达式的方法：
       matches()：匹配，使用给定的正则表达式验证当前字符串的格式是否符合要求，若符合则返
       回true，不符合则返回false
       replaceAll()：替换，将当前字符串中满足正则表达式的部分给替换为指定字符串
       split()：拆分，将当前字符串按照满足正则表达式的部分进行拆分，将拆分出的以String[]形式
       返回



object笔记:
3. Object：
       是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
       Object中有两个经常被派生类重写的方法：toString()和equals()
       调用Object类的toString()时默认返回：类的全称@hashcode值，没有参考意义，所以
       常常重写toString()来返回具体的属性值
       注意：String、StringBuilder都重写了toString()来返回具体的字符串内容了
       调用Object类的equals()时默认比较的还是==(即比较地址)，没有参考意义，所以常常重
       写equals()来比较具体的属性值
注意事项：
       1. String类、包装类重写了equals()来比较内容是否相等，但StringBuilder并没
       有。
       2. 重写equals()的基本原则：
       原则上要比较两个对象的属性值是否相同
       两个对象必须是同一类型的，若类型不同则直接返回false
4. 包装类：
       java定义了8个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使基
       本类型可以通过包装类的形式存在。
       包含：Integer、Character、Byte、Short、Long、Float、Double、Boolean，其中
       Character和Boolean是直接继承自Object类的，其余6个包装类继承自Number类。
       JDK1.5时推出了一个新特性：自动拆装箱。当编译器编译时若发现是基本类型与包装类型之
       间的相互赋值，则自动补齐代码完成转换工作，这个过程叫做自动拆装箱。
     	 //触发了自动装箱特性，会被编译为: Integer i = Integer.valueOf(5);
	Integer i = 5; //基本类型到包装类-------装箱
	//触发了自动拆箱特性，会被编译为: int j = i.intValue();
	int j = i; //包装类到基本类型-----------拆箱

	包装类可以将字符串转换为对应的基本类型----必须熟练掌握
      	String s1 = "39";
     	int age = Integer.parseInt(s1); //将字符串s1转换为int类型并赋值给age
    	System.out.println(age); //39---int类型
       	String s2 = "123.456";
        	double price = Double.parseDouble(s2); //将字符串s2转换为double类型并赋值给
      	System.out.println(price); //123.456----double类型


collection笔记：
1. 什么是集合：
       集合和数组一样，可以保存一组数据，并且提供了操作数组元素的相关方法，使用用更加方便
2. 集合框架中的相关接口：
       java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法，下面有很
       多实现类，因此我们可以有更多的数据结构来选择。
       Collection接口下面有两种常见的子接口：-----------------------明天详细介绍
       java.util.List：线性表，是可以重复集合，并且有序
       java.util.Set：不可重复集合，大部分实现类是无序的
3. Collection的常用方法：
       add()：向集合中添加一个元素，成功添加则返回true，否则返回false
       size()：返回当前集合的元素个数
       isEmpty()：判断当前集合是否为空集，当且仅当size()为0时返回true
       clear()：清空集合
       contains()：判断集合是否包含某元素(equals()相等即为true)
       remove()：从集合中删除给定元素(equals()相等即为true)，成功删除则返回true
       addAll()：将参数集合中的元素添加到当前集合中，添加后当前集合发生改变则返回true
       containsAll()：判断当前集合中是否包含参数集合中的所有元素
       retainAll()：取交集(交集元素留着)
       vremoveAll()：删交集(交集元素删除)
       iterator()：获取一个用于遍历当前集合元素的迭代器
       toArray()：将集合转换为数组
4. 集合的遍历：
       Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个
       用于遍历当前集合元素的迭代器(Iterator接口)
       java.util.Iterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自
       身元素的迭代器实现类，但我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。
       迭代器遍历遵循的步骤为：问(hasNext())、取(next())、删(remove())，但删除并不是必要操
       作
       5. 增强for循环/新循环：
       jdk1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合
       和数组。它的内部是通过Iterator实现的，所以不能动态的增删元素。
       语法：
6. 泛型：
       JDK1.5时推出了一个特性：泛型
       泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法
       参数或返回值类型，使得我们使用时更加方便。
       泛型在集合中被广泛使用，用来指定集合中元素的类型
       若不指定泛型的具体类型，则默认为Object
       若指定了泛型的具体类型，则在获取泛型的值时，编译器会自动补充强转操作
7. 集合与数组的互转：
       集合转换为数组：
	//若参数数组元素个数==集合元素个数，那就正常转换
       	//若参数数组元素个数<集合元素个数，那也正常转换(按照集合大小给数组)
       	//若参数数组元素个数>集合元素个数，那也正常转换，同时在末尾补默认值
 	 String 数组名[]=集合名.toArray(new String[5]);
       	 System.out.println(Arrays.toString(数组名));
       数组转换为集合：
                List<String> 集合名= Arrays.asList(数组名);
                System.out.println(集合名);
	//asList()方法会返回内部的ArrayList，内部直接引用给定数组array
	//对数组操作后，集合也会相应的改变
	//对集合操作后，数组也会做相应的改变
	//给集合添加/删除元素相当于给数组添加/删除元素
	list.add("!!!!"); //运行时会发生不支持操作异常


collection2精华笔记：
1. List接口：
       继承自Collection接口，List集合是可重复集合，并且有序，还提供了一套可以通过下标来操作元素的方法
       常见的实现类：
       ArrayList：内部使用数组实现，查询性能更好(直接下标找到物理地址)、增删性能不好
       LinkedList：内部使用链表实现，查询性能不好，首尾增删性能好
       注意：在对集合操作的增删性能没有特别苛刻的要求时，通常选择ArrayList
2. List集常用方法：
       get()：根据下标获取元素
       set()：将指定元素设置到指定位置，并返回被替换的元素(用时才接收)
       重载remove()：删除指定位置元素，并返回被删除的元素(用时才接收)
       重载add()：将指定元素添加到指定位置，理解为插入操作
       subList()：获取集合的子集(含头不含尾)
3. 集合排序：
       Collections为集合的工具类，里面定义了很多静态方法用于操作集合
       Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，但是其要求List集合
       中的元素必须是可比较的，判断是否可以比较的标准是元素是否实现了Comparable接口，若
       没有实现该接口则直接发生编译错误，但是在实际开发中，我们一般是不会不让我们自己写的
       类去实现Comparable接口的，因为这对我们的程序有侵入性。
       侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵
       入性。侵入性越强越不利于程序的后期维护，应尽量避免。
       建议使用重载的Collections.sort(List list, Comparator o);可以通过Comparator来自定义比较
       规则
       	List<String>list=new ArrayList<>();
       	 list.add("小明");
       	 list.add("啊是啊是的好是的");
       	 list.add("大华");
       	 list.add("老金");
      	  System.out.println("list原始的数据:"+list);//list原始的数据:[小明, 大华, 老金]

        	//自定义排序规则
       	 Collections.sort(list,new Comparator<String>() {
            	 @Override
         	 public int compare(String o1, String o2) {
                 return o1.length()-o2.length();//升序
                 //return o2.length()-o1.length(); //降序
                 }
                 });
               System.out.println("list排序后的数据"+list);//list排序后的数据[小明, 大华, 老金, 啊是啊是的好是的]
4. Lambda表达式：
       JDK1.8之后推出了一个新特性：Lambda表达式
       规则：
       不是任何匿名内部类都可以转换为Lambda表达式
       Lambda表达式对接口的要求：只能是函数式接口
       函数式接口:接口中要求实现类必须重写的方法只有一个
       Collections.sort(list1,(o1, o2) -> o1.length()-o2.length());
       System.out.println("Lambda排序后:"+list1);
5. Set接口：
       不可重复集合，并且大部分实现类都是无序的
       小面试题：如何去重？
       	List <String>a=new ArrayList<>();
     	Set  <String> c=new HashSet<>();
     	a.add("小明");
      	a.add("小兰");
     	a.add("小明");
     	a.add("小花");
      	System.out.println(a);//[小明, 小兰, 小明, 小花]
       	c.addAll(a);
      	System.out.println(c);//[小明, 小花, 小兰]


binary&&File笔记
1. 什么是二进制：逢2进1的计数规则。计算机中的变量/常量都是按照2进制来计算的
       2进制：
              规则：逢2进1
              数字：0 1
              基数：2
              权：128 64 32 16 8 4 2 1
              如何将2进制转换为10进制：
       正数：将二进制每个1位置的权相加
2. 十六进制：逢16进1的计数规则
      16进制：
              规则：逢16进1
              数字：0 1 2 3 4 5 6 7 8 9 a b c d e f
              基数：16
              权：4096 256 16 1
       用途：因为2进制书写太麻烦，所以常常用16进制来缩写2进制
       如何缩写：将2进制从低位开始，每4位2进制缩为1位16进制
	权: 8 4 2 1
	2进制: 0001 1011 1110 1010 0101
	16进制: 1        b     e        a      5------------0x1bea5
	权: 8 4 2 1
	2进制: 0010 1111 1101 0100 0111 1011
	16进制: 2        f       d      4       7       b-------0x2fd47b
	权: 8 4 2 1
	2进制: 0010 1001 0101 1010 1011 1001
	16进制:  2       9      5      a        b      9-------0x295ab9
3. 补码：-------------------了解
       计算机处理有符号数(正负数)的一种编码方式
       以4位2进制为例讲解补码的编码规则：
       计算机的时候如果超出4位则高位自动溢出舍弃，保持4位不变
       将4位2进制数分一半作为负数
       最高位称为符号位，高位为1是负数，高位为0是正数
       规律数：
       0111为4位补码的最大值，规律是1个0和3个1，可以推导出
       32位补码的最大值：1个0和31个1---------
       (01111111111111111111111111111111)
       1000为4位补码的最小值，规律是1个1和3个0，可以推导出
       32位补码的最小值：1个1和31个0---------
       (10000000000000000000000000000000)
       1111为4位补码的-1，规律是4个1，可以推导出
       32位补码的-1：32个1--------------------------
       (11111111111111111111111111111111)
深入理解负值：
       记住32位2进制数的-1的编码：32个1
       负值：用-1减去0位置的权
       权: 8 4 2 1
       2进制: 0001 1011 1110 1010 0101
       16进制: 1 b e a 5------------0x1bea5
       权: 8 4 2 1
       2进制: 0010 1111 1101 0100 0111 1011
       16进制: 2 f d 4 7 b-------0x2fd47b
       权: 8 4 2 1
       2进制: 0010 1001 0101 1010 1011 1001
       16进制: 2 9 5 a b 9-------0x295ab9
       1)11111111111111111111111111111111 = -1
       2)11111111111111111111111111111101 = -1-2 = -3
       3)11111111111111111111111111111010 = -1-1-4 = -6
       4)11111111111111111111111111110111 = -1-8 = -9
       5)11111111111111111111111111110101 = -1-2-8 = -11
       6)11111111111111111111111111010011 = -1-4-8-32= -45
4. File：
       File类的每一个实例可以表示硬盘中的一个文件或目录，但实际上它只表示一个抽象路径而
       已，只不过这个路径在硬盘上是真实存在的。
       使用File可以做到：
       访问其表示的文件或目录的属性信息,例如:名字,大小,修改时间等等
       创建和删除文件或目录
       访问一个目录中的子项
       注意：File不能访问文件数据
5. File的常用方法：
       getName()：获取文件或目录的名称
       length()：获取文件或目录大小
       isHidden()：获取文件或目录是否为隐藏的
       canRead()：获取文件或目录是否为可读的
       canWrite()：获取文件或目录是否为可写的
       exists()：获取文件或目录是否为已存在的
       createNewFile()：创建新文件
       mkdir()/mkdirs()：创建新目录dir.mkdirs(); //该方法创建目录时会连同将所有不存在的父目录一同创建出来(推荐使用)
       delete()：删除文件或目录
       isFile()：获取File对象表示的是否为一个文件且存在
       isDirectory()：获取File对象表示的是否为一个目录且存在
       listFiles()：获取一个目录中的所有子项


io笔记：
1. IO：可以让我们用标准的读写操作来完成对不同设备的读写数据工作。java将IO按照方向划分为输
       入与输出,参照点是我们写的程序
       输入：用来读取数据的,是从外界到程序的方向,用于获取数据。
       输出：用来写出数据的,是从程序到外界的方向,用于发送数据。
2. java将IO比喻为"流"，即：stream。 就像生活中的"电流"、"水流"一样，它是以同一个方向顺序移
       动的过程.只不过这里流动的是字节(2进制数据)。所以在IO中有输入流和输出流之分，我们理解他
       们是连接程序与另一端的"管道"。用于获取或发送数据到另一端。
3. Java定义了两个超类(抽象类)：
       java.io.InputStream：所有字节输入流的超类，其中定义了读取数据的方法，因此将来不管
       读取的是什么设备(连接该设备的流)都有这些读取的方法，因此我们可以用相同的方法读取不
       同设备中的数据
       java.io.OutputStream：所有字节输出流的超类,其中定义了写出数据的方法.
4. 文件流：用于读写文件数据的流，用于连接程序与文件(硬盘)的"管道"，负责读写文件数据.
       java.io.FileOutputStream：文件输出流
       java.io.FileInputStream：文件输入流
5. 单字节写：
6. 单字节读：
7. 单字节文件复制：慢
8. 块读写的文件复制操作：快
9. 写文本数据：
10. 读取文本数据：
FileOutputStream：括号里面加true是为了追加数据，要不然以前的数据都会被重写


io2笔记：
1. java将流分为节点流和处理流两类：
       节点流：也称为低级流，是真实连接程序和另一端的"管道"，负责实际读写数据的流，读写一
       定是建立在节点流的基础之上进行的。节点流好比家里的"自来水管"，连接我们的家庭与自来
       水厂，负责搬运水。就一对：文件流
       处理流：也称为高级流，不能独立存在，必须连接在其他流上，目的是当数据经过当前流时对
       其进行某种加工处理，简化我们对数据的同等操作。高级流好比家里常见的对水做加工的设
       备，比如"净水器"、"热水器"，有了它们我们就不必再自己对水进行加工了。好多对。
       实际开发中我们经常会串联一组高级流最终连接到低级流上，在读写操作时以流水线式
       的加工来完成复杂IO操作，这个过程称为"流的连接"
2. 缓冲流：是一对高级流，作用是提高读写数据的效率。
       缓冲流内部有一个字节数组,默认长度是8K.缓冲流读写数据时一定是将数据的读写方式转换为
       块读写来保证读写效率.
       通过缓冲流写出的数据会被临时存入缓冲流内部的字节数组,直到数组存满数据才会真实写出
       一次
3. 对象流：是一对高级流，在流连接中的作用是进行对象的序列化与反序列化。
       对象序列化:将一个java对象按照其结构转换为一组字节的过程
注意：
       1. 需要进行序列化的类必须实现接口:java.io.Serializable
       2. transient关键字可以修饰属性，用于在进行对象序列化时忽略不必要的属性，达
       到对象瘦身的目的
       对象反序列化:将一组字节还原为java对象(前提是这组字节是一个对象序列化得到的字节)
4. IO将流按照读写单位划分为字节流和字符流：
       字节流的超类: InputStream和OutputStream，以字节为单位读写数据的流
       字符流的超类：Reader和Writer，以字符为单位读写数据的流
注意：
       1. 这两组超类是平级关系，互相不存在继承关系
       2. 字节流分低级流也有高级流，文件流为低级流，缓冲流和对象流为高级流
       3. 字符流都是高级流
       4. 字符流最小读写单位为字符(char),但是底层实际还是读写字节,只是字符与字节的
       转换工作由字符流完成.
       5. 常用的字节流有三种：
       文件流：是一组低级流(见昨天的笔记)
       缓冲流：是一组高级流(见上)
       对象流：是一组高级流(见上)
6. 常用的字符流有两种：
转换流：是一组高级流
7. 转换流：是一对高级流，它们是字符流非常常用的一对实现类同时也是一对高级流,实际开发中我们
       不直接操作它们,但是它们在流连接中是非常重要的一环.
       转换流在在流连接中的意义:由于其它字符流在流连接中要求只能连接在其它字符流上，而不
       能直接连接在字节流上，原因:字符流是以字符为单位读写，而字节流是以字节为单位读写，
       读写单位不同，因此不能直接串联在一起工作。转换流是一对字符流，并且是唯一可以直接连
       接在字节流上的字符流。因此其它字符流都只能连接在转换流上，而转换再连接在字节流上，
       实现串联起写读写


缓冲流与异常/io3笔记:
1. 缓冲字符流：BufferedWriter/PrintWriter和BufferedReader
       内部也有一个缓冲区，读写文本数据以块读写形式加快效率
       缓冲字符流有一个特别的功能：可以按行读写文本数据。
       PrintWriter具有自动行刷新的缓冲字符输出流，实际开发中更常用，它内部总是会自动连接
       BufferedWriter作为块写加速使用。
2. IO总结：
       文件流：低级流/节点流，字节流--------------FileInputStream和FileOutputStream
       作用：实际连接程序与文件的"管道"，读写字节(单字节读写、块读写)
       缓冲字节流：高级流/处理流，字节流--------BufferedInputStream和BufferedOutputStream
       作用：块读写字节数据加速
       对象流：高级流/处理流，字节流---------------ObjectInputStream和ObjectOutputStream
       作用：对象序列化和反序列化
       转换流：高级流/处理流，字符流---------------InputStreamReader和OutputStreamWriter
       作用：衔接字符流与字节流、将字符转换为字节
       缓冲字符流：高级流/处理流，字符流---------BufferedReader和BufferedWriter/PrintWriter
       作用：块读写文本字符数据加速、按行读写字符串(PrintWriter具有自动行刷新功能)
3. 流的选择：读写java对象就用对象流，想读写字符串就是缓冲字符流

//缓冲流字节流
public class CopyDemo3Buffered {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("./ch.jpg");
        BufferedInputStream bis=new BufferedInputStream(fis);
        FileOutputStream fos=new FileOutputStream("./ch.jpg");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        long start = System.currentTimeMillis();
        int d;
        while((d=bis.read())!=-1){ //使用缓冲流读取字节
            bos.write(d); //使用缓冲流写出字节
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕!耗时:"+(end-start)+"ms");
        bis.close(); //只需关高级流，因为高级流中先关了低级流
        bos.close();
    }
}

//缓冲字符的输入流读取文本数据
public class PWDemo {
    public static void main(String[] args) throws IOException {
        //文件流(低级流)
        FileOutputStream fos=new FileOutputStream("pw3.txt");
        //转换流(高级流)
        OutputStreamWriter osw=new OutputStreamWriter(fos,StandardCharsets.UTF_8);
        //缓冲流(高级流)
        BufferedWriter bw=new BufferedWriter(osw);
        bw.write("长风破浪会有时");
        bw.write("直挂云帆济沧海");
        System.out.println("写出完毕");
        bw.close();
    }
}

//缓冲字符流---最常用的读写字符串流
public class BRDemo {
    public static void main(String[] args) throws IOException {
        //文件流(字节流,低级流)
        FileInputStream fis=new FileInputStream("pw1.txt");
        //转换流(字符流,高级流)
        InputStreamReader isr=new InputStreamReader(fis, StandardCharsets.UTF_8);
        //缓冲字符流(字符流,高级流)
        BufferedReader br=new BufferedReader(isr);
        String line;
        while((line= br.readLine())!=null){
            //System.out.println(line);//换行输出
            System.out.print(line);
        }
        br.close();
    }
}

4. 异常：
       java.lang.Throwable是所有异常的顶级超类，它的下面派生了两个子类型：
       Error：错误，表示系统级别错误，是不可恢复的错误，比如说：虚拟机内存溢出等，
       Error通过异常处理机制是处理不了的。
       Exception：异常/意外，表示程序级别的异常，是可以通过异常处理机制恢复的错误，
       下面有多个派生类表达不同的异常类型
5. 异常处理机制解决的问题：
       正常程序能走完，但因为某些特殊原因(网络问题、突发情况)导致程序无法正常走完，属于意
       外情况，通过程序逻辑(分支/循环)是无法解决了，这时才需要使用异常处理机制来做个B计
       划。直白的说：你明知道会发生，但是还没办法通过逻辑来处理的问题，才需要异常处理机制
       帮助解决。
异常追责过程：
       1. 当发生错误时，JVM会new一个异常出来，要求代码必须解决。
       2. 若代码中没有做异常处理，则找到代码所在的方法来处理
       3. 若代码所在的方法也没有处理，会继续往上追方法，直到追到main方法
       4. 若main方法也没有处理，则继续找到调用main方法的JVM，最后程序直接终止
6. 异常处理机制：
       try...catch：若try中代码出现异常，将会被catch捕获，若catch没有捕获住，则程序依然被杀
       死
       finally：是异常处理机制中的最后一块，不能独立存在，它可以跟着try后(try...finally)，或最
       后一个catch后(try...catch...finally)。
注意：
       1. finally可以保证无论try块中是否出现异常，最后finally都必定执行。通常用来做释
       放资源这类操作。
       2. JDK7之后，java提供了一个新特性：自动关闭特性。旨在IO操作中可以更简洁的
              使用异常处理机制完成最后的close操作。
       throw：用于对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常：
       当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
       程序执行遇到一个异常，但是该异常不应当在当前代码片段中被解决时可以抛出给调用
       者。

exception笔记：
1. 异常分两种，检查异常和非检查异常，检查是由编译器检查，检查的是当你抛出异常之后，你是否
       做了异常处理，处理手段只有两种：try...catch和throws。
       检查异常：当抛出检查异常时，编译器检查你是否做了异常处理，若没有做异常处理则编译错
       误
       非检查异常：当抛出非检查异常时，不管你做没做异常处理，都不会报错，只有
       RuntimeException才是非检查异常，当然它的子类也都是非检查异常。
2. 异常处理机制：
       throw：用于对外主动抛出一个异常，通常有两种情况需要主动抛出
       程序执行遇到一个异常，但是该异常不应当在当前代码片段中被解决时可以抛出给调用
       者
       当程序遇到一个满足语法，但不满足业务要求时，可以抛出一个异常告知调用者
       throws：当一个方法中使用throw抛出一个检查异常时，就要在该方法上使用throws声明这
       个异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译编译。
       注意：当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这
       个异常，否则编译不通过。 处理手段有两种:
       使用try-catch捕获并处理这个异常
       在当前方法上继续使用throws声明该异常的抛出给调用者解决。 具体选取那种取
       决于异常处理的责任问题。
       不要在main()方法上throws。
       自定义异常：通常用于定义业务逻辑上的异常，一般要符合如下规则：
       类名要见名知意
       继承Exception(直接继承或间接继承)
       提供超类异常所提供的所有构造器
3. 常见的RuntimeException的子类：----运行时异常
       NullPointerException：空指针异常，当程序通过引用去打点，但引用的值为null时，抛出该
       异常
       ArrayIndexOutOfBoundsException：数组下标越界异常，当使用数组下标超出范围时，抛
       出该异常
       StringIndexOutOfBoundsException：字符串下标越界异常，当使用字符串下标超出范围
       时，抛出该异常
       ClassCastException：类型转换异常，当引用类型强转不符合强转条件时，抛出该异常
       NumberFormatException：数字格式化异常，当试图将字符串转成某种类型，但不能正常转
       换时，抛出该异常


socket笔记：
1. Socket(套接字)：封装了TCP协议的通讯细节，我们使用它可以与服务端建立网络链接，
   并通过它获取两个流(一个输入一个输出)，然后使用这两个流的读写操作完成与服务端的数据交互

   - OutputStream getOutputStream()：获取一个字节输出流，通过这个输出流写出的字节数据会通过网络发送给对方。
   - InputStream getInputStream()：获取一个字节输入流，读取的是远端计算机发送过来的数据。

2. ServerSocket：运行在服务端，作用有两个:

   - 向系统申请服务端口，客户端的Socket就是通过这个端口与服务端建立连接的。

   - 监听服务端口，一旦一个客户端通过该端口建立连接则会自动创建一个Socket，并通过该Socket与客户端进行数据交互。

     > 如果我们把Socket比喻为"电话"，那么ServerSocket相当于是"某客服中心的总机"。

3. TCP连接中的三次握手和四次挥手：

   - 客户端与服务端建立TCP连接时需要进行三次握手(见图)
   - 双方断开链接时要进行四次挥手(见图)