JavaSE基础知识整理

1.Java语言是面向对象的程序设计语言，java程序的基本组成单元是类，类有属性和方法，每一个应用程序都必须包含一个main()方法，含有main()方法的类称为主类。
注意：代码的所有标点符号都为英文字符，不要再中文输入法下输入标点符号。文件名必须和类名First同名，即First.java。还要注意大小写，java是区分大小写的。一个java应用程序由若干个类组成，package为包的关键字。Import关键字导入包。

2.类的属性：称为类的全局变量(成员变量)，方法中的属性称为(局部变量)。全局声明在类中，局部声明在方法体中。

3.main()是类体中的主方法，范围一对括号。public(权限修饰符)，static(静态修饰符)，void(返回值修饰符)main方法必须public static void main(String [] args){}: String [] args是字符串类型的数组，他是main方法的参数。

4.基本数据类型8种： byte，short，int,long,float,double,char,boolean.
引用数据类型：类（class），接口（interface），数组（Array【】）；

5.整数类型： 整数类型用来存储整数数值，没有小数部分！！！。可正可负。Java中整数有3中表示形式：十，八，十六进制；不能以0作为十进制的开头（0除外）; 八进制必须以0开头； 十六进制必须以0X或者0x开头；
**内存空间：**byte：8位-128-127（2的7次幂）；short：16位-32768-32767（2的15次幂）； int ：32位； long：64位； long num=21457842L；不加L也对；

6.浮点类型表示有小数部分的数字。单精度浮点型（float）32位； 双精度浮点型（double）64位；Float f=13.24f; double d1=456.23d; double d2=4561233.4562;

7.char型：字符类型：存储单个字符，占用16位（两个字节）内存空间；单引号表示；a unicode 97；unicode编码采用无符号编码，可以存储65536个字符（0x0000-0xffff）; char word=’d’; int p=(int)word;

8.转义字符：是一种特殊的字符变量，它以“\”开头， \ddd：1-3位八进制数据，\132；\uxxxx：四位十六进制\u0052； \’：单引号； \反斜杠； \t:垂直制表符，将光标移到下一个制表符位置。 \r:回车； \n：换行； \b:退格； \f:换页

9.布尔类型又称逻辑类型：；标识符：字母，下划线，美元符号，第一个字符不可为数字，不可违java保留关键字。变量名： 有效标识符，不可关键字，不可重复，有意义。

10.系统区（OS），程序区（Program），数据区（Data）；

11.当定义final变量属于成员变量时，必须在定义时就设定它的初值，否则产生编译错误。Static final double PI=3.14；变量被定义出来后只暂存在内存中，等到程序执行到某一点，该变量就会被释放掉，有生命周期。静态变量，实例变量：静态变量的有效范围可以跨类，甚至可以达到整个应用程序之内。直接以： 类名.静态变量；的方式调用。
注意：局部变量可与成员变量的名字相同，此时成员变量被隐藏。

static int times = 3;public static void main(String[] args) {        int times = 4;        System.out.println(times)；}

12.X=y=z;可以不建议使用；自增，自减是单目运算符，操作源是一个整形或浮点型变量。 6个比较运算符：><==>=<=!=; 逻辑运算符：与或非，除了！是一元运算符，其他都是二元运算符。三元运算符： boolean b=2<5?true:false;

13.运算符优先级：单目优先双目，（）最高，之后一次算数，位，关系，逻辑，三元，赋值。

14.类型转换：是一个值转换为另一个类型的过程。重点：低精度向高精度数据类型转换，永远不会溢出，并且总能成功，而把高精度数据类型向地数据类型转换则必然会有信息丢失，有可能失败。

15.当：char，byte，short之间运算结果默认为int。当把高精度的变量的值赋给低精度的变量时，必须使用显示类型转换运算。（又称强制类型转换）。可能精度损失。

16.当把整数赋给byte，short，int，long时，不可超出范围，否则必须进行强制转型，例：byte b=（byte）129；

17.注释：提高程序的可读性，可维护性，好的编码规范可以使程序更易阅读和理解。单行注释：// ； 多行注释： /* / ； 多行注释可以嵌套单行注释；多行不可嵌套多行。文档注释：/* */ ; javadoc文档内容； 可读性第一，效率第二。

18.每条语句要单独占一行，一条命令要已分号结束； java中关键字和关键字中间多个空格，被视为一个空格。

19.复合语句：由开括号：{}；复合语句已整个块为单位，能够用到任何在一个单独语句可以用到的地方，复合语句可以嵌套复合语句。复合语句为局部变量创造了一个作用域，变量作用域之外使用会出错。

20.If（内值必须为boolean的）；有时候为了编程需要if，else后面括号内可以没有语句。范围小写上面。

21.switch：多选一，必须是整型，字符型，字符串类型。表达式可以是：byte，short，int，char，string，枚举。常量值1-n必须是整形，字符型，字符串型，default是可选的，如果他不存在，且switch语句中表达式的值不与任何case的常量值相同，switch不做任何处理。同一个switch，case的常量值必须互不相同。Case后的值绝不能是实数，case1.1不合法；

22.While（）条件判断语句:重点：while（x==5）；这是程序会认为要执行一条空语句，进入无限循环。Do｛｝while（）；语句后有分号；

23.Java5新增Foreach语法:循环嵌套：外层控制行数，内层控制列数；无限循环：for（；；）；可以break跳出；任何foreach语句都可以改写为for语句版本。Foreach并不是一个关键字。

24.break是中断循环；标签名：标签名： 循环体｛break 标签名；｝结束外层循环。

25.continue是执行下一次循环；不是立即跳出循环体，而是跳过本次循环，回到循环的条件测试部分，从新开始循环。 标签名： 循环体｛continue 标签名；｝；continue也支持标签。

26.String：不可变字符串，低层用char门存放，string是final的，一旦被赋值，不可改变。 String s= new String（char []a）; String (char [] a,offset,length); char a [] ={};//可以为空，中括号;
char [] b={’s’,’t’,’u’,’d’,’e’,’n’,’t’}; String str=new String(b,2,4);//从0开始，第二个取四个

27.String str1,str2; str1=”dsf”;str2=”dsf” 引用相同的字符串常量，因此具有相同的实体。“+”运算符可以连接多个字符串，并产生一个String对象。

28.Java中一句相连的字符串不能分开在两行中写，例如:System.out.println(“iki
ke”);错误的；但是可以用“+”连接。只要“+”运算符的一个操作数是字符串，编译器就会将另一个操作数转换成字符串形式。

29.str.length();获取长度方法。包含其中的空格。
str.indexOf(str);String str=”we are hero”;int size=str.indexOf(“a”);size=3;indexOf()返回参数字符串a在指定字符串中首次出现的位置，没有检索到a返回值为-1；
Str.indexOf(substr ,int fromindex);from是起始位置； 字符串下标：0-length-1；
Str.lastIndexOf（str）:返回指定字符串最后一次出现的索引位置；str.lastIndexOf(str, fromindex):起始位向前查找；
查找空字符串，lastIndexOf返回的结果与调用该字符串length（）方法返回结果相同。
Str.charAt(int index)方法将指定索引处的字符返回。
subString():方法被两种不同的方法重载，来满足不同的需求。
SubString(int begin):该方法返回的是从指定位置索引开始截取至尾。
SubString(int begin，int end)：包含左边，不包含右边。
trim()方法：返回字符串的副本，忽略前导和尾部空格。
Str.replaceAll(“ ”,””);去除字符串中所有的空白内容Replace（old，new）：替换方法old重复多次都替换
Str.startsWith(String prefix):判断当前字符串以什么字符开始。
Str.endsWith(String prefix):判断当前字符串以什么字符结束。

30.重点：“==”比较运算符比较的是两个字符串的地址是否相同，不 new String，则地址相同。

31.Equals()方法:相同的字符和长度；1.只能处理引用类型变量。2.在Object类中，发现equals仍然比较地址，因为String,包装类，file类，Date类，重写了Object类的equals方法，比较两个对象的实体是否相同。 EqualsIgnoreCase（）方法：忽略大小写比较，返回boolean。

32.compareTO()方法：按照字典顺序比较两个字符串，Unicode值，如果字典顺序此String对象位于字符串之前，比较结果返回一个负数，之后为正数，相等结果为零。 b compareTo a：1； b compareTo c:-1;

33.toLowerCase():String转换为小写， str.toUpperCase():转换为大写。
concat（str）：连接当前字符串。
split(String sign):根据给定的分隔符对字符串进行分割。split（String sign，int limit）:根据给定分隔符对字符串进行拆分，并限定拆分次数。String str=”192.168.0.1”;//按照“.”进行分割，使用转义字符“\.”
String [] firstArray=str.split(“\.”);//切割两次String [] secondArray=str.split(“\.”,2);

34.String类的静态format()方法用于创建格式化的字符串。Str.format(String format,Object…args);
Format是格式字符串，args格式字符串中由格式说明符引用的参数，此参数可变，可以为0； Format（local 1，String format，Object。。Args）：1为null，则不进行本地化。 Format（）通过给定的特殊转换符作为参数对日期和时间进行格式化。

35.字符串生成器：J2SE5.0新增了可变的字符序列String-builder；大大提高了频繁增加字符串的效率；

类名  String  StringBuilder   StringBuffer线程安全性   不安全 不安全 安全执行效率    低   中   高对象类型    字符串常量   字符串变量   字符串变量

36.+号连接与动态字符串的时间差异：

String str="";    long starTime =System.currentTimeMillis();//起始时间    for(int i=0;i<10000;i++){        str=str+i;    }    long endTime =System.currentTimeMillis();//结束时间    long time=endTime-starTime;//消耗时间    StringBuilder builder=new StringBuilder("");    starTime =System.currentTimeMillis();//起始时间    for(int i=0;i<10000;i++){        builder.append(i);    }    starTime =System.currentTimeMillis();//结束时间    time=endTime-starTime;//对比两个时间

37.StringBuilder：最后输出字符串，可使用toString方法；StringBuilder方法如下：
append()：该方法用于向字符串生成器中追加内容。
insert(int offset,arg):向字符串生成器中指定位置插入数据内容。Offset必须大于等于零，小于等于次序列长度。
delete(int start,int end):移除此序列的子字符串中的字符，从start开始，end-1结束。左包括，右不包括。
CharAt（int index）:返回指定index位置的字符； equals（）；比较相等；
regionMatches（int firstStart,String other,int otherStart,int length）:判断当前字符串从firstStart开始的子串与另一个字符串Other从OtherStart开始length的长度是否equals。

38.数组：使用new关键字分配数组时，必须指定数组元素的类型和个数。使用new关键字为数组分配内存时，整数数组中元素初始值为0；float，double初始值为0.0；对于char，默认为空格。对于boolean默认为false。引用数据类型默认为null。动态初始化：int [] a=new int [] {1,2,4}; 赋值声明分开进行 静态初始化：int [] a={34,3423,342,}赋值声明一起进行。

39.栈：存放局部变量，对象的引用。 **堆：**new出来的东西放在里面。

40.二维数组初始化：

type arrayname [] []={value1,value2.....};int[][]s=new int[1][];//前面必须有。后面可以没有。int a[][] = new int[3][4];// 默认值为0，定义二维数组        for (int i = 0; i < a.length; i++) {            for (int j = 0; j < a[i].length; j++) {                System.out.print(a[i][j]);            }            System.out.println("输出空格");        }

41.Arrays类：中的静态方法fill（）来对数组中的元素进行替换。 fill（int [] a, int value）:value分配给每个元素；

    int arr []=new int [5];Arrays.fill(arr, 8);

Arrays.fill(int [] a,int fromIndex,int toIndex,int value):左包括，右不包括。
Arrays.sort(arr):对数组实现排序；（升序）；
Arrays.copyOf(arr,int newlength):复制数组；

int arr []=new int [5];int newarr []=Arrays.copyOf(arr, 5);

Newlength：新数组的长度，大于原数组用0填充。Char用空格（记住）填充。小于就截取。
Arrays.copyOfRange(arr,int formIndex,int toIndex):formIndex:0-length,toIndex可以大于arr。

42.Arrays类的binarySearch()方法：可以使用二分法来搜索指定数组，获得指定对象。返回搜索元素的索引值。
binarySearch(Object[],Object key):如果key包含在数组中返回索引值的索引，否则返回-1或“-”(插入点)

int arr[] =new int []{4,25,10};Arrays.sort(arr);int index=Arrays.binarySearch(arr, 0,1,8);

System.out.println(index);元素8在索引0-1的位置。由于指定范围内并不存在元素8，index的值是插入点“-”，排序后，他在元素25的前面，25的索引值是2，所以index=-2；
必须在进行此调用之前对数组进行排序（sort）方法；

int arr[] =new int []{1,8,9,4,5};Arrays.sort(arr);int index=Arrays.binarySearch(arr,4);

System.out.println(index);该方法在指定范围neutral检索某一元素。返回值1是对数组a排序之后4的索引位置；

43.冒泡排序：基本思想是对比相邻的元素值。也就是交换两元素位置。由双层循环实现的，外层循环用于控制排序轮数，一般为要排序的数组长度减1次。

    public void sort(int [] array){//冒泡排序        for(int i=1;i<array.length;i++){            for(int j=0;j<array.length;j++){                if(array[j]>array[j+1]){                    int temp=array[j];//第一个元素值保存在临时变量中                    array[j]=array[j+1];//第二个元素值保存在第一个元素单元中                    array[j+1]=temp;//把临时变量放进第二个元素中        }}}}

44.直接选择排序：基本思想：将指定排序位置与其他数组元素分别对比，满足条件就交换元素值。与冒泡排序相比直接排序交换次数少，速度快。

public class BubbleSort {    int index;public void sort(int[] array) {// 直接选择排序        for (int i = 1; i < array.length; i++) {            index = 0;            for (int j = 1; j < array.length - i; j++) {                if (array[j] > array[index]) {                    index = j;                }            }            // 交换在位置array.length-i和index（最大值）上的两个元素            int temp = array[array.length - i];            array[array.length - i] = array[index];            array[index] = temp;        }}public static void main(String[] args) {    // index=1; 错误那不进主方法，但普通方法可以用。}}

45.反转排序：

public void sort(int [] array){    int temp;    int len=array.length;    for(int i=0;i<len/2;i++){        temp=array[i];        array[i]=array[len-1-i];        array[len-1-i]=temp;    }}

46.面向对象概述：面向对象的开发思想。类：实际上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例，类就是同一类事物的总称，如将现实世界中的一个事物抽象成对象，类就是这类对象的总称。同属性和行为的一类实体被称为类。

47.封装：将类的属性私有化，提供公共的方法调用。封装是面向对象编程的核心思想。采用封装的思想保证了类内部数据结构的完整性。为用户提供对象属性和行为的接口，通过接口使用类，无需了解类的构成。

48.继承：类之间的关系叫做关联；单继承：一个类只可继承一个父类。子类继承父类后，父类中的属性和方法子类获取，当父类私有属性和方法后，子类同时获得，但由于封装型，子类无法直接使用。子类的实例都是父类的实例，但不能说父类实例都是子类的实例。

49.多态：将父类对象应用于子类的特征就是多态。向下转型使用强转符号（）；日后的维护和调整只需要维护父类即可，降低了维护难度，节约了时间。多态的实现并不是依赖于具体类，而是依赖于抽象类和接口。
a instanceof A:如果a是A的实例，那么它也一定是A的父类的实例。判断是否为他的实例。

50.类：java中对象的属性也称为成员变量。不设初值有默认值。

51.Java中权限修饰符主要包括：private，public，protected。一个源文件中最多只有一个public类，别的类个数不限。如果源文件只包含了一个public类，则文件要按照该类名命名。

修饰符     同类  同包  子类  任何地方private     y           default     y   y       protected   y   y   y   public      y   y   y   y

52.局部变量：方法执行时创建，结束时删除，局部变量在使用时必须进行赋值或初始化，否则编译出错。有效范围叫做作用域，在互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量。独立互不干扰。

53.This关键字：调用类的成员变量和成员方法。1。可以用来修饰属性方法构造器。2.this理解为当前对象或当前正在创建的对象。This.Name；this.Show();
**重点：**this（形参）的方式调用本类中其他重载的制定构造器。要求构造器内部声明在首行，有n个构造器，最多n-1个构造器可以用this（）；

54.方法的重载：同一个类中，方法名相同，方法的参数列表不同。

55.类的构造方法：是一个与类同名的方法，对象的创建就是通过构造方法完成的。构造方法没有返回值，名称与本类名称相同。目的：给对象初始化值。在构造方法中可以为成员变量赋值，当这样实例化一个本类对象时，相应的成员变量也被初始化。

public class AnyThing {    public AnyThing() {        this("调用有参的构造器");        System.out.println("这是无參的构造器");    }public AnyThing(String str) {        System.out.println("这是有参的构造器");    }public static void main(String[] args) {new AnyThing();    }}

56.静态变量：static修饰的变量，常量，方法被称为静态变量常量方法。使用：类名。静态成员；对象。静态成员

57.各区域运行顺序：静态代码块–>非静态代码块–>构造方法–>成员方法；

58.Java中规定不能将方法体内的局部变量声明为static的。Static块执行一次。

59.主方法是类的入口点，它定义了程序从何处开始；主方法是静态的，主方法中直接调用其他方法，则该方法也必须是静态的，主方法没有返回值。主方法的形参为数组。Args【0】–args【n】分别代表代表程序的第一个是参数到第n个参数，可以使用args.Length获取参数的个数。

60.在java中对象和实例事实上可以通用。

61.被JVM视为垃圾的两种：对象引用超出范围，对象赋值为null；

62.垃圾回收机制：基本完善，垃圾回收机制只回收那些new操作符创建的对象，对象不new在内存中获取一块内存地址，这种对象不可能被垃圾回收机制所识别。记住：finalize（）方法；这个方法是Object类中的，他被声明为protected，用户可以自己定义这个方法。
有一点需要明确，垃圾回收机制finalize方法不保证一定会发生，如java虚拟机内存损耗待尽时，不执行垃圾回收机制。
Java提供了System.gc()方法强制启动垃圾回收机制。

63.Java.lang包中Integer类，Long类，Short类等封装类分别将对应基本类型封装成为一个类。都是Number的子类。

64.Integer：有两种构造方法。：Integer num=new Integer(7); Integer num=new Integer(“45”)；
Integer:常用方法： byteValue():返回值byte；
compareTo(i): int 数字上比较两个Integer对象。相等返0；前者小于i返回负值，大于i返回正值；
Equals(): boolean相等否； intValue():int; shortValue():short; toString(): String;
valueOf(str):Integer; parseInt(Str): int;
Integer的toString：转换为十进制字符串。 toBinaryString():二进制； toHexString():十六进制；
toOctalString():八进制；

65.Boolean(boolean value)：对于Boolean来讲，当形参为true返回true，除此之外返回false。
BooleanValue():boolean; equals(Object obj):boolean; parseBoolean(String s):booean;
toString():String; ValueOf(String s):boolean;

66.Byte: byteValue():byte; compareTo(Byte another Byte):int ; doubleValue():double;
intValue():int ; parseByte(String s):byte; toString():String; valueOf(String str):byte;
Equals():boolaen;

67.Character:character(char value):char; compareTo(character other):int 等0，前-1，后1；
Equals(Object obj): boolean; toUpperCase(char):大写： toLowerCase(char):小写；
toString():string; charValue():char; isUpperCase(char):boolean是否大写;isLowerCase(char);

68.Double(double);Double(str); byteValue():byte; compareTo():int; equals():boolean; intValue()**int; **isNaN():boolean:对象是非数字（NaN）值，返回true，否则返回false； toString（）；
ValueOf():Double; doubleValue():double; longValue():long;
Double类提供了一下常量：MAX_EXPONRNT:int，有限double变量可能具有最大指数。MIN_EXPONENT;标准化最小；NEGATIVE_INFINITY:double;负无穷大；POSITIVE_INFINITY：double正无穷大；

69.抽象类Number：是BigDecimal;BigInteger,Byte,Double,Float,Integer,Long,Short;
doubleValue():返回双精度； floatValue():返回单精度；各种类的value；

70.与时间有关的类：1.System类下的currentTimeMillis();2.Date类：java.uti.Date；3.SimpleDateFormat类；java.text.SimpleDateFormat格式时间， 解析：文本-》日期：prase()方法；数字格式化：java.text.DecimalFormat格式化数字，DecimalFormat类;

71.Math类：常量：Math.PI;Math.E;三角函数；
1.指数函数：exp(a)：e的a次方； log( double a):取自然对数，Ina的数值； log10(double a):取底数为10的对数；Sqrt（double a）: 求平方根； cbrt(double a):a的立方根； pow（a，b）:a的b次方；
2.取整函数：ceil(double a):向上取整； floor（double a）：向下去整；rint（double a）：返回参数最接近整数，同为整数同样接近，取偶数。Round（fload a）：加上0.5返回最近的整数；
取最大值：max(double a,double b):取最大； mix(double a,double b):取最小；Abs（）：取绝对值；

72.Math.random()方法：产生随机数字，0-1的double；可以为0； （char）(‘a’+Math.random()*(‘z’-’a’+1));
伪随机数，算法。

73.static:修饰属性(类变量)；属性，方法，代码块(初始化块)，内部类。1.由类创建的所有对象都公用一个属性。2.当其中一个对象对此属性进行修改时，会导致其他对象对此属性一个调用（非静态static修饰的属性，个个对象各自拥有一套副本。）类变量随着类的加载而加载，而且独一份。静态变量可以直接通过类。类变量的形式调用。类的加载早于对象，可以对象。类变量，但是类。实例变量不可以。类变量存在于静态域中。

74.static：修饰方法，随着类的加载而加载，在内存中也是独一份的，可以通过类。类方法的方式调用。内部可以调用静态的属性方法，而不能调用非静态的，

75**static代码块**：静态块中，里面可以有输出语句，随着类的加载而加载，只被加载一次。静态代码块早于非静态代码块。只能执行静态的结构（属性和方法）；

76.类的第四个成员：代码块（初始化块）；一个类可以有多个代码块按顺序执行，每创建一个对象，非静态代码块加载一次。

77.Super关键字：调用父类中指定操作；访问父类属性，调用父类成员，子类构造调用父类构造。
Super():调用父类构造方法； super.doSomeThing():调用父类成员方法；继承不只有扩展，还有重写；
重写（覆盖）：特殊的重写叫重构：子类与父类的成员方法返回值，方法名称，参数类型个数顺序完全相同。
重写：子类不能降低父类的修饰权限； 重写的前提：继承的基础上，子类获取父类的结构后，可以对父类的同名方法进行重构，方法的返回值类型，方法名，形参列表相同。子类权限不小于父类，子类异常不大于父类。子类重写父类方法可以修改返回值类型。

78.Super修饰构造器：子类中使用“super（形参列表）”必须声明在首行。This(形参)和Super(形参)只能出现一个。写一个类要一个空构造器。

79.实例化子类对象是首先要实例化父类对象，在实例化子类对象，这调用的是无参构造，有参构造要用super。调用构造方法的顺序，顶级父类，上一级父类，子类。
重点：如果使用finalize()方法对对象进行清理，确保子类 的finalize（）方法最后一个动作是调用父类的finalize方法，以保证当垃圾回收对象占用内存时，对象的所有部分都能被正常回收。

80.Object类：在java中所有的类都直接或者间接的继承了java.lang.Object类；Object类的getClass(),notify(),notifyAll(),wait()等方法不能被重写，定义为final类型。
getClass():他会返回对象执行时的Class实例，然后使用getName()：方法获得类的名称； getClass().getName();
toString():方法返回字符串形式，返回一个String实例。重写toStirng调用的就是自己的，不重写就是Object的。
重点：String类；File类；Date类包装类；已经实现了toString()的重写。
Public String toString(){//重写toString方法；
return “在”+getClass().getName()+”类中重写toString()方法” ；｝

81.“==”比较的两个对象的引用是否相等，equals()比较两个对象的实际内容。
Equals():默认实现使用‘==’运算符比较两个对象的引用地址，不是内容，真正比较需要重写equals；

82.对象类型的转换：主要包括向上转型，向下转型操作。把子类对象赋值给父类对象类型的变量，上转。
上转例子：Person p=new Man();
向下转型：Person p=new Man(); Man() man=(Man)p; 将父类对象强制转化为子类对象，显示类型转换；

83.Instanceof: 如果父类不是子类对象的实例，会发生ClassCastException；下转之前要判断父类对象是否为子类对象的实例。用instanceof：操作符判断一个类是否实现了某个接口，一个实例是否属于某一个类。
Person p=new Person();//实例化一个父类对象。
If(p instanceof Man){ Man man=(Man) p };//判断父类对象是否为子类实例，向下转型。返回boolean型；

84.方法的重载：就是在同一个类中允许同时存在一个以上的同名方法，只要这些方法参数个数类型顺序不同即可。
返回值类型可以不同；

85.Public static int add(int…a){//定义不定长参数看作int[]a;
Int s=0; for(int i-0;i

package practice1;public class OuterClass {    // 在外部类中实例化内部类的对象。    InnerClass in = new InnerClass();    // 在外部类方法中调用内部类方法    public void ouf() {        in.inf();    }    class InnerClass {        public InnerClass() {            // 不写默认构造器，系统也会提供。一个默认构造器        }        public void inf() {            // 内部类成员的方法；        }        int y = 0;// 定义内部类成员变量    }    public InnerClass doit() {        // 外部类方法返回值为内部类引用        in.y = 4;// 外部类不可以直接访问内部类成员        // 返回内部类引用        return new InnerClass();    }    public static void main(String[] args) {        //内部类的对象实例化操作必须在外部类或者外部类的非静态方法中实现。OuterClass out=new OuterClass();OuterClass.InnerClass in=out.doit();OuterClass.InnerClass in2=out.new InnerClass();//这个记住。    }}

1.创建非静态的内部类的对象：必须先创建外部类的对象，通过外部类的对象的调用内部类的构造器。
2.创建静态内部类的对象，可以直接通过外部类调用静态内部类构造器。

97.外部类创建内部类对象与与其他类创建对象引用时相同。内部类可以访问外部类成员，但内部类成员只有在内部类的范围内可知，不能被外部类使用。内部类对象与外部类对象关系非常紧密，内外可以交互使用彼此类中定义的变量。如果在外部类和静态方法之外实例化内部类对象，需要使用外部类。内部类的形式指定该对象的类型。

98.在主方法中实例化内部类对象，必须在new操作符之前提供一个外部类的引用。
Public static void main(String args []){ OuterClass out=new OuterClass(); OuterClass.innerClass in=out.doit();
OuterClass.innerClass in2-out.new innerClass();//实例化内部类对象。使用外部类对象创建内部类对象。}

99.内部类对象会依赖与外部类对象，除非已经存在一个外部类对象，否则类中不会出现内部类对象。

100.如果将一个权限修饰为private的内部类上转为其父类对象，或转为一个接口，在程序中可以完全隐藏内部类的具体实现过程。可以在外部提供一个接口，在接口中声明一个方法，如果在该接口中的内部类中实现该接口的方法，就可以定义多个内部类以不同的方式实现接口中的同一个方法，而在一般的类中是不能多次实现接口中同一方法。

public class TheSameName {    private int x;    private class Inner {        private int x = 9;        public void doit(int x) {            x++;// 调用的是形参x            this.x++;// 调用内部类的变量x            TheSameName.this.x++;// 调用外部类的变量x        }}}//内部类与外部类的成员重名的情况，可以使用this关键字处理。就是用外部类名称后跟一个点操作符和this关键字便可以获取外部类的一个引用。

101.局部内部类：内部类不仅可以在类中进行定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可以定义内部类。

interface OutInterface2 {//定义一个接口}public class OuterClass3 {public OutInterface2 doit(final String x) {//doit()方法参数为final类型    class InnerClass2 implements OutInterface2() {//定义一个内部类        InnerClass2(String s){            s=x;            System.out.println(s);        }    }return new InnerClass2("doit");}}

内部类被定义在了doit（）方法内，内部类InnerClass2是doit（）方法的一部分，并非OuterClass3类中的一部分，所以在doit（）方法外部不能访问该内部类，但是该内部类可以访问当前代码块的常量以及此外部类的所有成员。

102.如果方法体中使用局部变量，该局部变量需被设置为final类型变量。换句话说，在方法体中定义的内部类只能访问方法中final类型的局部变量，这是因为在方法定义的局部变量相当于一个常量，他的生命周期超出方法运行的生命周期，由于该局部变量被设置为final，所以不能再内部类中改变该局部变量的值。

class OuterClass4{    public OutInterface2 doit() {        return new OutInterface2() {//声明匿名内部类            private int i=0;            public int getValue() {                return i;            }        };    }}

Doit写的有些莫名其妙，但这种写法被java编译器认可，在doit方法内部首先返回一个OutInterface2的引用，然后在return语句中插入一个定义内部类的代码，由于这个类没有名称，所以这里将该内部类称为匿名内部类。实质上：这种内部类的作用就是创建一个实现于OutInterface2接口的匿名类的对象。
Return new A(){ ….//内部类体 }； return后面的；分号别忘了；
由于匿名内部类没有名称，所以匿名内部类使用默认构造器来生成OutInterface2对象。最后的分号是代表创建OutInterface2引用表达式的标识。

103.匿名内部类编译以后，会产生以“外部类名$序号”为名称 .class文件，序号以1-n排序，分别代表这1-n个匿名内部类。

104.静态内部类：在内部类之前增加修饰符static，可以声明static成员，但是非静态内部类不可以声明静态成员。静态内部类最大的特点就是不可以使用外部类的非静态成员，所以静态内部类在开发中比较少见。

105.内部类的继承：在某个类继承内部类时，必须硬性给予这个类一个带参数的构造器，并且该构造器方法的参数为需要内部类的引用，同时在构造方法体中使用a.super();,这样才为继承提供了必要的对象引用。

106.异常处理：error：错误，程序中不作处理； exception：异常，要求在编程时，就考虑对异常的处理。
Int result=3/0；异常：java.lang.ArithmeticException;(算数异常)；0永远不可以作为除数；

107.当某一个方法发生错误时，这个方法会创建一个对象，并且把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分开，即在编程同时在其他地方处理异常。

108.为了保证程序有效地执行，需要对发生的异常进行相对的处理。如果某个方法抛出异常，既可以在当前方法中进行捕捉，也可以将异常向上抛出，由方法调用者来处理。
Int age=Integer.parseInt(“20L”); NumberFormatException（数字转换异常）；

109.Java语言捕获异常结构由try，catch，finally三部分组成。Try{}存放可能发生异常的java语句；catch程序块在try之后，用来激发被捕获的语句。Finally语句块是异常处理结构的最后执行部分，try如何退处必须执行。

110.Try{}:内声明的变量，类似局部变量，出了try{}语句，无法被调用。 finally:语句是可选的,一定执行代码块。
Catch语句内部是对异常的处理：getMessage(); printStackTrace();
可以有多个catch语句，从上往下执行，满足某个catch语句后，跳出多条catch语句。
如果异常处理了，那么其后的代码继续执行，try-catch可以相互嵌套；
当try语句块中的语句发生异常时，程序就会跳转到catch代码块中执行。Try后不在执行，catch后抓住一次。
注意：Exception是try代码块传递给catch代码块的变量类型，e是变量名。Catch代码中语句“e.getMessage”用于输出错误性质。异常处理有三个函数：1.getMessage()函数：输出错误性质；2.toString()函数：给出异常的类型与性质； 3.printStackTrace()函数：指出异常的类型，性质，栈层次及出现在程序中的位置。

111.完整的异常处理一定要包含finally语句，无论程序中有无异常，并且无论之间的try-catch是否顺利完成，都执行finally语句。
以下四种情况finally语句不会执行：1.在finally语句块中发生了异常； 2.在前面的代码中使用了System.exit();退出程序； 3.程序所在的线程死亡。 4.关闭CPU；

112.常见异常类：1.ClassCastException：类型转换异常； 2.ClassNotFoundException：未找到相应类异常；
3.ArithmeticException:算术异常； 4.ArrayIndexOutOfBoundsException:数组下标越界异常；
5.ArrayStoreException：数组包含不兼容数值抛出异常； 6.SQLException：操作数据库异常；
7.NullPointerException：空指针异常； 8.NoSuchFieldException：字段未找到异常；
9.NoSuchMethodException：字段未找到异常； 10.NumberFormatException：字符串转换为数字异常；
11.NegativeArraySizeException：数组元素个数为负数抛出的异常；
12.StringIndexOutOfBoundsException：字符串索引超出范围抛出的异常；
13.IOException：输入输出异常； 14.IllegalAccessException：不允许访问某类异常；
15.InstantiationException：当应用程序视图使用Class类中的newInstance（）方法创建一个类的实例时，而指定的类对象无法被实例化时，输出该异常。
16.EOFException：文件已结束异常； 17.FileNotFoundException：文件未找到异常；

113.Java提供的异常处理的抓抛模型；自定义异常类继承现有的异常类。提供一个序列号，提供几个重载的构造器。

114.自定义异常：用户只需要继承Exception类即可自定义异常类；

public class MyException extends Exception{//创建自定义异常，继承Exception类public MyException(String ErrorMessage) {//构造方法    super(ErrorMessage);//父类构造方法。}}public class Tran {//定义方法，抛出异常    static int avg(int number1,int number2) throws MyException{        if(number1<0||number2<0) {            throw new MyException("不可以使用负数");        }        if(number1>100||number2>100) {            throw new MyException("数值过大");        }        return (number1+number2)/2;    }    public static void main(String[] args) {        try {            int result=avg(102,150);            System.out.println(result);        } catch (MyException e) {            // TODO Auto-generated catch block            System.out.println(e);}}}

115.在方法中抛出异常：使用throws关键字抛出异常；多个异常可以用逗号分隔。

public class Shoot {static void pop() throws NegativeArraySizeException{    int [] arr=new int[-3];}public static void main(String [] args) {    try {        pop();    }catch(NegativeArraySizeException e) {        System.out.println("pop()方法抛出的异常");    }//此方法内部出现异常的时候，会抛出一个异常类对象，抛给方法的调用者。}}

116.子类重写父类方法，其抛出的异常类型只能是被重写的方法异常类的子类或异常类型一样。
Throws关键字将异常抛给上一级后，如果不想处理，可以继续向上抛出，但最终还是要处理。
抛出的异常类型若是RuntimeException，可以不显示处理，若是Exception，必须显示处理。

117.Throw关键字用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，他后面的语句不执行。Throw通常用来抛出用户自定义异常。

118.Exception是所有异常的父类，如果将catch（Exception e）放在前面，后面的异常代码块将永不执行，也就没有什么意义了，所以catch语句的顺序不可调换。

119.运行时异常：RuntimeException异常时程序运行过程中产生的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable类派生了两个子类，非别是Exception和Error类。Error是java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Exception类为非致命类，可以通过捕捉处理使程序继续执行。Exception类又根据错误发生的原因分为RuntimeException和非RuntimeException异常。以下几个为常见的运行时异常。
NullPointerException：空指针异常； ArrayIndexOutOfBoundsException：数组下标越界异常；
ArithmeticException：算数异常； ArrayStoreException：数组中包含不兼容的值抛出的异常；
IllegalArgumentException：非法参数异常； SecurityException：安全性异常；
NegativeArraySizeException：数组长度为负异常；

120.集合类：java.util提供了一些集合类，容器。数组也是容器，数组长度固定，集合长度可变；数组用于存放基本类型数据，集合存放引用类型数据。
常用的集合：List集合；Set集合；Map集合；

121.List与Set继承了Collection接口，各接口还提供了不同的实现类。
Java.lang.Object:{一.Collection: 1.set:{hashSet,TreeSet; 2.List:{ArrayList,LinnkedList;
二.Map:{hashMap,TreeMap;
Collection接口是层次结构中的跟接口。构成Collection的单位称为元素。Collection接口通常不能直接使用。
Collection常用方法： add(E e) :将指定对象添加到该集合中。
AddAll(Collection col): 判断集合中是否包含指定obj元素，所有元素添加进当前集合。
remove(Object o) :将指定对象从集合中删除；
isEmpty(): 返回boolean值，用于判断当前集合是否为空。
iterator() : 返回在此Collection的元素上进行迭代的迭代器。用于遍历集合中的对象。
size(): 返回int型值，获取该集合中元素的个数。
Contain(Object obj):判断集合中是否包含指定obj元素，若包含，返回true。
toArray():方法可返回集合返回成数组。

122.Collection接口中的对象iterator()方法可返回在此Collection进行迭代的迭代器。

   import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class List112 {public static void main(String[] args) {    Collection<String> list=new ArrayList<>();//实例化集合类对象    list.add("a");//向集合添加数据    list.add("b");    list.add("c");    Iterator<String> it=list.iterator();//创建迭代器    while(it.hasNext()){//判断是否有下一个元素        String str=(String)it.next();//或去集合中的元素        System.out.println(str);    }    }}

123.List集合：元素有序，可重复。
List集合：包括List接口以及List接口的所有实现类。可重复，顺序为插入顺序。索引访问。
List接口继承了Collection接口，因此包含Collection中的所有方法。
常用方法： get(int index):获得指定索引元素位置。 set(int index,Object obj):指定位置修改
删除：remove(int index); 得到： get(int index) ； 添加：add(int index,Object obj);
长度：size();

124.ArrayList()类:可变数组，可保存所有元素，包括null，快速随机访问。缺点：插入删除慢。
LinkedList()类:采用链表结构保存对象。 优点：便于向集合中插入删除对象。随即查找慢。

import java.util.ArrayList;import java.util.LinkedList;import java.util.List;public class List112 {    public static void main(String[] args) {        List<String> list = new ArrayList<>();// 创建集合对象        List<String> list1 = new LinkedList();list.add("1");// 向集合添加元素        list.add("2");        list.add("3");        int i = (int) (Math.random() * list.size());// 获得0-2之间的随机元素        list.get(i);        // for(String s:list){//不可        // System.out.println();;        // }        list.remove(i);        list.get(i);        for (int i1 = 0; i1 < list.size(); i1++) {            System.out.println(list.get(i));//遍历        }}}

125.Set：存储元素无序，不可重复的。1.无序性：无序性！=随机性，指元素是底层。不可以重复，添加相同元素时添加不进去。说明：要求添加Set中元素所在的类，一定要重写equals（）和hsashcode（）方法。 Set：重用的方法都是collection下定义。
Set集合由Set接口和Set接口的实现类组成。Set集合继承了Collection接口，包含他的所有方法。
如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true;

126.Set接口常用的实现类有HsahSet类与TreeSet类也是主要实现类：
HashSet类：实现Set接口，哈希表支持，它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用nul元素。
TreeSet类：不仅实现了Set接口，还实现了java.Util.SortedSet,因此TreeSet类实现的Set集合在遍历集合时按自然顺序递增排序，也可以按照指定比较器递增排序。

127.TreeSet增加方法如下：first():返回当前第一个（最低）元素
last（）：返回当前最后一个（最高）元素
Comparator（）：返回对此Set中的元素进行排序的比较器，如果此Set使用自然排序，则返回null。
headSet（E toElement）：返回一个新的Set集合是toElement（不包含）之前的所有对象。
subSet（左，右） ：左包右不包，返回一个新集合。之间的所有对象。
tailSet(我是对象):返回一个新的Set集合，新的集合包含对象之后的所有对象。
LinkedHashSet:使用链表维护了一个添加进集合的顺序。导致我们遍历LinkedHashSet：是按顺序添加；

128.Set：若此位置之前没有对象存储，则这个对象直接存储在此位置。若此位置已有对象存储，在通过equals（）比较他们是否相同，若相同，无法添加进去。

import java.util.Iterator;import java.util.TreeSet;public class UpdateStu implements Comparable<Object> {//    String name;    long id;    public UpdateStu(String name, long id) {        this.id = id;        this.name = name;    }    public int compareTo(Object o) {        UpdateStu upstu = (UpdateStu) o;        int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);        return result;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public long getId() {        return id;    }    public static void main(String[] args) {        UpdateStu stu1 = new UpdateStu("李同学", 01011);        UpdateStu stu2 = new UpdateStu("陈同学", 01021);        UpdateStu stu3 = new UpdateStu("李同学", 01051);        UpdateStu stu4 = new UpdateStu("李同学", 01012);        TreeSet<UpdateStu> tree = new TreeSet<>();        tree.add(stu1);        tree.add(stu2);        tree.add(stu3);        tree.add(stu4);        Iterator<UpdateStu> it = tree.iterator();        while (it.hasNext()) {            UpdateStu stu = (UpdateStu) it.next();            System.out.println(stu.getId() + "  " + stu.getName());        }        it = tree.headSet(stu2).iterator();// 获取排在stu2之前的对象        while (it.hasNext()) {            UpdateStu stu = (UpdateStu) it.next();            System.out.println(stu.getId() + "  " + stu.getName());        }        it = tree.subSet(stu2, stu3).iterator();// 获取排在stu2与stu3之间的对象        while (it.hasNext()) {            UpdateStu stu = (UpdateStu) it.next();            System.out.println(stu.getId() + "  " + stu.getName());        }    }}

注意：compareTo（）与hashCode（）方法以及equals（）方法三者保持一致。

130.TreeSet：1.向TreeSet中添加元素必须为同一个类。2.可以按照添加集合中的元素的指定顺序排序。使String，包装类等默认从小到大顺序排序；3.当向TreeSet中添加自定义类对象时，有两种排序1,。自然排序。2.指定排序。4.自然排序：要求自定义类实现java.lang.comparace接口并重写其compareTo（Object obj）：的抽象方法，在此方法中指明按照自定义类那个属性排序。5.定制排序：创建一个实现了comparator接口类对象（匿名对象），将此对象作为形参传递给TreeSet构造器，向TreeSet中添加comparator接口中compare方法中涉及的类的对象。添加compare方法；
代码说明：存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo（Object obj）方法比较此对象与指定对象的顺序。如果该对象小于，等于或大于指定对象，则分别返回负整数，0或正整数；

131.Map集合：Map集合没有继承Collection接口，其提供的是key到value的映射；Map不可有相同的key，每个key只能映射一个value，key还决定存储位置。（散列技术）；

132.Map方法：Int size：返回长度； object remove（Object key）：删除指定的key-value；
Put(key,value):添加key，value映射关系；
containsKey（Object key）：此映射包含指定key的映射关系，返回true；
containsValue（Object value）：此映射将一个或多个key映射到指定值，则返回true；
get(Object key): 存在指定的key对象，则返回该对象对应的值，否则返回null；
keySet（）：返回该集合中所有key对象形成的Set集合。
values():返回该集合中所有值对象形成的collection集合；
Void clean(): 清空；

import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public class UpdateStu {    public static void main(String[] args) {        Map<String, String> map = new HashMap<String, String>();        map.put("01", "李同学");        map.put("02", "魏同学");        Set<String> set = map.keySet();// 构建Map集合中所有key对象的集合        Iterator<String> it = set.iterator();// 创建集合迭代器        while (it.hasNext()) {            System.out.println(it.next());        }        Collection<String> coll = map.values();// 构建map集合中所有value值得集合        it = coll.iterator();        while (it.hasNext()) {            System.out.println(it.next());        }    }}

LinkedHashMap：使用链表维护添加进map顺序，所以遍历map时，是按添加顺序的；

133.Map接口常用的实现类有HashMap和TreeMap；建议使用HashMap类实现Map集合。因为HashMap类实现的Map集合添加和删除映射关系效率更高。HashMap是基于哈希表的Map接口的实现，HashMap通过哈希码对其内部的映射关系进行快速查找；而TreeMap中的映射关系存在一定的顺序，如果希望Map集合中的对象也存在一定顺序，应该使用TreeMap类实现map集合。
entrySet()方法：获得一个Set集合； HashMap：key使用Set存放的，不可重复，value是用collection来存放。

134.HashMap类：基于哈希表的Map接口的实现，可以null值和null键，但必须保证键的唯一性。顺序可变。
TreeMap类：不仅实现Map接口，还是先了java.util.Sortedmap接口，因此集合中映射关系有一定顺序。有一定的顺序，不允许键和对象时null。按照添加进Map中元素的key的指定属性进行排序。Key必须是同一类的对象，自然排序，定制排序。

import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.TreeMap;public class MapText {    public static void main(String[] args) {        Map<String, String> map = new HashMap<String, String>();        Emp emp = new Emp("351", "张三");        Emp emp2 = new Emp("512", "李四");        Emp emp3 = new Emp("853", "王一");        Emp emp4 = new Emp("125", "赵六");        Emp emp5 = new Emp("341", "黄七");        map.put(emp4.getE_id(), emp4.getE_name());        map.put(emp5.getE_id(), emp5.getE_name());        map.put(emp.getE_id(), emp.getE_name());        map.put(emp2.getE_id(), emp2.getE_name());        map.put(emp3.getE_id(), emp3.getE_name());        Set<String> set=map.keySet();        Iterator<String> it=set.iterator();        System.out.println("HashMap类实现的Map集合，无序：");        while(it.hasNext()) {            String str=(String)it.next();            String name=(String)map.get(str);            System.out.println(str+"  "+name);        }    TreeMap<String,String> treemap=new TreeMap<>();    treemap.putAll(map);//添加对象；    Iterator<String> iter=treemap.keySet().iterator();    System.out.println("TreeMap类实现的Map集合，键对象升序");    while(iter.hasNext()) {        String str=(String)iter.next();//拿出key        String name=(String)treemap.get(str);//拿出value        System.out.println(str+"  "+name);}   }}

135.遍历Key集： Set set=map.keySet(); 遍历value： Collection values=map.values();
操作集合的工具类：Collections； reverse（List）：反转List中元素顺序；
Shuffle（List）：对List集合进行随机排序； Sort（list）：对list中元素自然顺序按升序排序；
Swap（List int i，int j）:将指定的集合中i处元素和j处元素。

136.流概述：流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。程序从指向源的输入流中读取源中的数据，输出流的指向是数据要到达的目的地。
所有输入流都是抽象类InputStream(字节输入流)或抽象类Reader(字符输入流)的子类；所有输出流都是抽象类OutputStream(字节输出流)或抽象类Writer(字符输出流)的子类；

137.InputStream类是字节输入流的抽象类，所有字节输入流的父类。
read()方法：从输入流中读取数据的下一个字节。返回0-255范围内的int字节值，流末尾没有可用字节，则返回-1；
Read(byte [] b):从输入流读入一定长度的数字，并以整数形式返回字节数。
mark(int readlimit):输入流放一个标记，readlimit参数警告此输入流在标记位置失效之前允许读取的字节数。
reset()方法：将输入指针返回到当前所做的标记处。
skip(long n):跳过输入流上的n个字节并返回实际跳过的字节数。
markSupported():如果当前支持mark()/reset()操作的话返回true。
close():关闭输入流并释放与该流关联的所有系统资源。

138.Java中的字符是Unicode编码，是双字节的。InputStream是用来处理字节的，并不适合处理字符文本。Reader类不是InputStream的替换者，只是在处理字符串时简化了编程。Reader类是字符串输入流的抽象类，所有字符输入流的实现都是它的子类。字符流（处理文本文件）。Reader类与InputStream类似。

139.OutputStream类：是字节输出流的抽象类，此抽象类是表示输出字节流的所有类的超类。
OutputStream类中的所有方法均返回void，在遇到错误的时候会引发IOException异常。
write(int b):将指定的字节写入输出流；
write(byte [] b):将b个字节从指定的byte数组写入此输出流。
write(byte[] b,int off,int len):将指定byte数组中从偏移量off开始的len个字节写入此输出流。
flush():彻底完成输出并清空缓存；
close():清空输出流；
Writer类是字符输出流的抽象类，所有字符输出流的实现都是他的子类。Writer类的层次结构：
Writer–OutputStreamWriter–FileWriter；
四个父类：InputStream，Reader，OutputStream，Writer。

140.File类：是java.io包中唯一代表磁盘文件本身的对象。（可以是文件活着文件夹），File类的对象常作为io流具体类的构造器的形参。
通常有一下三种构造方法创建文件对象：1.File file=new File(“D:/1.txt”);pathname：路径的意思；
2.new Flie(“D:/doc”,”letter.ext”);父路径，子路径；3.还有父路径对象，子路径字符串。\是绝对路径。
当前目录中不存在名称为word的文件，File类对象可通过调用createNewFile（）方法创建一个名称为word.txt
的文件，如果存在可以用delete() 方法删除。

import java.io.File;public class FlieText {    public static void main(String[] args) {        File file = new File("D:/work.txt");        if (file.exists()) {// 如果该文件存在            file.delete();        } else {            try {                file.createNewFile();// 创建该文件            } catch (Exception e) {                e.printStackTrace();            }        }    }}

141.获取文件信息：mkDir():创建一个文件目录，只有在上层文件目录是存在的情况下，才返回true；
mkDirs():创建一个文件目录，若上层文件目录不存在，一并创建。
getName():String;获得文件名称； canRead():boolean：文件是否可读；
canWriter():boolean:文件是否可写； exits():boolean:判断文件是否存在；
length():long :获取文件的长度（以字节为单位）； getParent():String :获得父路径；
getAbsolutePath():String :获取文件的绝对路径； isFile():boolean判断文件是否存在；
isDirectory():boolean:判断文件是否为一个目录； isHidden():boolean:判断文件是否为隐藏文件；
lastModified():long:获取文件最后的修改时间；

142.文件输入/输出流：输出的物理文件可以不存在，若不存在，将自动建立，若存在则覆盖。

143.FileInputStream类与FlieOutputStream类都用来操作磁盘文件；
构造方法如下2个：FileOutputStream(String name); FileOutputStream(File file);
第二个构造方法是允许把文件连接输入流之前对文件做进一步分析。
FileOutputStream类与FileInputStream类相同的参数构造方法，FileOutputStream创建对象可以指定不存在的文件名，但文件不能是一个被其他文件打开的文件。

import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class FlieText {    public static void main(String[] args) {        File file = new File("D:/work.txt");        try {            FileOutputStream out = new FileOutputStream(file);            byte[] buy = "我有一只小毛驴我从来也不骑马".getBytes();                out.write(buy);//讲述组中的信息写入文件中                out.close();//将流关闭；                FileInputStream in=new FileInputStream(file);            byte[] byt=new byte[1024];            int len=in.read(byt);//从文件中读取信息            System.out.println("文件中的信息是："+new String(byt,0,len));            in.close();        } catch (FileNotFoundException e) {//输出流找不到异常            // TODO Auto-generated catch block            e.printStackTrace();        } catch (IOException e) {//写入会有输入输出IO流异常            // TODO Auto-generated catch block            e.printStackTrace();}}}或者：while(len.read()!=-1){操作。。。}

注意：使用FileReader，FileWriter可以实现文本文件的复制，对于非文本文件只可以用字节流。

144.虽然java在程序结束时自动关闭所有打开的流，但是当使用完流后，显示地关所有流是好习惯。
一个被打开的流可能会用尽系统资源，这取决于平台的实现，如果没有关闭流，另一个程序试图打开另一个流时，可能会得不到需要的资源。

145.使用FileOutputStream类向文中写入数据，使用FileInputStream类从文件中将内容读出来，都存在不足，这两个类都只提供了对字节或字节数组的读取方法。所以采用字符流Reader和Writer类即可避免这种现象，只对文本进行操作。

import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class FlieText {    public static void main(String[] args) {        File file = new File("D:/work.txt");        try {            FileWriter out=new FileWriter(file);            String str="大傻子";            out.write(str);            out.close();            FileReader in=new FileReader(file);            char [] byt=new char[1024];            int len=in.read(byt);            System.out.println(new String(byt,0,len));            in.close();        } catch (IOException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }}}

146.带缓存的输入/输出流； 缓存是I/O的一种性能优化，缓存流为I/O流增加了内存缓存区；是的在流上执行skip（），mark(),reset()方法都成为了可能。输出先close();flush（）方法刷新。

147.BufferedInputStream类：可以对所有InputStream类进行带缓存区的包装已达到性能的优化，两个构造放方法：BufferedInputStream(InputStream in); BufferedInputStream(InputStream in,int size);
第一种构造方法创造了一个带有32个字节的缓存流；第二种形式按照指定大小创建缓存区。
注意：一个最优的缓存区的大小，取决于他所在的操作系统，可用的内存空间一级机器配置。

148.bufferedOutputStream输出信息和用OutputStream输出信息完全一样。只不过BufferedOutputStream有一个flush()方法用来将缓存区的数据强制输出完。有两个构造：BufferedOutputStream(OutputStream in);
BufferedOutputStream(OutputStream in,int size);一样的，第一种构造方法创建一个有32个字节的缓存区，第二种构造方法以指定的大小来创建缓存区。

149.Flush()方法就是用与即使缓存区没有满时，也将缓存区的内容强制写入到外设，俗称为刷新。Flush()方法只对使用缓存区的OutputStream类的子类有效，当调用close（）方法是，系统关闭流之前，也会将缓存中的信息刷新到磁盘文件中。

150.BufferedReader类与BufferedWriter类：这两个类同样具有内部缓存机制，并可以以行为单位进行输入输出。
BufferedReader类： read():读取单个字符； readLine():读取一个文本行，并将其返回为字符串，若无数据可读，返回null。
BufferedWriter类：方法都是void。：write(String s,int off,int len):写入字符串的某一个部分。
Flush():刷新该流的缓存； newLine():写入一个行分隔符；
在使用BufferedWriter类的Write()方法时，数据没有立即被写入输出流，而是首先进入缓存区。如果想立刻将缓存区中的数据写入输出流，一定要调用flush()方法。

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class FlieText {    public static void main(String[] args) {    String content[] ={"好久不见","最近好么","常联系"};    File file=new File("D:/word.txt");    try {        FileWriter fw=new FileWriter(file);        BufferedWriter bufw=new BufferedWriter(fw);        for(int k=0;k<content.length;k++){            bufw.write(content[k]);            bufw.newLine();//将数组以单行的形似写入磁盘        }        bufw.close();        fw.close();        FileReader fr=new FileReader(file);        BufferedReader bufr=new BufferedReader(fr);        String  str=null;        int i=0;        while((str=bufr.readLine())!=null){            i++;            System.out.println("第 "+i+"行 ： "+str);        }        bufr.close();        fr.close();    } catch (IOException e) {        // TODO Auto-generated catch block        e.printStackTrace();    }}}