JAVA I/O

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量88 收藏
点赞数
分类专栏： 笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44194692/article/details/120927947
版权

1.流的概念

  • 概念：内存与存储设备之间传输数据的通道

  • 水借助管道传输，流借助流传输

2.流的分类

  • 按方向[重点]:

    • 输入流：将<存储设备>中的内存读到<内存>中

    • 输出流：将<内存>中的内容写入到<存储设备>中

  • 按单位：

    • 字节流：以字节为单位，额可以读写所有数据

    • 字符流：以字符为单位，之能读写文本数据

  • 按功能：

    • 节点流：具有实际传输数据的读写功能

    • 过滤流：在节点流的基础之上增强功能

3.字节流

  • 字节流的父类（抽象类）：

    • InputStream：字节输入流

      • public int read(){}

      • public int read(byte[] b){}

      • public int read(byte[] b,int off,int len){}

    • OutputStream：字节输出流

      • public void write(int n){}

      • public void write(byte[] b){}

      • public void write(byte[] b,int off, int len){}

文件字节流

  • FileInputStream：

    • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节流；如果达到文件的尾部，则返回-1

  • FileOutputStream:

    • public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流

package com.io;
​
import java.io.FileInputStream;
​
/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 *
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
//        fis.read();
        //2.1单个字节读取
//        int data=0;
//        while ((data=fis.read())!=-1){
//            System.out.println((char)data);
//        }
        //2.2一次读取多个字节
​
        byte[] buf =  new byte[3];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
​
        //3.关闭
        fis.close();
        System.out.println("执行完毕");
    }
}
package com.io;
​
import java.io.FileOutputStream;
​
/**
 * 演示文件输出流的使用
 * FileOutputStream
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        //1.创建文件字节流输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
        //2.写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string = "helloworld";
        fos.write(string.getBytes());
        fos.close();
        System.out.println("执行完毕");
    }
}
package com.io;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
​
/**
 * 使用文件字节流实现文件的复制
 *
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\java1.jpg");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\java2.jpg");
        //2.一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

  • 缓冲流：BufferedInputStream/BufferedOutputStream

    • 提高IO效率，减少访问磁盘的次数

    • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close

package com.io;
​
import java.io.BufferedInputStream;
import java.io.FileInputStream;
​
/**
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
        int data = 0;
        while((data=bis.read())!=-1){
            System.out.print((char)data);
        }
//        byte[] buf = new byte[1024];
//        int count = 0;
//        while((count=bis.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //3.关闭
        bis.close();
    }
}
package com.io;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
​
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\r\n".getBytes());//写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        //3.关闭(内部调用flush方法)
        bos.close();
    }
}

对象流

  • 对象流：ObjectInputStream/ObjectOutputStream

    • 增强了缓冲区功能

    • 增强了读写8种基本数据类型和字符串功能

    • 增强了读写对象的功能

      • readObject() 从流中读取一个对象

      • writeObject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化

package com.io;
​
import java.io.Serializable;
​
/**
 * serialVersionUID:序列化版本ID：保证序列化的类和反序列化的类时同一个类
 */
public class Student implements Serializable {
    private static final long serialVersionUID = -4638253220549992163L;
    private String name;
    private transient int age;
​
    public static String country = "中国";
​
    public Student() {
    }
​
    public Student(String name, int age) {
        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;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
package com.io;
​
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
​
/**
 * ObjectOutputStream实现对象的序列化
 * 注意事项：
 * （1）序列化必须要实现Serializable接口
 * （2）序列化类中的属性要求实现Serializable接口
 * （3）保证序列化的类和反序列化的类时同一个类
 * （4）使用transient（瞬间的）修饰属性，这个属性就不能序列化
 * （5）静态属性不能序列化
 * （6）序列化多个对象，可以借助集合实现
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student zhangsan = new Student("张三", 20);
        Student lisi = new Student("李四",22);
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
//        oos.writeObject(zhangsan);
//        oos.writeObject(lisi);
        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
package com.io;
​
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
​
/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 *
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
//        Student student = (Student)ois.readObject();
//        Student student2 = (Student)ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(student.toString());
//        System.out.println(student2.toString());
        System.out.println(list.toString());
    }
}

4.编码方式

字符编码

  • ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号

  • UTF-8 针对Unicode码表的可变长度字符编码

  • GB2312 简体中文

  • GBK 简体中文、扩充

  • BIG5 台湾，繁体中文

当编码方式和解码方式不一致时，会出现乱码

5.字符流

  • 字符流的父类（抽象类）：

    • Reader：字符输入流

      • public int read(){}

      • public int read(char[] c){}

      • public int read(char[] b,int off,int len){}

    • Writer：字符输出流

      • public void write(int n){}

      • public void write(String str){}

      • public void write(char[] c){}

文件字符流

  • FileReader:

    • public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数：如果达到文件的尾部，则返回-1

package com.io.zifuliu;

import java.io.FileReader;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        //2.读取
        //2.1单个字符读取
//        int data=0;
//        while ((data=fr.read())!=-1){
//            System.out.println((char)data);
//        }
        char[] buf = new char[2];
        int count=0;
        while((count=fr.read(buf))!=-1){
            System.out.println(new String(buf, 0, count));
        }
        //3.关闭
        fr.close();
    }
}

  • FileWriter:

    • public void write(String str) //一次血多个字符，将b数组中所有字符，写入输出流

package com.io.zifuliu;

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 *使用字节流复制任意文件
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        FileWriter fw2 = new FileWriter("d:\\write2.txt");
        //2.写入方法
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\r\t");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

字符缓冲流

  • 缓冲流：BufferedReader/BufferedWriter

    • 高效读写

    • 支持输入换行符

    • 可一次写一行、读一行

package com.io.zifuliu;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 *
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //2.1第一种方式
//        char[] buf = new char[1024];
//        int count=0;
//        while ((count=br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2第二种方式，一行一行的读取
        String line = null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
        //3.关闭
        br.close();
    }
}
package com.io.zifuliu;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 演示BufferedWriter的使用
 *
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedWriter对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上");
            bw.newLine();// 写入一个换行符windows \r\n  linux \n
            bw.flush();
        }
        //3.关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

  • PrintWirter:

    • 封装了print() / println()方法，支持写入后换行

    • 支持数据原样打印

package com.io.zifuliu;

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 *
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

  • 桥转换流：InputStreamReader/OutputStreamWriter

    • 可将字节流转换为字符流

    • 可设置字符的编码方式

package com.io.zifuliu;

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 *
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}
package com.io.zhuanhuanliu;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 *
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱北京，我爱故乡\r\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行编码");
    }
}

6.File类

  • 概念：代表物理盘符中的ige文件或文件夹。

  • 方法

    • createNewFile()//创建一个新文件

    • mkdir()//创建一个新目录

    • delete()//删除文件或空目录

    • exists()//判断File对象所代表的对象是否存在

    • getAbsolutePath()//获取文件的绝对路径

    • getName()//取得名字

    • getParent()//获取文件/目录所在的目录

    • isDirectory()//是否是目录

    • isFile()//是否是文件

    • length()//获得文件的长度

    • listFiles()//列出目录中的所有内容

    • renameTo()//修改文件名为

package com.io.file;


import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class Demo01 {
    public static void main(String[] args)throws Exception{
    fileOpe();
    }
    //（1）分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+ File.separator);
    }
    //（2）文件操作
    public static void fileOpe() throws Exception {
        //1.创建文件
        File file = new File("d:\\file.txt");
//        System.out.println(file.toString());
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果："+b);
        }
        //2.删除文件
        //2.1直接删除
//        System.out.println("删除结果："+file.delete());
        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5);
        //3.获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称"+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件的创建时间："+new Date(file.lastModified()).toLocaleString());

        //4.判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }

    public static void directoryOpe() throws Exception {
        //1.创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
//            dir.mkdir();//只能单极目录
            System.out.println("创建结果是："+ dir.mkdirs());//创建多级目录
        }

        //2.删除问金价
        //2.1直接删除(注意删除空目录)
        System.out.println("创建结果："+dir.delete());
        //2.2使用jvm删除
        dir.deleteOnExit();
        Thread.sleep(5000);
        //3.获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("后去文件夹名称："+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());

        //4.判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏："+dir.isHidden());

        //5.遍历文件夹
        File dir2 = new File("d:\\图片");
        String[] files = dir2.list();
        System.out.println("-------------------");
        for (String string : files) {
            System.out.println("string");
        }
    }
}

FileFilter接口

  • public interface FileFilter

    • boolean accept(File pathname)

  • 当调用File类中的listFiles()方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中。

File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;
                }
                return true;
            }
        });
        for (File file: files2) {
            System.out.println(file.getName());
        }

递归遍历和递归删除

package com.io.file;

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 */
public class Demo02 {
    public static void main(String[] args) {
//        listDir(new File("d:\\myfiles"));
            deleteDir(new File("d:\\myfiles"));
    }
    //案例1：递归遍历文件夹
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);
                }else{
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
    //案例2：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }else{
                    //删除文件
                    System.out.println(file.getAbsolutePath()+"删除："+file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());
    }
}

Properties

package com.io.properties;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
import java.util.Set;

/**
 * 演示Properties集合的使用
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
        //1.创建集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("username","张三");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.1-----keyset-----
        //3.2----------entrySet-----
        //3.3-----stringPropertyNames()-----
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro : pronames) {
            System.out.println(pro+"======="+properties.getProperty(pro));
        }

        //4.和流有关的方法
        //----------1.list方法----------
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();

        //----------2.store方法----------
        FileOutputStream fos = new FileOutputStream("d:\\print.properties");
        properties.store(fos,"注释");
        fos.close();

        //----------3.load方法----------
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());

    }
}

总结

  • 流的概念：

    • 内存与存储设备之间传输数据的通道

  • 流的分类：

    • 输入流、输出流；字节流、字符流；节点流、过滤流

  • 序列化、反序列化：

    • 将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口

  • File对象：

    • 代表物理盘符中的一个文件或文件夹

Zealous...
关注
专栏目录
Java I/O 详解：基础、文件操作与 NIO 实践
微笑听雨
05-30 5410
Java I/O (输入输出) 是指用于读取和写入数据的 API，包括从文件、网络和其他数据源进行读取和写入操作。Java 提供了丰富的类和接口来实现各种 I/O 操作，主要包括标准 I/O、文件 I/O 和新 I/O (NIO)。
探索Java I/O 模型的演进
08-25
Java I/O 模型的演进是随着技术发展和并发需求的提升而逐步完善的。在理解Java I/O模型之前，我们需要先了解一些基础概念，包括同步与异步、阻塞与非阻塞。 同步和异步是描述用户线程与内核交互方式的概念。同步I/O...
Java_SE12.docset.rar
05-25
zeal离线api的java se12版本的离线文档，zeal文档无法下载时救急。包含java se12和一份离线文档的安装指南
JavaSE12-面向对象-基础
Joyechen1的博客
03-01 281
面向对象-基础
Java SE基础知识（12）
TuZiBuQing的博客
08-06 202
ArrayList 类 ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。 ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下： import java.util.ArrayList; // 引入 ArrayList 类 ArrayList<E> objectName =new ArrayList<>(
JavaSE基础【吐血整理汇总】
热门推荐
flyingwzb的博客
12-14 1万+
1. 方法 1.1 定义方法的完整格式 定义方法的完整格式: 修饰符 返回值类型 方法名称(参数类型 参数名称, ...) { 方法体 return 返回值; } 修饰符：现阶段的固定写法，public static 返回值类型：也就是方法最终产生的数据结果是什么类型 方法名称：方法的名字，规则和变量一样，小驼峰 参数类型：进入方法的数据是什么类型 参数名称：进入方法的数据...
Java I/O 相关面试题
qq_45818776的博客
10-01 4166
Java I/O 相关面试题
Java I/O 流代码实例大全（01~09）
07-27
Java I/O 流代码实例大全（01~09） File、FileInputStream、FileOutputStream、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
java I/O
02-16
Java I/O 是Java编程语言中一个至关重要的领域，它涵盖了数据的输入与输出操作，包括文件操作、流处理、字符编码、网络通信等。在Java I/O系统中，各种类和接口构成了一个庞大的框架，使得开发者能够高效地处理数据...
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O
12-26
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O Java是一种面向对象的编程语言，由Sun Microsystems于1995年推出。它是一种跨平台的语言，意味着可以在不同的操作系统上运行...
Java-网络
2301_81543552的博客
09-14 714
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 298
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1162
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 754
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
m0_66572126的博客
09-14 690
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Gradle
最新发布
xiaocaij_icai的博客
09-15 197
");
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 1020
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 958
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值