java：IO流基础学习

public class FileDemo1 {
    public static void main(String[] args) throws IOException {
        File file1 = new File("G:\\Java学习\\java.txt");
        System.out.println(file1);
        File file2 = new File("G:\\Java学习", "java.txt");
        System.out.println(file2);
        File file3 = new File("G:\\Java学习");
        File file4 = new File(file3, "java.txt");
        System.out.println(file4);
    }
}

public class FileDemo2 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("G:\\Java学习\\java.txt");
        System.out.println(f1.createNewFile());
        File f2=new File("G:\\Java学习\\javaee");
        System.out.println(f2.mkdir());
        File f3=new File("G:\\Java学习\\java\\javaee");
        System.out.println(f3.mkdirs());
    }
}

public class FileDemo3 {
    public static void main(String[] args) {
        File f = new File("java.txt");
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());
        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        f.delete();
        File f = new File("G:\\luan");
        String[] strArray = f.list();
        for (String s : strArray) {
            System.out.println(s);
        }
        File[] files = f.listFiles();
        for (File f1 : files){
            //System.out.println(f1);
            if (f1.isFile()) {
                System.out.println(f1.getName());
            }
        }
    }
}

public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        File file = new File("itcast1");
        file.mkdir();
        file.delete();
        File file1 = new File("itcast\\java.txt");
        file1.createNewFile();
        file1.delete();
    }
}

public class Demo {
    public static void main(String[] args) {
        File file = new File("G:\\luan");
        getAllFilePath(file);
    }
    public static void getAllFilePath(File src){
        File[] files = src.listFiles();
        if(files!=null){
            for(File file : files){
                if(file.isDirectory()){
                    getAllFilePath(file);
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
}

public class CopyJpg {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节流输入流对象，读取数据
        FileInputStream fileInputStream = new FileInputStream("E:\\itcast\\mm.jpg");
        //根据目的地创建字节流输出流对象，写入数据
        FileOutputStream fileOutputStream = new FileOutputStream("mm.jpg");
        //读写数据，一次读取一个字节数组，一次写入一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, len);
        }
        //释放资源
        fileInputStream.close();
        fileOutputStream.close();
    }
}

public class CopyMp4 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        method1();
        long endTime = System.currentTimeMillis();
        System.out.println("耗时" + (endTime - startTime) + "毫秒");
    }
    //基本字节流一次读取一个字节
    public static void method1() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("G:\\luan\\VID7.mp4");
        FileOutputStream fileOutputStream = new FileOutputStream("VID.mp4");
        int by;
        while ((by = fileInputStream.read()) != -1) {
            fileOutputStream.write(by);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
    //基本字节流一次读取一个字节数组
    public static void method2() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("G:\\luan\\VID7.mp4");
        FileOutputStream fileOutputStream = new FileOutputStream("VID.mp4");
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, len);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
    //字节缓冲流一次读取一个字节
    public static void method3() throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("G:\\luan\\VID7.mp4"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("VID.mp4"));
        int by;
        while ((by = bufferedInputStream.read()) != -1) {
            bufferedOutputStream.write(by);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
    //字节缓冲流一次读取一个字符数组
    public static void method4() throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("G:\\luan\\VID7.mp4"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("VID.mp4"));
        byte[] bytes = new byte[1024];
        int len;
        while((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s = "中国";

        byte[] bytes = s.getBytes("GBK");
        System.out.println(Arrays.toString(bytes));
        String ss = new String(bytes,"GBK");
        System.out.println(ss);

        byte[] bytes1 =s.getBytes("UTF-8");
        System.out.println(Arrays.toString(bytes1));
        String ss1 = new String(bytes1,"UTF-8");
        System.out.println(ss1);
    }
}

public class ConversionStream {
    public static void main(String[] args) throws IOException {
        /*
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("os.txt"),"UTF-8");
        outputStreamWriter.write("我爱你中国");
        outputStreamWriter.close();
        */
        //默认字符编码
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("os.txt"));
        outputStreamWriter.write("我爱你中国");
        outputStreamWriter.close();
        //使用指定字符解码方式解码
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("os.txt"),"GBK");
        int ch;
        //一次读取一个字符
        while ((ch = inputStreamReader.read()) != -1) {
            System.out.print((char) ch);
        }
        inputStreamReader.close();
    }
}

使用方法写完数据后需要使用OutputStreamWriter类对象的flush()方法刷新流，将数据写入。在close()方法执行前也会执行一次flush()方法。

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("os.txt"));
        /*int ch;
        while ((ch=inputStreamReader.read())!=-1){
            System.out.print((char)ch);
        }*/
        char[] chars = new char[1024];
        int len;
        while((len=inputStreamReader.read(chars))!=-1){
            System.out.print(new String(chars,0,len));
        }
        inputStreamReader.close();
    }
}

public class CopyJava {
    public static void main(String[] args) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("src\\com\\collectionDemo\\it8\\CollectionDemo.java"));
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("copy.java"));
        /*
        //读写一个字符
        int ch;
        while((ch=inputStreamReader.read())!=-1){
            outputStreamWriter.write(ch);
        }
        */
        //读写一个字符数组
        char[] chars = new char[1024];
        int len;
        while ((len=inputStreamReader.read(chars))!=-1){
            outputStreamWriter.write(chars,0,len);
        }
        inputStreamReader.close();
        outputStreamWriter.close();
    }
}

public class CopyJava2 {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("src\\com\\stream\\conversionStream\\ConversionStream.java");
        FileWriter fileWriter = new FileWriter("copy.java");
        /*
        int ch;
        while((ch=fileReader.read())!=-1){
            fileWriter.write(ch);
        }
        */
        char[] chars = new char[1024];
        int len;
        while((len=fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,len);
        }
        fileReader.close();
        fileWriter.close();
    }
}

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        FileWriter fileWriter = new FileWriter("bw.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write("hello\r\n");
        bufferedWriter.write("world");
        bufferedWriter.close();
        */
        BufferedReader bufferedReader = new BufferedReader(new FileReader("bw.txt"));
        /*
        int ch;
        while ((ch = bufferedReader.read()) != -1) {
            System.out.print((char) ch);
        }
        */
        char[] chars = new char[1024];
        int len;
        while((len=bufferedReader.read(chars))!=-1){
            System.out.print(new String(chars,0,len));
        }
        bufferedReader.close();
    }
}

public class CopyJava3 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\com\\stream\\bufferedStream\\BufferedStreamDemo.java"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("copy2.java"));
        /*int ch;
        while ((ch = bufferedReader.read()) != -1) {
            bufferedWriter.write(ch);
        }*/
        int len;
        char[] chars = new char[1024];
        while ((len = bufferedReader.read(chars)) != -1) {
            bufferedWriter.write(chars, 0, len);
        }
        bufferedReader.close();
        bufferedWriter.close();
    }
}

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("bw.txt"));
        for(int i=0;i<10;i++){
            bufferedWriter.write("hello"+i);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        */
        BufferedReader bufferedReader = new BufferedReader(new FileReader("bw.txt"));
        String line;
        while ((line=bufferedReader.readLine())!=null){
            System.out.println(line);
        }
        bufferedReader.close();
    }
}

public class CopyJava4 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\com\\stream\\bufferedStream\\BufferedStreamDemo.java"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("copy3.java"));
        String line;
        while((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        bufferedReader.close();
    }
}

public class ArrayListToTxt {
    public static void main(String[] args) throws IOException {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("world");
        BufferedWriter bufferedWriter =new BufferedWriter(new FileWriter("arrayList.txt"));
        for(String s:arrayList){
            bufferedWriter.write(s);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
    }
}

public class TxtToArrayList {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("arrayList.txt"));
        ArrayList<String> arrayList = new ArrayList<>();
        String line;
        while((line=bufferedReader.readLine())!=null){
            arrayList.add(line);
        }
        bufferedReader.close();
        for(String s:arrayList){
            System.out.println(s);
        }
    }
}

public class CallName {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("name.txt"));
        ArrayList<String> arrayList = new ArrayList<>();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            arrayList.add(line);
        }
        bufferedReader.close();
        Random r = new Random();
        int index = r.nextInt(arrayList.size());
        String name = arrayList.get(index);
        System.out.println(name);
    }
}

public class ArrayListToFile {
    public static void main(String[] args) throws IOException {
        ArrayList<Student> arrayList = new ArrayList<Student>();
        Student s1 = new Student("19313101", "张三", 29, "河南");
        Student s2 = new Student("19313102", "李四", 25, "湖南");
        Student s3 = new Student("19313103", "王五", 23, "山东");
        Student s4 = new Student("19313104", "周瑜", 25, "河北");
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("student.txt"));
        for (Student s : arrayList) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(s.getName()).append("{学号：").append(s.getSid()).append("，年龄：").append(s.getAge()).append("岁，住址：").append(s.getAddress()).append("}");
            bufferedWriter.write(stringBuilder.toString());
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
    }
}

public class FileToArrayList {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader =new BufferedReader(new FileReader("student.txt"));
        ArrayList<Student> arrayList = new ArrayList<>();
        String line;
        while((line= bufferedReader.readLine())!=null){
            String[] strings = line.split("，");
            Student s =new Student();
            s.setName(strings[0]);
            s.setSid(strings[1]);
            s.setAge(Integer.parseInt(strings[2]));
            s.setAddress(strings[3]);
            arrayList.add(s);
        }
        for(Student s:arrayList){
            System.out.println(s.getName()+","+s.getSid()+","+s.getAge()+","+s.getAddress());
        }
        bufferedReader.close();
    }
}

public class TreeSetToFile {
    public static void main(String[] args) throws IOException {
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //成绩从高到低
                int num = s2.scoreSum() - s1.scoreSum();
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                return num4;
            }
        });
        for (int i = 0; i < 5; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入学生信息");
            System.out.println("姓名");
            String name = sc.nextLine();
            System.out.println("语文，数学，英语成绩");
            int chinese = sc.nextInt();
            int math = sc.nextInt();
            int english = sc.nextInt();
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);
            treeSet.add(s);
        }
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("ts.txt"));
        for (Student s : treeSet) {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.scoreSum());
            bufferedWriter.write(stringBuilder.toString());
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
    }
}

public class CopyFolder {
    public static void main(String[] args) throws IOException{
        //创建数据源目录File对象
        File srcFolder = new File("G:\\Java\\demo1");
        //获取数据源目录File对象的名称
        String srcFolderName = srcFolder.getName();
        //创建目的地目录File对象
        File destFolder = new File(srcFolderName);
        //判断目的地目录对应的file是否存在
        if(!destFolder.exists()){
            destFolder.mkdir();
        }
        //获取数据源目录下的所有文件的File数组
        File[] files = srcFolder.listFiles();
        for(File srcFile:files){
            String srcFileName = srcFile.getName();
            File destFile = new File(destFolder,srcFileName);
            copyFile(srcFile,destFile);
        }
    }
    //复制文件
    public static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFile));
        byte[] bytes = new byte[1024];
        int len;
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

public class CopyFolders {
    public static void main(String[] args) throws IOException {
    	//数据源File对象
        File srcFile = new File("G:\\luan\\学生成绩管理系统");
        //目的地File对象
        File destFile = new File("G:\\");
        copyFolder(srcFile, destFile);
    }
    private static void copyFolder(File srcFile, File destFile) throws IOException {
    	//如果数据源File对象是目录
        if (srcFile.isDirectory()) {
            //在目的地下创建和数据源file名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile, srcFileName);
            if (!newFolder.exists()) {
                newFolder.mkdir();
            }
            //获取数据源file下所有的文件或目录的File数组
            File[] files = srcFile.listFiles();
            for (File file : files) {
                //把该File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file, newFolder);
            }
        } else {
            File newFile = new File(destFile, srcFile.getName());
            copyFile(srcFile, newFile);
        }
    }
    //字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFile));
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bufferedInputStream.read(bytes)) != -1) {
            bufferedOutputStream.write(bytes, 0, len);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}

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

    }
    //jdk9之后的改进
    private static void method4() throws IOException {
        FileReader fileReader = new FileReader("fr.txt");
        FileWriter fileWriter = new FileWriter("fw.txt");
        try (fileReader;fileWriter) {
            char[] chars = new char[1024];
            int len;
            while ((len = fileReader.read(chars)) != -1) {
                fileWriter.write(chars, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //jdk7之后改进方案
    private static void method3() {
        try (FileReader fileReader = new FileReader("fr.txt");
             FileWriter fileWriter = new FileWriter("fw.txt");) {
            char[] chars = new char[1024];
            int len;
            while ((len = fileReader.read(chars)) != -1) {
                fileWriter.write(chars, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //try..catch...finally
    private static void method2() {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            fileReader = new FileReader("fr.txt");
            fileWriter = new FileWriter("fw.txt");
            char[] chars = new char[1024];
            int len;
            while ((len = fileReader.read(chars)) != -1) {
                fileWriter.write(chars, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static void method1() throws IOException {
        FileReader fileReader = new FileReader("fr.txt");
        FileWriter fileWriter = new FileWriter("fw.txt");
        char[] chars = new char[1024];
        int len;
        while ((len = fileReader.read(chars)) != -1) {
            fileWriter.write(chars, 0, len);
        }
        fileWriter.close();
        fileReader.close();
    }
}

public class SystemIn {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        /*int by;
        while ((by = inputStream.read()) != -1) {
            System.out.print((char) by);
        }*/
        //一次读取一行数据是字符缓冲输入流的方法
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String s = bufferedReader.readLine();
        System.out.println(s);
        int i = Integer.parseInt(bufferedReader.readLine());
        System.out.println(i);
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println(x);
    }
}

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        PrintStream printStream = new PrintStream("ps.txt");
        printStream.write(97);
        printStream.println(97);
        printStream.print("王钰元");
        printStream.println("@163.com");
        printStream.close();
    }
}

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        PrintWriter printWriter = new PrintWriter("pw.txt");
        printWriter.write("hello");
        printWriter.write("\r\n");
        printWriter.println("world");
        printWriter.flush();
        //在构造方法中自动刷新
        PrintWriter printWriter1 = new PrintWriter(new FileWriter("pw1.txt"), true);
        printWriter1.write("hello");
        printWriter1.println();
        printWriter1.println("english");
    }
}

public class CopyJava5 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\com\\stream\\copyTest\\CopyAvi.java"));
        PrintWriter printWriter = new PrintWriter(new FileWriter("copy2.java"),true);
        String line;
        while((line=bufferedReader.readLine())!=null){
           printWriter.println(line);
        }
        bufferedReader.close();
        printWriter.close();
    }
}

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        Student s = new Student("张三", 19);
        objectOutputStream.writeObject(s);
        objectOutputStream.close();
        //反序列化流
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("oos.txt"));
        Object o = objectInputStream.readObject();
        Student s1 = (Student) o;
        System.out.println(s1.getName() + ":" + s1.getAge());
        objectInputStream.close();
    }
}

public class PropertiesDemo {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("193131322", "张三");
        properties.put("193131321", "李四");
        properties.put("193131301", "王五");
        Set<Object> set = properties.keySet();
        for (Object key : set) {
            Object value = properties.get(key);
            System.out.println(key + ":" + value);
        }

        Properties properties1 = new Properties();
        properties1.setProperty("193131325", "周瑜");
        properties1.setProperty("193131310", "黄盖");
        properties1.setProperty("193131336", "武松");
        Set<String> names = properties1.stringPropertyNames();
        for (String key : names) {
            String value = properties1.getProperty(key);
            System.out.println(key + ":" + value);
        }
    }
}

public class GuessNumber {
    private GuessNumber() {}
    public static void start() {
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入数字");
            int guessNumber = sc.nextInt();
            if (guessNumber > number) {
                System.out.println(guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println(guessNumber + "小了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
    }
}

public class GuessPropertiesTest {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        FileReader fileReader = new FileReader("game.txt");
        properties.load(fileReader);
        String count = properties.getProperty("count");
        int number = Integer.parseInt(count);
        if (number >= 3) {
            System.out.println("结束");
        } else {
            GuessNumber.start();
            number++;
            properties.setProperty("count", String.valueOf(number));
            FileWriter fileWriter = new FileWriter("game.txt");
            properties.store(fileWriter, null);
            fileWriter.close();
        }
    }
}