Java IO操作
Java当中的i/o
大文件的读写方法/字节流:
//第一步骤：导入类
import java.io.*;
class TestI{
public static void main (String args[]){
//声明输入流的引用
FileInputStream fis=null;
//声明输出流的引用
FileOutputStream fos=null;
try{
//生成代表输入流的对象
fis=new FileInputStream("e:/workspace/java4android/from.txt");
//生成代表输出流的对象
fos=new FileOutputStream("e:/workspace/java4android/to.txt");
//生成一个字节数组
byte [] buffer=new byte[1024];
//对于大文件需要使用循环，一次一次的读取
while(true){
int temp=fis.read(buffer,0,buffer.length);
if (temp==-1){
break;
}
fos.write(buffer,0,temp);
}
//调用输入流的read方法，读取数据，存放在buffer中
System.out.println(temp);
fos.write(buffer,0,temp);
for(int i=0;i<buffer.length;i++){
System.out.println(buffer[i]);
}
//生成一String对象
//String s=new String(buffer);
//调用String对象的trim方法，将会去除掉这个字符串的首尾空格和空字符
//s=s.trim();
//System.out.println(s);
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fis.close();
fis.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
字符流:
读写文件时,以字符为基础
字符输入流:Reader<--FileReader
Int read(char[] c,int off,int len);
字符输出流Writer《--FileWriter
Void write(char [] c,int off,int len);
import java.io.*;
public class TestChar {
public static void main(String args[]){
FileReader fr=null;
FileWriter fw=null;
try{
fr=new FileReader("e:/workspace/java4android/from.txt");
fw=new FileWriter("e:/workspace/java4android/to.txt");
char [] buffer=new char[100];
int temp=fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fr.close();
fw.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
IO节点流与处理流：
处理流是在节点流的基础上再处理，节点流也是字符流
import java.io.*;
class TestI{
public static void main(String args[]){
//生成一个fileReader对象的引用
FileReader fileReader=null;
//生成一个BufferReader的引用
BufferedReader bufferedReader=null;
try{
//生成fileReader对象
fileReader=new FileReader("e:/workspace/java4android/from.txt");
//生成bufferedReader对象，将fileReader对象传入
bufferedReader=new BufferedReader(fileReader);
String line=null;
while(true){
//调用readline()方法
line=bufferedReader.readLine();
if(line==null){
break;
}
System.out.println(line);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fileReader.close();
bufferedReader.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
装饰者模式：
装饰者是在被装饰者的基础上添加新的功能。
//定义一个接口
interface Worker{
public void doSomeWork();
}
//Awoker实现接口
class Aworker implements Worker{
//worker类型的成员变量
private Worker worker;
//构造方法，传入一个worker类型的变量
public Aworker(Worker worker){
this.worker=worker;
}
public void doSomeWork(){
System.out.println("hello");
worker.doSomeWork();
}
}
class Plumber implements Worker{
public void doSomeWork(){
System.out.println("modify water pull");
}
}
class Carpenter implements Worker{
public void doSomeWork(){
System.out.println("modify door");
}
}
class Test5{
public static void main(String args[]){
//生成plumber对象
Plumber plumber=new Plumber();
//生成aWorker 将plumber对象传入，因为plumber是worker的子类，这里向上转型后即为worker类型，直接传入
Aworker aWorker=new Aworker(plumber);
//调用aWorker.doSomeWork()方法
aWorker.doSomeWork();
Carpenter carpenter=new Carpenter();
Aworker aWorker2=new Aworker(carpenter);
aWorker2.doSomeWork();
}
}
内部类与匿名内部类
内部类可以随意的使用外部类定义的成员变量与成员函数
class A{
int i;
class B{
int j;
int funB(){
int result=i+j;
return result;
}
}
}
class Test{
public static void main(String args[]){
A a=new A();
A.B b=a.new B();
a.i=3;
b.j=0;
int result=b.funB();
System.out.println(result);
}
}
匿名内部类:
interface C{
public void doSome();
}
class D{
public void fun(C c){
System.out.println("D fun");
c.doSome();
}
}
class Testc{
public static void main(String args[]){
//CIm cim=new CIm();
//C c=cim;
D d=new D();
d.fun(new C(){
public void doSome(){
System.out.println("内部匿名类");
}
}
}
}