第一：读写字符串
input（读文件里的内容） 的步骤：
对于文件里的内容，是个很长的字符串，而我们每次要读取的是一个字节数组或者一个字符数组
1.读字符串（文件里的内容），可以按字节读，也可以按字节数组读
2.输出（如果是按照字节读的就按照字节输出，如果是按照字节数组读的就按照字符串的方式输出）
output:(把东西（字符串）写入文件)
1.先定义一个字符串
2.将字符串转化成字节数组（两种方式基本一样，第一种因为是一个一个的输出，因此多了一个for循环）
3，然后写入，输出
Reader:字符输入流（抽象类）
FileReader:文件字符输入流
int read() int :读取字符的编码
int read(char []ch) int表示读取字符的个数 ，ch是读取的字符内容
Writer:字符输出流（抽象类）:必须刷新
实现类：
（1）.FileWriter(文件输出流，处理流)
(2).write（int c）c是要写入字符的编码
flash:写的时候都写入了内存（这时候内存中是二进制），内存中现在把编码组织好了（变成自己能够看的），之后刷新，就把字符放入了文件中。
close里面自动调用了flash,因此close方法也会达到刷新的作用。
注意：
InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串
第二：读写字符串相关代码（字符流：输入流与输出流）
package com.charTest;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class ReaderWriterTest {
/**
*
* @方法的作用：字符输入输出流
* @作者：褚永也
* @日期：2014-7-16 下午4:33:25
* @返回值类型：void
*/
public static void main(String[] args) {
File file = new File("src/com/charTEst/test.txt");
write1(file);
write2(file);
System.out.println("--------------------");
read1(file);
read2(file);
}
/**
*
* @方法的作用：每次读取一个字符，code表示这个字符的二进制编码
* @作者：褚永也
* @日期：2014-7-16 下午3:43:46
* @返回值类型：void
*/
public static void read1(File file){
try {
FileReader fr = new FileReader(file);
int code=0;//字符的二进制编码
while((code=fr.read())!=-1){
System.out.println(code+" "+(char)code);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @方法的作用：每次读取一个字符数组，len表示此数组的长度
* @作者：褚永也
* @日期：2014-7-16 下午4:06:29
* @返回值类型：void
*/
public static void read2(File file){
try {
FileReader fr = new FileReader(file);
char[] ch=new char[6];//每次读6个
int len=0;//每次循环的元素个数
while((len=fr.read(ch))!=-1){
System.out.println(String.valueOf(ch,0,len));//转化成数组
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
*
* @方法的作用：每次写入一个字符
* @作者：褚永也
* @日期：2014-7-16 下午4:20:11
* @返回值类型：void
*/
public static void write1(File file){
try {
FileWriter fw = new FileWriter(file,true);
String content="dsfdsfds第三方可敬的酸辣粉静安寺看到了伐sssss放大法";
for(char c:content.toCharArray()){
fw.write(c);
System.out.println(c);
}
fw.flush();//注意要刷新，才能显示刚才写入的内容
fw.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
*
* @方法的作用：写入一个字符数组
* @作者：褚永也
* @日期：2014-7-16 下午4:31:08
* @返回值类型：void
*/
public static void write2(File file){
try {
FileWriter fw = new FileWriter(file,true);
String content="dsfdsfds第三方可敬的酸辣粉静安寺看到了伐sssss放大法";
fw.write(content.toCharArray(), 10, 20);
fw.flush();
fw.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
第三：对象流的概念
对象流：是字节流（也是处理流），ObjectInputStream对象输入流，也是InputStream的子类。
要求对象保存到记事本中
ObjectInputStream依赖于Fileoutputstream，Fileoutputstream是在铺管道
序列化接口中没有任何方法，就是个标示接口
//对对象里的数据进行解码，可是对象里的数据没法解码，因为对象的编码没有规律。（对象以二进制的形式保存了）
注释：在把对象写入文件的时候，对象的内容出现了乱码，但是在读取这个对象的内容的时候就能正常的读取出来
第四：对象流相关代码
package com.objectStreamTest;
import java.io.Serializable;
public class User implements Serializable{
private String username;
private String userpass;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUserpass() {
return userpass;
}
public void setUserpass(String userpass) {
this.userpass = userpass;
}
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(String username, String userpass) {
super();
this.username = username;
this.userpass = userpass;
}
@Override
public String toString() {
return "User [username=" + username + ", userpass=" + userpass + "]";
}
}
package com.objectStreamTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ObjectStreamTest {
/**
* @方法的作用：定义一个类，将该的对象进行序列化和反序列化操作
* @作者：褚永也
* @日期：2014-7-16 下午8:59:18
* @返回值类型：void
*/
public static void main(String[] args) {
File file = new File("src/com/objectStreamTest/test.txt");
//对象序列化
try {
FileOutputStream out=new FileOutputStream(file);
ObjectOutputStream oos=new ObjectOutputStream(out);
User u=new User("dddd","11111");
oos.writeObject(u);
} catch (Exception e) {
e.printStackTrace();
}
//对象反序列化
try {
FileInputStream in=new FileInputStream(file);
ObjectInputStream ois=new ObjectInputStream(in);
Object obj = ois.readObject();
if(obj instanceof User){
User user=(User)obj;
System.out.println(user.toString());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
第五：用Properties模拟用户登录
package com.login;
import java.io.FileInputStream;
import java.util.Properties;
import java.util.Scanner;
public class Login {
/**
*
* @方法的作用：用Properties文件保存用户和密码，模拟登陆功能，用键盘输入的用户和密码
和Properties文件保存用户和密码封装的用户和密码比较
* @作者：褚永也
* @日期：2014-7-16 下午9:23:36
* @返回值类型：void
*/
public static void main(String[] args) {
Properties p = new Properties();
try {
p.load(new FileInputStream("src/com/login/test.properties"));//提前在test.properties里写好东西。把这个文件加载一下就获得了文件里的东西
//System.out.println(p.getProperty("username"));
} catch (Exception e) {
e.printStackTrace();
}
Scanner input = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = input.next();
if(p.getProperty("username").equals(username)){
System.out.println("请输入密码");
String userpass = input.next();
if(p.getProperty("userpass").equals(userpass)){
System.out.println("登陆成功");
}else{
System.out.println("登陆失败，密码有误");
}
}else{
System.out.println("登陆失败，用户名有误");
}
}
}
test.properties里面的东西是：
username=张三
userpass=1234
第五：字节流的输入流与输出流
package com.byteTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileInputOutputStreamTest {
/**
* @方法的作用：测试文件字节输入输出流
* @作者：褚永也
* @日期：2014-7-16 下午2:10:29
* @返回值类型：void
*/
public static void main(String[] args) {
File file = new File("F:\\test\\sub/a.txt");
input1(file);
input2(file);
System.out.println("----------");
output1(file);
output2(file);
}
/**
*
* @方法的作用：文件输出流，每次向文件中写入一个字节。
* @作者：褚永也
* @日期：2014-7-16 下午3:22:50
* @返回值类型：void
*/
public static void output1(File file){
try {
FileOutputStream fos = new FileOutputStream(file,true);
String content="abcdefghijklmnopqrstuvwxyz";
byte[] bt=content.getBytes();//先将字符串转化成字节数组在输入到文件中
for(byte b:bt){
System.out.println(b);
fos.write(b);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @方法的作用：字节输出流，向文件中写入一个字节数组。
* @作者：褚永也
* @日期：2014-7-16 下午3:24:31
* @返回值类型：void
*/
public static void output2(File file){
try {
FileOutputStream fos = new FileOutputStream(file,true);
String content="abcdefghijklmnopqrstuvwxyz";
byte[] bt=content.getBytes();//先将字符串转化成字节数组
//fos.write(bt, 0, content.length());
fos.write(bt, 1, bt.length-4);//写入的时候可以截取这个字节数组
System.out.println(bt);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @方法的作用：每次读取一个字节，用的是FileInputStream类中的read方法，无参
* @作者：褚永也
* @日期：2014-7-16 下午2:48:12
* @返回值类型：void
*/
public static void input1(File file){
try {
FileInputStream fis = new FileInputStream(file);
int b=0;
while((b=fis.read())!=-1){//fis.read()这里的返回值b表示的是每个字节的二进制编码
System.out.println(b);//打印二进制编码
System.out.println((char)b);//把二进制编码转化成char字符类型然后输出具体内容
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
*
* @方法的作用：每次读取一个字节数组，用的是FileInputStream类中的read（byte[] b）方法，带参
*
* @作者：褚永也
* @日期：2014-7-16 下午3:02:56
* @返回值类型：void
*/
public static void input2(File file){
try {
FileInputStream fis = new FileInputStream(file);
byte[] b=new byte[9];//给每次循环定义大小。每次读9个字节
int len=0;
while((len=fis.read(b))!=-1){ //fis.read(b)这里的返回值len表示本次循环的这个数组中的元素个数
//fis.read(b);这句话不用写，因为写在了len=fis.read(b)中了
String str=new String(b,0,len);
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
第六：图片处理：
1.
package com.image;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class ImageTest {
/**
*
* @方法的作用：用字节流将一张图片由d盘拷贝到e盘
* @作者：褚永也
* @日期：2014-7-16 下午8:17:38
* @返回值类型：void
*/
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
File file=new File("f:\\login_bg.jpg");
try {
fis = new FileInputStream(file);
fos = new FileOutputStream("D:\\"+file.getName());
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf))!=-1)
{
fos.write(buf, 0, len);
}
}
catch (Exception e) {
e.printStackTrace();
}
finally
{
try
{
if(fis!=null)
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
try
{
if(fos!=null)
fos.close();
}
catch (Exception e) {
e.printStackTrace();
}
}
}}
2.
package com.image;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class TxtTest1 {
/**
* @方法的作用：用字节流将一张图片由d盘拷贝到e盘... 用字节流将一个记事本由e盘拷贝到d盘
* @作者：褚永也
* @日期：2014-7-16 下午7:03:57
* @返回值类型：void
*/
public static void main(String[] args) {
//1.对文本中的内容的拷贝
/*File file1=new File("F:\\test1\\a.txt");
File file2=new File("F:\\test1\\b.txt");*/
//2.对图片的拷贝
/*File file1=new File("f:\\login_bg.jpg");//原图片
File file2=new File("D:\\2.jpg");//拷贝到这个目录下，名字改成2.jpg*/
//3.对记事本的拷贝
/*File file1=new File("f:\\a.jnt");//原图片
File file2=new File("D:\\b.jnt");//拷贝到这个目录下，名字改成2.jpg*/
//4.对歌曲的拷贝
File file1=new File("f:\\tank.mp3");
File file2=new File("D:\\b.mp3");
try {
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos =new FileOutputStream(file2);
byte[] b=new byte[1024];
int len=0;
while((len=fis.read(b))!=-1){
/*String str=new String(b,0,len);
byte[] bt=str.getBytes();
fos.write(bt, 0, bt.length);*/
//上面三句跟这一句一样
fos.write(b, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}