Java基础笔记

目录
02进制 2
03函数及数组初识 3
05面向对象1 5
06面向对象2 6
07继承和接口 8
08多态 9
09内部类和异常 10
10异常和包 11
11多线程 12
12多线程 13
13String 14
14集合框架 17
15泛型 21
16Map集合 24
17集合框架类collections 25
18其他对象和IO流 25
18IO流 26
19IO流 27
20IO流 29
21IO流 31

02进制
十进制转二进制：
原理：对十进制数进行除2 取余。

变量：就是将不确定的数据进行存储。也就是在内存中开辟一个空间。
定义变量格式：数据类型 变量名=初始化值；
什么时候定义变量？

1. 当数据不确定时；
2. 对数据需要进行存储时；

Byte型取值范围：-128到127；
Short型取值范围：-32768到32767；
Char类型需要单引号；
Boolean类型取值范围：true or false；

转义字符：通过\来转变后面字母或者符号的含义，写在被转义字符的前面
\n：换行：
\b：退格：相当于backspace
\r：按下回车键：
\t：制表符：相当于tab键

赋值：
+= ：把左右两边加起来赋给左边

逻辑运算符：用于连接Boolean类型的逻辑表达式
&(与)：只要两边的Boolean表达式结果，有一个为false，则结果为false。只有两边都为true则结果为true
|（或）：只要两边的Boolean表达式结果，有一个为true，则结果为true。只有两边都为false则结果为false
^（异或）:只要两边的Boolean表达式结果，两边相同结果为false，两边不同结果为true

位运算符：
<<:乘以2的移动的位数次幂。

:处以2的移动的位数次幂。

程序流程控制：
1、顺序结构：
2、判断结构：
○1if（条件表达式）满足条件-{执行语句}；
○2if（条件表达式）满足条件-{执行语句}
不满足---->else{执行语句}
If else 结构 简写结构： 变量=（条件表达式）？表达式1：表达式2；
三元运算符：好处（可以简写if else 代码。）弊端（因为是一个运算符，所以运算完必须有一个结果）
三元运算符格式：c=a>b?100:200;注：如果a>b把100赋给c，如果a<b把200赋给c。
○3if （条件表达式）{执行语句；}
else if（条件表达式）{执行语句；}
·····
else {执行语句；}//多次判断
3、选择结构（switch语句）
Switch（表达式）{
case 取值1：
执行语句；
Break；
Case 取值2：
执行语句；
Break；
…………
default：
执行语句；
break；
}
注：如果判断的数值不多时而且符合byte、short、int、char这四种类型，建议使用switch语句判断，因为效率稍高；对结果为布尔型或者为区间时用if语句，if适用范围更广；
03函数及数组初识
1、 循环结构：while、do while、for
○1while：先判断条件，只有满足条件才执行循环体。While（条件表达式）{执行语句；}
○2do while：先执行循环体再判断条件，条件满足，再继续执行循环体。do {执行语句；}while（条件表达式）；
○3for（初始化表达式；循环条件表达式；循环后的表达式）{执行语句；}
注释：变量有自己的作用域；for和while可以进行互换。如果需要定义循环增量。For更为合适；当要对某些语句执行很多次时，使用循环结构。
2、 循环语句的其他特点：
○1无限循环最简单的表达形式：
for（ ； ； ）{}
while （true）{}
break：跳出当前所在循环；
continue：只能作用于当前循环，用于结束本次循环开启下次循环
注：break和continue单独存在时下方不能有任何语句，因为执行不到
标号：只能用于循环上，给循环起名字
3、 函数的定义：
○1什么是函数？
函数是定义在类中具有特定功能的一段独立小程序。
函数也叫做方法。
○2函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，……）
{
执行语句；
return 返回值；
}
返回值类型：函数运行后结果的数据类型；
参数类型：是形式参数的数据类型；
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数；
实际参数：传递给形式参数的具体数值；
Return：用于结束函数；
返回值：改值会返回给调用者；
4、 函数的特点：
○1定义函数可以将代码进行封装；
○2便于对该功能进行复用；
○3函数只有被调用才能执行；
○4函数的出现提高了代码的复用性；
○5对于函数没有具体返回值的情况，返回值类型用关键字void表示，该函数的return语句可以省略不写；
○6主函数的功能：调用函数
○7注意：函数中只能调用函数，不可以在函数内部定义函数；定义函数时，函数的结果只能返回给调用者，交由调用者处理。类型是void的函数不能在输出语句里面输出
5、 函数的重载：
○1重载的概念：一个类中只允许存在一个以上的同名函数，只要他们的函数类型跟函数个数不同即可。
○2重载的特点：与返回值类型无关只看参数列表。
○3重载的好处：方便阅读优化了程序设计
6、 数组的定义：
○1概念：同一种类型数据的集合。其实数组就是一个容器。
○2数组的好处：可以自动给数组中的元素从零开始编号，方便操作这些数据。
○3定义格式：元素类型[ ] 数组名=new 元素类型[ 元素个数或者数组长度]
元素类型 数组名[ ]=new 元素类型[ 元素个数或者数组长度]
05面向对象1
一、 理解面向对象：
1、 面向对象是相对面向过程而言；
2、 面向对象和面向过程都是一种思想‘
3、 面向过程强调的是功能行为；
4、 面向对象强调的是将功能封装成对象，强调了具备功能的对象；
5、 面向对象是基于面向过程的
二、 面向对象的三个特征：
1、 封装；
2、 继承；
3、 多态
三、 定义一个类就是在描述事物，在定义属性和行为；属性对应类中的变量，行为对应类中的方法（函数）；属性和行为共同成为类中的方法；类类型变量指向对象
四、 匿名对象使用方法：
1、 当对象的方法只调用一次时，可以用匿名对象来完成；如果一个对象进行多个成员调用必须给这个对象起一个名字；
2、 匿名对象可以作为实际参数来进行传递
3、 格式：
五、 封装：（Encapusulation）指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
1、 好处：
○1将变化隔离；
○2便于使用；
○3提高重用性；
○4提高安全性；
2、 封装原则：
○1将不需要对外提供的内容全部隐藏起来。
○2把属性都隐藏，提供公共方法对其访问。
3、 private（私有；权限修饰符）：用于修饰类中的成员（成员变量；成员方法），私有指只在本类中有效
六、 构造函数：
1、 特点：
○1函数名与类名相同；
○2不用定义返回值类型；
○3不可以写return语句；
2、 作用：给对象进行初始化。
3、 注意：
○1默认构造函数的特点；
○2多个构造函数是以重载的形式存在的
○3对象一建立就会调用与之对应的构造函数
○4当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数
4、 构造函数与一般函数的不同：
○1写法不同
○2运行方法不同：构造函数一建立就运行，给对象初始化。一般函数是对象调用才运行，给对象添加对象具备的功能
○3一个对象建立，只运行一次构造函数；而一般方法可以被该对象调用多次
5、格式：类名+{ };
七、 构造代码块：
1、 作用：给对象进行初始化，对象一建立就运行，并且优先于构造函数运行
2、 构造函数和构造代码块的区别：构造代码块是给所有对象进行统一初始化，构造函数是对相对应的对象进行初始化。
3、 注意：构造代码块中定义的是不同对象的共性的初始化内容。
4、 格式：{ };
八、 this关键字：区分局部变量和成员变量同名的情况。代表所在函数所属对象的引用，简单说哪个对象在调用this所在的函数，this就代表哪一个对象
06面向对象2
一、 static（静态关键字）：用于修饰成员（成员变量和成员方法）
1、 被修饰的成员具有以下特点：
○1随着类的加载而加载；随着类的消失而消失；静态的成员（变量/方法）称为类（变量/方法）
○2优先于对象存在
○3被所有对象共享
○4可以直接被类名调用
2、 使用注意：
○1静态方法只能访问静态成员；非静态方法可以访问静态也可以访问非静态
○2静态方法中不可以写this和super关键字；因为静态优先于对象存在
○3主函数是静态的
3、 实例变量和类变量的区别：
○1存放位置：
类变量随着类的加载而存在于方法区中
实例变量随着对象的建立存放于堆内存中
○2生命周期：
类变量的生命周期最长，随着类的消失而消失
实例变量随着对象的消失而消失
4、 静态的利处和弊端：
○1利处：对对象的共享数据进行单独空间存储，节省空间；并且静态可以直接被类名调用。
○3弊端：生命周期过长；访问出现局限性（静态成员方法只能访问静态的成员方法和静态的成员变量）
5、 什么时候定义静态函数（功能/方法）
当该功能并没有访问到非静态数据（对象的特有数据）时，就可以把该函数定义成静态的
6、 静态代码块：
格式：
Static{}
特点：随着类的加载而执行，只执行一次，并优先于主函数执行,用于给类进行初始化
7、 静态代码块：给类初始化；
构造代码块：给对象初始化；
构造函数：给对对应的对象进行初始化
8、 例：类名 变量=new 类名（）；
问：这句话做了什么？
○1new用到了一个类，所以先找到类文件并将其加载到内存中
○2如果该类有静态代码块，则用静态代码块对类进行初始化
○3在堆内存中开配空间，分配内存地址
○4在堆内存中建立对象的特有属性，进行默认初始化
○5对对象的特有属性进行显示初始化
○6对对象的构造代码块进行初始化
○7对对象相对应的的构造函数进行初始化
○8将内存地址值赋给栈内存中的变量
07继承和接口
一、 继承

1. 提高了代码的复用性
2. 让类与类之间产生了关系。有了这个关系，才有了多态的特性
3. 注意：不要为了获取其他类的功能，简化代码而继承；必须是类与类之间存在所属关系才能继承
   二、 覆盖：当父类与子类中有一摸一样的函数时，当类调用该函数时会运行子类函数中的内容，如同父类的函数被覆盖了一样（重写）。当子类继承父类，沿袭了父类的功能功能到子类中，子类具备该功能但功能类型却不一样这时没必要在子类中定义新的功能，利用覆盖的特性保留子类的功能定义，并且重写功能内容。
   注意：子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖；静态只能覆盖静态
   三、子父类出现后，类成员的特点
   类中成员：
4. 变量：如果父类和子类中出现非私有同名成员变量时，子类要访问本类中的变量，用this关键字；如果要访问父类中的变量，用super关键字；在Java中super和this使用基本一致；this代表本类对象引用，super代表父类对象引用。
5. 函数：
6. 构造函数：对子类对象进行初始化时，父类构造函数也会运行，因为子类中默认的构造函数默认第一行有一条隐式的语句super（）；
   问：为什么子类一定要访问父类中的构造函数？
   因为父类中的数据子类可以直接获取，所以在子类对象建立时，先查看在父类中时如何对这些数据进行初始化的，所以子类在进行对象初始化时，需要先访问一下父类中的构造函数，如果要访父类中得指定的构造函数时，可以通过手动定义super（）语句进行指定。
   注意：super语句必须定义在子类构造函数的第一行。
   结论：子类中所有的构造函数都会默认访问父类中的空构造函数。当父类中没有空参数的构造函数时，子类必须通过super或者this语句形式来指定要访问的构造函数。子类中的第一行也可以手动指定this语句进行访问本类中的构造函数。构造函数第一行只能有一个super或者一个this。子类中至少会有一个构造函数访问父类中的构造函数
   四、 Final（最终）关键字
7. final可以修饰类、方法、变量。
8. final修饰的类不可以被继承。
9. final修饰的方法不可以被覆盖。
10. final修饰的变量是一个常量，只能被赋值一次。常量书写时必须全部大写，单词之间用_连接。
11. 内部类只能访问被final修饰的局部变量
    五、 抽象类（abstract）特点：
12. 抽象方法一定定义现在抽象类中
13. 抽象方法和抽象类一定被abstract关键字修饰
14. 抽象类不可以被new创建对象，因为调用抽象方法没有意义
15. 抽象类中的方法只要被使用，必须由子类复写所有抽象方法后创建子类对象调用。如果只覆盖了部分抽象方法，那么该子类还是一个抽象类
16. 注意：抽象类和普通类没有什么不同，只不过是多了一些不确定的部分，也就是该方法的功能，需要明确出现，但是无法定义主体。抽象类比一般类中多了一个抽象方法。抽象类不可以被实例化，抽象类中也可以不定义抽象方法，这样做仅仅是为了不让这个抽象类建立对象。
    六、接口（interface）：一个特殊的抽象类；如果一个类中所有的方法都是抽象的，那么可以将它定义成为接口；class用于定义类；interface用于定义接口
    1、格式特点：
    ○1接口中常见定义：常量、抽象方法。
    ○2接口中的成员都有固定的修饰符。
    常量：public static final 。
    方法：public abstract 。
    注：接口中的成员都是public的。接口不可以创建对象，因为有抽象的方法，需要被子类实现，子类对接口的抽象方法全部覆盖后才可以进行实例化，否则子类仅仅是一个抽象类
    2、接口继承的关键字：implements
    3、接口的特点：
    ○1接口是对外暴露的规则。
    ○2接口是程序功能的扩展。
    ○3接口可以用来多实现。
    ○4类与接口之间是实现关系，而且类可以继承一个类同时实现多个接口。
    ○5接口与接口之间可以有继承关系。

08多态
一、多态：某一种事物的多种存在形态。
1、多态的体现：父类引用指向了自己的子类对象；父类引用也可以接收自己的子类对象。
2、多态的前提：必须是类与类之间有关系，要么继承要么实现；存在覆盖。
3、多态的好处：多态的出现大大提高了代码的复用性。
4、多态的弊端：虽然提高了扩展性，但是只能是使用父类的引用访问父类中的成员
二、instanceof（类型判断）
三、
1、在多态中成员函数的特点：编译看左边，执行看右边
○1在编译时期：参阅引用型变量所属的类中是否有调用方法，有？编译通过：编译失败；
○2在运行时期：参阅对象所属类中是否有调用方法。
2、在多态中成员变量的特点：无论编译运行，都看左边
3、在多态中静态成员函数的特点：无论编译运行，都看左边
09内部类和异常
一、内部类：将一个类定义在另一个类的里面，对里面的那个类就称为内部类（内置类/嵌套类）。
1、访问特点：内部类可以直接访问外部类的成员，包括私有成员。内部类之所以可以访问外部类成员，因为内部类持有一个外部类引用，其格式是：外部类.this；外部类访问内部类成员必须要建立内部类对象
2、当内部类在外部类的成员位置上时，内部类可以被private和static修饰
注意：当内部类被static修饰时，内部类只能访问外部类中的静态成员，出现了访问局限性
3、访问格式：内部类定义在外部类成员位置上，并且非私有，可以在其他外部类中直接建立内部类对象，格式：外部类.内部类 类名=new 外部类().new 内部类();
4、在外部其他类中访问静态内部类的非静态成员的格式：new 外部类.内部类().内部类非静态方法()；
5、在外部其他类中访问静态内部类的静态成员的格式：外部类.内部类.静态方法();
6、当内部类定义了静态成员，该内部类必须是静态的；当外部类中的静态方法访问内部类时，内部类也必须是静态的。
7、内部类定义原则：在描述事物时，事物内部还有事物，该事物用内部类来描述。内部类事物在使用外部类事物
8、内部类定义在局部时：
○1不可以被成员修饰符修饰
○2可以直接访问外部类中的成员，但是不能访问他所在局部中的变量。只能访问局部中被final修饰的局部变量。
二、匿名内部类：是内部类的一个简写格式
1、定义匿名内部类的前提：内部类必须定义一个类或者实现一个接口
2、匿名内部类的书写格式：new 父类/接口(){定义子类内容}
3、匿名内部类其实是一个子类对象
4、匿名内部类中定义的方法最好不要超过三个
一、异常：程序在运行时出现的不正常情况
1、异常的由来：问题也是现实生活中的一个具体事物，可以通过Java 类进行描述，并封装成对象。
2、对问题的划分：严重问题；非严重问题。
○1对于严重问题，Java通过Error类进行描述。
○2对于非严重问题，Java用Exception类进行描述。
3、throwable
○1error
○2exception
4、 try{ }
catch（Exception e）{ }
finally{ }
5、对于多异常的处理：
○1声明异常时，建议声明更为具体的异常，这样处理也会更为具体
○2有几个异常就写几个catch块，不要定义多余的catch快，当catch块中的异常出现继承关系，父类catch异常放在最下面。
二、自定义异常：因为项目中出现一些特有问题，这些问题未被Java描述封装对象，对这些特有的问题可以按照Java对问题封装的思想，对特有的问题，进行自定义封装
1、继承Exception原因：
异常 体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
2、throw和throws的区别：
○1throw定义在函数内；throws定义在函数上。
○2throw用于抛出异常对象；throws用于抛出异常类，可以跟多个，中间需要用逗号隔开。
3、RuntimeException(运行时异常)：是Exception中一个特殊的子类，如果函数内容抛出该异常函数可以不用声明，编译一样通过。如果函数上声明了该异常，调用者可以不用进行处理。编译通过。
4、自定义异常时，如果该异常发生导致下面程序无法继续进行运算，自定义异常类时就让它继承RuntimeException类

10异常和包
一、finally：存放着一定会被系统执行的代码（不管出不出现异常，代码一定会被执行）。通常用于关闭资源。例如“数据库连接”等等。
注意：只有一种情况finally读不到：System.exit(0);
二、异常在子父类覆盖的体现 ：
1、子类在覆盖父类时，如果父类方法抛出异常，子类的覆盖方法只能抛出父类的异常或者父类抛出异常的子类。
2、如果父类方法抛出多个异常，子类覆盖该方法时只能抛出父类异常的子集或者不抛。
3、如果父类方法没有异常抛出，子类在覆盖该方法时，也不可以抛出异常，如果有异常发生，必须进行try处理，在内部解决，绝对不能抛出
二、包：
1、对类文件进行分类管理。
2、给类提供多层命名空间。
3、写在程序的第一行。
4、类名的全称是 包名.类名。
5、包也是一种封装形式。
编译格式：javac -d 编译文件产生位置 文件名
运行格式：java 包名.类名
6、总结：
○1包与包之间进行访问，被访问包的类及其成员方法需要用public修饰
○2不同包之间的子类可以访问父类中用protectde权限修饰的成员
○3包与包之间的访问权限只有两种 public protected
Public Protected Default Private
同一个类中 Yes Yes Yes Yes
同一个包中 Yes Yes Yes
子类 Yes Yes
不同包中 Yes
三、jar包：Java的压缩包
1、作用：
○1方便项目的携带
○2便于使用

11多线程
一、多线程
1、进程：正在进行中的程序，每一个进程都有一个执行顺序，该顺序是一个执行路径(控制单元)
2、线程：是进程中一个独立的控制单元，控制着进程的执行(一个进程至少有一个线程)
3、多线程存在的意义：提升程序运行速度。
4、多线程的特性：随机性
5、setName()：设置线程名称。
6、currentThread()：获取当前线程对象。
7、getName()：获取线程名称。
8、创建线程的方法：
○1继承Thread类
○2复写Thread类中的run方法
目的：将自定义代码存放在run方法中。让线程运行
○3通过start方法让Java虚拟机调用该线程中的run方法
注释：为什么要覆盖run方法？
Thread类用于描述线程，run方法用于存储线程要运行的代码，start的作用是启动run方法
9、创建线程的另一种方法
○1创建类实现Runnable接口
○2覆盖Runnable接口中的run方法
○3创建Thread对象
○4将Runnble接口的子类的对象作为一个实际参数传递给Thread类
○5使用Thread类对象调用start()方法开启线程并调用Runnable接口子类中的run方法
为什么要将Runnable接口的子类对象传递给Thread的构造函数？
因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
10、实现方式和继承方式有什么区别呢？
实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。
11、两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法
12、多线程同步代码块：
synchronized（对象）{需要被同步的代码}
前提：需要两个及其两个以上的线程；必须是多个线程使用一段代码
好处：解决了多线程的安全问题。
弊端：较为消耗资源
13、同步函数：用synchronized修饰的函数具备同步的特性。
14、同步函数用的锁是this
15、静态同步函数用的锁是“类名.class”
12多线程
1、○1wait:○2notify();○3notifyAll();都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
2、JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
○1condition 类提供了signal、signal、await方法替代了object类中的notify、notifyAll、wait方法。
○2、ReentrantLock类实现了Lock接口，提供了lock()、unlock()还可以通过调用newCondition()方法来获取一个condition实例。
3、stop方法已经过时。如何停止线程？
只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。
特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类提供该方法 interrupt();
4、守护线程： setDaemon (Boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。
5、join()方法：当A线程执行到了B线程的join方法时，A就会等待，等待B线程执行结束，A线程才会执行。
Join方法可以用来临时加入线程进行执行。
6、Threat类中的.toString()方法覆盖了object类中的toString()方法用来以字符串的方式返回当前线程的名称、优先级(代表抢资源的频率)及其它的线程组(线程A启动了线程B，则线程B属于线程A的组)。
7、设置线程优先级：Thread.setPriority(int newPriority)更改线程的优先级。
8、Thread类中的yield()方法：暂停当前正在执行的线程对象，并执行其他线程
13String
一、String类：
1、String s1=”abc”;s1是一个类类型的变量，abc是一个对象，字符串最大的特点是一旦被初始化进不能改变
2、String s1=new String(“abc”)与String s1=“abc”是一样的
s1和s2的区别：
○1s1有一个对象，s2有两个对象
二、String类的常见功能
1、获取：
○1字符串包含的字符数。也就是字符串的长度。int length()方法。
注意：length()是获取字符串长度。length是获取数组长度
○2根据位置获取这个位置上的某个字符：char charAt(int index)
○3根据字符获取该字符在字符串中的位置:
int indexOf(int ch)返回ch在字符串中第一次出现的位置
int lastIndexOf(int ch)返回ch在字符串中最后一次出现的位置
int indexOf(String str)返回str在字符串中第一次出现的位置
int lastIndexOf(String str) 返回在此字符串中最右边出现的指定子字符串的索引
int indexOf(int ch, int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置
int lastIndexOf(int ch, int fromIndex)从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此字符串中的索引。
int indexOf(String str int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置
int lastIndexOf(String str, int fromIndex)从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。
2、判断
○1字符串中是否包含某一个子字符串：boolean contains(str)
○2字符串中是否有内容：boolean isEmpty()当length为零时返回false
○3字符串是否以指定内容开头：boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始。
○4字符串是否以指定内容结尾：boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。
○5判断字符串内容是否相等：String()类中覆写了object类中的equals()方法，用来比较两个字符串是否相同
○6判断内容是否相同，并且忽略大小写：boolean equalsIgnoreCase();
3、转换：
○1将字符数组转成字符串：
构造函数：String (char [] value)
String(char[] value, int offset, int count)将字符数组的第offset到第count部分转换成字符串
静态方法：static String copyValueOf(char[] value)相当于String(char[] value)
static String copyValueOf (char[] value, int offset, int count)相当于String(char[] value, int offset, int count)
○2将字符串转成字符数组：char[] toCharArray ():
○3将字节数组转成字符串：String (byte [])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
○4将字符串转成字节数组：byte [] getBytes ()
○5将基本数据类型转成字符串：static String valueOf(int)
static String valueOf(double)
4、替换：String replace(oldchar,newchar);char类型替换
String replace(CharSequence target, CharSequence replacement) 字符串替换
将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。
5，切割String[] split(regex);regex代表分割符
6，子串。获取字符串中的一部分。String substring(begin);从指定位置开始到结尾
String substring(begin,end);包含头不包含尾
7，转换，去除空格，比较。
○1将字符串转成大写或则小写。String toUpperCase();
String toLowerCase();
○2将字符串两端的多个空格去除。String trim();
○3对两个字符串进行自然顺序的比较。int compareTo(string);
二、StringBuffer(字符串缓冲区)
特点
○1是一个容器，
○2长度是可变化的，
○3可以直接操作多种数据类型，最终会通过tostring方法变成字符串。
1、存储：StringBuffer append():将指定数据作为参数添加到已有数据结尾处
StringBuffer insert(int 位置，数据):将指定数据插入到指定位置
2、删除：StringBuffer delete(int start,int end)删除start到end之间的数据，包含start不包含end。
StringBuffer deleteCharAt(index)删除指定位置的字符
3、获取：char charAt(index):通过角标获取字符；
int indexOf(String str):通过字符串获取位置
int lastindexOf(String str): 返回在此字符串中最右边出现的指定子字符串的索引。
int length():获取长度。
String substring(begin);从指定位置开始到结尾
String substring(begin,end);包含头不包含尾
4、修改:StringBuffer replce(int start,int end,String str)将指定位置的字符串用str字符串代替。
void setCharAt(int index,char ch):将index角标位的字符替换成ch
5、反转：StringBuffer reverse()
6、将缓冲区中的指定数据存储到指定字符数组中的指定位置：void getChars(int scrBegin,int scrEnd,char[] ch,int chBegin)
7、jdk1.5版本以后出现了StringBuilder
StringBuffer是线程同步，多线程使用安全
StringBuilder是线程不同步，但是可以提高效率，可在单线程时使用
三、基本数据类型数据包装类
基本数据类型 byte short int long boolean float double char
引用数据类型 Byte Short Integer Long Boolean Float Double Character
基本数据类型对象包装类的最常见作用是用于基本数据类型和字符串类型之间的转换
○1基本 数据类型转成字符串：
基本数据类型+””
基本数据类型.toString(基本数据类型值);
○2字符串转基本数据类型：
static int parseInt(String s)
static long parseLong(String s)
static byte parseByte(String s)
static short parseShort(String s)
static boolean parseBoolean(String s)
static float parseFloat(String s)
static double parseDouble(String s)
○3十进制转二进制
Integer.toBinaryString()
○4十进制转十六进制
Integer.toHexString()
○5十进制转八进制
Integer.toOctalString()
○6其它进制转十进制
Integer.parseInt(“3c”,16)
Integer.parseInt(“110”,2)
Integer.parseInt(“123”,8)
14集合框架
一、集合类
1、为什么会出现集合类？
面向对象的语言对事物的体现都是以对象的形式，所以为了方便对多个对象进行操作，就对对象进行存储。集合是存储对象的一种最常用的方式。
2、数组和集合类同是容器，有何不同？
○1数组也可以存储对象但长度是不变的；集合的长度是可变的。
○2数组中可以存储基本数据类型；集合只能存储对象
3、集合类的特点：
○1集合只能用于存储对象。
○2集合的长度是可变的。
○3集合可以存储不同和类型的对象。
4、为什么会出现这么多的容器？
因为每一个容器对数据的存储方式都有不同。我们称之为“数据结构”。

5、迭代器Iterator：用于集合中取出元素的方式；
○1判断：boolean hasNext()如果仍有元素可以迭代，返回true
○2取出：E next()返回迭代的下一个元素
○3移除：void remove()从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。
示例：
ArrayList a1=new ArrayList；
a1.add(“java”);
a1.add(“java1”);
a1.add(“java2”);
Iterator t1=a1.iterator()
6、Collection(单列集合)方法摘要：
○1增加：add(e)将对象添加到容器中
addAll(collection)将集合添加到集合中
○2删除：remove(e)删除对象：底层调用的equals()方法
removeAll(collection)
clear()清空集合
○3判断：contains(e)判断对象在集合中是否存在：底层调用的equals()方法
isEmpty()判断集合是否为空
○4获取：Iterator iterator()获取迭代器，用于取出集合中的元素
size()获取集合长度
○5获取交集：retianAll()
○6集合变数组： t[] toArray(T[] a)
例：String[] arr=al.toArray(new String[al.size()])
指定类型的数组到底要定义多长？当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，集合长度为size。当所指定类型的数组长度大于了集合的size，就不会创建一个新的数组，而使用传递进来的数组。多余的长度用null填充，所以创建一个刚刚好的数组最好。
为什么要集合变数组？限制对集合的操作，不需要进行增删了
7、List：元素是有序的，元素可以重复，该集合体系有索引
特有方法：只要是可以操作角标的方法都是该集合特有方法。
○1添加：add(index,element)在指定位置添加一个元素
add(index,collection)在指定位置后添加一堆元素
○2删除：remove(index)根据角标删除对象
○3修改：set(index,element)将角标位置的元素替换
○4查询：get(index)返回角标位置的元素
subList(from,to)获取from到to之间的对象，包含form不包含to
indexOf(obj)通过对象获取对象位置
8、List集合特有的迭代器listIterator()，它是Iterator的子接口。在迭代过程中，不可以通过集合对象的方法来操作集合中的元素，因为会出现并发修改异常(ConcurrentModificationException)。所以在迭代时只能用迭代器的方法来操作元素，但是，Iterator的方法是有限的，只能进行判断、取出、删除操作，所以想要进行其他操作例如：添加、修改等操作，需要用到Iterator的子接口ListIterator.该接口只能由List集合的List Iterator方法获取。
○1添加：void add(e)添加一个元素
○2查询：boolean hasNext()正向便利列表，
boolean hasPrevious()反向便利列表,
E next()返回列表的后一个元素
E previous()返回列表的前一个元素
○3修改：void set(E ) 用指定元素替换 next 或 previous 返回的最后一个元素
○4删除：void remove() 从列表中移除由 next 或 previous 返回的最后一个元素
示例
ArrayList a1=new ArrayList；
a1.add(“java”);
a1.add(“java1”);
a1.add(“java2”);
ListIterator t1=a1.listiterator
9、ArrayList：底层数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢。线程不同步
10、LinkedList：底层数据结构使用的是链表数据结构。特点：增删速度很快，查询速度稍慢。
特有方法：addFirst()在头部位置添加。
addLast()在尾部位置添加
getFirst()获取头部
getLast()获取尾部
removeFirst()删除头部
removeLast()删除尾部
注意：如果链表中没有数据会返回NoSuchElementException.在jdk1.6中出现了替代方法：
offerFirst()在头部位置添加
offerLast()在尾部位置添加
peekFirst()获取头部
peekLast()获取尾部
pollFirst()删除头部
pollLast()删除尾部
注意：如果链表中没有数据会返回null。
11、Vector：底层数据结构使用的是数组结构。特点：查询速度慢，但是增删慢。线程同步。枚举是Vector的特有的取出方式。枚举和迭代器是一样的，因为枚举的名称及其方法名都过长，所以被迭代器(Iterator)取代
12、Set：元素是无序的(元素的存入和取出顺序不一定一致)，元素不可以重复，该集合体系没有索引，方法与Collection一致。
13、HashSet：底层数据结构使用的是哈希表。线程是非同步的，存储是无序的。
HashSet是如何保证元素惟一性的？
通过两个元素的方法hashCode和equals来完成，如果两个元素的hashCode值相同，才会会来判断equals，如果两个元素的hashCode值不相同，就不用判断equals。
一般使用集合来存储数据的话，需要复写hashCode和equals方法，因为你可能需要往HashCode里面存储，元素的删除与判断都是依赖于hashCode和equals，而ArrayList对元素的判断仅仅依赖于equals
14、TreeSet：底层的数据结构使用的是二叉树，对Set集合中的元素进行排序
○1保证元素惟一性的依据是：comparato方法return 0；
○2TreeSet排序的第一种方式：让元素具有比较性。元素需要实现(implements)comparable接口，覆盖comparato方法，这种方式称为元素的自然排序，也叫做默认排序。
○3TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的时，这时就需要让集合自身具备比较性，定义比较器，将对象作为参数传递给TreeSet集合的构造函数，当两种排序都存在时以比较器为主。
定义比较器的方法：定义一个类，实现(implements)comparator接口，覆盖compare方法

15泛型
一、泛型：JDK1.5以后出现的新特性。用于解决安全问题，是一个类型安全机制。T t
1、好处：○1将运行时期出现的ClassCastException 异常转移到了编译时期，方便程序员解决问题，让运行事情问题减少，更加安全。
○2避免了强制转换的麻烦
2、泛型格式：通过<>来定义要操作的引用数据类型。
3、什么时候使用泛型？
在集合框架中使用的很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的，使用集合时，将要存储的数据类型作为参数传递到<>中即可。
4、什么时候定义泛型？
当类中要操作的引用数据类型不确定的时候，早期通过定义Object类来完成扩展，现在通过定义泛型来完成扩展
5、泛型类定义的泛型在整个类中有效，泛型类对象在明确具体操作类型后，所要操作的类型就已经固定。
示例在类中定义泛型
class Demo
{
public void show(T t)
{
System.out.println();
}
public void print(T t)
{
System.out.println();
}
}
6、为了让不同的方法可以操作不同的类型，而且类型还不确定，那么可以将泛型定义在方法上,将类型定义在方法上以后，调用函数时往里面传什么类型就操做什么类型。
示例在方法上定义泛型
class Demo
{
public void show(T t)
{
System.out.println(“show = ”+t);
}
public void print(Q q)
{
System.out.println();
}
}
class Demo1
{
public static void main(String[]agrs)
{
Demo d=new Demo();
d.show(“lalala”);
d.show(new Integer(5));
}
}在方法上定义泛型，定义了返回值的前面，修饰符的后面
输出结果：show = lalala
show = 5
7、静态方法不可以访问类上定义的泛型，如静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
方法示例
class Demo
{
public void show(T t)
{
System.out.println(“show:”+t);
}
public static void method(W w)
{
System.out.println(“method:”+w);
}
}
class Demo1
{
public static void main(String[] args)
{
Demo d = new Demo();
Demo.method(new Integer(666));
}
}
在方法上定义泛型，定义了返回值的前面，修饰符的后面
输出结果：666
8、可以在类与方法上定义不同的泛型
方法示例
class Demo
{
public void show(T t)
{
System.out.println(“show:”+t);
}
public void print(Q q)
{
System.out.println(“print:”+q);
}
}
class Demo1
{
public static void main(String[] args)
{
Demo d = new Demo();
d.show(“haha”);
d.print(5);
d.print(“hehe”);
}
}
输出结果：show：haha
print：5
print：hehe
9、泛型定义在接口上的两种实现方法：
○1方法1
interface Inter
{
void show(T t);
}
class InterImpl implements Inter
{
public void show(String t)
{
System.out.println(“show :”+t);
}
}
class Demo
{
public static void main(String[] args)
{
InterImpl i = new InterImpl();
i.show(“haha”);
}
}
输出结果：haha
○2方法2
interface Inter
{
void show(T t);
}
class InterImpl implements Inter
{
public void show(T t)
{
System.out.println(“show :”+t);
}
}
class Demo5
{
public static void main(String[] args)
{
InterImpl i = new InterImpl();
i.show(4);
}
}
二、泛型高级应用：
1、？通配符；也可以理解为占位符。
2、泛型的限定：？ extends E：可以接收E类型或者E的子类型：上限
？ super E：可以接收E类型或者E的父类型：下限
16Map集合
一、Map集合：该集合存储键值对，一对一对往里存，而且要保证键的惟一性。(双列集合；一一对应)
1、添加：put(K key,V value)将指定值与映射中指定键关联，当对相同键添加不同值时，新的值会把旧的值替代，并将旧的值返回回来。
putAll(Map<? extends K,?extend V>m)
2、删除：clear()从映射中移除所有映射关系。
remove(Object key)如果存在一个键的映射关系，则将此从映射中移除。
3、判断：cotainsKey(Object key)如果次映射包含指定键的映射关系，返回true。
conrainsValue(Object value)如果此映射将一个或者多个键映射到指定值，返回true。
equals(Object o)比较指定对象与此映射是否相等。
isEmpty()如果此映射未包含键——值映射关系。返回true。
4、获取：get(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，返回null。
hasCode()返回此映射的哈希值。
size()返回此映射中的键 值映射关系数。
Valus()返回此映射中包含值的Collection视图。返回值类型为Collection
Set<Map.Entry<K,V>> entrySet():将Map集合的映射关系存入到了Set集合中，这个关系的数据类就是：Map.Entry
Set keySet():将Map中所有的键取出存入Set集合中，Set具备迭代器，用迭代方式取回所有的键，根据get方法，获取每一个键对应的值
5、Hashtable：底层是哈希表数据结构，不可以存入null键和null值，该集合是线程同步的。jdk1.0出现，效率底
6、HashMap：底层是哈希表数据结构，允许存入null键和null值，该集合是不同步的，jdk1.2出现，效率高
7、TreeMap：底层是二叉树结构，线程不同步，可以用于给map集合中的键进行排序
注：Map集合和Set集合很像，因为Set底层就是使用了Map集合。
Map集合的取出原理：将Map集合转成Set集合，通过迭代器取出
什么时候使用Map集合呢？当数据之间存在映射关系时，就要先想到Map集合
Map扩展知识：map集合被使用是因为具备映射关系
17集合框架类collections
一、collections集合工具类：
1、Collections.sort(集合A):给集合A排序
Collections.sort(集合A，比较器):给集合A用比较器排序
2、Collections.max(集合)取集合的最大值
Collections.sort(集合A，比较器):根据比较器取出最大值
3、Collections.binarySearch(要查找的集合，要查找的值)通过二分查找法搜索List获得指定对象（搜索的List集合必须是有序的）
4、Collections.fill(集合,”A”)将几何中所有元素替换成A
5、Collections.replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
6、Collections.reverse(List<?> list) 反转指定列表中元素的顺序
7、Collections.reverseOrder()返回一个比较器，它对实现 Comparable接口的对象集合施加了自然排序的相反。
8、Collections.reverseOrder(Comparator cmp)返回一个比较器，它强制指定比较器的反向排序。
9、Collections.synchronizedList(List list)返回由指定列表支持的同步（线程安全）列表。
10、Collections.synchronizedMap(Map<K,V> m)返回由指定地图支持的同步（线程安全）映射。
11、Collections.synchronizedSet(Set s)返回由指定集合支持的同步（线程安全）集。
12、Collections.swap(List<?> list, int i, int j)交换指定列表中指定位置的元素。
13、Collections.shuffle(List<?> list)对集合进行随机重新排列
二、Arrays：用于操作数组的工具类，里面都是静态方法
1、Arrays.asList(T… a) 将数组转变成集合
将数组变成集合的好处：可以用集合的思想和方法来操作数组中的元素。
注：将数组变成集合，不可以使用集合中的增删方法来进行操作，因为数组的长度是固定的，如果数组中的元素都是对象那么变成集合时，数组中的元素直接转换成集合中的元素，如果数组中的元素都是基本数据类型，那么将该数组作为集合中的元素存在。
三、增强for循环
格式：for(数据类型 变量名：被遍历的集合(Collection)或者数组)
局限性：对集合进行遍历，只能获取元素，不能对集合进行操作
四、可变参数：jdk1.5出现的新特性。
可变参数其实就是数组的简写形式。不用每一次都手动建立数组对象。只要将这些要操作的元素作为参数传递即可，隐性的将这些参数封装成了数组。
注意：可变参数一定要定义在参数列表的最后面。
18其他对象和IO流
一、System类：类中的方法都是静态的
out：标准输出；默认是显示器
in：标准输入，默认是键盘
Properties 变量名=System.getProperties()获取系统属性信息：因为Properties是Hashtable的子类，也就是说他是Map集合的子类对象，那么可以通过map集合中的方法取出该集合中的元素。该集合中存储的是字符串，没定义泛型
二、Runtime类：每一个Java程序都有一个Runtime类实例，能够使程序与其运行环境相连接。可以使用getTime方法获取当前运行时。应用程序不能创建自己的Runtime类实例
1、Runtime类并没有构造方法，说明它不能创建对象，可是该类中还有非静态方法，这让我们想到了“单例设计模式”。说明该类肯定会提供方法来获取本类对象。并且该方法是静态的，返回值类型也是本类类型。通过查阅api发现该类获取对象的方法是getRuntime，静态的，返回值类型是Runtime。
Runtime 变量名=Runtime.getRuntime()
变量名.exec(“启动的程序路径”)启动进程
变量名.destroy()杀死进程
三、Date类：
四、Math类：
18IO流
一、IO流：IO流用来处理设备之间的数据传输。
Java对数据的操作是通过流的方式。
Java对于操作流的对象都在IO包中。
流按数据分为两种：字节流和字符流。
流按流向分为：输入流和输出流。
1、IO流常用基类：
○1字节流的抽象基类：InputStream，OutputStream。
○2字符流的抽象基类：Reader，Writer
注：由这四个类派生出来的子类名称都是以其父类名称作为子类名称的后缀。
例如：InputStream的子类FileInputStream
Reader的子类FileReader。
二、字符流：Reader，Writer。
1、输入流：
void write(char[] cbuf) 写入一个字符数组。
abstract void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(String str) 写一个字符串。
void write(String str, int off, int len) 写一个字符串的一部分。
2、输出流：
int read()读取单个字符
int read(char[] cbuf)将字符读入数组（返回的是读到字符的个数）
abstract int read(char[] cbuf,int off,int len)将字符读入数组的一部分
int read(CharBuffer target)试图将字符读入指定的字符缓冲区
三、FileWriter：专门操作文件的Writer对象，是Writer的子类。
1、FileWriter fw=new FileWriter(“文件存放位置及文件名”)该对象一被初始化就要明确被操作的文件。而且该文件会被创建到指定目录下。如果该目录下有同名文件，原文件将被覆盖。
2、fw.write(“写入的数据”)调用write方法，将字符串写入到流里面去进行暂时存储。
3、fw.flush()刷新流对象中缓存的数据。将数据刷到目的地。
4、fw.close()关闭流资源，但是关闭之前会刷新一次内部缓存中的数据，将数据刷到目的地中，
注意：flush()和close()的区别：flush()刷新后，流可以继续使用，close()刷新后，流将会关闭。
四、FileReader：专门操作文件的Writer对象，是Reader的子类。
1、FileReader fw=new FileReader(“要读取得文件名称”)要确保该文件已经存在，如果不存在，会发生FileNotFoundException
2、fw.read()读取文件的第一个字符，返回值类型是int，可以通过强制转换将其转换为char类型int i=fw.read()；char cha=(char)i；如果读取到了最后一个字符，该read方法将会返回-1，所以可以将-1作为判断条件，如果返回值类型是-1，结束读取。
3、fw.close()读取完成后关闭流。

19IO流
一、BufferedWriter（字符流的输入缓冲区）：字符流缓冲区的出现提高了对数据的读写效率；缓冲区要结合流才能用；在流的基础上对流的功能进行了增强。
1、缓冲区的出现是为了提高流的操作效率出现的，所以在创建缓冲区之前，必须要先有流对象。
○1创建一个字符写入流对象。FileWriter fw=new FileWriter(“x.txt”);
○2为了提高字符写入的流效率，加入了缓冲技术，只需要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可.BufferWriter bfw=new BufferWriter(fw);
○3写入数据：bfw.write(“asiohfdaofhdsjhc”)
○4只要往缓冲区里面写入数据，就需要刷新：bfw.flush();
○5关闭缓冲区，就是关闭缓冲区中的流对象：bfw.close();
2、在BufferWriter中添加了一个新的方法：void newLine()：写入一个行分隔符。
二、BufferedReader（字符流的读取缓冲区/包装类；装饰类）：字符流缓冲区的出现提高了对数据的读写效率；缓冲区要结合流才能用；在流的基础上对流的功能进行了增强。
1、String readLine()读取一个文本行。
三、LineNumberReader(包装类；装饰类)
1、方法：int getLineNumber()获得当前行号。
void SetLineNumber(int lineNumber)设置行号。
String ReadLine()读取文本行
四、字节流：InputStream/OutPutStream
五、字节流的缓冲区：BufferedInputStream/BufferedOutputstream
六、System.out对应的是标准输出设备：控制台。
System.in对应的是标准输入设备：键盘。
例：InputStream in = System.in；
int x = 0;
while((x=in.read())!=-1)
{
System.out.println((char)x);
}
七、字符流和字节流之间的转换：InputStreamReader/OutputStreamWriter：字节流通向字符流的桥梁。
什么时候使用转换流？涉及到字符编码转换时用到转换流
1、InputStreamReader：键盘录入及输出示例
BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
String s=null;
while((s=bfr.readLine())!=null)
{
System.out.println(s.toUpperCase());
}
bfr.close();
2、OutputStreamWriter：键盘录入及输出示例
BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bfr.readLine())!=null)
{
if (“over”.equals(line))
{
break;
}
bw.write(line.toUpperCase());
bw.newLine();
bw.flush();
}
bw.close();
八、流操作的基本规律：
1、明确源和目的：
源：输入流。InputSream/Reader
目的：输出流。OutputStream/Writer
2、操作的数据是否是纯文本：
是：字符流。
不是：字节流。
3、当体系明确后，在明确要使用那个具体的对象(通过设备来区分)
源设备：内存/硬盘/键盘
目标设备：内存/硬盘/控制台

20IO流
一、File类：○1将文件或文件夹封装成对象。
○2方便对文件与文件夹的属性信息进行操作。
○3File对象可以作为参数传递给流的构造函数。
○4了解File类的常用方法。
1、File.separator：目录分隔符。
2、File类的常见方法：
○1创建：boolean creatNewFile();创建一个文件，当目录中没有指定文件，则创建成功，返回true，否则返回false(和输出流不一样，输出流一创建文件，文件就会存在，如果有文件，则会覆盖)
boolean mkdir()创建目录
boolean mkdirs()递归创建多级目录
○2删除：boolean delete()如果删除文件成功，返回true，删除失败或者文件不存在返回false
void deleteOnExit()在程序结束时删除文件
○3判断：boolean canExecute()测试文件是否能执行
boolean canRead()测试文件是否能读
boolean canWrite()测试文件是否能写
int compareTo(File pathname)按字母顺序比较两个抽象路径名
boolean equals(Object obj)测试抽象路径名与给定对象的是否相等
boolean exists()文件或目录是否存在
boolean isDirectory()判断路径名表示的是否是一个目录
boolean isFile()判断路径名表示的是否是一个标准文件
boolean isHidden()判断文件是不是一个隐藏文件
boolean isAbsolute()判断路径名是否为绝对路径名
○4获取信息：
String getName()返回由此抽象路径名表示的文件或目录的名称
String getPath()将抽象字符名称转换成一个路径名称字符串
String getAbsolutePath()返回路径名的绝对路径名字符串
String getParent()返回抽象路径名的父路径名的路径名字符串，如果路径名没有指定父目录，则返回null
File getAbsoluteFile()返回抽象路径名的绝对路径形式
long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间
long length()返回抽象路径表示的文件大小
boolean renameTo(File dest)文件重命名
○5目录：String[] list()获取目录下所有文件名称(调用list方法的File对象必须是封装了一个目录)
String[] list(FilenameFileter filter) 返回由包含在目录中的文件和目录的名称所组成的字符串数组，这一目录是通过满足指定过滤器的抽象路径名来表示的。
File[] listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件
File[] listFiles(FileFilter filter)返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
File[] listFiles(FilenameFilter filter)返回表示此抽象路径名所表示目录中的文件和目录的抽象路径名数组，这些路径名满足特定过滤器。
static File[] listRoots()返回所有卷标
3、递归调用：列出指定目录下的所有文件夹，包含子文件夹中的内容。因为目录中还有目录，使用同一个列出目录功能的函数即可完成。也就是函数自身调用自身，这种表现形式，或者叫做编程手法被称为递归调用。
参考：E:\study video\毕向东\黑马程序员毕向东教程\笔记\20IO流\便利文件夹下的所有文件
注意：
○1递归调用的限定条件。
○2要注意递归的次数，尽量避免内存溢出。
4、window删除原理：在删除目录时是从最里面往外删的
二、Properties类：是Hashtable的子类；也就是说它具备了Map集合的特点，而且它里面存储的键值对都是字符串，不需要泛型。properties是集合和IO技术相结合的集合容器，该对象的特点：可以用于键值对形式的配置文件。在加载数据时，需要数据有固定的格式，即：键=值
1、常用方法：Object setProperty(String Key,String Value)调用Hashtable的put方法
Set StringPropertyName()将键值对关系返回到一个Set集合中
void list(PrintStream out)将属性列表输出到指定输出流
void list(PrintWriter out)将属性列表输出到指定输出流
void load(InputStream inStream)从输出流中读取属性列表（键和元素对）
void load(Reader inStream) 以简单的线性格式从输入字符流读取属性列表（关键字和元素对）。
void stor将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法加载到 Properties表中的格式输出流。
IO包中的其他流
一、打印流：PrintWriter与PrintStream：可以直接操作输入流和文件，该流提供了打印方法，可以将各种类型的数据原样打印
1、字节打印流：PrintWriter：
○1构造函数可以接收的参数类型：
file对象
字符串路径
字节输出流
字符输出流
2、字符打印流：printStream：
○1构造函数可以接收的参数类型：
file对象
字符串路径
字节输出流
二、合并流：SequenceInputStream：
21IO流
一、ObjectOutputStream可以直接操作对象的流
1、构造方法：ObjectOutputStream(OutputStream out)创建写入指定OutputStreamd的ObjectOutputStream。
2、特有方法：void writeObject(Object Obj)将指定对象写入ObjectOutputStream。
二、管道流PipedInputStream/PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用
1、构造方法：PipedInputStream()创建尚未连接的 PipedInputStream。
PipedInputStream(PipedOutputStream src)创建PipedInputStream，以使其连接到传送输出流 src。
2、特有方法：void connect(PipedOutputStream src)使此传送输入流连接到传送输出流 src。
int read(byte[]b,int off,int len)将最多len个数据字节从此传送输入流读入字节数组。
三、RandomAccessFile：随机访问文件，自身具备读写的方法。该类不算是IO体系中的子类。而是直接继承自Object，但他是IO包中的成员，因为它具备读和写的功能，它的内部封装了一个数组，通过指针对数组元素进行操作可以通过getFilePointer方法获取指针的位置，同时可以通过改变seek改变指针的位置，他能够完成读写的原理是因为内部封装了字节流输入流和字节输出流。通过构造函数来看，RandomAccessFile类只能操作文件，而且操作文件有模式：只读：“r”；如果模式为只读，不会创建文件，会去读取一个已存在的文件，如果文件不存在，会出现异常。读写：“rw”，该函数要操作的文件不存在，会自动创建，如果存在，就不会覆盖
1、特有方法：void seek(long pos)从第pos个字节开始读取。
int skipByte(int n)跳过n个字节数
四、DateInputStream/DateOutputStream操作基本数据类型
1、构造方法：DateOutputStream(OutputStream out)创建一个新的数据输出流，将数据写入指定基础输出流
2、特有方法：writeUTF()以UTF—8修改版编码形式写入
readUTF()以UTF—8修改版编码形式读取
本类还包括所有基本数据类型的读取和写入方法。
五、BatyArrayInputStream：在封装的时候，需要就收数据源。而且数据源是一个字节数组。
BatyArrayOutputStream：在构造的时候，不需要定义字节目的地。因为该对象内部封装了可变长度的字节数组，这就是数据的目的地。
注意：该流不需要关闭资源。
1、特有方法：void writeTo(OutputStream out)将此Baty数组的全部内容写入到指定的输出流参数中
六、CharArrayInputStream/CharArrayOutputStream操作字符型数组(同BatyArrayInputStream/ BatyArrayOutputStream)
七、StringReader/StringWriter操作字符串：(同BatyArrayInputStream/ BatyArrayOutputStream)
流中的字符编码问题
一、字符编码
1、目的：○41字符流的出现为了方便操作字符。
○2加入了字符编码的转换
○3通过子类转换流来完成。(InputStreamReader/OutputStreamReader)
○4在两个对象进行构造的时候可以加入字符集
2、编码表的由来：计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表。
3、常见的编码表：ASCII美国标准信息交换码：用一个字节的七位可以表示。
ISO8859—1拉丁码表，欧洲码表：用一个字节的八位表示。
GBK2312中国的中文编码表。
GBK：中国的中文的编码表的升级，融合了更多的中文文字符号。
Unicode：国际标准码，融合了多种文字，所有文字都用两个字节来表示，被Java语言使用
UTF—8：最多用三个字节来表示一个字符。
4、编码：字符串变成字节数组:String——>byte[]:str.getBytes();按照GBK编码表编码
str.getBytes(String charseName);按照指定编码表编码
解码：字节数组变成字符串:byte[]——>String:new String(byte[]);按照GBK编码表编码
new String(byte[]，String charseName);按照指定编码表编码