1. 人机交互
（1）.图形化界面
（2）.命令行方式 进入 e: dir显示当前目录的东东 cd
cd..退回 cd.返回上一级 cd\直接退到根目录 cls清屏
总结：结论就是你双击没有出现图形化界面的时候，那么他就是命令行的方式。如果是命令行的方式，首先要打开命令提示符。
2．Java三种技术架构
J2SE >>JAVASE标准版：可以开发普通桌面的应用程序
J2EE >>JAVAEE企业版：可以是企业级的开发，针对web应用程序的开发
J2ME>>JAVAME小型版，主要用于开发电子消费产品。（手机app，现已被安卓取代）
3. java语言特性（主：*跨平台原理）
（1）.开源，免费的
（2）.跨平台性，一次编写到处运行。
主：*平台指的是：操作系统 例子：windows Linux mac
（3）.Java之所以可以在任意操作系统上运行，是因为不同的操作系统上装了不同的jvm（java虚拟机）。>>>jvm存在只是为了java程序到操作系统的运行一个过渡。
（4）.Jre：java运行环境 Jvm java虚拟机 Jdk 开发工具包
Jre = Jvm+支持jvm运行的核心类库
Jdk = jre + java开发工具包
配图：
补充：bin（文件夹下） >>>全称binary 装的都是工具或者叫做命令，或叫可执应用程序（基本都是.exe文件）
4.关键字和标识符关键字：在Java语言中被赋予了特定含义的一些单词或者字母的组合。（比如说eclipse中的红色字体显示的）。
标识符：表示起一定标识作用的符号。标识作用的符号指的是在程序中定义的名称。比如Demo，haha等。
命名范围：**a-z A-Z _ $ 0-9
类名：每个单词首字母大写 驼峰式命名
规定：
（1）标识符不能以数字开始
（2）关键字在不能单独作为标识符
5. 符合含义
{}表示范围
[]表示数组
（）表示方法
；在java中表示一句话的结束
“”在java中表示字符串常量
6. 语法格式
常量：不能被改变的数据，固定不变的数据。
数值：
整数：1 2 3
小数：3.14 1.2
字符串：“” 空字符串也是字符串（双引号内的就是字符串）
字符：‘’（单引号内的就是字符）
布尔类型：boolean true false
null 空常量给引用数据类型赋值
变量：可以改变的量，其实变量用来存储常量数据的。
定义格式：1.数据类型 变量名 = 常量值 如：int a = 5;2.
2.数据类型 变量名；不赋值
命名格式：除第一个单词，其余单词首字母大写。
换算关系
1 byte = 8 bit; (bit：比特位 byte 字节)
1 KB = 1024 byte;
1 MB = 1024 KB;
1 GB = 1024 MB;
1 TB = 1024 GB;
7.**数据类型**分两类：
（1）引用数据类型：数组 类 接口 null
（2）基本数据类型：
四类八种：
1）.整数数据类型：byte -128~127(1byte) short(2byte) int(4byte) long(8byte）
2）.小数数据类型：float(4byte) double(8byte)
3）.字符数据类型：char (2byte)
4）.布尔数据类型：boolean （1byte）
（3）
1）一般在java中书写一个整数，这个整数默认是int类型。
注意：在开发中给long类型赋值，一般在整数后面加字母L。
2）在java中书写一个小数，那么小数默认是double类型
注意：给小数单精度是，需在小数后面加一个字母F。
8.***数据类型转换***
（1）. 隐式数据类型转换
转换：byte,short,char -- int -- long -- float – double
注释：可以把小的空间中数据给大的空间保存（哎，也是把小的数给大的赋值（系统自动转换））
（2）. 强制数据类型转换
格式：
需要转成的数据类型 变量名 = （需要转成的数据类型）（被转的数据）
例如：int a = (double)(3.14);
9. 运算符
定义：对常量和变量进行操作的符号称为运算符。
***常用运算符：
算术运算符、赋值运算符、关系运算符（或叫比较运算符）、逻辑运算符和三元运算符。
（1）算术运算：
1）在java中进行算术运算的时候，运算符两侧的类型一致的时候，运算的结果必须和运算的数据类型保持一致。
例如：int a = 4321/1000*1000; 4
2）当算术运算两侧的类型不一致的时候，结果向大的类型保持。
例如：double b = 4321/1000.0*1000; 4321.0
字符与+运算：
‘0’ 48
‘A’ 65
‘a’ 97
int +char >>>int 如：（10 + ‘0’）>>58
String + int +int>>>Stringint 如：“hell”+5+6 >>>(“hell5”+6)>>(“hell56”)可以以此理解。
Int + int + String >>intString 如：5+6+“hell”>>(11+“hell”)>>(“11hell”)。
char+char +String >>intString 如：‘0’+‘a’+“hell”>>(145+“hell”)>>(145hell)。
char+String 与String + char + char >>charString
例如：‘0’+“hell” >>“0hell”
“hell”+‘a’+‘0’>>“hella0”
算数运算符++和—用法
自我理解：++i i++ i-- --i 谁在前面先执行谁
（2）赋值运算符
基本赋值运算符：=
混合的赋值运算符：+=，-=，*=，/=,%=
注意：a+=20；相当于a=(a的数据类型)（a+20）;
（3）关系运算符
关系运算符：==，!=,>,>=,<,<=
他的运算结果都是boolean型（true false）
（4）逻辑运算符
逻辑运算符：要求两侧的运算类型必须是boolean类型。逻辑运算符就是把多个boolean类型的值连接在一起。
双与（短路与）&& 单与 & >>>>>>一假即假
双或（短路或） || 单1或 | >>>>>>>一真即真
异或^ >>>>>>>两侧结果不同为真
非 ！true>>false !false = true
（5）三元运算符
格式：
表达式1？表达式2：表达式3；
表达式1结果为真，则表达式2为结果
表达式2结果为假，则表达式3为结果
键盘录入三步走：导包>>>创建键盘录入对象>>>获取数据
随机数三步走：导包>>>创建对象>>>获取随机数
补充：
// 1.单词联想 alt+/
// 2.删除一行 Ctrl+d
// 3.向下复制一行Ctrl+alt+向下键
// 4.向上复制一行Ctrl+alt+向上键
// 5.向下移动一行 alt+向下键
// 6.向上移动一行 alt+向上键
// 7.换行shift+Enter
// 8.美观代码 格式化 Ctrl+shift+f
//9.将字母转换为大写Ctrl+shift+x
//10.将字母转换为小写Ctrl+shift+y
//11.解决小红叉错误ctrl+1
//12.想输出打印某个变量 连续按alt+/两次
//13.添加注释单行 ctrl+/ 取消单行注释 在按一次ctrl+/
//14.添加多行注释/**/ ctrl+shift+/ 取消多行注释 ctrl+shift+\
//15.生成get和set方法 alt+shift+s
例如：89 = 64+16+8+1 89-64=25>16 89-64-16=9>8 依次类推
99 = 64+32+2+1
1 1 1 1 1 1 1 1
128 64 32 16 8 4 2 1
0 1 0 1 1 0 0 1
0 1 1 0 0 0 1 1
11.选择流程控制语句
（1）If语句
第一种格式：if(判断的条件){
判断成立后应该执行的动作；
}
第二种格式：if(判断的条件){
判断条件成立后执行的语句；
}else{
判断不成立后执行的语句；
}
第三种格式：if(判断的条件){
判断成立后执行的语句；
}else if(判断的条件){
判断成立后执行的语句；
}
…
else{
上述的所有判断都不成立之后执行的语句；
}
注意：这里判断条件最后必须是一个boolean值，如果判断条件是true，则执行if后面的{}中的内容；如果判断条件是false，则跳过大括号中的内容，向下继续执行其他内容。
（2）多分支结构/选择结构（switch）
switch(表达式)
{ case 常量1：
语句1；
break;
case 常量2：
语句2；
break;
…
default:
语句；
Break;
}
注意注意：* 表达式结果的类型只能是：byte short int char string 枚举
12.
循环流程控制语句
循环三要素：
1） 循环初始值
2） 循环的条件
3） 控制循环条件（修改循环条件）
while(循环条件){
循环条件成立后要执行的语句；//循环体
}
do{
循环体语句；
}while(循环条件);
for(循环初始值；循环条件；控制循环条件)
注意事项：
do…while循环至少会执行一次循环体
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环和while循环语句的小区别
使用区别：
for循环的初始化变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
**无线循环：
while(true){
循环体；
}
for的格式：
for(;;){
循环体；
}
13.控制循环****
（1）break:在java中break有两个作用
1）使用在switch语句中：结束switch语句
2）使用在循环中，结束或者终止当前循环
（2）continue：跳过本次循环，执行本循环的下一次的循环
14.数组*******
一位数组定义：一次性可以开辟出一组空间，然后这些空间中可以保存多个数据。而我们把这一组空间统称为数组。
二位数组定义：在java中二维数组就是先定义一个一维数组，然后在这个一维数组的每个空间中保存另外一维数组的内存地址名。通过空间中保存的内存地址名来管理其他的一维数组。
数组：既可以存储基本数据类型，也可以存储引用数据类型。
一维数组格式：
第一种：数据类型[] 数组名 = new 数据类型[长度]；
第二种：数据类型[] 数组名 = {值，值。值...}；
或数据类型[] 数组名 = new 数据类型[]{值，值。值...}(基本上不用)
二位数组（一个一维数组还有一个一维数组）格式：
第一种：数据类型[][] 数组名 = new 数据类型[行的个数][每行中列的个数];
第二种：数据类型[][] 数组名 = {
{值，值。值...}，
{值，值。值...}
…
}；
优点：
1） 一次性开辟更多空间
2） 可以对多个空间进行统一的管理
3） 数组》》》索引（下标，角标），操作数组中的数据
4） 下标从0开始，（数组长度-1）结束
5） length属性，可获得数组长度
15.java的内存分配
1）栈内存：所有方法都在栈内存开辟空间并运行
2）堆内存：只要new创建的空间都会在堆内存中存在
特点：如果一个变量没有赋值，那么jvm会给堆中的变量默认初始化值。整数：0 小数：0.0 布尔:false 引用数据类型:null。
只要在堆内存中开辟空间，那么jvm都会给空间整体随机分配一个十六进制的地址值。
方法区：存放.class文件的
本地方法区：主要是保存native关键字标注的方法（和系统相关）
寄存器：是给CPU用的；
注意：ArrayIndexOutOfBoundsException:数组下标越界错误（超越数组空间的真实下标）
NullPointerException:空指针异常
（在当前的程序中使用一个引用变量，但是这个引用变量并没有指向一个真实的内存空间，导致这个问题。）
特别提示：在java中当被new出来的堆中的内存，没有任何一个引用指向它的时候，这时候它就是一个垃圾，JVM就是用垃圾回收器把当前这片内存清理。
数组类问题：
1）求最值思路：假设一个最大值或者最小值，遍历数组与这个最值比较，数组中只要比这个最值大的，就把数组中取出的这个比其大的值替换假设的最值。
（技巧：一般假设的这个值一定是数组中存在的值）
2）水仙花数：数的每个位上的数立方和等于这个数
3）回文数：只要满足将某位数的各位数字反向排列所得自然数与之前的数字比较相等就是回文数
4）斐波那契数列：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和。
1 1 2 3 5 8...
int[] arr = new int[20]
初始数组的前两个索引
arr[0] = 1;//表示第一个月 数组索引从0开始
arr[1] = 1;//表示第二个月 数组索引从0开始
arr[2] = arr[0]+arr[1];
arr[3] = arr[2]+arr[1];
…
f(n) = f(n-1) + f(n-2)(n>=3);
5）数组反转：反转思想
for(
int startIndex=0,endIndex=arr.length-1;startIndex<=endIndex;startIndex++, endIndex--){
int temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}16.方法（函数）的概述及基本使用
定义：表示可以独立运行的一段代码，具有独立功能。当在程序中需要使用的时候可以通过方法的名字的调用。
作用：提高程序中代码的复用性
格式：
函数的修饰符 void（函数的返回值类型） 函数的名（接收的参数类型 参数名， 接收的参数类型 参数名 …）
{
函数体代码；//具体完成相应功能的代码
（return 返回值;）//函数定义时，声明函数返回值类型的，需要用到return
}
注意：return 结束方法
return 问题：
1）一个函数能不能返回多个值？
不能。只能返回一个值。
2）一个函数么有返回值的时候，可以书写return语句吗？
能，return；，表示快速结束函数。
17.方法（函数）的重载
三大特点：
1） 要求必须在同一个类中（程序）
2） 要求函数的名称必须相同
3） 要求函数的参数列表（参数的个数，类型，顺序）必须不同
例如：class Demo{
void show(int a,float b,char c){
}
}
下列哪些函数和给定的函数重载
int show(int x,float y,char z) 不是，参数列表和指定的函数一样，函数的重载和返回值类型无关。
void show（int c，float a，char b） 不是，参数列表和指定的函数一样，函数的重载和参数的变量名无关。
void show（float a，int a，char c）重载
void show（int a，int b，int c）重载
double show（） 重载
方法命名规范：
与变量一样：多个单词，从第二个单词开始，首字母大写。
（1） 方法中参数传递
方法的参数是基本类型的时候：
形式参数的改变不影响实际参数。
形式参数：用于接收实际数据的变量
实际参数：实际参与运算的变量
》》》******重要的东西：
值的传递（常量值传递或者就是基本数据类型传递）和引用的传递区别：
1） 在程序中如果把具体的一个值传递给其它的方法，那么在方法中只能操作传递过来的那个值。不影响实际参数的值。
2） 在程序中如果把某个地址传递给了其它的方法，这是在其他方法获取的是地址，那么通过地址就可以找到真实存放数据的空间，这是通过地址去操作同一空间。影响空间的值。
补充：断点调试 用来解决逻辑错误，不是语法错误
18.面向对象************
面向对象：
当我们在程序如果需要使用某些功能的时候，这是先不要自己盲目的去想这个功能的代码自己应该使用什么语句，以及其他什么逻辑结构，而是先思考有没有已经写好的功能存在，而直接去找那些存在的功能，传递参数进行，最后得到自己想要的结果。
（在程序中的组成单位就是类（类中封装了函数）。是由若干个类组成的。）
面向过程：在程序中的组成单位是函数。是由若干个函数组成。
面向对象是基于面向过程的基础之上的。在开发中，面向对象和面向过程是配合使用的。
事物的基本属性 --------- 基本功能
事物的基本数据，一般在生活中就是一个数据，这个数据可以使用学习过得一个变量来表示。
事物的行为/功能/动作，可以使用java中的函数的来描述
注意：如果在当前这个class类仅仅是为了描述一个事物，不需要独立运行。所以可以不用写main函数，如果一个类需要独立运行，那么必须写main函数。
（1）成员变量：事物的基本属性使用了变量描述，书写的位置与类中的函数（方法）属于并列关系。
（2）成员函数：负责描述行为（功能）的函数。
在使用java中的new关键字创建当前这个类的对象时，这个类中的所有成员变量，会随着对象在堆中的出现而存在。所有成员变量随着的对象在堆中出现之后，都会有默认的初始化值。
（3）成员变量和局部变量的区别
局部变量：定义在方法中的那些变量。局部变量只在定义它的方法中有效。
成员变量（全局变量）：定义在类的成员位置上的变量。成员变量在整个类中都有效。
成员变量：实例（对象）变量和类变量（static静态变量）
优先级：在类中和该类的一个方法中，同时存在一个相同类型相同名称的变量，在方法被执行时，方法中优先使用定义在方法中的变量（局部变量）。就近原则。
1）. 从定义上讲：
局部在方法中定义。
成员在类中定义。
2）.从内存存储来讲
局部随着方法的执行在栈内存中出现，局部存在栈内存中。
成员随着对象的出现在堆中存在，成员存储在堆内存中。
3）.从初始值来讲
局部定义时需要指定初始值（无默认初始值），只有初始化之后才能使用。
成员可以不用初始化，有默认值。
4）.从存活时间上来讲（生命周期）
局部随着方法的进栈在方法所属的栈内存中存在，随着方法的出栈就消失。
成员随着对象的出现在堆中出现。随着对象的消失而消失。
面向对象特性之封装
所有的面向对象的语言：
三个最基本的特征：封装，继承，多态
封装：对事物进行包装。封装会造成事物的部分细节被隐藏。
private是java中的关键字
public：公开的，公共的 访问范围没有底限（在java中属于最大的访问权限）
private：私有的 访问范围只能在本类中使用（在java中属于最小的访问权限）
面向对象定义类的要求：
类中的所有成员变量全部私有，并对外提供相应的public访问方法（函数）。
一般对于成员变量访问只有两种:赋值（setter）取值（getter）
注意：
1） 在开发中如果在外界想给类中的私有成员变量赋值，那么通过类中的setXxxx函数进行对该成员变量赋值。
2） 在开发中如果在外界想使用类中的私有成员变量，那么通过类中的getXxxx函数获得该成员变量。
（在基础进阶时，会详说，暂写一部分）
19.this关键字和面向对象的构造方法
（1）this:方法被哪个对象调用，在方法中就会有一个隐式的变量this记录着调用对象的地址。
使用：当局部变量和成员变量重名时。
可以用来区分成员变量和局部变量。格式：this.成员变量名
（2）构造函数（方法）：在创建对象是（使用new时），会自动调用的函数。
new 类名()：就是以无参数构造方法实例化的对象。
构造函数格式：
修饰符 构造函数名（参数列表）
{
}
定义细节：
1） 构造函数用来创建对象的，它不需要书写返回值类型
2） 构造函数名字与当前类名一致。
3） 参数列表，可以和一般函数的参数列表一样。
作用：就是为了给对象成员变量初始化值使用的。
（3）构造函数和一般函数异同
1）执行时间不同：
构造函数是在创建对象的过程中执行。当对象创建完成了，构造函数就已经执行结束。
一般函数执行时间有两种情况：
1)）如果调用其他类中的函数时：一般函数通过是在对象创建完成之后，通过对象的引用来调用。
2)）如果调用本类中的函数时：什么时候使用，什么时候调用。
2）它们的调用次数不同：
构造函数只有在new对象的时候，会被调用，一旦对象创建完成，我们不能手动的人为去调用构造函数。
一般函数可以通过对象随意的调用，没有次数限制。
3）它们互相调用问题：
在构造函数中可以去调用一般的函数，但是在一般的函数中不能调用构造函数。
（4）使用this来实现构造函数互调
1) this调用其它构造函数的格式： this(参数列表); //相当于 构造函数(参数列表)。
2）在Java中只要是通过名称调用函数，那么调用的都是一般函数，构造函数之间不能通过函数名调用。
注意:
1） 构造函数之间不能相互嵌套调用，这样就会导致无限制的调用构造函数，导致永远无法停止调用。
2） this调用构造函数，必须放在构造函数的第一句。我们通过this调用构造函数的目的是希望通过其他的构造函数完成初始化动作，因此要求其他构造函数的初始化必须在本构造函数中执行之前先初始化完成。
20.Api的使用（基础学习遇到的一些api）
String类：字符串常量，是引用类型，也称类类型。
****String******描述的字符串，所有在java程序中使用双引号引用起来的数据都是一个对象。
注意：字符串常量，它属于对象，但是它不是存储在堆空间中，而是存储在方法区中的字符常量池中。
注意：使用双引号本身就可以得到一个字符串对象。
String类提供了大量的构造函数，目的是可以帮助我们将其他的数据变成字符串对象。
只要使用String类的构造函数创建的对象，那么这个对象就会在堆中出现。
而在创建出的字符串对象中的字符数据保存在常量池中。
String类的一些构造方法
boolean equals(object obj):比较字符串的内容是否相同
boolean equalsgnoreCase(String str):比较字符串内容是否相同，忽略大小写
boolean startsWith(String str):判断字符串的内容是否以指定的str开头
boolean endsWith(String str):判断字符串对象是否以指定的str结尾
int length（）：获取字符串的长度，及字符的个数
char charAt（int index）：获取指定索引处的字符
int indexOf（String str）：获取str在字符串中第一次出现的索引
String subString（int start）：从start索引开始截取字符串，截取到字符串最后
String substring（int strat，int end）：从start开始，到end结束截取字符串，包括start，不包括end。（包头不包尾）
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串中的所有大写字母转换为小写字母
String toUpperCase():把字符串中的小写字母转换为大写字母
String trim():去除字符串两端的空格
String[] split(String str):按照指定的字符串分割字符串
21.字符串缓冲区介绍
缓冲区：就是一个临时的空间，它里面可以临时存储数据。缓冲区本身就是一个容器。
字符串缓冲区：它本身就是一个容器，只不过这个缓冲区最后会把里面的所有数据全部给变成字符串而已。
对于StringBuilder()构造函数，其初始容量为16个字符表示，如果存在StringBuilder的数据超过了16个字符，这个容器可以自动扩容(容器空间自动变大)。（经常使用）
StringBuilder底层体现就是一个字符数组。
StringBuilder
1）是一个字符串缓冲区，其实就是一个容器。
2）长度是可变的，任意类型都可以。但都转换为字符串进行存储。
3）容器对象提供很多对容器中的数据操作功能，比如添加，删除，修改，查询。
4）所有的数据最终都会变成一个字符串。
与数组的不同：
数组存储完可以单独操作每一个元素，每一个元素都是独立的。
字符缓冲区，所有存储的元素都会被转成字符串，而且变成了一个更长的字符串。
成员方法：
public int capacity（）：返回当前容量（理论值）
public int length（）:返回长度（已存储的字符个数）
StringBuilder和String相互转换：
toString StringBuilder>>>>>>>>String
StringBuilder(String str) String >>>>>>>StringBuilder4
实现字符串反转
String >>>>>StringBuilder>>>>>reverse()>>>>>String
22.对象数组和集合
保存数据的容器：
1） 变量空间中就可以保存数据
2） 数组中可以保存多个类型的相同的数据
3） 字符串缓冲区中可以保存任何类型的数据
集合：
定义：集合也是一种容器，也可以存放数据。可以存储对象。
集合和数组的区别：
1）从长度来讲：
数组：需要固定长度。
集合：长度可以改变，可以根据保存的数据进行扩容
2）从存储内容上：
数组：可以存储基本类型数据，还可以存储引用类型的数据。
集合：只能存储引用类型的数据，也就是说集合只能存储类的对象。
3）从存储类型上：
数组：只能存储相同的类型的数据。
集合：可以存储不同类型的数据，集合中可以存储任意类型的引用类型。
集合底层：是一个大小可变的数组。
ArrayList删改查方法
a：获取元素
public E get(int index):返回指定索引处的元素
b：集合长度
public int size():返回集合中的元素的个数
c：删除元素
public Boolean remove（Object o）:删除指定的元素，返回删除是否成功。
public E remove(int index):删除指定索引处的元素，返回被删除的元素。
d：修改元素
Public E set(int index,E element):修改指定索引出的元素，返回被修改的元素。
23.IO流
（个人理解）（输入缓冲流是指从（持久设备的））文本文件中把其中的数据读取到（如集合或者数组或者字符串等等））
（输入缓冲流是指从（如集合或者数组或者字符串等等））把其中的数据写到（持久设备中）文本文件中）。
IO技术：它主要的功能就是把我们程序中的数据可以保存到程序以外的其他持久设备中(如：我们电脑的硬盘)，或者从其他持久设备中(如：我们电脑的硬盘)进行读取数据，把数据读取到我们的Java程序中。
IO流分类：
1）按流分向
输入流:读取数据，把持久设备的数据读取到内存中。
输出流：写出数据，把内存的数据写到持久设备。
2）按读取的数据类型分：
字节流：java就给出了字节流可以直接操作字节数据。例如：.avi .jpg等存放的都是字节数据。
可以处理任意类型，但是处理文本类型有可能会出现bug。
字符流：读取字符数据。
注意：只能对文本类型的文件进行操作。
文本类型文件：只要可以使用记事本打开并看得懂的文件就是文本文件。（如：.java .txt文件）
输出流写数据的步骤：
a:创建输出流对象{
创建输出流对象做了哪些事情：
1. 调用系统资源创建了一个文件
2. 创建输出流对象
3. 把输出流对象指向文件
}
b:调用输出流对象的写数据方法
c:释放资源
输入流读数据的步骤：
a:创建输入流对象
b:调用输入流对象读数据的方法
c:释放资源
结论：
* 在创建对象时，构造方法做了哪些事情？
* 1.如果指定整体路径不存在，就会报异常： java.io.FileNotFoundException: D:\aha\1.txt (系统找不到指定的路径。)
* 2.如果指定路径存在，文件不存在，那么就会帮助我们自动创建一个文件
* 3.如果文件存在，并且文件中有数据，那么底层也会创建新的文件，并且覆盖源文件
* 4.写完数据的时候要调用flush方法进行刷新，最后调用close方法进行关闭资源，将资源还给系统
* 5.关于路径的问题：
* D:\\aaa\\1.txt
* 绝对路径(全路径)：带盘符的路径就是绝对路径
* 相对路径：不带盘符的路径就是相对路径 1.txt。对于程序中书写的相对路径都是相对于当前项目。
复制文本的文件的5种方式：
String srcFileName = "D:\\demo\\123.txt";
String destFileName = "copy123.txt";a:利用基本流一次读写一个字符
public static void method1(String srcFileName,String destFileName) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(srcFileName);
//创建输出流对象
FileWriter fw = new FileWriter(destFileName);
//一次读写一个字符
int ch=0;
while((ch=fr.read())!=-1) {
fw.write(ch);
fw.flush();
}
//释放资源
fw.close();
fr.close();
}
}b:利用基本流一次读写一个字符数组
public static void method2(String srcFileName,String destFileName) throws IOException {
//创建输入流对象
FileReader fr = new FileReader(srcFileName);
//创建输出流对象
FileWriter fw = new FileWriter(destFileName);
//一次读写一个字符数组
char[] chs = new char[1024];
int len=0;
while((len=fr.read(chs))!=-1) {
fw.write(chs,0,len);
}
//释放资源
fw.close();
fr.close();
}
c:利用缓冲流一次读写一个字符
public static void method3(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
FileReader fr=new FileReader(srcFileName)
BufferedReader br = new BufferedReader(fr);
//创建输出缓冲流对象
FileWriter fw=new FileWriter(destFileName)
BufferedWriter bw = new BufferedWriter();
//一次读写一个字符
int ch=0;
while((ch=br.read())!=-1) {
bw.write(ch);
bw.flush();
}
//释放资源
bw.close();
br.close();
}d:利用缓冲流一次读写一个字符数组
public static void method4(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
FileReader fr=new FileReader(srcFileName)
BufferedReader br = new BufferedReader(fr);
//创建输出缓冲流对象
FileWriter fw=new FileWriter(destFileName)
BufferedWriter bw = new BufferedWriter(fw);
//一次读写一个字符数组
char[] chs = new char[1024];
int len=0;
while((len=br.read(chs))!=-1) {
bw.write(chs,0,len);
bw.flush();
}
//释放资源
bw.close();
br.close();
}e:利用缓冲流的特有方法一次读写一行字符串
public static void method5(String srcFileName,String destFileName) throws IOException {
//创建输入缓冲流对象
FileReader fr=new FileReader(srcFileName)
BufferedReader br = new BufferedReader(fr);
//创建输出缓冲流对象
FileWriter fw=new FileWriter(destFileName)
BufferedWriter bw = new BufferedWriter(fw);
//一次读写一行字符串
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
