泛型 File 对象 与 IO流

已于 2022-04-21 10:43:50 修改
阅读量216 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-04-20 13:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53625788/article/details/124295507
版权

1.泛型

1.1什么是泛型

1.泛型就是限制我们的数据类型、

2.为什么使用泛型？

//集合没有使用泛型
        List list = new ArrayList();
        list.add("小明");
        list.add("小红");

        //指定下标获取元素  需要进行强制类型转换
        String s = (String) list.get(0);
        System.out.println(s);

 获取元素时，不方便对元素进行相应的其他操作。

1.2如何使用泛型

List<类型> list=new ArrayList<类型>(); 只能在该集合中存储指定得类型。

//限制每个集合中的元素类型
        List<String> list = new ArrayList();
        //集合中只能添加String类型
        list.add("小明");
        list.add("小红");
        list.add("小黑");
        //在获取元素时  默认都是相应的类型所以不用在进行调换了
        String s = list.get(1);
        System.out.println(s);

        //<k , v> k: 表示键的 泛型   v: 表示值的 泛型
        HashMap<String , Integer> pp = new HashMap<>();
        pp.put("name",1);
        pp.put("age",2);
        System.out.println(pp);

1.3自己能否定义泛型类型

肯定可以

public  class 类名<标识,标识....> {
     标识  变量名;
     
     public 标识 方法名(){
        
     }
     
     public void 方法名(标识 参数名){
     
     
     }
     .........

}

定义坐标类

public static void main(String[] args) {
        //在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型
        Coords c = new Coords();
        c.setX("北纬34°");
        c.setY("东经113°");
        c.coords();
        //这里得泛型必须都是对象类型
        Coords<Integer> a = new Coords<>();
        a.setX(15);
        a.setY(30);
        Integer x = a.getX();
        Integer y = a.getY();
        a.show();
    }
}
class Coords<E> {
    private E x;
    private E y;

    public void show() {
        System.out.println("x的坐标为"+x+" y的坐标为"+y);
    }
    public void coords() {
        System.out.println("金水区的坐标为"+x+y);
    }

    public E getX() {
        return x;
    }

    public void setX(E x) {
        this.x = x;
    }

    public E getY() {
        return y;
    }

    public void setY(E y) {
        this.y = y;
    }

2.File 对象

2.1file的简绍

File 类 就是当前系统中 文件或者文件夹的抽象表示

通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件夹

学习File类 其实就是学习 如果通过file对象 对系统中的文件/文件夹进行增删改查

2.2创建File对象

1.磁盘准备一个目录xxx。对文件操作放在该目录下。

 public static void main(String[] args) {
        //创建一个File对象并指定文件的路径   \转移字符串
        File file = new File("E:\\qy151\\AAA\\aaa.txt");

        /*
           \\目录层级  在window系统下层级分割符为\  但是在linux和mac系统上分割符为 /
           我们得java代码是一种跨平台得语言。 我们得开发在window  但是我们项目得部署在linux.
           我们使我们得代码能在任意系统下来用。 我们有两种解决办法
           (1)第一种 因为window 兼容 / 和 \
         */
        File file02 = new File("E:/qy151/AAA/bbbbb.txt");
        File file03 = new File("E:"+File.separator+"qy151"+File.separator+"AAA"+File.separator+"aaa.txt");
    }

2.3增加操作

package ketang20220419.two;/*
 * @author     : zzz
 * @date       : 2022/4/19 22:19
 * @description: some description
 */

import java.io.File;
import java.io.IOException;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //创建File对象
        File file = new File("E:/qy151/AAA/aaaa.txt");
        //创建相应的文件
        file.createNewFile();

        File file1 = new File("E:/qy151/AAA/bbbbb");
        //创建目录 make directory 单层目录
        file1.mkdir();

        File file2 = new File("E:/qy151/AAA/ttt/aaa");
        //创建多层目录
        file2.mkdirs();

        File file3 = new File("E:/qy151/AAA/ee");
        file3.createNewFile();
        //使根据你调用得方法不同 而创建不同得类型
    }
}

2.4删除操作

 public static void main(String[] args) throws InterruptedException {
        File file = new File("E:/qy151/AAA/wjcj/a.txt");
        //删除文件
        file.delete();

        File file1 = new File("E:/qy151/AAA/wjcj/q");
        //当程序退出后删除
        file1.deleteOnExit();

        Thread.sleep(5000);//休眠五秒。

        File file2 = new File("E:/qy151/AAA/wjcj/qq");
        //删除空目录
        file2.delete();
    }

2.5修改操作

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

        File file = new File("E:/qy151/AAA/ccc/bb.txt");
        file.createNewFile();

        //设置文件的权限为不能读取
        file.setReadable(false);

        //设置文件不能写
        file.setWritable(false);

        //设置只读取权限
        file.setReadOnly();

        //重命名
        file.renameTo(new File("E:/qy151/AAA/ccc/a.txt"));

    }

2.6查询操作

public static void main(String[] args) {
        File file = new File("E:/qy151/AAA/bbb/b.txt");

        //得到文件的名称
        String name = file.getName();
        System.out.println("文件的名称 "+name);

        //得到父级路径名称
        String parent = file.getParent();
        System.out.println("父级路径名称"+parent);

        //得到文件路径名称
        String path = file.getPath();
        System.out.println("文件路径名称"+path);

        //判断该文件是否为文件类型
        boolean b1 = file.isFile();
        System.out.println("文件是否为文件类型"+b1);

        //判断文件对象是否为目录类型
        boolean b2 = file.isDirectory();
        System.out.println("文件对象是否为目录类型"+b2);

        File file1 = new File("E:/qy151/AAA");

        //列出目录下所有的子文件的名称
        String[] list = file1.list();
        System.out.println(Arrays.toString(list));

        //列出目录下所有文件的的对象
        File[] files = file1.listFiles();
        for (File f : files) {
            System.out.println(f.toString());
        }

        File[] files1 = file1.listFiles();
        System.out.println(Arrays.toString(files1));
    }
}

经典题目: 用的方法的递归调用。

public class Test3 {
    public static void main(String[] args) {
       // 显示指定目录下的所有文件。E:/qy151/AAA下所有的文件.
        showAllFiles("E:/qy151/AAA");
    }
    public static void showAllFiles (String path) {
        //使用传入的路径构建文件对象
        File file = new File(path);
        //判断文件是否存在 或者文件是否为目录.
        //       不是文件             不是目录
        if (!file.exists() || !file.isDirectory()) {
            return;
        }
        //列出该目录下所有的文件对象。
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isDirectory()) {
                System.out.println(f.getPath()+" <Dir>");
                //继续调本方法
                showAllFiles(f.getPath());
            } else {
                System.out.println(f.getPath()+" ");
            }
        }
    }
}

3.IO流

  1. IO 表示有两个单词的缩写。I: Input 输入 O: Output 输出

  2. IO的作用：就是对文件中的内容进行操作。 输入: 读操作（读取文件的内容） 输出: 写操作(往文件中写内容)

  3. IO流的分类：

(1)根据流的方向:

---输入流: 程序可以从中读取数据的流。
---输出流: 程序能向其中写入数据的流。

(2)根据流的单位:

---字节流: 以字节为单位传输数据的流
---字符流: 以字符为单位传输数据的流

(3)根据功能

---节点流: 直接和文件进行交互
---处理流: 不是直接作用在文件上。

四个基本的流: 其他的流都是在这四个流的基础上进行扩展的

    字节输入流
    字节输出流 

    字符输入流
    字符输出流

3.1 Writer字符输出流

它是所有字符输出流的跟类。---FileWriter类

public static void main(String[] args) throws IOException {
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        Writer writer = new FileWriter("E:/qy151/AAA/bb.txt");

        String s = "hello 今天是个大晴天";
        writer.write(s);

        //刷新流
        writer.flush();
        //关闭流资源
        writer.close();
    }

上面每次往文件中写内容时 就会把原来的内容覆盖了。 如何追加内容

public static void main(String[] args) throws IOException {
        //字符输出流 ---指定对哪个文件（路径）进行写操作
        Writer writer = new FileWriter("E:/qy151/AAA/bb.txt",true);

        String s = "我们去公园散步吧";
        writer.write(s);

        //刷新流
        writer.flush();
        //关闭流资源
        writer.close();
    }

3.2 Reader字符输入流

它是所有字符输入流的根类 它的实现类有很多，我们使用FileReader实现类

Reader reader=new FileReader("E:/qy151/AAA/bb.txt");

        char[] cs =new char[2]; //每次读取2个字符放入该数组中。
        int c=reader.read(cs);// 每次读取两个字符放入cs数组中 返回读取的个数
        System.out.println(c);
        System.out.println(cs);
        String s=new String(cs,0,c);//把字符数组转换为字符串。
        System.out.println(s);

        c = reader.read(cs);
        System.out.println(c); //
        System.out.println(cs); // [a,b]-->[c,b]
        String s1=new String(cs,0,c);
        System.out.println(s1);

        c = reader.read(cs);
        System.out.println(c);
        System.out.println(cs); // [a,b]-->[c,b]

回顾

1. 泛型: 限制类中属性或方法的数据类型。 再创建集合对象时限制该集合中元素的类型.
    例如: List<String> list=new ArrayList();//该集合中的元素只能存放String数据类型。

2. File文件类: 对我们系统上的文件和文件夹的一种抽取。
       (1)创建该类对象时的方法: File file=new File("文件的路径");
       (2)方法: 
             list();列出该目录下所有的子文件名.
             listFiles()；列出该目录下所有的子文件对象
             getPath():得到文件的路径
             createNewFile()：创建文件
             mkdir();创建单层目录
             mkdirs():创建多层目录
             exists():判断文件是否存在。
             isDirectory():判断是否该文件为目录.
             delete():删除文件
             
3. IO: 就是通过IO流对文件的内容进行操作。   
      IO按照方向: 输入流和输出流
      IO按照内容: 字节流和字符流。
      IO功能： 节点流和处理流
      
4.IO中的4个基类:
      InputStream:字节输入流
      OutputStream:字节输出流
      Reader: 字符输入流
      Writer: 字符输出流

5. 字符输出和输入流

3.2完成文件内容的复制

 

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

public class Copy {
    @Test
    public void test() throws Exception {
        //创建一个字符输入流
        FileReader fileReader = new FileReader("E:/qy151/AAA/bb.txt");
        //创建一个字符输出流
        FileWriter fileWriter = new FileWriter("E:/qy151/mulu/ppp.txt");

        //读取到字符的个数
        int a = 0;
        //把读取的内容放到数组当中
        char[] c = new char[10];
        while ((a = fileReader.read(c)) !=-1) {
            fileWriter.write(c,0,a);
            //刷新
            fileWriter.flush();
        }
        fileWriter.close();
        fileReader.close();
    }
}

4.字节流

4.1字节输出流--OutputStream

        它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类，FileOutputStream

//测试字节输出流
@Test
    public void test() throws Exception {
        OutputStream out = new FileOutputStream("E:/qy151/AAA/bb.txt");
        String str = "asdfghjkl123456";
        //把字符串装换为字节数组
        byte[] bytes = str.getBytes();
        out.write(bytes);
        out.flush();
        out.close();
    }

4.2 字节输入流---InputStream

        它可以对任意文件进行读操作 ，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream

public class In {
    //如果文件内容非常大  就使用循环来读
    @Test
    public void test1() throws Exception {
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        byte[] bytes = new byte[200];
        //读取到的个数
        int c = 0;
        while ( (c = in.read(bytes)) !=-1){
            //把byte数组转换为字符串
            String s = new String(bytes,0,c);
            System.out.println(s);
        }
        in.close();
    }





    @Test
    public void test() throws Exception{
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        byte[] b = new byte[5];
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        int c = in.read(b);
        System.out.println(b+"---------->个数: "+c);
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        c = in.read(b);
        System.out.println(b+"---------->个数: "+c);
        //一次读取五个字节  并把读取到的字节的内容放入到字节数组中  返回读取到字节的个数
        c = in.read(b);
        System.out.println(b+"---------->个数: "+c);




    }
}

        使用字节输入和输出流完成文件的复制功能:

@Test
    public void Test() throws Exception {
        //1.创建字节输入流 视频
        InputStream in = new FileInputStream("E:/qy151/AAA/tu.jpg");
        //2.字节输出流
        OutputStream out = new FileOutputStream("E:/qy151/mulu/tu1.jpg");

        byte[] b = new byte[10];
        int c = 0;
        while ( (c = in.read(b)) !=-1 ) {
            out.write(b,0,c);
        }
        in.close();
        out.close();
    }

5.缓存流

        缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.

        BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数。

@Test
    public void Test() throws Exception {
        OutputStream out = new FileOutputStream("E:/qy151/AAA/bb.txt");
        //缓存流要作用再基础流上
        BufferedOutputStream buff = new BufferedOutputStream(out);
        String str = "dfafdhsajkfdhjska";
        byte[] b = str.getBytes();
        //因为你写的内容 暂时放入缓存池中  并没有直接放入文件中。 所以文件中没有你的内容。
        buff.write(b);
        //刷新缓存池---把池子中的内容输入到文件上
        //buff.flush();
        //关闭----先刷新缓冲池 再关闭流资源
        buff.close();
    }

 

6.对象流--对java对象进行IO操作

为什么需要对象流

        我们现在操作IO流的时候 都是将字符串读写操作 可不可以将java对象在文件中进行读写呢？ 可以的 Student st=new Student();对象 将java对象进行读写操作 意义在于持久化信息 例如： 游戏存档。

        // 因为运行的时候 所有的数据都是在运行内存中的 持久化 将运行内存的数据 保存到硬盘上 存档（写） 读档(读)

import org.junit.Test;


import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

public class Myobjeat implements Serializable {
    private String name;//姓名
    private String property;//属性
    private String estate;//等级
    private int id;
    private String other;//其他属性


    public Myobjeat() {
    }

    @Override
    public String toString() {
        return "Myobjeat{" +
                "name='" + name + '\'' +
                ", property='" + property + '\'' +
                ", estate='" + estate + '\'' +
                ", id=" + id +
                ", other='" + other + '\'' +
                '}';
    }

    public Myobjeat(String name, String property, String estate, int id, String other) {
        this.name = name;
        this.property = property;
        this.estate = estate;
        this.id = id;
        this.other = other;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public String getEstate() {
        return estate;
    }

    public void setEstate(String estate) {
        this.estate = estate;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getOther() {
        return other;
    }

    public void setOther(String other) {
        this.other = other;
    }
}


import org.junit.Test;

import javax.management.relation.Role;
import java.io.*;

public class MyTest {
    @Test //存档：----序列化:
    public void testObjectStream() throws Exception {
        OutputStream out = new FileOutputStream("E:/qy151/AAA/bb.txt");
        //对象输出流
        ObjectOutputStream ob = new ObjectOutputStream(out);

        //使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
        Myobjeat m = new Myobjeat("张飞","战士","99级",1,"老三");
        ob.writeObject(m);
        ob.close();
    }
  //测试 读档: ----反序列化:
    @Test
    public void test() throws Exception {
        InputStream in = new FileInputStream("E:/qy151/AAA/bb.txt");
        ObjectInputStream oob = new ObjectInputStream(in);
        Object o = oob.readObject();
        System.out.println(o);
        oob.close();
    }

}


1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
         ---java对象所属的类必须实现序列化接口.implements Serializable 
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。

总结:

1.  通过字符流完成文件的复制---->它只能复制文本文件
2.  字节流:---字节输入流和字节输出流。
3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
4.  缓存流--->它基本流的基础上 添加了一个缓存池 
5.  对象流: ObjectInputStream  ObjectOutputStream
     序列化:
     反序列化:

 

阿磊学不会001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
File对象 IO流
m0_56352213的博客
04-20 613
1.File的介绍 File类就是当前系统中 文件或者文件夹的抽象表示 通俗地讲就是使用File对象来操作我们电脑系统中的文件或者文件夹 学习File类其实就是学习 如果通过file对象对系统中的文件/文件夹进行增删改查 2.创建File对象 File file = new File("D:/AAA/aaaa.txt"); 3.添加操作 public static void main(String[] args) throws IOException { File fi
File类和IO流
weixin_46056866的博客
02-17 176
IO流小结 1.File类 文件和目录路径名的抽象表示。 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。**它可以是存在的，也可以是不存在的.**将来是要通过具体的操作把这个路径的内容转换为具体存在的 构造方法 File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。 File(String pathname) 通过将给定的路径名字符串
File对象和IO流
m0_58380757的博客
04-19 250
目录 1.File对象 1.1file的介绍 1.2创建File对象 1.3增加操作 1.4删除操作 1.5修改操作 1.6查询操作 1.7经典题目: 用的方法的递归调用 2 IO流 2.1IO流介绍 2.2Writer字符输出 2.3Reader字符输入流 1.File对象 1.1file的介绍 File 类 就是当前系统中 文件或者文件夹的抽象表示 通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件夹 学习File类 其实就是学习 如果通过...
IO流的总结和File类的总结
weixin_43447266的博客
08-19 192
IO流 一.为什么要学习IO流? 我们以前的数据都是存放在内存里的—程序一旦关闭,数据就会丢失. 我们可以通过IO远程传输数据(网络编程). 内存:不能永久存储数据,断电后(或关闭程序后),内存的数据就会被擦除. 硬盘:数据存储的一种介质,只要硬盘不坏,数据就会永久保存. File类 用来描述文件(或者文件夹),文件是否是可执行文件,文件是否可读,是否只写,文件多少个字节,文件的名称,文件的绝对路径,还可以操作文件或者文件夹 新建文件,新建文件夹.等等…File类只能操作文件或者文件夹本身(修改名称,创
JAVA——文件（File)对象与IO流
weixin_54204139的博客
04-20 1045
目录 1、File对象 2、File对象的使用 2.1 创建File对象 2.2 添加文件 2.3 删除操作 2.4 修改文件 2.5 查询文件 3、IO流 3.1 IO流概念 3.2 IO流的分类 3.3 Writer字符输出流 3.4 Reader字符输入流 1、File对象 File 类 就是当前系统中文件或者文件夹的抽象表示 ，通俗的讲就是使用File对象，来操作我们电脑系统中的文件或者文件夹。 File类 其实就是通过file对象，...
IO流与File对象基本操作
张叔的博客
10-17 724
一、IO流 1、IO流中的基本概念 IO流：用来处理设备之间的数据传输。 设备：各种存储设备 IO：用于处理设备上的数据的技术。设备：内存、硬盘、光盘等 流：系统资源，window系统本身就可以操作这些设备，各种语言只是使用系统平台上的这个资源。 并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源。 流使用完一定要释放！ 流的分类： 字节流与字符流 操作的数据
Java中的File类和IO流
热门推荐
Jack
08-19 1万+
概述： 1.File：翻译是文件，用于表达java中的路径名。 2.路径：用于表示文件或者文件夹在当前系统中的位置 3.路径的分类： 绝对路径 相对路径 4.绝对路径：没有任何的歧义，也没有任何的前提条件 Windows，从盘符开始的路径，例如"D:/a/b/c/d/a.txt" ...
多线程精品资源--Java教程，包括多线程，泛型，反射，IO，容器类,注解.zip
02-17
Java编程语言以其强大的功能和广泛的应用领域而备受程序员青睐，特别是在多线程、泛型、反射、输入/输出（IO）以及容器类和注解等方面的深入理解和应用，能够提升程序的性能和可维护性。本资源包聚焦于这些关键知识...
JavaTutorial, Java教程，包括多线程，泛型，反射，IO，容器类,注解.zip
09-17
Java的IO系统提供了丰富的类和接口来处理输入和输出，包括File类、InputStream和OutputStream类族、Reader和Writer类族等。NIO（New IO）是Java 1.4引入的改进，提供了一种非阻塞I/O模型，可以提高性能，特别是在...
580.578.JAVA基础教程_泛型与File-File类的课后练习(580).rar
11-09
Java编程语言是软件开发领域广泛使用的工具，尤其在企业级应用...通过这个Java基础教程的泛型与File类部分，你将能够更加自如地应对实际项目中的文件操作和类型安全问题。不断实践和总结，你的编程能力将得到显著提升。
565.563.JAVA基础教程_泛型与File-为什么要使用泛型(565).rar
11-09
5. **文件I/O操作：** 虽然File类本身并不直接进行文件的读写，但它可以与其他I/O流结合使用，如`new FileInputStream(file)`和`new FileOutputStream(file)`。 了解并熟练运用泛型和File类是每个Java开发者的基本...
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 481
SpringBoot 项目集成 xxl-job
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1156
浅析synchronized锁升级的原理与实现
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 637
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 612
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 521
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 387
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 829
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1675
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
《Java 语言程序设计》实验报告：泛型、集合和IO流的使用 实验06
本次实验的目的是为了让学生们对泛型、集合以及 Java IO 流等概念有更深入的理解，并学习并掌握相关的类及其方法的使用。通过本次实验，学生将能够应用泛型动态数组作为工具，使用课本195页的File对象及其方法，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值