Java基础语法学习 day11

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量93 收藏
点赞数
分类专栏： java基础语法学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mereoic/article/details/120374955
版权

1.字节流读数据（一次读一个字节数组数据）

在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt");
        /*
        //从该输入流读取第一个字节数据
        int read = fis.read();
        System.out.println(read);
        System.out.println((char)read);
        //从该输入流读取第二个字节数据，到达文件末尾后返回-1
        read=fis.read();
        System.out.println(read);
        System.out.println((char)read);
        */

        /*
        //读取所有
        int read = fis.read();
        while (read!=-1){
            System.out.print((char) read);
            read=fis.read();
        }
        */
        
        //优化上面的程序
        int by;
        while ((by=fis.read())!=-1){
            System.out.print((char)by);
        }


        //释放资源
        fis.close();
    }
}

案例：字节流复制文本文件
在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt");
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\out.txt");

        int by;
        while ((by=fis.read())!=-1){ //循环读，末尾返回-1
            fos.write(by);  //写
        }
        
        fis.close();
        fos.close();
    }
}

2.字节流读数据（一次读一个字节数组数据）

int read(byte[] 5):从该输入流读取最多b.length个字节的数据到一个字节数组

public class App 
{
    public static void main( String[] args ) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt");
        /*
        //int read(byte[] 5):从该输入流读取最多b.length个字节的数据到一个字节数组
        byte[] bys = new byte[5];

        //第一次读取
        int len = fis.read(bys);
        System.out.println(len);//实际读取的数据个数 5
        System.out.println(new String(bys,0,len));

        //第二次读取
        len = fis.read(bys);
        System.out.println(len);//实际读取的数据个数 5
        System.out.println(new String(bys,0,len));

        //第二次读取
         len = fis.read(bys);
        System.out.println(len);//实际读取的数据个数 4
        //String(byte[] bytes, int offset , int length) :从第0个位置开始读，读取len个字节
        System.out.println(new String(bys,0,len));
        */

        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes))!=-1){        //到达末尾返回长度len为-1
            System.out.println(new String(bytes,0,len));
        }
        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次:ld\r\n
         */
        fis.close();
    }
}

案例：字节流复制图片

public class App 
{
    public static void main( String[] args ) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\mn.png");
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\mq.png");
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes))!=-1){        //到达末尾返回长度len为-1
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

3.字节缓冲流

在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
//          FileOutputStream fos = new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt");
//          BufferedOutputStream bos = new BufferedOutputStream(fos);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("").getCanonicalPath()+"\\dddd.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("").getCanonicalPath()+"\\dddd.txt"));
        
        //读数据
        /*
        //一次字节
        int by;
        while ((by=bis.read())!=-1){
            System.out.print((char)by);
        }
         */
        
        //一次一数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        bis.close();
    }
}

案例：字节流复制视频

public class App 
{
    public static void main( String[] args ) throws IOException {
        //记录开始时间
        long starttime = System.currentTimeMillis();

        //复制视频
        method1(); //基本字节流一次读一个字节,共耗时：72496毫秒
        method2();//基本字节流一次读一个字节数组,共耗时：132毫秒
        method3();//字节缓冲流一次读一个字节,共耗时：525毫秒
        method4();//字节缓冲流一次读一个字节数组,共耗时：54毫秒
        //记录结束时间
        long endtime = System.currentTimeMillis();
        System.out.println("共耗时："+(endtime-starttime)+"毫秒");

    }
    //基本字节流一次读一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\hali.mp4");
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\halibote.mp4");
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
    //基本字节流一次读一个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\hali.mp4");
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\halibote.mp4");
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys);
        }
        fos.close();
        fis.close();
    }
    //字节缓冲流一次读一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\hali.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\halibote3.mp4"));
        int by;
        while ((by=bis.read())!=-1){
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
    //字节缓冲流一次读一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\hali.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\halibote4.mp4"));
        int len;
        byte[] bys = new byte[1024];
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }
}

4.字符流

为什么会出现字符流
在这里插入图片描述
在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        String s1 = "abc";
        String s2 = "中国";
        byte[] bys1 = s1.getBytes();
        byte[] bys2 = s2.getBytes();
        byte[] bys3 = s2.getBytes("UTF-8"); //一个汉字占两个字节
        byte[] bys4 = s2.getBytes("GBK");   //一个汉字占三个字节

        System.out.println(Arrays.toString(bys1));
        System.out.println(Arrays.toString(bys2));
        System.out.println(Arrays.toString(bys3));
        System.out.println(Arrays.toString(bys4));
        /*
            输出结果
            
            [97, 98, 99]
            [-28, -72, -83, -27, -101, -67]
            [-28, -72, -83, -27, -101, -67]
            [-42, -48, -71, -6]
            
         */
     }
}

编码表
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

字符串中的编码解码问题
在这里插入图片描述
字符流中的编码解码问题
在这里插入图片描述

public class App 
{
    /*
        OutputStreamWriter(OutputStream out)   创建一个使用默认字符编码的OutputStreamWriter。
        OutputStreamWriter(OutputStream out, Charset cs)   创建一个使用给定字符集的OutputStreamWriter。
        
     */
    public static void main( String[] args ) throws IOException {
        String s2 = "中国";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt"),"GBK");
        osw.write(s2);

        osw.close();

        InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\Users\\Faker\\Desktop\\study\\test.txt"),"GBK");
        //一次读一个字符
        int ch;
        while ((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }
        
        isr.close();
     }
}

字符流写数据五种方式
在这里插入图片描述
在这里插入图片描述
字符流读数据两种方式

在这里插入图片描述
字符流复制java文件（改进）
在这里插入图片描述

5.字符缓冲流

在这里插入图片描述
字符缓冲流复制java文件（改进）

public class App 
{
    public static void main( String[] args ) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\Faker\\Desktop\\study\\test.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\Faker\\Desktop\\study\\testc.java"));
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            bw.write(chs,0,len);
        }
        bw.close();
        br.close();
     }
}

字符缓冲流特有功能
在这里插入图片描述
复制java文件（字符缓冲流特有功能）

public class App 
{
    public static void main( String[] args ) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\Faker\\Desktop\\study\\test.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\Faker\\Desktop\\study\\testc.java"));

        String line;
        while ((line=br.readLine())!=null){
            bw.write(line);//写数据
            bw.newLine();//换行
            bw.flush();//刷新
        }
        bw.close();
        br.close();
     }
}

6. IO流小结

字节流
在这里插入图片描述
在这里插入图片描述
字符流
在这里插入图片描述
在这里插入图片描述
案例：集合到文件

public class App 
{
    public static void main( String[] args ) throws IOException {
        //创建ArrayList集合
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("hello");
        arrayList.add("world");
        arrayList.add("java");

        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\Faker\\Desktop\\study\\testc.txt"));

        for (String s: arrayList){
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        bw.close();
     }
}

案例：文件到集合

public class App 
{
    public static void main( String[] args ) throws IOException {
        //创建ArrayList集合
        ArrayList<String> arrayList = new ArrayList<String>();
        BufferedReader bw = new BufferedReader(new FileReader("C:\\Users\\Faker\\Desktop\\study\\testc.txt"));

        String line;
        while ((line=bw.readLine())!=null){
            arrayList.add(line);
        }

        bw.close();

        for (String s : arrayList){
            System.out.println(s);
        }
     }
}

案例：文件到集合（排序改进版）

public class App 
{
    public static void main( String[] args ) throws IOException {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge()-o1.getAge();
            }
        });

        //录入
        for (int i=0;i<5;i++){
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第"+(i+1)+"个学生信息");
            System.out.println("姓名：");
            String name =  sc.nextLine();
            System.out.println("年龄：");
            int age =  sc.nextInt();

            Student student = new Student(name,age);
            ts.add(student);
        }

        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\Faker\\Desktop\\study\\student.txt"));

        for (Student s:ts){
           StringBuilder sb = new StringBuilder();
           sb.append(s.getUsername()).append(",").append(s.getAge());

           bw.write(sb.toString());
           bw.newLine();
           bw.flush();
        }

        bw.close();
    }
}

案例：复制单级文件夹
在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        //原目录
        File src = new File("C:\\Users\\Faker\\Desktop\\study\\itcast");

        String srcFolderName = src.getName();

        //目标目录
        File  dest = new File("C:\\Users\\Faker\\Desktop",srcFolderName);

        if (!dest.exists()){
            dest.mkdir();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = src.listFiles();

        for (File f:listFiles){
            String srcfilename = f.getName();
            File destfile = new File(dest,srcfilename);
            //复制
            copyFile(f,destfile);
        }
    }

    private static void copyFile(File f, File destfile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}

案例：复制多级文件夹
在这里插入图片描述

public class App 
{
    public static void main( String[] args ) throws IOException {
        //原目录
        File srcFile = new File("E\\itcast");
        //目的地
        File destFile = new File("F\\");

        //写方法实现文件夹的复制
        copyFolder(srcFile,destFile);
    }
    //复制文件夹
    private static void copyFolder(File srcFile, File destFile) throws IOException {
        //判断原文件是否为目录
        if (srcFile.isDirectory()){
             String srcFileName = srcFile.getName();
             File newFolder = new File(destFile,srcFileName);//F:\\itcast
            if(!newFolder.exists()){
                newFolder.mkdir();
            }
            //复制文件数据
            File[] fileArray = srcFile.listFiles();
            for (File file:fileArray){
                copyFolder(file,newFolder);
            }
        }else { //是文件
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    private static void copyFile(File f, File destfile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}

复制文件异常处理
在这里插入图片描述
JDK7:
在这里插入图片描述
JDK9:
在这里插入图片描述

Wu.u
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础语法-day01
01-04
【Java基础语法-day01】 Java是一门广泛使用的高级编程语言，它由Sun Microsystems公司（现已被Oracle公司收购）于1995年发布。Java的设计目标是具有平台独立性，能够编写一次，到处运行。这得益于其跨平台的Java...
day02_Java基础语法.rar
08-30
Java是一种广泛使用的面向对象的编程语言，...总的来说，这个"day02_Java基础语法"的学习资料将引导你逐步掌握Java编程的基础，从简单的变量声明到复杂的面向对象设计，这些都是成为一个合格的Java开发者所必备的知识。
Java基础Day01-Java基础语法
Puffy的博客
03-16 2015
Java基础语法Java发展史java的应用平台java特点jdk jre jvm集成开发环境 eclipse注释常量变量数据类型标识符就是用来给包 类 方法 变量定义名称的定义变量和使用变量使用变量的注意事项数据类型转换 Java发展史 诞生时间 1995年 java之父 詹姆斯 高斯林 目前最新的版本 java11 java的应用平台 javase 桌面应用开发 javaee 企业级应用开...
Day5:Java基础语法学习6.9
Brood42的博客
06-11 1175
总目标：学会JAVA 本周目标：Java的入门知识（6.5——6.12） 今日目标：Java基础语法学习（1）6.9 注释 注释并不会被执行，是给我们写代码的人看的 Java中的注释有三种： 单行注释——//单行注释 多行注释——可以注释一段文字 /* 内容 */ 文档注释——/** */有功能，可以识别参数 javadoc javadoc命令是用来 生成自己API文档的 参数信息 @author 作者名 @version 版本号 @since 指明需要最早使用的jdk版本 @p
Java基础语法学习笔记（day01）
qq_43470538的博客
06-02 146
java基础语法day10
weixin_57469302的博客
12-01 321
Api、object类、Math类、Random类、String类、、字符串的比较、String的常用方法、StringBuffer、Date类、格式化日期、递归
Java基础语法-day01
weixin_39547543的博客
11-04 561
文章目录1. Java概述1.1 Java语言背景介绍1.2 Java语言跨平台原理1.3 JRE和JDK1.4 JDK的下载和安装1.4.1 下载1.4.2 安装1.4.3 JDK的安装目录介绍2. 第一个演示程序2.1 常用DOS命令2.2 Path环境变量的配置2.2.1 为什么配置环境变量2.3 HelloWorld案例2.3.1 Java程序开发运行流程2.3.2 HelloWorld案例的编写2.3.3 HelloWorld案例的编译和运行2.4 HelloWorld案例详解2.5 Notepa
java基础语法学习（复习）day10
Mereoic的博客
09-16 87
1.泛型
Day2 Java基础语法
m0_62292203的博客
02-05 290
注释
[Javaweb开发]2.java基础语法-Day1
05-29 1761
​ 关键字是指被Java赋予了特定含义的英文单词,这些单词是不允许使用的>例如像我们所学的第一个HelloWorld程序中的 ***class***;***main*** ... 等都是Java中的关键字。
day02 - Java基础语法
2401_84814326的博客
05-14 975
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
day2Java基础语法
allselects
12-03 121
Java基础语法
Day02Java基础语法.md
04-20
鉴于目前很多前端工程师也非常想自学Java,以求在公司发展更好，所以我用大白话的方式整理了一套Java基础语法的知识点，让大家对Java语法理解的更加透彻。
day02-Java基础语法
06-13
day02-Java基础语法
day01-java基础语法
06-13
day01-java基础语法
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 806
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 488
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java语法基础深入探索：从Day01到Day03
这个Java语法基础的课程体系旨在帮助初学者系统地掌握Java编程语言，从基础语法到高级特性，为后续的Java开发工作打下坚实的基础。通过Day01-Day03的学习，学习者可以逐步建立起自己的Java知识框架，并具备编写和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值