黑马程序员——java学习12（毕20--21）——IO_2

1、File

1.1、增删判获

package learn2;
/*File类的常见方法：
 * 1、创建
 *     boolean createNewFile();//在指定位置创建如果，如果该文件已存在，则不创建，返回false;
 *                                     输出流会覆盖
 *     boolean mkdir();//创建文件夹
 *             mkdirs();//创建多级文件夹
 * 
 * 2、删除
 *     boolean delete();//删除失败，返回 false
 *     void deleteOnExit();//在程序退出时删除
 * 3、判断
 *     boolean exists();//文件是否存在
 *     isFile();
 *     isDirectory();
 *     isHidden();
 *     isAbsolute();测试此抽象路径名是否是绝对路径，即使不存在也可以判断
 *     
 * 4、获取信息
 *     getName();
 *     getPath();
 *     getParent();
 * 
 *     getAbsolutePath();
 *     long LastModify();
 *     long length();
 * 
 * */
import java.io.File;
import java.io.IOException;

public class FileDemo {
    public static void main(String[] args) throws IOException{
        method_4();
    }
    public static void method_5()throws IOException
    {
        File f1 = new File("c:\test.java");
        File f2 = new File("c:\hahaha.java");
        sop("rename"+f1.renameTo(f2));
        
    }
    public static void method_4()throws IOException
    {
        File f = new File("c:\abc\a.txt");
        sop("path:"+f.getPath());//你封装的是什么路径，返回什么
        sop("abspath:"+f.getAbsolutePath());//无论封装的是什么。都返回其所属目录变绝对路径
        sop("parent:"+f.getParent());//该方法返回的是绝对路径中的文件父目录,如果获取相对路径，返回空
                                        //如果相对路径中有上一层目录。该目录则是返回结果
    }
    public static void method_3()throws IOException
    {
        File f = new File("file.txt");
        f.createNewFile();
        //记住，在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在
        //通过exists判断
        sop("dir:"+f.isDirectory());
        sop("file:"+f.isFile());
        sop(f.isAbsolute());
    }
    public static void method_2()throws IOException
    {
        File f = new File("file.txt");
//        sop("execute:"+f.canExecute());
        //创建文件夹
        File dir = new File("abc");
        //只能创建一级目录
//        sop("mkdir:"+dir.mkdir());
        sop("mkdir:"+dir.mkdirs());
    }
    public static void method_1()throws IOException
    {
        File f= new File("file.txt");
        f.deleteOnExit();//在程序退出时删除
//        sop("create:"+f.createNewFile());
        sop("delete:"+f.delete());
    }
    
    
    
    public static void consMethod()
    {
        //将a.txt封装成file对象,可以将已有的和未出现的文件或者文件夹封装成对象
        File f1= new File("a.txt");
        //
        File f2= new File("c:\abc","b.txt");
        
        File d = new File("c:\abc");
        File f3= new File(d,"c.txt");
        
        sop("f1:"+f1);
        sop("f2:"+f2);
        sop("f3:"+f3);
        
        File f4 = new File("c:"+File.separator+"abc\");
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

1.2、文件列表

调用list方法的对象，必须是真实存在的目录

File[] listFiles(FilenameFilter filter)根据文件名过滤器过滤后得到的文件名数组

package learn2;

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo2 {
    public static void main(String[] args) {
        File dir = new File("c:\");
        File[] files = dir.listFiles();
        for(File f:files)
        {
            System.out.println(f.getName()+"::"+f.length());
        }
    }
    public static void listDemo_2()
    {
        File dir = new File("c:\");
        //内部类
        String[] arr = dir.list(new FilenameFilter()
        {
            public boolean accept(File dir, String name)
            {    
//                System.out.println("dir:"+dir);
//                System.out.println("name:"+name);
//                if(name.endsWith(".bmp"))
//                    return true;
//                else
//                return false;
                return name.endsWith(".bmp");
            }
        });
        System.out.println("leng:"+arr.length);
        for(String name:arr)
        {
            System.out.println(name);
        }
    }
    public static void listDemo()
    {
        File f = new File("c:\");
        String[] names = f.list();//包含隐藏文件，调用list的必须封装了一个真实存在的目录
        for(String name :names)
        {
            System.out.println(name);
        }
    }
    private static void listRootDemo() {
        // TODO Auto-generated method stub
        File[] files= File.listRoots();
        for(File f:files)
        {
            System.out.println(f);
        }
        
    }
}

运行结果为对应目录下的文件名数组

1.3、列出目录下所有文件和文件夹&递归

递归时注意限定条件，注意内存溢出

package learn2;

import java.io.File;

/*列出指定目录下文件或者文件夹，包含子目录中的内容
 * 也就是列出制定目录下所有内容
 * 
 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可
 * 在列出过程中出现的还是目录的话，可以再次调用本功能
 * 也就是函数自身调用自身
 * 这种表现形式或者变成手法，成为递归
 * 递归注意
 * 1、限定条件
 * 2、要注意递归的次数，尽量避免内存溢出
 * */
public class FileDemo3 {
    public static void main(String[] args) {
        File dir = new File("F:\test");
        showDir(dir,0);
//        toBin(6);
        //注意内存溢出
//        int n = getSum(10);
//        System.out.println("n="+n);
    }
    public static String getLevel(int level)
    {
        StringBuilder sb = new StringBuilder();
        for(int x=0;x<level;x++)
        {
            sb.append("|--");
        }
        return sb.toString();
    }
    public static void showDir(File dir,int level)
    {
        
        System.out.println(getLevel(level)+dir.getName());
        level++;
        File[] files = dir.listFiles();
        for(int x=0;x<files.length;x++)
        {
            if(files[x].isDirectory())
                showDir(files[x],level);
            else
            System.out.println(getLevel(level)+files[x]);
        }
    }
    public static int getSum(int n)
    {
        if(n==1)
            return 1;
        return n+getSum(n-1);
    }
    public static void toBin(int num)
    {
        if(num>0)
        {
            toBin(num/2);
            System.out.println(num%2);
        }
//        while(num>0)
//        {
//            System.out.println(num%2);
//            num=num/2;
//        }
    }
    public static void method()
    {
        method();
    }
    
}

1.4、删除文件夹及文件

注意不能操作隐藏文件，否则返回空指针异常

package learn2;

import java.io.File;

/*删除一个带内容过的目录
 * 原理
 * windows中，删除目录从里面往外删除的
 * 
 * 既然是从里往外删除，就需要用到递归
 * 
 * */
public class RemoveDir {
    public static void main(String[] args) {
        File dir = new File("F:\test");
        removeDir(dir);
    }
    public static void removeDir(File dir)
    {
        File[] files =dir.listFiles();
        for(int x=0;x<files.length;x++)
        {
            if(!files[x].isHidden()&&files[x].isDirectory())
                removeDir(files[x]);
            else 
                //判断有没删错，打印一下看看
                System.out.println(files[x].toString()+":-file-:"+files[x].delete());
            
        }
        System.out.println(dir+"::dir::"+dir.delete());
    }
}

运行结果

1.5、创建java文件列表

package learn2;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/*
 * 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中
 * 建立一个java文件列表文件
 * 
 * 思路
 * 1、对指定目录递归
 * 2、获取递归过程中所有java文件路径
 * 3、将这些路径存储到集合中
 * 4、将集合中的数据写入到一个文件中
 * */
public class JavaFileList {
    public static void main(String[] args) throws IOException
    {
        File dir = new File("D:\Workspaces\MyEclipse 10\day14IO");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);
//        System.out.println(list.size());
        File file = new File(dir,"JavaFileList.txt");
        writeToFile(list,file.toString());
    }
    public static void fileToList(File dir,List<File>list)
    {
        File[] files = dir.listFiles();
        for(File file:files)
        {
            if(file.isDirectory())
                fileToList(file,list);
            else
            {
                if(file.getName().endsWith(".java"))
                    list.add(file);
            }
        }
    }
    public static void writeToFile(List<File> list,String javaListFile) throws IOException
    {
        BufferedWriter bufw = null;
        try
        {
            bufw = new BufferedWriter(new FileWriter(javaListFile));
            for(File f:list)
            {
                String path = f.getAbsolutePath();
                bufw.write(path);
                bufw.newLine();
                bufw.flush();
            }
        }
        catch(IOException e)
        {
            throw e;//或者抛runtimeE
        }
        finally
        {
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch(IOException e)
            {
                throw e;
            }
        }
    }
}

运行结果

1.6、Properties存取配置

存入格式为

键=值

package learn2;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/*
 * Properties是hashtable的子类
 * 也就是说它具备map集合的特点。而且它里面存储的键值都是字符串
 * 是集合中和IO技术相结合的集合容器
 * 该对象的特点：可以用于键值对形式的配置文件
 * 固定格式  键=值
 * */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException{
        loadDemo();
    }
    public static void loadDemo()throws IOException
    {
        Properties prop = new Properties();
        FileInputStream fis =new FileInputStream("info.txt");
        prop.load(fis);
        prop.setProperty("wangwu", "39");
        FileOutputStream fos = new FileOutputStream("info.txt");
        prop.store(fos, "haha");
//        System.out.println(prop);
        prop.list(System.out);
        fos.close();
        fis.close();
    }
    
    //想要将流中的数据存储到集合中
    //想要将into.txt中键值数据存到集合中进行操作
    /*
     * 1.用一个流和info.txt文件关联
     * 2、读取一行数据，将该行数据用"="进行切割
     * 3、等号左边作为键，右边作为值，存入到Properties集合中即可
     * */
    public static void method_1()throws IOException
    {
        BufferedReader bufr= new BufferedReader(new FileReader("info.txt"));
        String line = null;
        Properties prop = new Properties();
        while((line = bufr.readLine())!=null)
        {
            String[]arr = line.split("=");
//            System.out.println(line);
            prop.setProperty(arr[0], arr[1]);
        }
        bufr.close();
        System.out.println(prop);
    }
    //设置和获取元素
    public static void setAndGet()
    {
        Properties prop = new Properties();
        prop.setProperty("zhangsan", "30");
        prop.setProperty("lisi", "39");
//        System.out.println(prop);
        String value = prop.getProperty("lisi");
//        System.out.println(value);
        prop.setProperty("lisi", 89+"");
        Set<String> names = prop.stringPropertyNames();
        for(String s:names)
        {
            System.out.println(s+":"+prop.getProperty(s));
        }
    }
}

1.7、配置文件应用-计算使用次数

package learn2;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/*
 * 用于记录应用程序运行次数，
 * 如果使用次数已到，那么给出注册提示
 * 
 * 易想到：计数器
 * 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增
 * 可是随着该应用程序的退出，该计数器也在内存中消失了
 * 下一次再启动改程序，又重新开始从0计数
 * 所以建立配置文件，下次使用会先加载然后+1
 * 
 * 该配置文件使用键值对形式。是map集合。
 * 数据是文件形式存储，使用IO技术，IO+MAP-->properties
 * 
 * */
public class RunCount {
    public static void main(String[] args) throws IOException{
        Properties prop = new Properties();
        
//        先把文件封装成对象
        File file = new File("count.ini");
        if(!file.exists())//如果文件不存在
            file.createNewFile();
        FileInputStream fis = new FileInputStream(file);
        prop.load(fis);
        int count=0;
        String value = prop.getProperty("time");
        if(value!=null)
        {
            count=Integer.parseInt(value);
            if(count>5)
            {
                System.out.println("您好,使用次数已到，拿钱！");
            }
        }
        count++;
        prop.setProperty("time", count+"");
        FileOutputStream fos = new FileOutputStream(file);
        prop.store(fos, "");
        fos.close();
        fis.close();
    }
}

运行结果

1.8、打印流

package learn2;

import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

/*
 * 打印流：
 * 该流提供了打印方法，可以将各种数据类型的数据都原样打印
 * 字节打印流
 * PrintStream
 * 构造函数可以接收的参数类型：
 * 1、file 对象 File 
 * 2、字符串路径 String 
 * 3、字节输出流 OutputStream
 * PrintWriter
 * 1、file 对象 File 
 * 2、字符串路径 String 
 * 3、字节输出流 OutputStream
 * 4、字符输出流 Writer
 * */
public class PrintSystreamDemo {
    public static void main(String[] args)throws IOException {
        BufferedReader bufr = 
                new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
        String line =null;
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            out.println(line.toUpperCase());
            //有println和true才可刷
//            out.flush();
        }
        out.close();
        bufr.close();
    }
}

1.9、多个文件组合成一个，并输出

package learn2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class SequenceDemo {
    public static void main(String[] args) throws IOException{
        //文件存入流，存入集合中
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("D:\Workspaces\MyEclipse 10\day14IO\1.txt"));
        v.add(new FileInputStream("D:\Workspaces\MyEclipse 10\day14IO\2.txt"));
        v.add(new FileInputStream("D:\Workspaces\MyEclipse 10\day14IO\3.txt"));
        //输出vector中所有元素
        Enumeration<FileInputStream> en = v.elements();
        //多个流变成了一个流
        SequenceInputStream sis = new SequenceInputStream(en);
        FileOutputStream fos = new FileOutputStream("D:\Workspaces\MyEclipse 10\day14IO\4.txt");
        //源和目的的读写操作
        byte[] buf = new byte[1024];
        int len =0;
        while((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
    
    
}

1.10、文件切割和合并

package learn2;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;

public class SplitFile {
    public static void main(String[] args)throws IOException {
        merge();
        
    }
    public static void merge()throws IOException
    {
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=1;x<4;x++)
        {
            al.add(new FileInputStream("C:\spilitifiles\"+x+".part"));
        }
        final Iterator<FileInputStream> it = al.iterator();
        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
        {
            public boolean hasMoreElements()
            {
                return it.hasNext();
            }
            public FileInputStream nextElement()
            {
                return it.next();
            }
        };
        SequenceInputStream sis = new SequenceInputStream(en);
        FileOutputStream fos = new FileOutputStream("C:\spilitifiles\0.mp3");
        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 splitFile()throws IOException
    {
        FileInputStream fis= new FileInputStream("c:\3.mp3");
        FileOutputStream fos = null;
        
        byte[] buf = new byte[1024*1024];
        
        int len = 0;
        int count = 1;
        while((len=fis.read(buf))!=-1)
        {
            //已经不是完成文件了，扩展名为part或任意
            fos = new FileOutputStream("C:\spilitifiles\"+(count++)+".part");
            fos.write(buf,0,len);
            fos.close();
            
        }
        if(fos!=null)
            fos.close();
        fis.close();
    }
}

运行结果

2、

2.1、对象的序列化

ObjectOutputStream读，则必须是ObjectInputStream写的，否则无法读出

java.io.NotSerializableException;查看是否实现标号接口implements Serializable

此类内可自行添加序列号，也可以通过transient、static来防止修改文件，

package learn3;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException{
        readObj();
//        writeObj();
    }
    public static void readObj()throws IOException, ClassNotFoundException
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
        Person p =(Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
    public static void writeObj() throws IOException
    {
        ObjectOutputStream oos = 
                new ObjectOutputStream(new FileOutputStream("obj.txt"));
        oos.writeObject(new Person("lisi",39,"kr"));
        oos.close();
    }
}

其中Person

package learn3;

import java.io.Serializable;

//没有方法的接口，标记接口,
//为了实现序列化，实现了标记接口,序列化的是堆内存
public class Person implements Serializable {
    //自定义序列号
    public static final long serialVersionUID = 42;
    String name;
    //保证值在堆内存中存在而不在文本文件
    transient int age;
    static String country ="cn";
    Person(String name,int age,String country)
    {
        this.name=name;
        this.age=age;
        this.country=country;
    }
    public String toString()
    {
        return name+":"+age+":"+country;
    }
}

运行结果

2.2、管道流

read其实是一种阻塞式的方法，没有数据时都得等

package learn3;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/*
 * 
 * */
class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in)
    {
        this.in=in;
    }
    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];
            //阻塞式的方法read，没有数据都得等
            int len =in.read(buf);
            String s = new String(buf,0,len);
            System.out.println(s);
            in.close();
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道读取流失败");
        }
    }
}
class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
        this.out=out;
    }
    public void run()
    {
        try
        {
            out.write(("pipedlaila".getBytes()));
            out.close();
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道输出流失败");
        }
    }
}
public class PipedStreamDemo {
    public static void main(String[] args) throws IOException{
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        //相接
        in.connect(out);
        Read r = new Read(in);
        Write w = new Write(out);
        new Thread(r).start();
        new Thread(w).start();
    }
}

运行结果

2.3、随机读取访问

package learn3;

import java.io.IOException;
import java.io.RandomAccessFile;

/*
 * RandomAccessFileDemo
 * 该类不算是IO体系中的子类
 * 而是直接继承自Object
 * 但是它是IO包中成员。因为它具备读和写功能。
 * 内部封装了一个byte数组，而且通过指针对数组的元素进行操作
 * 可以通过getFilePointer获取指针位置
 * 同时通过seek改变指针位置
 * 其实完成读写的原理就是内部封装了字节输入流和输出流
 * 
 * 通过构造函数看出只能操作文件
 * 且操作文件有模式选择
 * 如果R模式，不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常
 * 如果RW模式，操作的文件不存在，会自动创建，如果存在则不会覆盖
 * 
 * */
public class RandomAccessFileDemo {
    public static void main(String[] args)throws IOException {
        writeFile_2();
//        readFile();
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.write("haha".getBytes());
        
    }
    public static void readFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
        //调整对象中指针
//        raf.seek(8*0);
        //跳过指定的字节数
        raf.skipBytes(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);
        raf.close();
    }
    public static void writeFile_2() throws IOException
    {    
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.seek(8*3);
        raf.write("周期".getBytes());
        raf.writeInt(103);
    }
    public static void writeFile()throws IOException
    {    
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.write("李四".getBytes());
        //强转时会添加三个空格
        raf.writeInt(97);
        raf.write("王五".getBytes());
        raf.writeInt(99);
        raf.close();
        
    }
}

2.4、基本数据类型流的操作

package learn3;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
 * DateInputStream与DateOutputStream
 * 可以操作基本数据类型的流对象
 * */
public class DateStreamDemo {
    public static void main(String[] args)throws IOException {
        writeUTFDemo();
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
        osw.write("你好");
        osw.close();
    }
    public static void readUTFDemo() throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("utfdate.txt"));
        String s = dis.readUTF();
        System.out.println(s);
        dis.close();
    
    }
    public static void writeUTFDemo() throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));
        dos.writeUTF("你好");
        dos.close();
    }
    public static void readData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();
        System.out.println("num:"+num);
        System.out.println("b:"+b);
        System.out.println("d:"+d);
        dis.close();
    }
    public static void writeData()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        dos.writeInt(234);
        dos.writeBoolean(true);
        dos.writeDouble(9887.543);
        
        dos.close();
    }
}

2.5、ByteArrayStream

package learn3;

import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;

/*
 * 用于操作字节数组的流对象
 * ByteArrayInputStream:在构造的时候，需要接受数据源，而且数据源是一个字节数组
 * ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中已经封装了可变长度的字节数组。
 * 这就是数据目的地
 * 
 * 因为这两个流对象都操作的数组，并没有使用系统资源
 * 所以，不用进行close关闭。
 * 
 * 在流操作规律讲解时，
 * 源设备
 *     键盘system.in，硬盘FileStream，内存ArrayStream
 * 目的设备
 *     控制台system.out，硬盘FileStream，内存ArrayStream
 * 用流的读写思想操作数组
 * */
public class ByteArrayInputStreamDemo {
    public static void main(String[] args) {
        //数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());
        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        
        int by = 0;
        
        while((by=bis.read())!=-1)
        {
            bos.write(by);
        }
        
        System.out.println(bos.size());
        System.out.println(bos.toString());
    }
}

2.6、字符编码

 2.6.1、转换流

你好 出？？G编码 U8解码

　　 出浣豺U8编码 GBK解码

package learn3;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class EncodeStream {
    public static void main(String[] args)throws IOException {
//        writeText();
        readText();
    }
    public static void readText()throws IOException
    {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"GBK");
        char[] buf = new char[10];
        int len = isr.read(buf);
        String str = new String(buf,0,len);
        System.out.println(str);
        isr.close();
    }
    public static void writeText()throws IOException
    {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"));//"uft.txt",UTF-8
        osw.write("你好");
        
        osw.close();
    }

}

2.6.2、字符编码，错误的处理

package learn3;

import java.io.IOException;
import java.util.Arrays;

/*
 * 编码：字符串变成字节数组
 * 
 * 解码：字节数组变成字符串
 * String-->byte; str.getbytes(charsetName);
 * byte[]-->String: new String(byte[],charsetName);
 * */
public class EncodeDemo {
    public static void main(String[] args)throws IOException {
        String s = "你好";
        byte[] b1 = s.getBytes("GBK");
        String s1 = new String(b1,"ISO8859-1");//若u8则易出问题，中文解错不易解
        System.out.println("s1="+s1);
        
        //对S1进行ISO8859-1编码
         byte[] b2 = s1.getBytes("iso8859-1");
         System.out.println(Arrays.toString(b2));
         String s2 = new String(b2,"gbk");
         System.out.println("s2="+s2);
        
//        System.out.println(Arrays.toString(b1));
        
    }
}

运行结果

2.6.3、联通

往前面加中文即可

package learn3;

import java.io.IOException;

public class EncodeDemo2 {
    public static void main(String[] args) throws IOException{
        String s = "联通";
        byte[] by = s.getBytes("gbk");
        for(byte b:by)
        {
            System.out.println(Integer.toBinaryString(b&255));
        }
    }
}

2.6.4、练习

package Test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/*
 *有五个学生，每个学生有3门课的成绩
 *从键盘输入以上数据（包括姓名，三门课成绩）
 *输入的格式，如：zhangsan,30,40,60计算出总成绩
 *并把学生的信息和计算出的总分数高低排序存放在磁盘文件"stud.txt"中
 *
 * 1、描述学生对象
 * 2、定义一个可以操作学生对象的工具类
 * 
 * 思想：
 * 1、通过获取键盘录入的一行数据，并将改行数据中的信息取出，封装成学生对象
 * 2、因为学生对象有很多，那么就需要存储，使用到集合，因为要对学生的总分排序，
 * 所以可以使用TreeSet
 * 3、将集合中的信息写入到一个文件中
 * */

class Student implements Comparable<Student>
{
    private String name;
    private int ma,cn,en;
    private int sum;
    Student(String name,int ma,int cn, int en)
    {
        this.name=name;
        this.ma=ma;
        this.cn=cn;
        this.en=en;
        sum = ma+cn+en;
    }
    //实现了comparable,所以判断比较方法,compareTo方法是类，所以Integer包装一下
    public int compareTo(Student s)
    {
        int num =new Integer(this.sum).compareTo(new Integer(s.sum));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    public String getName()
    {
        return name;
    }
    public int getSum()
    {
        return sum;
    }
    public int hashCode()
    {
        return name.hashCode()+sum*78;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
        Student s = (Student)obj;
            return this.name.equals(s.name)&&this.sum==s.sum;
    }
    public String toString()
    {
        return "student["+name+", "+ma+", "+cn+", "+en+"]";
    }
}

class StudentInfoTool
{
    //没有比较器的
    public static Set<Student> getStudents()throws IOException
    {
        return getStudents(null);
    }
    //有比较器的
    public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
    {
        BufferedReader bufr =
                new BufferedReader(new InputStreamReader(System.in));
        String line = null;
        Set<Student> stus =null;
        if(cmp==null)
            stus = new TreeSet<Student>();
        else
            stus = new TreeSet<Student>(cmp);
        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            String[] info = line.split(",");
            Student stu = new Student(info[0],Integer.parseInt(info[1]),
                    Integer.parseInt(info[2]),
                    Integer.parseInt(info[3]));
            stus.add(stu);
        }
        bufr.close();
        return stus;
    }
    public static void write2File(Set<Student> stus)throws IOException
    {
        //定义数据存储位置
        BufferedWriter bufw =new BufferedWriter(new FileWriter("stuInfo.txt"));
        for(Student stu:stus)
        {
            bufw.write(stu.toString()+"	");
            //别忘记+""转型
            bufw.write(stu.getSum()+"");
            bufw.newLine();
            bufw.flush();
        }
        bufw.close();
    }
}
public class StudentInfoTest {
    public static void main(String[] args)throws IOException {
        //强行逆转比较器
        Comparator<Student> cmp = Collections.reverseOrder();
        Set<Student> stus = StudentInfoTool.getStudents(cmp);
        StudentInfoTool.write2File(stus);
    }
}

运行结果