一、Java IO 编程

Java IO 编程 
1、基本概念 
   Java中对文件的操作是以流的方式进行的，流是Java内存中一组有序数据序列。Java将数据从源（文件、内存、键盘、网络）读入到内存中，形成了流，然后还可以将这些流写到另外的目的地（文件、内存、控制台、网络）之所以叫做流，是因为这个数据序列在不同时刻所操作的是源的不同部分。 
2、流的分类 
流的分类方式一般有以下三种： 
（1） 输入的方向分：输入流和输出流，输入和输出的参照对象是Java程序。 
（2） 处理数据的单位分：字节流和字符流，字节流读取的最小单位是一个字节。 
（3） 功能的不同分：节点流和处理流，一个是直接一个是包装的。 
3、流分类的关系 
流分类的根源来自四个基本的类，这四个类的关系如下： 
   字节流            字符流 
输入流 InputStream Reader 
输出流 OutputStream Writer 
4、其他知识补充 
（1）什么是IO 
   IO（Input/Output）是计算机输入/输出的接口，Java的核心库java.io提供了全面的IO接口，包括：文件读写、标准设备输出等等。Java中的IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。 
（2）流IO和块IO 
   此外，Java也对块传输提供支持，在核心库java.nio中采用的便是块IO，流IO和块IO对比而言，流IO的好处是简单易用，缺点是效率不如块IO；相反块IO是效率比较高但是编程比较复杂。Java的IO模型设计非常优秀，它使用了Decorator模式，按照功能进行划分stream，编程过程中可以动态地装配这些stream，以便获取所需要的功能。 
   备注：以上资料提取自百度文库，链接地址如下： 
   http://wenku.baidu.com/view/9aa0ec35eefdc8d376ee3280.html 
5、代码模拟实战 

import java.io.File;
import java.io.IOException;

public class FileDemoTest {
    /**
     * @description 基础File类操作
     * @param args
     * @throws IOException IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // Windows系统下的文件目录格式，这个和Unix系统等不同
        // String pathSeparator = File.pathSeparator; // ;
        // String separator = File.separator; // \

        // 1、创建和删除文件
        File file = new File("d:\\helloworld.txt");
        // File file = new File("d:"+File.separator+"helloworld.txt");
        file.createNewFile(); // 创建文件
        if (file.exists()) { // 如果文件存在，则删除文件
            file.delete();
        }

        // 2、创建文件夹操作
        File file2 = new File("d:\\helloworld");
        // File file2 = new File("d:"+File.separator+"helloworld");
        file2.mkdir(); // 建立文件夹
        if (file2.isDirectory()) {
            System.out.println("hello-directory"); // 判断是否是目录
        }

        // 3、遍历文件或者文件夹操作
        File file3 = new File("d:\\");
        // File file3 = new File("d:"+File.separator);
        File files[] = file3.listFiles(); // 列出全部内容
        for (int i = 0; i < files.length; i++) {
            System.out.println(files[i]);
        }
    }
}

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;

public class InputStreamDemo {
    /**
     * @description 字节流：输入流InputStream
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 字节流的输入流和输出流过程步骤比较固定
        // 第1步、使用File类找到一个文件
        File f = new File("d:" + File.separator + "helloworld.txt");
        // 第2步、通过子类实例化父类对象(InputStream为抽象类，本身不能直接实例化)
        InputStream input = new FileInputStream(f);
        // 第3步、进行读操作
        byte b[] = new byte[(int)f.length()]; // 数组大小由文件大小来确定
        for (int i = 0; i < b.length; i++) {
            b[i] = (byte) input.read(); // 读取内容
        }
        // 第4步、关闭输出流
        input.close();
    }
}

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.FileOutputStream;

public class OutputStreamDemo {
    /**
     *@description 字节流：输出流OutputStream类
     *@param args
     *@throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 输入和输出流参考的是Java程序，输出流操作步骤也比较固定
        // 第1步、使用File类找到一个文件
        File f = new File("d:" + File.separator + "helloworld.txt");
        // 第2步、通过子类实例化父类对象
        //OutputStream out = new FileOutputStream(f);
        OutputStream out = new FileOutputStream(f,true);
        // 第3步、进行写操作
        String str = "say hello world!!!";
        byte b[] = str.getBytes();
        for(int i=0;i<b.length;i++){
            out.write(b[i]); // 单个写入
        }
        // out.write(b);
        // 重载方法write
        // public abstract void write(int b) throws IOException;
        // public void write(byte b[]) throws IOException {}
        // 第4步、关闭输出流
        out.close(); // 关闭输出流
    }
}

import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.FileReader;

public class ReaderDemo {
    /**
     *@description 字节流和字符流按照处理数据的单位划分
     *@param args
     *@throws IOException IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // 第1步、使用File类找到一个文件
        File f = new File("d:" + File.separator + "helloworld.txt");
        // 第2步、通过子类实例化父类对象
        Reader input = new FileReader(f);
        // 第3步、进行读操作
        char c[] = new char[1024];
        int temp = 0;
        int len = 0;
        while ((temp = input.read()) != -1) {
            // 如果不是-1就表示还有内容，可以继续读取
            c[len] = (char) temp;
            len++;
        }
        // 第4步、关闭输出流
        input.close();
    }
}

import java.io.File;
import java.io.IOException;
import java.io.Writer;
import java.io.FileWriter;

public class WriterDemo {
    /**
     *@description 通过代码学习发现，基本上步骤一致的
     *@param args
     *@throws IOException
     */
    public static void main(String[] args) throws IOException {
        // 第1步、使用File类找到一个文件
        File f = new File("d:" + File.separator + "helloworld.txt");
        // 第2步、通过子类实例化父类对象
        Writer out = new FileWriter(f); // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "\nsay hello\tworld";
        out.write(str);
        // 第4步、关闭输出流
        // out.flush(); // 清空缓冲
        out.close(); // 关闭输出流

        // 另外有缓冲功能的类为：BufferedReader
    }
}

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

public class ByteAndCharStreamTest {
    /**
     *@description  字节流：InputStream,OutputStream
     *              字符流：Reader,Writer
     *              // 字节流和字符流相互转换测试
     *@param args
     * @throws IOException 文件操作异常处理
     */
    public static void main(String[] args) throws IOException {
        // 1、输入流-字节流转换成字符流
        // 通过InputStreamReader类来进行转换
        InputStream is = new FileInputStream("d:\\helloworld.txt");
        Reader reader = new InputStreamReader(is); // 将字节流转换成字符流
        char c[] = new char[1024];
        int len = reader.read(c); // 读取操作，保存在字符数组中
        reader.close(); // 关闭操作
        System.out.println(new String(c,0,len)); // 字符数组转换成String类实例

        // 2、输出流-字节流转换成字符流
        // 通过OutputStreamWriter类来进行转换
        File f = new File("d:" + File.separator + "helloworld.txt");
        Writer out = new OutputStreamWriter(new FileOutputStream(f)); // 字节流变为字符流
        out.write("hello world!!!"); // 使用字符流输出
        out.close();

        // 3、从字符流到字节流转换可以采用String类提供的操作
        // 从字符流中获取char[]，转换成String实例然后再调用String API的getBytes()方法
        // 接1中的代码如下，最后通过ByteArrayInputStream即可完成操作
        String str = new String(c,0,len);
        byte b[] = str.getBytes();
        InputStream is2 = new ByteArrayInputStream(b);
        is2.close();

        // 4、其他常见的流
        // 内存操作流ByteArrayInputStream,ByteArrayOutputStream
        // 管道流PipedOutputStream,PipedInputStream
        // 打印流PrintStream
        // 缓存流BufferedReader
        // ...等等
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class CharSetDemo {
    /**
     * @description 字符编码学习测试方法
     * @param args
     * @throws IOException 文件IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // 1、字符编码，通过system类来获取
        String fe = System.getProperty("file.encoding");
        System.out.println(fe); // GBK

        // 2、进行转码操作
        OutputStream out = new FileOutputStream("d:\\helloworld.txt");
        byte b[] = "Java，你好！！！".getBytes("ISO8859-1"); // 转码操作
        out.write(b); // 保存
        out.close(); // 关闭
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Demo implements Serializable{ // 实现序列化接口
    // 序列化方式之一，Java自身提供的序列化支持
    // 其他序列化方式，待以后有需要进一步学习
    private static final long serialVersionUID = 1L;
    private String info; // 定义私有属性

    // 如果某个属性不想被序列化，采用transient来标识
    //private transient String noser;

    public Demo(String info){
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
    public String toString() {
        return "info = " + this.info;
    }
}
public class SerializedDemo {
    /**
     *@description 对象序列化、反序列化操作
     *@param args
     *@throws Exception
     */
    public static void main(String[] args) throws Exception {
        // 1、对象序列化是将内存中的对象转换成二进制形式的数据流
        // 2、对象反序列化刚好和对象序列化方向相反，将二进制数据流转换成对象

        // a、对象序列化采用ObjectOutputStream类
        ObjectOutputStream oos = null; // 声明对象输出流
        OutputStream out = new FileOutputStream("d:\\helloworld.txt");
        oos = new ObjectOutputStream(out);
        oos.writeObject(new Demo("helloworld"));
        oos.close();

        // b、对象反序列化采用ObjectInputStream类
        ObjectInputStream ois = null; // 声明对象输入流
        InputStream input = new FileInputStream("d:\\helloworld.txt");
        ois = new ObjectInputStream(input); // 实例化对象输入流
        Object obj = ois.readObject(); // 读取对象
        ois.close();
        System.out.println(obj);
    }
}

二、Java类集合框架 
在百度搜到的一个比较详细的java类集合笔记，链接如下： 
http://wenku.baidu.com/view/52cf133f5727a5e9856a6186.html 
最后，记录一个思考题目：采用Java类集合如何实现一个stack，使得增加、删除、获取最大值、最小值以及中值的时间操作效率相当。 

/**
 * @author Administrator
 *
 * @description 如何从java类集框架中选取适当的数据结构呢???
 * @history
 */
public interface Stack<T> {
    public void add(T t); // 添加元素
    public void delete(T t); // 删除元素
    public T getMax(); // 获取最大值
    public T getMin(); // 获取最小值
    public T getMiddle(); // 获取第中间大值
}

<!--EndFragment-->