精华内容
下载资源
问答
  • * 计算机是如何识别什么时候该把两个字节转换为一个中文呢? * 在计算机中中文的存储分两个字节: * 第一个字节肯定是负数。 * 第二个字节常见的是负数,可能有正数。但是没影响。 */ public class StringDemo {...

     
    import java.util.Arrays;
     
    /*
     * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
     * 在计算机中中文的存储分两个字节:
     * 第一个字节肯定是负数。
     * 第二个字节常见的是负数,可能有正数。但是没影响。
     */
    public class StringDemo {
    public static void main(String[] args) {
    // String s = "abcde";
    // // [97, 98, 99, 100, 101]
     
    String s = "我爱你中国";
    // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
     
    byte[] bys = s.getBytes();
    System.out.println(Arrays.toString(bys));
    }
    }
    转换流出现的原因及思想
    
    由于字节流操作中文不是特别方便,所以,java就提供了转换流。
    字符流=字节流+编码表。
     
    import java.io.FileInputStream;
    import java.io.IOException;
     
    /*
     * 字节流读取中文可能出现的小问题:
     */
    public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
    // 创建字节输入流对象
    FileInputStream fis = new FileInputStream("a.txt");
     
    // 读取数据
    // int by = 0;
    // while ((by = fis.read()) != -1) {
    // System.out.print((char) by);
    // }
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
    System.out.print(new String(bys, 0, len));
    }
     
    // 释放资源
    fis.close();
    }
    }
    编码表概述和常见的编码表
    
    编码表
      由字符及其对应的数值组成的一张表
     
    计算机只能识别二进制数据,早期由来是电信号。
    为了方便应用计算机,让它可以识别各个国家的文字。
    就将各个国家的文字用数字来表示,并一一对应,形成一张表。
     
    ASCII:美国标准信息交换码。
    用一个字节的7位可以表示。
    ISO8859-1:拉丁码表。欧洲码表
    用一个字节的8位表示。
    GB2312:中国的中文编码表。
    GBK:中国的中文编码表升级,融合了更多的中文文字符号。
    GB18030:GBK的取代版本
    BIG-5码 :通行于台湾、香港地区的一个繁体字编码方案,俗称“大五码”。
    Unicode:国际标准码,融合了多种文字。
    所有文字都用两个字节来表示,Java语言使用的就是unicode
    UTF-8:最多用三个字节来表示一个字符。
     
    UTF-8不同,它定义了一种“区间规则”,这种规则可以和ASCII编码保持最大程度的兼容:
    它将Unicode编码为00000000-0000007F的字符,用单个字节来表示
    它将Unicode编码为00000080-000007FF的字符用两个字节表示 
    它将Unicode编码为00000800-0000FFFF的字符用3字节表示 
     
     
     
     
     
    字符串中的编码问题
    
    编码
      把看得懂的变成看不懂的
    解码
      把看不懂的变成看得懂的
     
    import java.io.UnsupportedEncodingException;
    import java.util.Arrays;
     
    /*
     * String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
     * byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
     *
     * 编码:把看得懂的变成看不懂的
     * String -- byte[]
     *
     * 解码:把看不懂的变成看得懂的
     * byte[] -- String
     *
     * 举例:谍战片(发电报,接电报)
     *
     * 码表:小本子
     * 字符数值
     *
     * 要发送一段文字:
     * 今天晚上在老地方见
     *
     * 发送端:今 -- 数值 -- 二进制 -- 发出去
     * 接收端:接收 -- 二进制 -- 十进制 -- 数值 -- 字符 -- 今
     *
     * 今天晚上在老地方见
     *
     * 编码问题简单,只要编码解码的格式是一致的。
     */
    public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
    String s = "你好";
     
    // String -- byte[]
    byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
    // byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]
    // byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
    System.out.println(Arrays.toString(bys));
     
    // byte[] -- String
    String ss = new String(bys); // 你好
    // String ss = new String(bys, "GBK"); // 你好
    // String ss = new String(bys, "UTF-8"); // ???
    System.out.println(ss);
    }
    }
     
     
    转换流概述
    
    OutputStreamWriter 字符输出流
      public OutputStreamWriter(OutputStream out)
      public OutputStreamWriter(OutputStream out,String charsetName)
    InputStreamReader 字符输入流
      public InputStreamReader(InputStream in)
      public InputStreamReader(InputStream in,String charsetName)
     
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
     
    /*
     * OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
     * OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
     * 把字节流转换为字符流。
     * 字符流 = 字节流 +编码表。
     */
    public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    // 创建对象
    // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    // "osw.txt")); // 默认GBK
    // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    // "osw.txt"), "GBK"); // 指定GBK
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    "osw.txt"), "UTF-8"); // 指定UTF-8
    // 写数据
    osw.write("中国");
     
    // 释放资源
    osw.close();
    }
    }
     
     
     
     
    /*
     * InputStreamReader(InputStream is):用默认的编码读取数据
     * InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
     */
    public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
    // 创建对象
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"));
     
    // InputStreamReader isr = new InputStreamReader(new FileInputStream(
    // "osw.txt"), "GBK");
     
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
    "osw.txt"), "UTF-8");
     
    // 读取数据
    // 一次读取一个字符
    int ch = 0;
    while ((ch = isr.read()) != -1) {
    System.out.print((char) ch);
    }
     
    // 释放资源
    isr.close();
    }
    }
     
     
    OutputStreamWriter写数据
    
    OutputStreamWriter写数据方法
    public void write(int c)
    public void write(char[] cbuf)
    public void write(char[] cbuf,int off,int len)
    public void write(String str)
    public void write(String str,int off,int len)
    字符流操作要注意的问题
    flush()的作用
    flush()和close()的区别
     
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
     
    /*
     * OutputStreamWriter的方法:
     * public void write(int c):写一个字符
     * public void write(char[] cbuf):写一个字符数组
     * public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
     * public void write(String str):写一个字符串
     * public void write(String str,int off,int len):写一个字符串的一部分
     *
     * 面试题:close()和flush()的区别?
     * A:close()关闭流对象,但是先刷新一次缓冲区。关闭之后,流对象不可以继续再使用了。
     * B:flush()仅仅刷新缓冲区,刷新之后,流对象还可以继续使用。
     */
    public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    // 创建对象
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    "osw2.txt"));
     
    // 写数据
    // public void write(int c):写一个字符
    // osw.write('a');
    // osw.write(97);
    // 为什么数据没有进去呢?
    // 原因是:字符 = 2字节
    // 文件中数据存储的基本单位是字节。
    // void flush()
     
    // public void write(char[] cbuf):写一个字符数组
    // char[] chs = {'a','b','c','d','e'};
    // osw.write(chs);
     
    // public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
    // osw.write(chs,1,3);
     
    // public void write(String str):写一个字符串
    // osw.write("我爱林青霞");
     
    // public void write(String str,int off,int len):写一个字符串的一部分
    osw.write("我爱林青霞", 2, 3);
     
    // 刷新缓冲区
    osw.flush();
    // osw.write("我爱林青霞", 2, 3);
     
    // 释放资源
    osw.close();
    // java.io.IOException: Stream closed
    // osw.write("我爱林青霞", 2, 3);
    }
    }
     
    读取文件
    
     
    /*
     * InputStreamReader的方法:
     * int read():一次读取一个字符
     * int read(char[] chs):一次读取一个字符数组
     */
    public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
    // 创建对象
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
    "StringDemo.java"));
     
    // 一次读取一个字符
    // int ch = 0;
    // while ((ch = isr.read()) != -1) {
    // System.out.print((char) ch);
    // }
     
    // 一次读取一个字符数组
    char[] chs = new char[1024];
    int len = 0;
    while ((len = isr.read(chs)) != -1) {
    System.out.print(new String(chs, 0, len));
    }
     
    // 释放资源
    isr.close();
    }
    }
     
    字符流复制文本文件
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
     
    /*
     * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
     *
     * 数据源:
     * a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
     * 目的地:
     * b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
     */
    public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    InputStreamReader isr = new InputStreamReader(new FileInputStream(
    "a.txt"));
    // 封装目的地
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
    "b.txt"));
     
    // 读写数据
    // 方式1
    // int ch = 0;
    // while ((ch = isr.read()) != -1) {
    // osw.write(ch);
    // }
     
    // 方式2
    char[] chs = new char[1024];
    int len = 0;
    while ((len = isr.read(chs)) != -1) {
    osw.write(chs, 0, len);
    // osw.flush();
    }
     
    // 释放资源
    osw.close();
    isr.close();
    }
    }
    方案二
    
    转换流的简化写法
    
    转换流的名字比较长,而我们常见的操作都是按照本地默认编码实现的,所以,为了简化我们的书写,转换流提供了对应的子类。
    FileWriter
    FileReader
     
     
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
     
    /*
     * 由于我们常见的操作都是使用本地默认编码,所以,不用指定编码。
     * 而转换流的名称有点长,所以,Java就提供了其子类供我们使用。
     * OutputStreamWriter = FileOutputStream + 编码表(GBK)
     * FileWriter = FileOutputStream + 编码表(GBK)
     *
     * InputStreamReader = FileInputStream + 编码表(GBK)
     * FileReader = FileInputStream + 编码表(GBK)
     *
     /*
     * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
     *
     * 数据源:
     * a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
     * 目的地:
     * b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
     */
    public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    FileReader fr = new FileReader("a.txt");
    // 封装目的地
    FileWriter fw = new FileWriter("b.txt");
     
    // 一次一个字符
    // int ch = 0;
    // while ((ch = fr.read()) != -1) {
    // fw.write(ch);
    // }
     
    // 一次一个字符数组
    char[] chs = new char[1024];
    int len = 0;
    while ((len = fr.read(chs)) != -1) {
    fw.write(chs, 0, len);
    fw.flush();
    }
     
    // 释放资源
    fw.close();
    fr.close();
    }
    }
    Demo3
    
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
     
    /*
     * 需求:把c:\\a.txt内容复制到d:\\b.txt中
     *
     * 数据源:
     * c:\\a.txt -- FileReader
     * 目的地:
     * d:\\b.txt -- FileWriter
     */
    public class CopyFileDemo3 {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    FileReader fr = new FileReader("c:\\a.txt");
    // 封装目的地
    FileWriter fw = new FileWriter("d:\\b.txt");
     
    // 读写数据
    // int ch = 0;
    int ch;
    while ((ch = fr.read()) != -1) {
    fw.write(ch);
    }
    //释放资源
    fw.close();
    fr.close();
    }
    }
     
     
     
    字符缓冲流
    
    BufferedWriter基本用法
    BufferedReader基本用法
    字符缓冲流复制文本文件
    特殊功能
       BufferedWriter
       void newLine()
       BufferedReader
       String readLine()
    字符缓冲流特殊功能复制文本文件
     
    /*
     * 字符流为了高效读写,也提供了对应的字符缓冲流。
     * BufferedWriter:字符缓冲输出流
     * BufferedReader:字符缓冲输入流
     *
     * BufferedWriter:字符缓冲输出流
     * 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
     * 可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。
     */
    public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
    // BufferedWriter(Writer out)
    // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
    // new FileOutputStream("bw.txt")));
     
    BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
     
    bw.write("hello");
    bw.write("world");
    bw.write("java");
    bw.flush();
     
    bw.close();
    }
    }
     
    BufferedReader
    
    /*
     * BufferedReader
     * 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
     * 可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。
     *
     * BufferedReader(Reader in)
     */
    public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
    // 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
     
    // 方式1
    // int ch = 0;
    // while ((ch = br.read()) != -1) {
    // System.out.print((char) ch);
    // }
     
    // 方式2
    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
    System.out.print(new String(chs, 0, len));
    }
     
    // 释放资源
    br.close();
    }
    }
     
    字符缓冲流特殊功能复制文本文件
    
    /*
     * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
     *
     * 数据源:
     * a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
     * 目的地:
     * b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
     */
    public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
     
    // 两种方式其中的一种一次读写一个字符数组
    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();
    }
    }
     
    字符缓冲流的特殊方法
    
    /*
     * 字符缓冲流的特殊方法:
     * BufferedWriter:
     * public void newLine():根据系统来决定换行符
     * BufferedReader:
     * public String readLine():一次读取一行数据
     * 包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null
     */
    public class BufferedDemo {
    public static void main(String[] args) throws IOException {
    // write();
    read();
    }
     
    private static void read() throws IOException {
    // 创建字符缓冲输入流对象
    BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
     
    // public String readLine():一次读取一行数据
    // String line = br.readLine();
    // System.out.println(line);
    // line = br.readLine();
    // System.out.println(line);
     
    // 最终版代码
    String line = null;
    while ((line = br.readLine()) != null) {
    System.out.println(line);
    }
    //释放资源
    br.close();
    }
     
    private static void write() throws IOException {
    // 创建字符缓冲输出流对象
    BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
    for (int x = 0; x < 10; x++) {
    bw.write("hello" + x);
    // bw.write("\r\n");
    bw.newLine();
    bw.flush();
    }
    bw.close();
    }
     
    }
     
     
    文件的复制
    
    /*
     * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
     *
     * 数据源:
     * a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
     * 目的地:
     * b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
     */
    public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
     
    // 读写数据
    String line = null;
    while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();
    bw.flush();
    }
     
    // 释放资源
    bw.close();
    br.close();
    }
    }
     
    IO流小结
    
    字节流
      字节输入流
      字节输出流
    字符流
      字符输入流
      字符输出流
     
     
     
     
    复制文本
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
     
    /*
     * 复制文本文件
     *
     * 分析:
     * 复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
     * 通过该原理,我们知道我们应该采用字符流更方便一些。
     * 而字符流有5种方式,所以做这个题目我们有5种方式。推荐掌握第5种。
     * 数据源:
     * c:\\a.txt -- FileReader -- BufferdReader
     * 目的地:
     * d:\\b.txt -- FileWriter -- BufferedWriter
     */
    public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
    String srcString = "c:\\a.txt";
    String destString = "d:\\b.txt";
    // method1(srcString, destString);
    // method2(srcString, destString);
    // method3(srcString, destString);
    // method4(srcString, destString);
    method5(srcString, destString);
    }
     
    // 字符缓冲流一次读写一个字符串
    private static void method5(String srcString, String destString)
    throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
     
    String line = null;
    while ((line = br.readLine()) != null) {
    bw.write(line);
    bw.newLine();
    bw.flush();
    }
     
    bw.close();
    br.close();
    }
     
    // 字符缓冲流一次读写一个字符数组
    private static void method4(String srcString, String destString)
    throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
     
    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
    bw.write(chs, 0, len);
    }
     
    bw.close();
    br.close();
    }
     
    // 字符缓冲流一次读写一个字符
    private static void method3(String srcString, String destString)
    throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
     
    int ch = 0;
    while ((ch = br.read()) != -1) {
    bw.write(ch);
    }
     
    bw.close();
    br.close();
    }
     
    // 基本字符流一次读写一个字符数组
    private static void method2(String srcString, String destString)
    throws IOException {
    FileReader fr = new FileReader(srcString);
    FileWriter fw = new FileWriter(destString);
     
    char[] chs = new char[1024];
    int len = 0;
    while ((len = fr.read(chs)) != -1) {
    fw.write(chs, 0, len);
    }
     
    fw.close();
    fr.close();
    }
     
    // 基本字符流一次读写一个字符
    private static void method1(String srcString, String destString)
    throws IOException {
    FileReader fr = new FileReader(srcString);
    FileWriter fw = new FileWriter(destString);
     
    int ch = 0;
    while ((ch = fr.read()) != -1) {
    fw.write(ch);
    }
     
    fw.close();
    fr.close();
    }
    }
     
    复制图片
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
     
    /*
     * 复制图片
     *
     * 分析:
     * 复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。
     * 通过该原理,我们知道我们应该采用字节流。
     * 而字节流有4种方式,所以做这个题目我们有4种方式。推荐掌握第4种。
     *
     * 数据源:
     * c:\\a.jpg -- FileInputStream -- BufferedInputStream
     * 目的地:
     * d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
     */
    public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
    // 使用字符串作为路径
    // String srcString = "c:\\a.jpg";
    // String destString = "d:\\b.jpg";
    // 使用File对象做为参数
    File srcFile = new File("c:\\a.jpg");
    File destFile = new File("d:\\b.jpg");
     
    // method1(srcFile, destFile);
    // method2(srcFile, destFile);
    // method3(srcFile, destFile);
    method4(srcFile, destFile);
    }
     
    // 字节缓冲流一次读写一个字节数组
    private static void method4(File srcFile, File destFile) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    srcFile));
    BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(destFile));
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
    bos.write(bys, 0, len);
    }
     
    bos.close();
    bis.close();
    }
     
    // 字节缓冲流一次读写一个字节
    private static void method3(File srcFile, File destFile) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    srcFile));
    BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(destFile));
     
    int by = 0;
    while ((by = bis.read()) != -1) {
    bos.write(by);
    }
     
    bos.close();
    bis.close();
    }
     
    // 基本字节流一次读写一个字节数组
    private static void method2(File srcFile, File destFile) throws IOException {
    FileInputStream fis = new FileInputStream(srcFile);
    FileOutputStream fos = new FileOutputStream(destFile);
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
    fos.write(bys, 0, len);
    }
     
    fos.close();
    fis.close();
    }
     
    // 基本字节流一次读写一个字节
    private static void method1(File srcFile, File destFile) throws IOException {
    FileInputStream fis = new FileInputStream(srcFile);
    FileOutputStream fos = new FileOutputStream(destFile);
     
    int by = 0;
    while ((by = fis.read()) != -1) {
    fos.write(by);
    }
     
    fos.close();
    fis.close();
    }
    }
     
     
    把ArrayList集合中的字符串数据存储到文本文件
    
    /*
     * 需求:把ArrayList集合中的字符串数据存储到文本文件
     *
     * 分析:
     * 通过题目的意思我们可以知道如下的一些内容,
     * ArrayList集合里存储的是字符串。
     * 遍历ArrayList集合,把数据获取到。
     * 然后存储到文本文件中。
     * 文本文件说明使用字符流。
     *
     * 数据源:
     * ArrayList<String> -- 遍历得到每一个字符串数据
     * 目的地:
     * a.txt -- FileWriter -- BufferedWriter
     */
    public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
    // 封装数据与(创建集合对象)
    ArrayList<String> array = new ArrayList<String>();
    array.add("hello");
    array.add("world");
    array.add("java");
     
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
     
    // 遍历集合
    for (String s : array) {
    // 写数据
    bw.write(s);
    bw.newLine();
    bw.flush();
    }
     
    // 释放资源
    bw.close();
    }
    }
    从文本文件中读取数据(每一行为一个字符串数据)到集合中,并遍历集合
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
     
    /*
     * 需求:从文本文件中读取数据(每一行为一个字符串数据)到集合中,并遍历集合
     *
     * 分析:
     * 通过题目的意思我们可以知道如下的一些内容,
     * 数据源是一个文本文件。
     * 目的地是一个集合。
     * 而且元素是字符串。
     *
     * 数据源:
     * b.txt -- FileReader -- BufferedReader
     * 目的地:
     * ArrayList<String>
     */
    public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
    // 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("b.txt"));
    // 封装目的地(创建集合对象)
    ArrayList<String> array = new ArrayList<String>();
     
    // 读取数据存储到集合中
    String line = null;
    while ((line = br.readLine()) != null) {
    array.add(line);
    }
     
    // 释放资源
    br.close();
     
    // 遍历集合
    for (String s : array) {
    System.out.println(s);
    }
    }
    }
     
    小游戏
    
    /*
     * 需求:我有一个文本文件中存储了几个名称,请大家写一个程序实现随机获取一个人的名字。
     *
     * 分析:
     * A:把文本文件中的数据存储到集合中
     * B:随机产生一个索引
     * C:根据该索引获取一个值
     */
    public class GetName {
    public static void main(String[] args) throws IOException {
    // 把文本文件中的数据存储到集合中
    BufferedReader br = new BufferedReader(new FileReader("b.txt"));
    ArrayList<String> array = new ArrayList<String>();
    String line = null;
    while ((line = br.readLine()) != null) {
    array.add(line);
    }
    br.close();
     
    // 随机产生一个索引
    Random r = new Random();
    int index = r.nextInt(array.size());
     
    // 根据该索引获取一个值
    String name = array.get(index);
    System.out.println("该幸运者是:" + name);
    }
    }
     
    复制单个文件夹
    
    /*
     * 需求:复制单个文件夹
     *
     * 数据源:e:\\demo
     * 目的地:e:\\test
     *
     * 分析:
     * A:封装目录
     * B:获取该目录下的所有文本的File数组
     * C:遍历该File数组,得到每一个File对象
     * D:把该File进行复制
     */
    public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
    // 封装目录
    File srcFolder = new File("e:\\demo");
    // 封装目的地
    File destFolder = new File("e:\\test");
    // 如果目的地文件夹不存在,就创建
    if (!destFolder.exists()) {
    destFolder.mkdir();
    }
     
    // 获取该目录下的所有文本的File数组
    File[] fileArray = srcFolder.listFiles();
     
    // 遍历该File数组,得到每一个File对象
    for (File file : fileArray) {
    // System.out.println(file);
    // 数据源:e:\\demo\\e.mp3
    // 目的地:e:\\test\\e.mp3
    String name = file.getName(); // e.mp3
    File newFile = new File(destFolder, name); // e:\\test\\e.mp3
     
    copyFile(file, newFile);
    }
    }
     
    private static void copyFile(File file, File newFile) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    file));
    BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(newFile));
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
    bos.write(bys, 0, len);
    }
     
    bos.close();
    bis.close();
    }
    }
     
    复制单极文件夹中指定文件并修改文件名称
    
     
    /*
     * 需求:复制指定目录下的指定文件,并修改后缀名。
     * 指定的文件是:.java文件。
     * 指定的后缀名是:.jad
     * 指定的目录是:jad
     *
     * 数据源:e:\\java\\A.java
     * 目的地:e:\\jad\\A.jad
     *
     * 分析:
     * A:封装目录
     * B:获取该目录下的java文件的File数组
     * C:遍历该File数组,得到每一个File对象
     * D:把该File进行复制
     * E:在目的地目录下改名
     */
    public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
    // 封装目录
    File srcFolder = new File("e:\\java");
    // 封装目的地
    File destFolder = new File("e:\\jad");
    // 如果目的地目录不存在,就创建
    if (!destFolder.exists()) {
    destFolder.mkdir();
    }
     
    // 获取该目录下的java文件的File数组
    File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
    @Override
    public boolean accept(File dir, String name) {
    return new File(dir, name).isFile() && name.endsWith(".java");
    }
    });
     
    // 遍历该File数组,得到每一个File对象
    for (File file : fileArray) {
    // System.out.println(file);
    // 数据源:e:\java\DataTypeDemo.java
    // 目的地:e:\\jad\DataTypeDemo.java
    String name = file.getName();
    File newFile = new File(destFolder, name);
    copyFile(file, newFile);
    }
     
    // 在目的地目录下改名
    File[] destFileArray = destFolder.listFiles();
    for (File destFile : destFileArray) {
    // System.out.println(destFile);
    // e:\jad\DataTypeDemo.java
    // e:\\jad\\DataTypeDemo.jad
    String name =destFile.getName(); //DataTypeDemo.java
    String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
    File newFile = new File(destFolder,newName);
    destFile.renameTo(newFile);
    }
    }
     
    private static void copyFile(File file, File newFile) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    file));
    BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(newFile));
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
    bos.write(bys, 0, len);
    }
     
    bos.close();
    bis.close();
    }
    }
     
    复制多个文件夹
    
     
    /*
     * 需求:复制指定目录下的指定文件,并修改后缀名。
     * 指定的文件是:.java文件。
     * 指定的后缀名是:.jad
     * 指定的目录是:jad
     *
     * 数据源:e:\\java\\A.java
     * 目的地:e:\\jad\\A.jad
     *
     * 分析:
     * A:封装目录
     * B:获取该目录下的java文件的File数组
     * C:遍历该File数组,得到每一个File对象
     * D:把该File进行复制
     * E:在目的地目录下改名
     */
    public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
    // 封装目录
    File srcFolder = new File("e:\\java");
    // 封装目的地
    File destFolder = new File("e:\\jad");
    // 如果目的地目录不存在,就创建
    if (!destFolder.exists()) {
    destFolder.mkdir();
    }
     
    // 获取该目录下的java文件的File数组
    File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
    @Override
    public boolean accept(File dir, String name) {
    return new File(dir, name).isFile() && name.endsWith(".java");
    }
    });
     
    // 遍历该File数组,得到每一个File对象
    for (File file : fileArray) {
    // System.out.println(file);
    // 数据源:e:\java\DataTypeDemo.java
    // 目的地:e:\\jad\DataTypeDemo.java
    String name = file.getName();
    File newFile = new File(destFolder, name);
    copyFile(file, newFile);
    }
     
    // 在目的地目录下改名
    File[] destFileArray = destFolder.listFiles();
    for (File destFile : destFileArray) {
    // System.out.println(destFile);
    // e:\jad\DataTypeDemo.java
    // e:\\jad\\DataTypeDemo.jad
    String name =destFile.getName(); //DataTypeDemo.java
    String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
    File newFile = new File(destFolder,newName);
    destFile.renameTo(newFile);
    }
    }
     
    private static void copyFile(File file, File newFile) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    file));
    BufferedOutputStream bos = new BufferedOutputStream(
    new FileOutputStream(newFile));
     
    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
    bos.write(bys, 0, len);
    }
     
    bos.close();
    bis.close();
    }
    }
    键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
    
    public class Student {
    // 姓名
    private String name;
    // 语文成绩
    private int chinese;
    // 数学成绩
    private int math;
    // 英语成绩
    private int english;
     
    public Student() {
    super();
    }
     
    public Student(String name, int chinese, int math, int english) {
    super();
    this.name = name;
    this.chinese = chinese;
    this.math = math;
    this.english = english;
    }
     
    public String getName() {
    return name;
    }
     
    public void setName(String name) {
    this.name = name;
    }
     
    public int getChinese() {
    return chinese;
    }
     
    public void setChinese(int chinese) {
    this.chinese = chinese;
    }
     
    public int getMath() {
    return math;
    }
     
    public void setMath(int math) {
    this.math = math;
    }
     
    public int getEnglish() {
    return english;
    }
     
    public void setEnglish(int english) {
    this.english = english;
    }
     
    public int getSum() {
    return this.chinese + this.math + this.english;
    }
    }
     
    /*
     * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
     *
     * 分析:
     * A:创建学生类
     * B:创建集合对象
     * TreeSet<Student>
     * C:键盘录入学生信息存储到集合
     * D:遍历集合,把数据写到文本文件
     */
    public class StudentDemo {
    public static void main(String[] args) throws IOException {
    // 创建集合对象
    TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
    int num = s2.getSum() - s1.getSum();
    int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
    int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
    int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
    int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
    : num4;
    return num5;
    }
    });
     
    // 键盘录入学生信息存储到集合
    for (int x = 1; x <= 5; x++) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请录入第" + x + "个的学习信息");
    System.out.println("姓名:");
    String name = sc.nextLine();
    System.out.println("语文成绩:");
    int chinese = sc.nextInt();
    System.out.println("数学成绩:");
    int math = sc.nextInt();
    System.out.println("英语成绩:");
    int english = sc.nextInt();
     
    // 创建学生对象
    Student s = new Student();
    s.setName(name);
    s.setChinese(chinese);
    s.setMath(math);
    s.setEnglish(english);
     
    // 把学生信息添加到集合
    ts.add(s);
    }
     
    // 遍历集合,把数据写到文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
    bw.write("学生信息如下:");
    bw.newLine();
    bw.flush();
    bw.write("姓名,语文成绩,数学成绩,英语成绩");
    bw.newLine();
    bw.flush();
    for (Student s : ts) {
    StringBuilder sb = new StringBuilder();
    sb.append(s.getName()).append(",").append(s.getChinese())
    .append(",").append(s.getMath()).append(",")
    .append(s.getEnglish());
    bw.write(sb.toString());
    bw.newLine();
    bw.flush();
    }
    // 释放资源
    bw.close();
    System.out.println("学习信息存储完毕");
    }
    }
     
    已知s.txt文件中有这样的一个字符串:“hcexfgijkamdnoqrzstuvwybpl”
    
     请编写程序读取数据内容,把数据排序后写入ss.txt中。
    
    /*
     * 已知s.txt文件中有这样的一个字符串:“hcexfgijkamdnoqrzstuvwybpl”
     * 请编写程序读取数据内容,把数据排序后写入ss.txt中。
     *
     * 分析:
     * A:把s.txt这个文件给做出来
     * B:读取该文件的内容,存储到一个字符串中
     * C:把字符串转换为字符数组
     * D:对字符数组进行排序
     * E:把排序后的字符数组转换为字符串
     * F:把字符串再次写入ss.txt中
     */
    public class StringDemo {
    public static void main(String[] args) throws IOException {
    // 读取该文件的内容,存储到一个字符串中
    BufferedReader br = new BufferedReader(new FileReader("s.txt"));
    String line = br.readLine();
    br.close();
     
    // 把字符串转换为字符数组
    char[] chs = line.toCharArray();
     
    // 对字符数组进行排序
    Arrays.sort(chs);
     
    // 把排序后的字符数组转换为字符串
    String s = new String(chs);
     
    // 把字符串再次写入ss.txt中
    BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
    bw.write(s);
    bw.newLine();
    bw.flush();
     
    bw.close();
    }
    }
     
     
    1:字符流(掌握)
    (1)字节流操作中文数据不是特别的方便,所以就出现了转换流。
       转换流的作用就是把字节流转换字符流来使用。
    (2)转换流其实是一个字符流
    字符流 = 字节流 + 编码表
    (3)编码表
    A:就是由字符和对应的数值组成的一张表
    B:常见的编码表
    ASCII
    ISO-8859-1
    GB2312
    GBK
    GB18030
    UTF-8
    C:字符串中的编码问题
    编码
    String -- byte[]
    解码
    byte[] -- String
    (4)IO流中的编码问题
    A:OutputStreamWriter
    OutputStreamWriter(OutputStream os):默认编码,GBK
    OutputStreamWriter(OutputStream os,String charsetName):指定编码。
    B:InputStreamReader
    InputStreamReader(InputStream is):默认编码,GBK
    InputStreamReader(InputStream is,String charsetName):指定编码
    C:编码问题其实很简单
    编码只要一致即可
    (5)字符流
    Reader
    |--InputStreamReader
    |--FileReader
    |--BufferedReader
    Writer
    |--OutputStreamWriter
    |--FileWriter
    |--BufferedWriter
    (6)复制文本文件(5种方式)
     
    2:IO流小结(掌握)
    IO流
    |--字节流
    |--字节输入流
    InputStream
    int read():一次读取一个字节
    int read(byte[] bys):一次读取一个字节数组
    |--FileInputStream
    |--BufferedInputStream
    |--字节输出流
    OutputStream
    void write(int by):一次写一个字节
    void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
    |--FileOutputStream
    |--BufferedOutputStream
    |--字符流
    |--字符输入流
    Reader
    int read():一次读取一个字符
    int read(char[] chs):一次读取一个字符数组
    |--InputStreamReader
    |--FileReader
    |--BufferedReader
    String readLine():一次读取一个字符串
    |--字符输出流
    Writer
    void write(int ch):一次写一个字符
    void write(char[] chs,int index,int len):一次写一个字符数组的一部分
    |--OutputStreamWriter
    |--FileWriter
    |--BufferedWriter
    void newLine():写一个换行符
    void write(String line):一次写一个字符串
     
    3:案例(理解 练习一遍)
    A:复制文本文件 5种方式(掌握)
    B:复制图片(二进制流数据) 4种方式(掌握)
    C:把集合中的数据存储到文本文件
    D:把文本文件中的数据读取到集合并遍历集合
    E:复制单级文件夹
    F:复制单级文件夹中指定的文件并修改名称
    回顾一下批量修改名称
    H:键盘录入学生信息按照总分从高到低存储到文本文件
    I:把某个文件中的字符串排序后输出到另一个文本文件中
     
     
     
     
     
     
     
     
     
     
     


    展开全文
  • 字节流 字节输入流 读取数据 InputStream 字节输出流 出数据 OutputStream 字符流 字符输入流 读取数据 Reader 字符输出流 出数据 Writer 利用字符流复制文本文件 利用字符流将当前工程下的IODemo....

    概述

    IO流分类:

    流向
      输入流	读取数据	FileReader	Reader
       输出流	写出数据	FileWriter	    Writer
     数据类型
         字节流	
         	字节输入流   读取数据	InputStream
    	    字节输出流   写出数据	OutputStream
    	字符流
    	     字符输入流  读取数据	    Reader
              字符输出流  写出数据	Writer
    

    利用字符流复制文本文件

    利用字符流将当前工程下的IODemo.java拷贝到d盘的a文件夹下

    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 使用字符流复制文本文件
     * 
     * 数据源		IODemo.java
     * 目的地		d:\\IODemo.java
    
     * 	
     */
    public class FileCopyDemo {
    	public static void main(String[] args) throws IOException  {
    		//创建字符输入流对象
    		FileReader fr = new FileReader("IODemo.java");
    		//创建字符输出流对象
    		FileWriter fw = new FileWriter("d:\\IODemo.java");
    		
    		//一次读写一个字符
    		
    		/*int ch;
    		while((ch = fr.read()) != -1) {
    			fw.write(ch);
    			fw.flush();
    		}*/
    		
    		//一次读写一个字符数组
    		int len;//用于存储读到的字符个数
    		char[] chs = new char[1024];
    		while((len = fr.read(chs)) != -1) {
    			fw.write(chs,0,len);
    			fw.flush();
    		}
    		
    		//释放资源
    		fw.close();
    		fr.close();
    	}
    }
    

    利用字节流复制文本文件

    利用字节流将当前工程下的IODemo.java拷贝到d盘下

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 使用字节流复制文本文件
     * 
     * 数据源		IODemo.java
     * 目的地		d:\\a\\IODemo.java
     * 
    
     */
    public class FileCopyDemo {
    	public static void main(String[] args) throws IOException  {
    		//创建字节输入流对象
    		FileInputStream fis = new FileInputStream("IODemo.java");
    		//创建字节输出流对象
    		FileOutputStream fos = new FileOutputStream("d:\\a\\IODemo.java");
    		
    		//一次读写一个字节
    		/*int by;
    		while((by = fis.read()) != -1) {
    			fos.write(by);
    		}*/
    		//一次读写一个字节数组
    		int len;//存储读到的字节个数
    		byte[] bys = new byte[1024];
    		while((len = fis.read(bys)) != -1) {
    			fos.write(bys,0,len);
    		}
    		
    		
    		//释放资源
    		fos.close();
    		fis.close();
    	}
    }
    

    复制图片

    字节流可以操作所有类型的文件,因为所有的文件在计算机中都是以字节形式存储
    而字符流只能用来操作纯文本类型的文件,不能操作字节类型的文件

    能使用字符流一定可以使用字节流,但是使用字节流不一定能使用字符流

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 分别使用字符流和字节流复制图片
     * 
     * 二进制文件只能使用字节流进行复制(使用windows自带记事本打开读不懂的)
     * 文本文件的复制即可使用字符流,也可以使用字节流
     * 
     * 先随便复制一张图片至项目下
     */
    public class CopyImage {
    	public static void main(String[] args) throws IOException  {
    		//method();
    		
    		//创建字节输入流对象
    		FileInputStream fis = new FileInputStream("a.jpg");
    		//创建字节输出流对象
    		FileOutputStream fos = new FileOutputStream("d:\\a.jpg");
    		
    		//一次读写一个字节数组
    		int len;//用于存储读到的字节个数
    		byte[] bys = new byte[1024];
    		while((len = fis.read(bys)) != -1) {
    			fos.write(bys,0,len);
    		}
    		
    		//释放资源
    		fos.close();
    		fis.close();
    	}
    
    	private static void method() throws FileNotFoundException, IOException {
    		//创建字符输入流对象
    		FileReader fr = new FileReader("a.jpg");
    		//创建字符输出流对象
    		FileWriter fw = new FileWriter("d:\\a.jpg");
    		
    		//一次读写一个字符数组
    		int len;//用于存储读到的字符个数
    		char[] chs = new char[1024];
    		while((len = fr.read(chs)) != -1) {
    			fw.write(chs,0,len);
    			fw.flush();
    		}
    		
    		//释放资源
    		fw.close();
    		fr.close();
    	}
    }
    
    展开全文
  • 字节流和字符流Java流字符流操作使用字符流读取文件使用字符流写文本文件三级目录 Java流 我们知道了如何利用file类对文件或者目录属性进行操作,但File类不能访问文件的内容,即不能从文件中读取数据或向文件里写...

    Java流

    我们知道了如何利用file类对文件或者目录属性进行操作,但File类不能访问文件的内容,即不能从文件中读取数据或向文件里写数据。
    读文件,是指把文件的数据读取到内存中,反之写文件就是把内存中的数据写到文件中。
    流呢,是指一连串流动的字符,是以先进先出的方式发送和接收数据的通道。
    在java.io包中,封装了许多输入\输出流API。在程序中,这些输入输出流的类的对象成为流对象。可以通过这些流对象将内存中的数以流的方式写入文件,也可以通过流对象将文件中的数据以流的方式读取到内存。
    流对象构造的时候往往会和数据源联系起来。数据源分为源数据流和目标数据流源。
    1.输入流联系的是源流数据源
    2.输出流联系的则是目标数据源。
    按照不同的分类方式,可以将流分成不同的类型。
    1.按照流的流向进行划分可以分成输入流和输出流。
    输出流:OUTPutStream和Writter作为基类。只能向其中写入数据,不能读。
    输入流:InputStream和Reader作为基类。只能读取数据,不能写。
    2.按照所操作的数据单元的不同,流又可以分成字节流和字符流。
    字节流操作的最小的数据单位为8位字节,而字符流操作的最下数据单元是16位字符。
    字节流和字符流的区分也很简单,字节流建议使用于二进制数据操作,而字符流用于文本。他们的用法几乎一样。

    字符流操作

    使用字符流读取文件

    1.字符流输入流Reader类
    Reader类是读取字符流的抽象类,他提供了常用的方法。
    int read() 输入流中读取单个字符
    int read(byte[] c)从输入流中读取c.length长度的字符,保存到字符数组C中,返回实际读取的字符数。
    read(char[] c,int off,int len)从输入流中读取最多len的长度字符,保存到字符数组c中,保存的位置从off位置开始,返回实际读取的字符长度。
    close() 关闭流
    2.字符输入流FileReader类
    FileReader类是Reader的子类,常用的构造方法格式如下。
    FileReader(String fileName)其中,fileName是指要从中读取数据文件的名称。使用的方法如下:

    Reader fr=new FileReader(“C:\\myTest.txt”);
    

    3.使用FileReader读取文件
    使用字符流类FileReader读取文本文件的操作如下。
    1.引入类

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

    2.创建FileReader对象

    Reader re = new FileReader("C:\\mytest.txt");
    

    3.利用FileReader类方法读取文本文件
    int read();//读取单个字符
    4.关闭相关的流对象
    fr.close();

    l练习:

    Reader fe=null;
    		StringBuffer sbf=null;
    		try {
    			fe=new FileReader("hello.txt");
    			char ch[]=new char[1024];//创建字符数组作为中转站
    			sbf=new StringBuffer();
    					int lenth=fe.read(ch);//将字符读入数组
    					while((lenth!=-1)){
    						sbf.append(ch);//追加字符
    						lenth=fe.read();
    					}		
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			if(fe!=null){
    				try {
    					fe.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    

    创建字符的中转站,存入每次读取的数据内容,然后调用FileReader对象的Read()方法将字符读入数组ch,并追加到字符串sbf中。

    或者我们可以这样写:

    char[] cbuf = new char[5];
    		int len = 0;
    		try {
    			fileReader = new FileReader(file);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		try {
    			while ((len = (fileReader.read(cbuf))) != -1) {
    				String str = new String(cbuf, 0, len);
    				System.out.println(str);
    			}
    

    上面我们演示了FileReader类读取文件。而开发中,我们会将FileReader类和BufferReader类结合使用。提高文件的效率。

    4.字符输入流BufferedReader类
    BufferedReader类是Reader的子类,它与FileReader类的区别在于BufferReader类带有缓冲区,它可以先把一批数据读到缓冲区,接下来的读操作都是从缓冲区内获取数据,避免每次都从数据源读取数据进行字符编码转换,从而提高读取操作的效率。BufferedReader类常用的构造方法如下。
    BufferedReader(Reader in);
    使用此方法创建字符输入对象如下。

    Reader fr=new FileReader(“C:\\mytest.txt”);
    BufferedReader br=new BufferedReader(fr);
    

    其中br就是创建的一个使用默认大小输入缓冲区的缓冲字符输入流。
    5.使用FileReader和BufferedReader读取文本文件。
    具体操作如下;
    1.引入相关类
    2.创建一个BufferedReader对象
    3.利用BufferedReader类的方法读取文本文件的数据。
    4.关闭相关的流对象。
    测试代码:

    public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Reader fe=null;
    		BufferedReader br=null;
    		try {
    			fe=new FileReader("hello.txt");
    			br=new BufferedReader(fe);
    					String lenth=br.readLine();//读取行内容
    					while(lenth!=null){
    						System.out.println(lenth);
    						lenth=br.readLine();
    					}
    		} catch (Exception e) {
    			System.out.println("文件不存在");
    		}finally{
    				try {
    					if(br!=null){
    						br.close();
    					}
    					if(fe!=null){
    					fe.close();
    					}
    				} catch (IOException e) {
    					e.printStackTrace();
    				}	
    		}
    	}
    
    

    使用字符流写文本文件

    1.字符流输出Writer
    writer类是向文件写入数据流的字符流,它提供了常用的方法。
    writer(string str)将str字符串里包含的字符输出到指定的输出流中
    writer(String str,int off,int len)将str字符串里从off位置开始长度为len的字符输出到输出流中。
    close()关闭输出流
    flush()刷新输出流
    2.字符输出流FileWriter类
    FileWriter类是Reader的子类,常用的构造方法如下:
    FileWriter(String fileName)
    其中,filename表示与系统有关的文件名,使用此构造方法创建字符流输出流对象如下。
    Writer fr=new FileWriter(“C:\myTest.txt”);
    3.使用FileWriter写文本文件
    使用FileWriter将数据写入文本文件的步骤如下。
    1.引入相关类
    2.创建一个FileWriter对象
    3.利用FileWriter类的方法写文本文件。
    4.相关流对象的清空和关闭。
    4.字符输出流BufferedWriter类
    同理BufferedWriter也是Writer的子类。其他的情况和上面的BufferedReader类相同。
    5.BufferedWriter和FileWriter写文本文件
    步骤其实是和上面相同。直接练习显示

    try{fw=new FileWriter("hello.txt");
    			bw=new BufferedWriter(fw);
    					bw.write("大家好");
    					bw.write("dsafdfa");
    					bw.newLine();//插入换行
    					bw.write("dthadsn");
    					bw.write(123);
    					bw.flush();//刷新流
    					bw.close();//关闭流
    	}				
    

    字节流操作

    使用字节流读取文本文件

    1.字节输入流InputStream类
    字节输入流InputStream的作用就是将文件中的数据输入到内部存储器(内存)中,它提供了一系列和读取数据有关的方法,常用的方法如下。
    int read() 读取一个字符
    int read(byte[] b)将数据读到字节中
    int read(byte[] b,int off,int len)从输入流中读取最多len长度的字节,保存到字节数组b中,保存的位置从off开始。
    void close() 关闭输入流
    int availabe() 返回输入流读取的估计字节数
    无参的read()方法从输入流读取一个八位的字节,把它转换为0~255的整数返回。
    有参的两个read()方法从输入流批量读取若干字节。从文件或键盘读数据时,采用read(byte[] b)或者int read(byte[] b,int off,int len)方法可以减少进行物理读文件或键盘的次数,提高输入输出操作效率。
    2.字节输入流FileInputStream类
    在实际应用中,我们通常使用InputStream的子类FileStream类来实现本文文件内容的读取,常用的构造方法如下。
    1)FileinputStream(File file)。其中,file指定文件数据源。使用此构造方法创建文件输入流对象如下。

    File file=new File(“C:\\myTest.txt”);
    InputStream fileObject=new FileInputStream(file);
    

    此时的文件输入流对象fileObject就和数据源(“C:\myTest.txt”);联系起来了。
    2)FileInputStream(String name)。其中,name指定文件数据源包含路径信息。使用此构造方法创建文件输入流对象如下。

    InputStream in =new FileInputStream(“C:\\myTest.txt”);
    

    3.使用FileInputStream读取文件
    使用FileInputStream读取文件具体操作如下。
    1)引入相关类

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

    2)创建一个文件输入流对象

    InputStream fileObject=new FileInputStream(“C:\\myTest.txt”);
    

    3)利用文件输入的方法读取文本文件的数据。

    fileObject.avaliable()//可读取的字节数
    fileObject.read()//读取文件的数据
    

    4)关闭文件输入流对象。

    fileObject.close();
    

    下面我们示例学习一下。首先,我们创建一个文件,hello.txt,然后文件保存的内容为abc,然后输出到控制台上。
    示例:

    FileInputStream fis=null;
    		try{
    			fis=new FileInputStream("hello.txt");
    			int data;
    			System.out.println("可读取的字节数"+fis.available());
    			System.out.println("文件内容为:");
    			while((data=fis.read())!=-1){
    				System.out.println(data+" ");
    			}
    		}catch (Exception e) {
    			// TODO: handle exception
    			e.printStackTrace();
    		}finally{
    			if(fis!=null){
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    

    发现输出的东西和文件中的东西不一致,那是因为InputStream和read方法是从输入流读取一个八位字节,把它转换为0~255的整数返回。abc各占一个字节所以输出的整数就是97 98 99.

    注意:使用FileInputStream类读文件数据的时候还要注意下面方面。
    1)read()方法返回整数,若读取的是字符串,则需要强制类型转换。例如如果想正常输出abc则要修改语句System.out.print((char)data+" ");
    2)流对象使用完毕之后要关闭。

    使用字节流写文本文件

    1.字节输出流OutputStream类
    字节输出流OutputStream类的作用是把内存中的数据输出到文件中,它提供了一系列文件中写数据的有关方法。常见的方法如下。
    void write(int c)写入一个字节数据
    void write(byte[] buf)写入数组buf的所有字节
    void write(byte[] b,int off,int len)将字节数组从off位置开始,长度为len的字节数据输出到输出流中。
    void close() 关闭输出流
    2.字节输出流FileOutputStream类
    我们通常使用OutputStream的子类FileOutputStream类来实现向文本文件写入数据,常用的构造方法有以下三个。
    1)FileOutputStream(File file)。其中,file指定文件目标数据源。使用此构造方法创建文件输出流对象如下。

    File file=new File(“C:\\myTest.txt”);
    FileOutputStream fos=new FileOutputStream(file);
    

    此时的文件输出流fos就和目标数据源(“C:\myTest.txt”)联系起来。
    2)FileOutputStream(String name)。其中,name指定目标文件数据源,包含路径信息。

    FileOutputStream fos=new FileOutputStream(“C:\\myTest.txt”);
    

    3)FileOutputStream(String name,boolean append)。其中,name指定目标文件数据源,包含路径信息。append表示是否在文件末尾添加数据,若设置为true,则在文件末尾添加数据。使用此构造方法创建文件输出流对象如下。

    FileOutputStream fos=new FileOutputStream(“C:\\myTest.txt”,true;
    

    要注意的是第一种方法和第二种构造方法在向文件写数据时将覆盖文件中原有内容。另外,在使用FileOutputStream的构造方法创建FileOutputStream实例时,如果相应的文件并不存在,就会自动创建一个空的文件。若参数file或name表示的文件路劲尽管存在,但是代表一个文件目录,则此时会抛出FileNotFoundException异常。

    3.使用FileOutputStream写文本文件
    使用FileOutputStream向文本文件中写入数据的具体使用步骤。
    1)引入相关的类。

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

    2)构造一个文件输出流对象

    OutputStream fos=new FileOutputStream(“C:\\myTest.txt”);
    

    3)利用文件输出流的方法把数据写入文本文件中

    String str=“好好学习”;
    byte[] words =str.getBytes[];
    fos.write(words,0,words.length);
    

    4)关闭文件输出流

    fos.close();
    

    下面示例是具体的应用。

    	FileOutputStream fos=null;
    		try {
    			String str="学习xuexi";
    			byte[] words=str.getBytes();//字节数组
    			fos=new FileOutputStream("hello.txt");//写文件
    			fos.write(words,0,words.length);
    			System.out.println("hello 文件已经更新了");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			if(fos!=null){
    				try {
    					fos.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    

    首先将要写入文件的字符串通过getBytes()方法转换成字节数组words,然后调用输出流对象的write()方法,将字节数组words中的内容添加到文件(“hello.txt”)的末尾。

    注意:

    // 字节流处理 ( .jpg .mp3 .mp4 .avi .doc .ppt)
    // 字符流 处理 (.txt .java)字符流

    同理,字符流中也有缓冲输入输出 BufferedInputStream 和 BufferedOutputStream
    使用方式和字节流也一样。
    示例复制音乐:

    public  void  BufferedTest() {
    		File file1 = new File("admin.mp3");
    		File file2=new File("tom.mp3");
    		FileInputStream fileInputStream=null;
    		FileOutputStream fileOutputStream=null;
    		try {
    			fileInputStream = new FileInputStream(file1);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		try {
    			fileOutputStream = new  FileOutputStream(file2);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    		BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
    		BufferedOutputStream bufferedOutputStream = new  BufferedOutputStream(fileOutputStream);
    		byte  [] buffer=new byte[1024];
    		int len=0;
    		try {
    			while((len=bufferedInputStream.read(buffer))!=-1) {	
    				bufferedOutputStream.write(buffer, 0, len);
    				
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		if(fileInputStream!=null) {
    			try {
    				fileInputStream.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		if(fileOutputStream!=null) {
    			try {
    				fileOutputStream.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    展开全文
  • 文本文件中,写入文本数据分为三步:搭桥、运输、拆桥 ...对于输出而言,利用写操作,让数据在传输通道中,流动起来 Ⅰ public void write(int b) Ⅱ public void write(byte[] b) Ⅲ public v

    在文本文件中,写入文本数据分为三步:搭桥、运输、拆桥

    ①搭桥
    搭建好数据传输通道——流对象
    创建FileOutputStream对象
    构造方法:
    Ⅰ FileOutputStream(File file) //用File对象创建
    Ⅱ FileOutputStream(String name) //用路径名创建

    ②运输
    对于输出流而言,利用写操作,让数据在传输通道中,流动起来
    Ⅰ public void write(int b)
    Ⅱ public void write(byte[] b)
    Ⅲ public void write(byte[] b,int off,int len)

    ③拆桥
    关闭流
    public void close()

    例:通过OutputStream对象,完成向文本文件中输出” hello world”

    public static void outPutStream() throws IOException {
            File file = new File("d:\test\a.txt");
            if(!file.exists()){
                file.createNewFile();
            }
            //搭桥
            OutputStream os = new FileOutputStream(file);
            
            //运输
            String s = "hello world";
            byte[] bytes = s.getBytes();
            os.write(bytes);
    
            //拆桥
            os.close();
        }
    

    字节输出流常见问题:
    ①创建字节输出流jvm到底做了哪些事情?

    1. FileOutputStream对象在被创建之前,jvm会首先到操作系统中,找目标文件
      如果找到,首先,清空已经存在的目标文件内容(因为默认向文件中写入数据中的方式,从文件头开始写入)
      如果找不到,jvm会创建一个新的目标文件
    2. 在jvm内存中,创建FileOutputStream对象
    3. 在FileOutputStream对象和目标文件之间,建立数据传输通道

    ②数据写成功后,为什么要close()?

    1. 关闭此输出流,即断开数据传输通道
    2. 释放与此流有关的所有系统资源。

    ③如何向文件中写入换行字符

    1. windows操作系统: ‘\r’’\n’
    2. 类unix操作系统:’\n’

    ④如何实现数据的追加写入?

    1. FileOutputStream(File file, boolean append)
    2. FileOutputStream(String name, true)

    字节输入流
    与字节输出流类似,从文件中读取数据也需要搭桥、运输、拆桥。有两种常用的方式:
    ①按单个字节

    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class HomeWork01 {
        public static void main(String[] args) throws IOException {
            FileInputStream in = new FileInputStream("d:\\test\\a.txt");
    
            //按单个字节读取
            //read()方法返回的是0 到 255 范围内(8位无符号整数)的 int 字节值。
            //没有则返回-1
            int read;
            while ((read = in.read()) != -1){
                char c = (char)read;
                System.out.print(c);
            }
    
            in.close();
        }
    }
    

    ②按多个字节读取

    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class HomeWork01 {
        public static void main(String[] args) throws IOException {
            FileInputStream in = new FileInputStream("d:\\test\\a.txt");
    
            //一次读取多个字节
            //利用int read(byte[] b)方法读取字节,并将其存储在缓冲区数组 b 中,返回实际读取到的字节数,用len接受
            //把b数组的从0-len个元素转化为字符串并输出
            byte[] b = new byte[1024];
            int len = in.read(b);
            System.out.println(new String(b, 0, len));
    
            in.close();
        }
    }
    

    字节流复制数据练习

    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    
    public class HomeWork01 {
        public static void main(String[] args) throws IOException {
            FileInputStream in = new FileInputStream("d:\\test\\a.txt");
            FileOutputStream out = new FileOutputStream("d:\\test\\b.txt");
            byte[] b = new byte[1024];
    
            int len;
            while ((len = in.read(b)) != -1){
                out.write(b, 0, len);
            }
    
            in.close();
            out.close();
        }
    }
    

    字节缓冲流
    为什么要设置字节缓冲流?
    答:字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多,这是加入了数组这样的缓冲区效果。java本身在设计的时候,也考虑到了这样的情况,所以提供了字节缓冲区流。

    字节缓冲输出流
    BufferedOutputStream
    构造方法:
    BufferedOutputStream(OutputStream out)
    //创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
    //参数OutputStream out其实是一个继承了OutputStream抽象类的子类

    字节缓冲输入流
    BufferedInputStream
    构造方法
    BufferedInputStream(InputStream in)
    //创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
    //参数InputtputStream in其实是一个继承了OutputStream抽象类的子类

    注意

    1. 在创建一个流对象的时候,需要基于其他的流对象来创建的,这种流对象叫做包装流。
    2. 对于包装流而言,如果我们要关闭包装流,只需要调用流的close方法即可,不用try–catch。因为,包装流自己会保证,正常关闭,包装流锁关闭的底层流。
    3. void flush()刷新此缓冲的输出流。 flush可以可以帮助我们,强制把缓冲流中的字节数字,写入底层流中,从而写入目标文件中

    用字节缓冲流复制数据

    
    import java.io.*;
    
    
    public class HomeWork01 {
        public static void main(String[] args) throws IOException {
            InputStream in = new FileInputStream("d:\\test\\a.txt");
            OutputStream out = new FileOutputStream("d:\\test\\b.txt");
            InputStream bfin = new BufferedInputStream(in);
            OutputStream bfout = new BufferedOutputStream(out);
            byte[] b = new byte[1024];
    
            int len;
            while ((len = bfin.read(b)) != -1){
                bfout.write(b, 0, len);
            }
    
            bfin.close();
            bfout.close();
        }
    }
    
    展开全文
  • java IO

    2021-01-16 12:03:32
    使用字节流复制文本文件4. 分别使用字符流和字节流复制图片 1. IO流分类 流向 输入流 读取数据 FileReader Reader 输出流 出数据 FileWriter Writer 数据类型 字节流 字节输入流 读取数据 InputStream ...
  • 4.字节流每次读取或者写入一个字节,而字符流每次读取或者写入一个字符(两个字节),通常字节流用来对图片、音频、视频等文件进行操作,而字符流用来对文本文件进行操作 5.节点流是处理流的基础,因为处理流的构造...
  • 我们利用JAVA的IO类进行读写数据的时候所提供的大部份的方法都是采用读写字节的方式,而且通过这种读写字节的方法是可以保存任可类型的数据的,因为任数据类型在计算机中都是字节码,前提是你要先将你写入的数据先...
  • 除了字节流,JDK还提供了用于实现字符操作的字符流,和字节流一样,字符流也有两个抽象顶级父流,分别是Reader和Writer。 思考:什么情况下使用字符流? 字符流也可以拷贝文本文件,但不推荐使用。因为读取时会把...
  • IO(字符)

    2017-05-06 08:36:18
     * 字符流是可以直接读写字符的IO流(字符流操作纯文本的,字节流可操作任意类型的数据)  * 字符流读取字符, 就要先读取到字节数据(因计算机存储的都是字节数据), 然后转为字符(利用编码表). 如果要出字符, ...
  • 字节流处理文件2. 字符流处理文件二、字节数组流IO 工具类装饰器设计模式字节缓冲流字符缓冲流字符转换流数据流对象流打印流文件序列流文件分割文件合并CommonIO 类 Java IO 利用 Java IO 你可以访问文件与目录,...
  • 读取记事本中的纯文本可以采用字符流,其他时候一律使用字节流。IO流主要有四个抽象类,InputStream和OutputStream,Reader和Writer。 Java.io是专门为用户提供I/O操作的软件包。 字符流的缓冲装饰类:利用字符输入...
  • 同缓冲字节流一致,利用缓存机制,大大提高了读写文本文件的效率。 BufferedReader新增了逐行读取方法 readLine(); BufferedWriter新增了换行方法 newLine(); import java.io.*; public class BufferedReaderTest {...
  • java 面向字符.字节

    2014-07-09 22:38:00
    字符是针对字符数据的特点进行过优化的,因而提供一些面向字符的有用特性,字符的源或目标通常是文本文件。 Reader和Writer是java.io包中所有字符的父类。由于它们都是抽象类,所以应使用它们的子类来创建实体...
  • 首先确定IO流的类型:因为文件可能不是文本文件,故选择字节流,然后选择读取和写入的方式,因为文件可能较大,故采用边读边较好。 编写一个Cop类,利用主函数的两个参数分别获取待操作的文件路径,从而根据路径...
  • 二进制方式文件主要利用流对象调用成员函数write() 函数原型:ostream& write(const char * buffer, int len); 参数解释:字符指针buffer指向内存中一段存储空间,len是读写的字节数 来看一个代码例子 #...
  • 关于输入输出首先想到的是byte和char,这是输入输出里基本的两个,若是纯文本的读写就用char,比如word读写或者聊天工具的开发;若是非纯文本比如图片音频视频的数据的传输就用byte。System.in只能按...
  • 使用字节流写二进制文件重定向标准I/O 读写二进制文件 读写二进制文件常用的类有DataInputStream和DataOutputStream。 1.使用字节流读二进制文件 利用DataInputStream类读进制文件, 其实与利用FileInputStream 类...
  • 最近闲来无聊,想一个简单的文件操作的类。... .NET中操作文件的类如下: FileStream:提供一个访问文件对文件进行读写、打开、关闭等操作 StreamReader:用于读取文本信息。他会检查字节
  • 第十三周学习总结

    2019-05-30 22:30:23
    这周我们学习了文件复制,利用字节流完成文件读写操作,以文件字符流来实现文件读写操作,还有随机存取文件的读写操作,还有许多基本概念:数据从程序到文件,叫做输出,引入流的概念,那就叫输出流,这个流是以字节...
  • 编程题 1. 文件IO练习 ...利用字节流+桥转换+缓冲流读入这个文本文件,然后按照行的顺序,以 UTF-8 的编码方 式,到 test2.txt 文件中,例: 低头思故乡 举头望明月 疑是地上霜 窗前明月光 n...
  • 尚学堂Java300集:IO

    2021-02-27 13:54:11
    文章目录前言1 基本概念和IO入门1.1 数据源1.2 流的概念1.3 流的分类1.4 Java中IO流类的体系1.5 四大IO抽象类2 常用的流2.1 文件字节流2.1.1 作用2.1.2 将文件内容读取到程序中2.1.3 将字符串/字节数组的内容写入到...
  • /* 事先在当前目录下准备好一个test.txt ...利用字节流+桥转换读入这个文本文件,然后按照行的顺序,以UTF-8 的编码方式, 到test2.txt 文件中,例: test2.txt 低头思故乡 举头望明月 疑是地上霜 窗前明月光
  • 文件操作

    2019-09-24 17:18:13
    二进制文件 需要特定的软件 字节流 c++通过fstream头文件进行文件的调用 文本文件一般使用 get put 进行读写 二进制文件利用 write和read 打开关闭openclose is_open 读写文件get/putread/writegetline输入输.....
  • 实例30 利用字节流读取文件中的内容 实例31 利用字节流把内容写入文件 实例32 用字符输入流读取文件 实例33 用字符输出流写文件 实例34 随机读取文件程序示例 实例35 故事接龙 实例36 文件上传 实例37 在...
  • 13.第十三章 文件.txt

    2019-11-08 16:33:27
    C语言中对文件的存取是以字符(字节)为单位的,输入输出数据的开始和结束仅受程序控制不受物理符号控制(如回车换行符)。输出时不会自动增加回车换行符作为记录结束的标志,输入时不以回车换行符作为记录的间隔...
  • “wt” 只打开或建立一个文本文件,只允许数据 “at” 追加打开一个文本文件,并在文件末尾数据 “rb” 只读打开一个二进制文件,只允许读数据 “wb” 只打开或建立一个二进制文件,只允许数据 “ab”...
  • 实例329 获取文本框内文本行数 实例330 文本框实现撤销功能 11.2 列表框、组合框控件应用 实例331 向列表框控件添加数据 实例332 利用ListBox控件实现标签式的数据选择 实例333 删除列表框中的复选数据 实例...
  • c# 加密和解密相关代码

    热门讨论 2011-09-06 11:04:59
    在字符串中查找指定字符时,可以先将字符串显示在richTextBox 控件中,然后利用richTextBox 类的Find 方法在该控件中查找指定字符。在字符串中查找指定字符的代码如下: 第19章 加密与解密技术 833 M_int_index = ...
  • C#全能速查宝典

    热门讨论 2014-04-26 16:16:27
    《C#全能速查宝典》共分为8章,分别介绍了C#语言基础、Windows窗体及常用控件、Windows高级控件、控件公共属性、方法及事件、数据库开发、文件、数据与注册表、GDI+绘图技术和C#高级编程,共包含562个C#编程中常用...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java访问权限控制,为Java操作文件、写入文件分配合适的权限,定义到文件的信息、定义文件,输出到c:/hello.txt、信息到文件、关闭输出。 Java绘制图片火焰效果 1个目标文件 摘要:Java源码,图形操作,火焰...

空空如也

空空如也

1 2 3 4 5
收藏数 90
精华内容 36
关键字:

利用字节流写文本