Java 文件IO续

文件IO续

File类
    用来将文件和文件夹封装成对象 方便对文件和文件夹的属性信息进行操作
    File对象可以作为参数传递给流的构造函数

Demo1 File的构造方法

public class FileDemo {
  public static void main(String[] args) {

    constructorDemo();

  }

  public static void constructorDemo() {

    // 可以将一个已存在的，或者不存在的文件或者目录封装成file对象。
    File f1 = new File("c:\\a.txt");

    File f2 = new File("c:\\", "a.txt");

    File f = new File("c:\\");

    File f3 = new File(f, "a.txt");

    File f4 = new File("c:" + File.separator + "abc" + File.separator + "a.txt");
    System.out.println(f4);

  }
}

File类
    用于将文件和文件夹封装成对象。
    1，创建。
        boolean createNewFile():如果该文件不存在，会创建，如果已存在，则不创建。不会像输出流一样会覆盖。        
        boolean mkdir();
        boolean mkdirs();
    2，删除。
        boolean delete();
        void deleteOnExit();
        
    3，获取：
        String getAbsolutePath();
        String getPath();
        String getParent();
        String getName();
        long length();
        long lastModified();
        
    
    4，判断：
        boolean exists();
        boolean isFile();
        boolean isDirectory();

Demo2 File的常用方法

public class FileMethodDemo {
  public static void main(String[] args) throws IOException {

     getDemo();
     createAndDeleteDemo();
     isDemo();
     renameToDemo();

     listRootsDemo();
  }

  public static void listRootsDemo() {

    File file = new File("d:\\");

    System.out.println("getFreeSpace:" + file.getFreeSpace());
    System.out.println("getTotalSpace:" + file.getTotalSpace());
    System.out.println("getUsableSpace:" + file.getUsableSpace());

    // File[] files = File.listRoots();
    // for(File file : files){
    // System.out.println(file);
    // }
  }

  public static void renameToDemo() {

    File f1 = new File("c:\\9.mp3");

    File f2 = new File("d:\\aa.mp3");

    boolean b = f1.renameTo(f2);

    System.out.println("b=" + b);
  }

  public static void isDemo() throws IOException {
    File f = new File("aaa");

    // f.mkdir();
    f.createNewFile();

    // boolean b = f.exists();
    // System.out.println("b="+b);
    // 最好先判断是否存在。
    System.out.println(f.isFile());
    System.out.println(f.isDirectory());

  }

  public static void createAndDeleteDemo() throws IOException {

    File dir = new File("abc\\q\\e\\c\\z\\r\\w\\y\\f\\e\\g\\s");

    // boolean b = dir.mkdir();//make directory
    // System.out.println("b="+b);
    // dir.mkdirs();//创建多级目录
    System.out.println(dir.delete());

    // System.out.println(dir.delete());

    // 文件的创建和删除。
    // File file = new File("file.txt");

    /*
     * 和输出流不一样，如果文件不存在，则创建，如果文件存在，则不创建。
     */
    // boolean b = file.createNewFile();
    // System.out.println("b="+b);

    // boolean b = file.delete();
    // System.out.println("b="+b);

  }

  public static void getDemo() {
    // File file = new File("E:\\java0331\\day22e\\a.txt");
    File file = new File("a.txt");

    String name = file.getName();

    String absPath = file.getAbsolutePath();// 绝对路径。

    String path = file.getPath();

    long len = file.length();

    long time = file.lastModified();

    Date date = new Date(time);

    DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);

    String str_time = dateFormat.format(date);

    System.out.println("parent:" + file.getParent());

    System.out.println("name:" + name);
    System.out.println("absPath:" + absPath);
    System.out.println("path:" + path);
    System.out.println("len:" + len);
    System.out.println("time:" + time);
    System.out.println("str_time:" + str_time);

  }
}

Demo3 文件浏览器

public class FileTest {
  public static void main(String[] args) {

    File dir = new File("E:\\ADT");

    listAll(dir, 0);
  }

  public static void listAll(File dir, int level) {

    System.out.println(getSpace(level) + dir.getName());
    // 获取指定目录下当前的所有文件夹或者文件对象

    level++;
    File[] files = dir.listFiles();

    for (int x = 0; x < files.length; x++) {

      if (files[x].isDirectory()) {
        listAll(files[x], level);
      } else
        System.out.println(getSpace(level) + files[x].getName());
    }
  }

  private static String getSpace(int level) {

    StringBuilder sb = new StringBuilder();

    sb.append("|--");
    for (int x = 0; x < level; x++) {
      sb.insert(0, "|  ");
    }

    return sb.toString();
  }
}
}

Demo4 删除一个带文件的目录

public class RemoveDirTest {
  public static void main(String[] args) {

    File dir = new File("D:\\Java");
    // dir.delete();
    removeDir(dir);
  }

  public static void removeDir(File dir) {

    File[] files = dir.listFiles();

    for (File file : files) {

      if (file.isDirectory()) {
        removeDir(file);
      } else {
        System.out.println(file + ":" + file.delete());
      }
    }
    System.out.println(dir + ":" + dir.delete());
  }
}

Properties集合：
    Map |--Hashtable |--Properties:
    1，该集合中的键和值都是字符串类型。 2，集合中的数据可以保存到流中，或者从流获取。
    3 通常该集合用于操作以键值对形式存在的配置文件。

Demo5 Properties的使用

public class PropertiesDemo {
  public static void main(String[] args) throws IOException {

    // methodDemo_4();
    // myLoad();

    test();
  }

  // 对已有的配置文件中的信息进行修改。
  /*
   * 读取这个文件。 并将这个文件中的键值数据存储到集合中。 在通过集合对数据进行修改。 在通过流将修改后的数据存储到文件中。
   */
  public static void test() throws IOException {
    // 读取这个文件。
    File file = new File("E:\\info.txt");
    if (!file.exists()) {
      file.createNewFile();
    }
    FileReader fr = new FileReader(file);

    // 创建集合存储配置信息。
    Properties prop = new Properties();

    // 将流中信息存储到集合中。
    prop.load(fr);

    prop.setProperty("wangwu", "16");

    FileWriter fw = new FileWriter(file);

    prop.store(fw, "");

    // prop.list(System.out);

    fw.close();
    fr.close();

  }

  // 模拟一下load方法。
  public static void myLoad() throws IOException {

    Properties prop = new Properties();

    BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));

    String line = null;

    while ((line = bufr.readLine()) != null) {

      if (line.startsWith("#"))
        continue;

      String[] arr = line.split("=");

      // System.out.println(arr[0]+"::"+arr[1]);
      prop.setProperty(arr[0], arr[1]);
    }

    prop.list(System.out);

    bufr.close();

  }

  public static void methodDemo_4() throws IOException {

    Properties prop = new Properties();

    // 集合中的数据来自于一个文件。
    // 注意；必须要保证该文件中的数据是键值对。
    // 需要使用到读取流。
    FileInputStream fis = new FileInputStream("info.txt");

    // 使用load方法。
    prop.load(fis);

    prop.list(System.out);

  }

  public static void methodDemo_3() throws IOException {
    Properties prop = new Properties();

    // 存储元素。
    prop.setProperty("zhangsan", "30");
    prop.setProperty("lisi", "31");
    prop.setProperty("wangwu", "36");
    prop.setProperty("zhaoliu", "20");

    // 想要将这些集合中的字符串键值信息持久化存储到文件中。
    // 需要关联输出流。
    FileOutputStream fos = new FileOutputStream("info.txt");

    // 将集合中数据存储到文件中，使用store方法。
    prop.store(fos, "info");

    fos.close();

  }

  /**
   * 演示Properties集合和流对象相结合的功能。
   */

  public static void methodDemo_2() {
    Properties prop = new Properties();

    // 存储元素。
    // prop.setProperty("zhangsan","30");
    // prop.setProperty("lisi","31");
    // prop.setProperty("wangwu","36");
    // prop.setProperty("zhaoliu","20");

    prop = System.getProperties();
    prop.list(System.out);
  }

  /*
   * Properties集合的存和取。
   */

  public static void propertiesDemo() {
    // 创建一个Properties集合。

    Properties prop = new Properties();

    // 存储元素。
    prop.setProperty("zhangsan", "30");
    prop.setProperty("lisi", "31");
    prop.setProperty("wangwu", "36");
    prop.setProperty("zhaoliu", "20");

    // 修改元素。
    prop.setProperty("wangwu", "26");

    // 取出所有元素。
    Set<String> names = prop.stringPropertyNames();

    for (String name : names) {
      String value = prop.getProperty(name);
      System.out.println(name + ":" + value);
    }
  }
}

Demo6 获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示。并不要在运行程序

public class PropertiesTest {
  public static void main(String[] args) throws IOException {

    getAppCount();

  }

  public static void getAppCount() throws IOException {

    // 将配置文件封装成File对象。
    File confile = new File("E:\\count.properties");

    if (!confile.exists()) {
      confile.createNewFile();
    }

    FileInputStream fis = new FileInputStream(confile);

    Properties prop = new Properties();

    prop.load(fis);

    // 从集合中通过键获取次数。
    String value = prop.getProperty("time");
    // 定义计数器。记录获取到的次数。
    int count = 0;
    if (value != null) {
      count = Integer.parseInt(value);
      if (count >= 5) {
        // System.out.println("使用次数已到，请注册，给钱！");
        // return;
        throw new RuntimeException("使用次数已到，请注册，给钱！");
      }
    }
    count++;

    // 将改变后的次数重新存储到集合中。
    prop.setProperty("time", count + "");

    FileOutputStream fos = new FileOutputStream(confile);

    prop.store(fos, "");

    fos.close();
    fis.close();

  }
}

IO包中的其他类
    打印流 PrintWriter PrintStream
        1,提供了打印方法可以对多种数据类型值进行打印。并保持数据的表示形式。
        2 它不抛IOException.
        构造函数，接收三种类型的值  1，字符串路径  2，File对象。3，字节输出流

Demo7 PrintStream

public class PrintStreamDemo {
  public static void main(String[] args) throws IOException {

    PrintStream out = new PrintStream("E:\\info.txt");

//    int by = read();
//    write(by);

//    out.write(610);//只写最低8位，

//    out.print(97);//将97先变成字符保持原样将数据打印到目的地。 

    out.close();

  }
}

Demo8 PrintWriter

public class PrintWriterDemo {
  public static void main(String[] args) throws IOException {
    /*
     * PrintWriter：字符打印流。 构造函数参数： 1，字符串路径。 2，File对象。 3，字节输出流。 4，字符输出流。
     */
    BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

    PrintWriter out = new PrintWriter(new FileWriter("out.txt"), true);

    String line = null;
    while ((line = bufr.readLine()) != null) {
      if ("over".equals(line))
        break;
      out.println(line.toUpperCase());
      // out.flush();
    }

    out.close();
    bufr.close();
  }
}

序列流 SequenceInputStream

Demo8 将1.txt 2.txt 3.txt文件中的数据合并到一个文件中。

public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
    ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    for(int x=1; x<=3; x++){
      al.add(new FileInputStream("E:\\" + x+".txt"));
    }

    Enumeration<FileInputStream> en = Collections.enumeration(al);

    SequenceInputStream sis = new SequenceInputStream(en);

    FileOutputStream fos = new FileOutputStream("E:\\1234.txt");

    byte[] buf = new byte[1024];

    int len = 0;

    while((len=sis.read(buf))!=-1){
      fos.write(buf,0,len);
    }

    fos.close();
    sis.close();

  }
}

Demo9 文件切割

public class SplitFileDemo {
  private static final int SIZE = 1024 * 1024;

  public static void main(String[] args) throws Exception {

    File file = new File("E:\\cloud.apk");

    //splitFile(file);
    splitFile_2(file);
  }

  private static void splitFile_2(File file) throws IOException {

    // 用读取流关联源文件。
    FileInputStream fis = new FileInputStream(file);

    // 定义一个1M的缓冲区。
    byte[] buf = new byte[SIZE];

    // 创建目的。
    FileOutputStream fos = null;

    int len = 0;
    int count = 1;

    /*
     * 切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数。 以方便于合并。
     * 这个信息为了进行描述，使用键值对的方式。用到了properties对象
     */
    Properties prop = new Properties();

    File dir = new File("E:\\partfiles");
    if (!dir.exists())
      dir.mkdirs();

    while ((len = fis.read(buf)) != -1) {

      fos = new FileOutputStream(new File(dir, (count++) + ".part"));
      fos.write(buf, 0, len);
      fos.close();
    }

    // 将被切割文件的信息保存到prop集合中。
    prop.setProperty("partcount", count + "");
    prop.setProperty("filename", file.getName());

    fos = new FileOutputStream(new File(dir, count + ".properties"));

    // 将prop集合中的数据存储到文件中。
    prop.store(fos, "save file info");

    fos.close();
    fis.close();

  }

  public static void splitFile(File file) throws IOException {

    // 用读取流关联源文件。
    FileInputStream fis = new FileInputStream(file);

    // 定义一个1M的缓冲区。
    byte[] buf = new byte[SIZE];

    // 创建目的。
    FileOutputStream fos = null;

    int len = 0;
    int count = 1;

    File dir = new File("E:\\partfiles");
    if (!dir.exists())
      dir.mkdirs();

    while ((len = fis.read(buf)) != -1) {

      fos = new FileOutputStream(new File(dir, (count++) + ".part"));
      fos.write(buf, 0, len);
    }

    fos.close();
    fis.close();

  }
}

Demo10 合并文件

public class MergeFile {
  public static void main(String[] args) throws IOException {

    File dir = new File("E:\\partfiles");

    mergeFile_2(dir);
  }

  public static void mergeFile_2(File dir) throws IOException {

    /*
     * 获取指定目录下的配置文件对象。
     */
    File[] files = dir.listFiles(new SuffixFilter(".properties"));

    if (files.length != 1)
      throw new RuntimeException(dir + ",该目录下没有properties扩展名的文件或者不唯一");
    // 记录配置文件对象。
    File confile = files[0];

    // 获取该文件中的信息================================================。

    Properties prop = new Properties();
    FileInputStream fis = new FileInputStream(confile);

    prop.load(fis);

    String filename = prop.getProperty("filename");
    int count = Integer.parseInt(prop.getProperty("partcount"));

    // 获取该目录下的所有碎片文件。 ==============================================
    File[] partFiles = dir.listFiles(new SuffixFilter(".part"));

    if (partFiles.length != (count - 1)) {
      throw new RuntimeException(" 碎片文件不符合要求，个数不对!应该" + count + "个");
    }

    // 将碎片文件和流对象关联 并存储到集合中。
    ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    for (int x = 0; x < partFiles.length; x++) {

      al.add(new FileInputStream(partFiles[x]));
    }

    // 将多个流合并成一个序列流。
    Enumeration<FileInputStream> en = Collections.enumeration(al);
    SequenceInputStream sis = new SequenceInputStream(en);

    FileOutputStream fos = new FileOutputStream(new File(dir, filename));

    byte[] buf = new byte[1024];

    int len = 0;
    while ((len = sis.read(buf)) != -1) {
      fos.write(buf, 0, len);
    }

    fos.close();
    sis.close();

  }

  public static void mergeFile(File dir) throws IOException {

    ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

    for (int x = 1; x <= 3; x++) {
      al.add(new FileInputStream(new File(dir, x + ".part")));
    }

    Enumeration<FileInputStream> en = Collections.enumeration(al);
    SequenceInputStream sis = new SequenceInputStream(en);

    FileOutputStream fos = new FileOutputStream(new File(dir, "1.bmp"));

    byte[] buf = new byte[1024];

    int len = 0;
    while ((len = sis.read(buf)) != -1) {
      fos.write(buf, 0, len);
    }

    fos.close();
    sis.close();

  }

}

class SuffixFilter implements FilenameFilter {

  private String suffix;

  public SuffixFilter(String suffix) {
    super();
    this.suffix = suffix;
  }

  @Override
  public boolean accept(File dir, String name) {

    return name.endsWith(suffix);
  }

}

ObjectInputStream 和 ObjectOutputStream

　　对象的序列化和反序列化。
　　writeObject  readObject
　　Serializable标记接口
　　关键字：transient //非静态数据不想被序列化可以使用这个关键字修饰。

Demo11

public class ObjectStreamDemo {
  public static void main(String[] args) throws IOException, ClassNotFoundException {

    writeObj();
    readObj();
  }

  public static void readObj() throws IOException, ClassNotFoundException {

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\obj.object"));
    // 对象的反序列化。
    Person p = (Person) ois.readObject();

    System.out.println(p.getName() + ":" + p.getAge());

    ois.close();

  }

  public static void writeObj() throws IOException, IOException {

    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\obj.object"));
    // 对象序列化。 被序列化的对象必须实现Serializable接口。
    oos.writeObject(new Person("小强", 30));

    oos.close();

  }
}

public class Person implements Serializable/*标记接口*/ {

  /**
   * transient:非静态数据不想被序列化可以使用这个关键字修饰。
   */
  private static final long serialVersionUID = 9527l;
  private transient String name;
  private static int age;

  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }

}

RandomAccessFile
    一看这个类名字，纠结。不是io体系中的子类。
    1，该对象即能读，又能写。
    2，该对象内部维护了一个byte数组，并通过指针可以操作数组中的元素，
    3，可以通过getFilePointer方法获取指针的位置，和通过seek方法设置指针的位置
    4，其实该对象就是将字节输入流和输出流进行了封装。
    5，该对象的源或者目的只能是文件。通过构造函数就可以看出。

Demo12

public class RandomAccessFileDemo {
  public static void main(String[] args) throws IOException {

    // writeFile();
    // readFile();
    randomWrite();
  }

  public static void randomWrite() throws IOException {
    RandomAccessFile raf = new RandomAccessFile("E:\\ranacc.txt", "rw");

    // 往指定位置写入数据。
    raf.seek(3 * 8);

    raf.write("哈哈".getBytes());
    raf.writeInt(108);

    raf.close();
  }

  public static void readFile() throws IOException {

    RandomAccessFile raf = new RandomAccessFile("ranacc.txt", "r");

    // 通过seek设置指针的位置。
    raf.seek(1 * 8);// 随机的读取。只要指定指针的位置即可。

    byte[] buf = new byte[4];
    raf.read(buf);

    String name = new String(buf);

    int age = raf.readInt();

    System.out.println("name=" + name);
    System.out.println("age=" + age);

    System.out.println("pos:" + raf.getFilePointer());

    raf.close();

  }

  // 使用RandomAccessFile对象写入一些人员信息，比如姓名和年龄。
  public static void writeFile() throws IOException {
    /*
     * 如果文件不存在，则创建，如果文件存在，不创建
     */
    RandomAccessFile raf = new RandomAccessFile("ranacc.txt", "rw");

    raf.write("张三".getBytes());
    raf.writeInt(97);
    raf.write("小强".getBytes());
    raf.writeInt(99);
    //
    raf.close();
  }

}

管道流：需要和多线程技术相结合的流对象。
　　PipedOutputStream　　
　　PipedInputStream

Demo13

public class PipedStream {
  public static void main(String[] args) throws IOException {

    PipedInputStream input = new PipedInputStream();
    PipedOutputStream output = new PipedOutputStream();

    input.connect(output);

    new Thread(new Input(input)).start();
    new Thread(new Output(output)).start();

  }

}

class Input implements Runnable {

  private PipedInputStream in;

  Input(PipedInputStream in) {
    this.in = in;
  }

  public void run() {

    try {
      byte[] buf = new byte[1024];
      int len = in.read(buf);

      String s = new String(buf, 0, len);

      System.out.println("s=" + s);
      in.close();
    } catch (Exception e) {
      // TODO: handle exception
    }

  }
}

class Output implements Runnable {
  private PipedOutputStream out;

  Output(PipedOutputStream out) {
    this.out = out;
  }

  public void run() {

    try {
      Thread.sleep(5000);
      out.write("hi，管道来了！".getBytes());
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}

IO包中其它类
    操作基本数据类型 DataInputStream DataOutputStream

Demo14

public class DataSteamDemo {
  public static void main(String[] args) throws IOException {

     writeData();
    readData();

  }

  public static void readData() throws IOException {

    DataInputStream dis = new DataInputStream(new FileInputStream("E:\\data.txt"));

    String str = dis.readUTF();

    System.out.println(str);
  }

  public static void writeData() throws IOException {

    DataOutputStream dos = new DataOutputStream(new FileOutputStream("E:\\data.txt"));

    dos.writeUTF("你好");

    dos.close();

  }
}

操作字节数组 ByteArrayInputStream ByteArrayOutputStream

Demo15

public class ByteArrayStreamDemo {
  public static void main(String[] args) {

    ByteArrayInputStream bis = new ByteArrayInputStream("abcedf".getBytes());

    ByteArrayOutputStream bos = new ByteArrayOutputStream();

    int ch = 0;

    while((ch=bis.read())!=-1){
      bos.write(ch);
    }

    System.out.println(bos.toString());
  }
}

操作字符数组

操作字符串

编码表
    计算机只能识别二进制数据 早期由来是电信号
    为了方便应用计算机 让它可以识别各个国家的文字
    就将各个国家的文字用数字来表示 并一一对应 形成一张表
    就是编码表
常见编码表
    ASCII 美国标准信息交换码 用一个字节的7位表示
    ISO8858-1 拉丁码表 欧洲码表 用一个字节的8位表示
    GB2312 中国的中文编码表
    GBK 中国的中文编码表升级 加入更多中文字符
    Unicode 国际标准码 用两个字节表示一个字符
    UTF-8 最多用三个字节表示一个字符

　　字符串 --> 字节数组：编码
　　字节数组 --> 字符串：解码
　　你好：GBK:  -60 -29 -70 -61
　　你好: utf-8: -28 -67 -96 -27 -91 -67
　　如果你编错了，解不出来
　　如果编对了，解错了，有可能有救

三个编码例子

Demo1

public class EncodeDemo {
  public static void main(String[] args) throws IOException {

    String str = "谢谢";

    byte[] buf = str.getBytes("gbk");

    String s1 = new String(buf, "UTF-8");

    System.out.println("s1=" + s1);

    byte[] buf2 = s1.getBytes("UTF-8");// 获取源字节.

    printBytes(buf2);// -17 -65 -67 -17 -65 -67 -17 -65 -67
    // -17 -65 -67 -17 -65 -67 -17 -65 -67 -17 -65 -67
    // -48 -69 -48 -69
    String s2 = new String(buf2, "GBK");

    System.out.println("s2=" + s2);

    // encodeDemo(str);

  }

  public static void encodeDemo(String str) throws UnsupportedEncodingException {
    // 编码；
    byte[] buf = str.getBytes("UTF-8");

    // printBytes(buf);

    // 解码：
    String s1 = new String(buf, "UTF-8");

    System.out.println("s1=" + s1);
  }

  private static void printBytes(byte[] buf) {
    for (byte b : buf) {
      System.out.print(b + " ");
    }
  }
}

Demo2

public class LianTong {
public static void main(String[] args) throws IOException {

    String str = "联通";
    /*
    11000001
    10101010
    11001101
    10101000
    */

    byte[] buf = str.getBytes("gbk");

    for(byte b :buf){
      System.out.println(Integer.toBinaryString(b&255));
    }
  }
}

Demo3

public class Test {
  public static void main(String[] args) throws IOException {

    String str = "ab你好cd谢谢";
    // str = "ab琲琲cd琲琲";

    // int len = str.getBytes("gbk").length;
    // for(int x=0; x<len; x++){
    // System.out.println("截取"+(x+1)+"个字节结果是："+cutStringByByte(str, x+1));
    // }

    int len = str.getBytes("utf-8").length;
    for (int x = 0; x < len; x++) {
      System.out.println("截取" + (x + 1) + "个字节结果是：" + cutStringByU8Byte(str, x + 1));
    }

    // String str = "琲";
    // byte[] buf = str.getBytes("gbk");
    // for(byte b : buf){
    // System.out.println(b);//-84 105
    // }

  }

  /*
   * 在java中，字符串“abcd”与字符串“ab你好”的长度是一样，都是四个字符。 但对应的字节数不同，一个汉字占两个字节。
   * 定义一个方法，按照最大的字节数来取子串。 如：对于“ab你好”，如果取三个字节，那么子串就是ab与“你”字的半个，
   * 那么半个就要舍弃。如果去四个字节就是“ab你”，取五个字节还是“ab你”.
   */

  public static String cutStringByU8Byte(String str, int len) throws IOException {

    byte[] buf = str.getBytes("utf-8");

    int count = 0;
    for (int x = len - 1; x >= 0; x--) {
      if (buf[x] < 0)
        count++;
      else
        break;
    }

    if (count % 3 == 0)
      return new String(buf, 0, len, "utf-8");
    else if (count % 3 == 1)
      return new String(buf, 0, len - 1, "utf-8");
    else
      return new String(buf, 0, len - 2, "utf-8");

  }

  public static String cutStringByByte(String str, int len) throws IOException {

    byte[] buf = str.getBytes("gbk");

    int count = 0;
    for (int x = len - 1; x >= 0; x--) {
      if (buf[x] < 0)
        count++;
      else
        break;
    }

    if (count % 2 == 0)
      return new String(buf, 0, len, "gbk");
    else
      return new String(buf, 0, len - 1, "gbk");
  }
}