精华内容
下载资源
问答
  • java文件流转文件

    万次阅读 2018-10-22 14:27:54
    java文件流转文件 **public static void getFile(String url, String destFileName) { String result = null; HttpClient httpClient = null; try { httpClient = new SSLClient(); HttpGet h...

    java文件流转文件

    **public static void getFile(String url, String destFileName) {
        String result = null;
        HttpClient httpClient = null;
        try {
            httpClient = new SSLClient();
            HttpGet httpGet = new HttpGet(url);
            httpGet.setHeader("111", "111");
            httpGet.setHeader("111", "111");
            HttpResponse response = httpClient.execute(httpGet);
            HttpEntity entity = response.getEntity();
            InputStream in = entity.getContent();
            File file = new File(destFileName);
            try {
                FileOutputStream fout = new FileOutputStream(file);
                int l = -1;
                byte[] tmp = new byte[1024];
                while ((l = in.read(tmp)) != -1) {
                    fout.write(tmp, 0, l);
                    // 注意这里如果用OutputStream.write(buff)的话,图片会失真,大家可以试试
                }
                fout.flush();
                fout.close();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 关闭低层流。
                in.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }**
    

    在这里插入图片描述

    展开全文
  • 文件流保存图片java

    千次阅读 2020-04-18 13:51:13
    package com.example.demo.utils; import java.io.*; import java.text.SimpleDateFormat; import java.util.Date; public class LoadImage { public static String name(){ Date date = new Dat...
    package com.example.demo.utils;
    
    import java.io.*;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class LoadImage {
    
        public static   String  name(){
            Date date = new Date();
            String time = getFisrtDayOfMonth(date);
            String idsts = getIdstrs(time);
            char c1 = (char) (int) (Math.random() * 26 + 97);
            char c2 = (char) (int) (Math.random() * 26 + 97);
            char c3 = (char) (int) (Math.random() * 26 + 97);
            char c4 = (char) (int) (Math.random() * 26 + 97);
            char c5 = (char) (int) (Math.random() * 26 + 97);
            char c6 = (char) (int) (Math.random() * 26 + 97);
            String questionbankid = idsts + c1+c2+c3+c4+c5+c6;
            return questionbankid;
        }
    
    
        //根据时间Date获取字符串String格式的数据
        public static String getFisrtDayOfMonth(Date date){
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String firstDayOfMonth = sdf.format(date.getTime());
            return firstDayOfMonth;
        }
    
        //根据String字符串yyyy-MM-dd HH:mm:ss格式数据,拼接成数字字符串
        public static String getIdstrs(String time){
            String result = "";
            String[] two = time.split(" ");
            String[] one = two[0].split("-");
            String[] three = two[1].split(":");
            result+=one[0]+one[1]+one[2]+three[0]+three[1]+three[2]+"";
            return result;
        }
    
        public static void mkdirs(String address) {
            File file=new File(address);
            if (file.exists() && file.isDirectory()) {
                return;
            }
            if (file.exists()) {
                file.delete();
                file.mkdirs();
            } else {
                file.mkdirs();
            }
        }
    
    
    
    
    
    
        public static String loadpicture(String pic,String tel,String titleid) throws IOException {
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(pic));  //原先图片所在路径
    
         String ad="src\\main\\resources\\static\\image\\"+tel+"\\"+titleid+"\\";//这个根据你本地的路径设置保存点
            mkdirs(ad);
            String picture=name()+".jpg";
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(ad+picture));  //你要保存在哪个目录下面
            int i;
    
            while((i=in.read())!=-1){
                out.write(i);
            }
            out.flush();
            out.close();
            in.close();
            return picture;
        }
    
    public static void main(String args[]) throws IOException {
    //需要的图片地址,,,,电话,,,,题号
            System.out.println(loadpicture("C:\\Users\\Administrator\\Desktop\\mysql\\3556745_092302332151_2.jpg",
                    "17859901738","4348u3u3"));
    
    }
    
    
    
    
    }
    
    展开全文
  • 一,java端 ...2,这种传输图片的方式可以用于Java后台代码生成条形码二维码,直接转成base64传给前台展示。 @RequestMapping("/login") public String login(Map<String ,Object> map){ by...

    一,java端

    1,项目是基于springboot的。读取本地图片,转成base64编码字节数组字符串,传到前端。
    2,这种传输图片的方式可以用于Java后台代码生成条形码二维码,直接转成base64传给前台展示。ps:(在传给前台的字符串前要加上data:image/png;base64,,这样html的img标签的src才能以图片的格式去解析字符串)

    @RequestMapping("/login")
        public String login(Map<String ,Object> map){
            byte[] data = null;
            // 读取图片字节数组
            try {
                InputStream in = new FileInputStream("E://aa.jpg");
                data = new byte[in.available()];
                in.read(data);
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 对字节数组Base64编码
            BASE64Encoder encoder = new BASE64Encoder();
            // 返回Base64编码过的字节数组字符串
            map.put("image","data:image/png;base64,"+ encoder.encode(Objects.requireNonNull(data)));
            return "login";
        }
    

    二,html端

    用的是thymeleaf模板引擎,只是单纯地展示base64编码的图片。

    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>登录</title>
    </head>
    <body>
    	<img th:src="${image}">
    </body>
    </html>
    

    三,效果

    在这里插入图片描述

    展开全文
  • 主要为大家详细介绍了基于Java文件输入输出流实现文件上传下载功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java文件流转换大全

    千次阅读 2019-03-28 11:30:55
    Java中,文件的输入和输出是通过流(Stream)来实现的。一个流,必有源端和目的端,它们可以是计算机内存的某些区域,也可以是磁盘文件,甚至可以是 Internet 上的某个 URL。对于流而言,我们不用关心数据是如何...

    一、概念
    在Java中,文件的输入和输出是通过流(Stream)来实现的。一个流,必有源端和目的端,它们可以是计算机内存的某些区域,也可以是磁盘文件,甚至可以是 Internet 上的某个 URL。对于流而言,我们不用关心数据是如何传输的,只需要向源端输入数据,从目的端获取数据即可。
    流按照处理数据的单位,可以分为字节流和字符流。字节流的处理单位是字节,通常用来处理二进制文件,例如音乐、图片文件等。而字符流的处理单位是字符,因为Java采用Unicode编码,Java字符流处理的即为Unicode字符,所以在操作汉字、国际化等方面,字符流具有优势。
    二、读写流
    流就是管道,向管道里面写数据用输出流:write
    从管道里面读数据,用输入流:read
    流的分类:
    流,按照不同的维度有不同的分类,按照从流中每次读取数据单位不同,划分为字节流字符流。按照流-对应操作的角色的不同(是IO设备,还是其他流)是否能够直接向特定的IO设备如文件、网络、磁盘等,能够直接与这些进行读写的称之为节点流,对节点流进一步封装的流,通过封装后的流来实现读写功能,处理流也被称为高级流。
    三、流的特点
    1、流和数组不一样,不能通过索引读写数据。在流中,你也不能像数组那样前后移动读取数据,除非使用RandomAccessFile 处理文件。
    2、流仅仅只是一个连续的数据流。流中的数据只能够顺序访问。当达到流末尾时,返回-1。
    3、InputStream的read()方法返回一个字节大小,返回值的范围在0到255之间。
    4、Reader的read()方法返回一个字符,会根据文本的编码,一次读取一个或者多个字节,返回值的范围在0到65535之间。
    5、read(byte[])会尝试读取与给定字节数组容量一样大的字节数,返回值int表示已经读取过的字节数。如果InputStream内可读的数据不足以填满字节数组,那么数组剩余的部分将包含本次读取之前的数据。记得检查有多少数据实际被写入到了字节数组中。
    6、read(byte, int offset, int length)同样将数据读取到字节数组中,不同的是,该方法从数组的offset位置开始,并且最多将length个字节写入到数组中。同样地,read(byte, int offset, int length)方法返回一个int变量,表示有多少字节已经被写入到字节数组中,所以请记得在读取数据前检查上一次调用read(byte, int offset, int length)的返回值。

    import java.io.*;
     
    /**
     * Created by Briario on 2019/3/27 20:15
     */
    public class FileStreamOperate {
     
        public static final String READ_UTF8_FILE_PATH = "D:\\input-utf8.txt";
        public static final String READ_UNICODE_FILE_PATH = "D:\\input-unicode.txt";
        public static final String WRITE_BYTES_FILE_PATH = "D:\\output-bytes.txt";
        public static final String WRITE_CHARS_FILE_PATH = "D:\\output-char.txt";
     
     
        /**
         * 按照字节流的方式读取文件内容
         *
         * Step 1.根据文件路径,构建文件对象
         * Step 2.创建输入流用来读取文件内容
         * Step 3.创建字节数组来存放读取内容
         * Step 4.关闭读取文件的输入流
         *
         * @return
         */
        public void readFileByFileInputStream() {
            System.out.println("=== readFileByFileInputStream Start ===");
            // 构建文件对象
            File inputFile = new File(READ_UTF8_FILE_PATH);
            // 初始化输入流
            InputStream inputStream = null;
            try {
                // 创建字节输入流
                inputStream = new FileInputStream(inputFile);
                // 读取到1KB字节数组中
                byte[] buffer = new byte[100];
                // 每次读取的字节数
                int readLength;
                // 读取数据并放到buffer数组中
                while ((readLength = inputStream.read(buffer)) != -1) {
                    // UTF-8为变长编码,一个汉字占3个字节
                    System.out.println("本次读取" + readLength + "个字节数据内容为:" + new String(buffer));
                }
            } catch (FileNotFoundException e) {
                // 文件未找到时异常处理
                e.printStackTrace();
            } catch (IOException e) {
                // 读取过程中,删除文件会出此异常
                e.printStackTrace();
            } finally {
                if (inputStream != null) {
                    try {
                        // 关闭流过程,也有可能出现异常
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("=== readFileByFileInputStream End ===");
        }
     
        /**
         * 按照字符流的方式读取文件内容
         *
         * Step 1.根据文件路径,构建文件对象
         * Step 2.创建字符输入流读取文件内容
         * Step 3.创建字符数组来存放读取内容
         * Step 4.关闭读取文件的字符输入流
         *
         * @return
         */
        public void readFileByFileReader(){
            System.out.println("=== readFileByFileReader Start ===");
            // 根据路径拿到文件对象
            File file = new File(READ_UTF8_FILE_PATH);
            // 初始化字符输入流
            Reader fileReader = null;
            // 初始化存放读取内容的字符数组
            char[] charArray = new char[100];
            // 初始化一个字符
            char once;
            try {
                fileReader = new FileReader(file);
                // 一次读取一个数组长度的字符串
                fileReader.read(charArray);
                System.out.println(charArray);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fileReader != null) {
                    try {
                        // 关闭流过程,也有可能出现异常
                        fileReader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("=== readFileByFileReader End ===");
        }
     
        /**
         * 通过字节流的方式写入信息到文件
         *
         * Step 1.根据文件路径,构建文件对象
         * Step 2.创建字节输出流写出信息到文件
         * Step 3.构造待写出的内容,并转为字节数组
         * Step 4.关闭读取文件的字符输出流
         */
        public void writeFileByFileOutputStream() {
            System.out.println("=== writeFileByFileOutputStream Start ===");
            // 创建写出文件
            File file = new File(WRITE_BYTES_FILE_PATH);
            // 初始化字节输出流
            OutputStream outputStream = null;
            // 写出内容
            String outInfo = "写出测试";
            // 转成字节数组
            byte[] byteArray = outInfo.getBytes();
            try {
                // 创建输出字节流
                outputStream = new FileOutputStream(file);
                outputStream.write(byteArray);
                System.out.println("按照字节流成功写出内容:"+outInfo);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outputStream != null) {
                    try {
                        // 关闭写出流时,注意抓异常
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("=== writeFileByFileOutputStream End ===");
        }
     
        /**
         * 通过字符流的方式写入信息到文件
         *
         * Step 1.根据文件路径,构建文件对象
         * Step 2.创建字符输出流写出信息到文件
         * Step 3.构造待写出的内容,并转为字符数组
         * Step 4.关闭读取文件的字符输出流
         */
        public void writeFileByFileWriter(){
            System.out.println("=== writeFileByFileWriter Start ===");
            // 创建写出文件
            File file = new File(WRITE_CHARS_FILE_PATH);
            // 初始化字符输出流
            Writer fileWriter = null;
            String strInfo = "字符写出数据";
            try {
                // 创建输出字符流
                fileWriter = new FileWriter(file);
                // 写出内容
                fileWriter.write(strInfo);
                System.out.println("按照字符流成功写出内容:"+strInfo);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fileWriter != null){
                    try {
                        // 关闭写出流时,注意抓异常
                        fileWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("=== writeFileByFileWriter End ===");
        }
     
        /**
         * 任意读取文件内容
         */
        public void randomAccessFile(){
            System.out.println("=== randomAccessFile Start ===");
            File file = new File(READ_UTF8_FILE_PATH);
            try {
                RandomAccessFile randomAccessFile = new RandomAccessFile(file,"r");
                // 获取文件当前的指针位置
                System.out.println("file now pointer is "+randomAccessFile.getFilePointer());
                // 将文件指针设置到指定位置(绝对位置)
                randomAccessFile.seek(3);
                // 相对位置,相对于当前的位置,
                randomAccessFile.skipBytes(3);
                System.out.println("file now pointer is "+randomAccessFile.getFilePointer());
                // 字节数组
                byte[] buffer = new byte[17];
                // off是指的写到buffer的数组的起始位置
                randomAccessFile.read(buffer,0,buffer.length);
                System.out.println(new String(buffer));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("=== randomAccessFile End ===");
        }
     
        /**
         * 通过字节流的方式将文件内容拷贝到另一个文件中
         *
         * Step 1.根据文件路径,构建源文件对象
         * Step 2.根据文件路径,构造目的文件对象
         * Step 3.创建字节输入流从源文件中读取信息
         * Step 4.将读入到内存的信息再写出到目的文件中
         * Step 5.拷贝完成后关闭输入输出流
         */
        public void copyFile() {
            System.out.println("=== copyFile Start ===");
            // 输入文件对象
            File inFile = new File(READ_UTF8_FILE_PATH);
            // 输出文件对象
            File outFile = new File(WRITE_BYTES_FILE_PATH);
            // 初始化输入流
            InputStream inputStream = null;
            // 初始化输出流
            OutputStream outputStream = null;
            try {
                // 将输入流怼到输入文件,使程序内存与磁盘建立联系
                inputStream = new FileInputStream(inFile);
                // 将输出流怼到输出文件,使程序内存与磁盘建立联系
                outputStream = new FileOutputStream(outFile);
                while (true) {
                    // 读取信息到内存
                    int temp = inputStream.read();
                    // 拷贝完成
                    if (temp == -1) {
                        break;
                    }
                    // 将内容拷贝到输出文件中
                    outputStream.write(temp);
                }
                System.out.println("拷贝文件成功完成");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (inputStream != null) {
                    try {
                        // 关闭输入流异常后,也要保证输出流关闭
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (outputStream != null) {
                            try {
                                outputStream.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
            System.out.println("=== copyFile End ===");
        }
     
        public static void main(String[] args) {
            FileStreamOperate fileStreamOperate = new FileStreamOperate();
            // 按照字节流读取的话,一个汉字两个字节
            fileStreamOperate.readFileByFileInputStream();
            // 按照字符读取,java Unicode编码一个字符(不论字母还是汉字)两个字节
            fileStreamOperate.readFileByFileReader();
            // 采用任意读取的方式读取文件信息
            fileStreamOperate.randomAccessFile();
            // 按照字节流的方式写信息到文件
            fileStreamOperate.writeFileByFileOutputStream();
            // 按照字符流的方式写信息到文件
            fileStreamOperate.writeFileByFileWriter();
            // 拷贝文件
            fileStreamOperate.copyFile();
        }
    }  
    
    展开全文
  • 主要介绍了Java实现图片转换PDF文件的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JavaBase64流转文件

    2020-12-18 09:58:52
    * @Description:TODO(base64流转文件) * @param base64 流 * @param fileName 文件名字得有后缀 * @param savePath 保存路径末尾注意//结尾 * @return 图片路径 */ public static String base64ToFile...
  • base64图片流转为MultipartFile文件 java后台

    千次阅读 热门讨论 2018-07-24 09:30:48
    base64," + "base64图片字符串"; MultipartFile file = BASE64DecodedMultipartFile.base64ToMultipart(avatar); //得到输入流 InputStream inputStream = file.getInputStream(); 得到流就可以保存或传输了 有...
  • java使用了itext7将PDF文件转成png图片格式,里面有demo可以直接运行,希望给需要的朋友带来帮助,谢谢支持!
  • 通常从界面上传的文件,后台接口都用MultipartFile格式的文件流接收,如果要直接对物理磁盘目录里的文件进行操作,则只能实用File流进行操作,有时由于一些定制化的需求,需要对File流和MultipartFile流转换,笔者...
  • Java实现pdf文件图片

    千次阅读 2020-08-24 22:07:21
    Java实现pdf文件转换为图片 可根据自己的逻辑进行修改 pom依赖 <!-- https://mvnrepository.com/artifact/org.apache.pdfbox/pdfbox --> <dependency> <groupId>org.apache.pdfbox</groupId&...
  • Java流转化为文件

    千次阅读 2016-01-26 10:06:53
    import java.io.ByteArrayInputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;.../*** 将二进制流转换成图片文件* @author 晚风工作室 www.soservers.com**
  • Java实现字节流与图片的转化Java源码
  • java实现图片转pdf文件

    2021-01-04 16:35:47
    答案当然是不能啊,我的贫贱怎么能让我花这钱呢~~~突然脑壳一亮,截个图直接把图片转为pdf文件不就完事了吗,说干就干: 今天记录个小知识点,主要是将图片转为pdf文档。 首先引入依赖: <dependency> <...
  • 用于利用Java程序将图片转换为Base64编码。简单易懂。
  • java转换图片

    2014-02-18 12:32:41
    图片转化为base编码,然后在转化为图片
  • public static String storePic(MultipartFile file) { String fileName = file.getOriginalFilename();... // 保存文件 return fileName; } catch (Exception e) { e.printStackTrace(); return "false"; } }
  • 主要介绍了Java实现将png格式图片转换成jpg格式图片的方法,涉及java文件读写及图形创建等相关操作技巧,需要的朋友可以参考下
  • JAVA--将二进制流转换成图片文件

    万次阅读 热门讨论 2014-01-27 17:26:27
    import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream;... * 将二进制流转换成图片文件 * @author 晚风工作室 www.soserve
  • Java实现PDF文件转换为图片

    千次阅读 2020-09-02 23:05:59
    前几天写了一篇博客Java实现图片转换PDF文件,在博客下方有同学评论是否能够将PDF文件转换为图片,所以今天就在这里写了一个将PDF文件转换为图片的简单系统。
  • Java-图片BLOB的存取DEMO

    2018-08-29 09:44:48
    20180828开发,提供了三种通过JDBC实现图片存储到BLOB的方式: 1、com.ztf:实现小页面,实现 指定保存的图片+打开指定编号图片 2、com.ub:实现简单的插入及读取操作,读取后的BLOB可以生成新图片,并使用JFrame...
  • Java中输入流转字节数组输入流转字节数组应用场景 输入流转字节数组 /** * @param is 输入流 * @return 将输入流转为字节数组 */ public static byte[] streamToByte(InputStream is) { ...
  • java如何将 图片路径转换为DestFile文件流? 话不多说,直接上代码!! public static File getFile(String url) throws Exception { //对本地文件命名 String fileName = url.substring(url.lastIndexOf("."),url....
  • java 图片转字节流 字节流转图片

    千次阅读 2011-03-23 11:38:29
    最近做一个活动,需要上传logo并压缩图片到适合的尺寸,但是这次由于给予使用率不高,所以想把图片压缩存到数据库里面,然后再前台通过流将图片转换回来 主要使用了java的   &lt;dependency&gt;  &...
  • JAVA_将二进制流转换成图片文件

    千次阅读 2013-05-08 17:10:00
    * 将二进制流转换成图片文件 009 * @author 晚风工作室 www.soservers.com 010 * 011 */ 012 013 ...
  • 首先在实现时需要清楚,图片及文本都是一个个字节组成,所以我们读取有效的字节将其写入文件就可以实现相互转换。  public class txtPngDemo{  //将图片转为文本文件 @Test public void jpg2Txt()throws Ex
  • JAVA图片与字节流的相互转换

    万次阅读 2019-01-16 22:41:43
    今天我们学习:java图片与字节流的相互转换。 场景:用户端上传一个图片图片转换成字节流,字节流使用Base64编码,然后服务端收到Base64编码后的字符串,然后转换成图片,最终实现图片的传输。 为什么要...
  • 这个是最简单的图片转化为二进制,再将二进制转化为图片 public static void main(String[] args) { //图片转化为二进制 byte[] imageBytes = null; try (FileInputStream fileInputStream = new ...
  • java文件转base64

    2020-12-29 17:40:58
    public static String encodeImageToBase64ForNetUrl(String imageUrl) {// 将图片文件转化为字节数组字符串,并对其进行Base64编码处理 ByteArrayOutputStream outputStream = null; try { URL url = new URL...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,214
精华内容 3,685
关键字:

java文件流转图片

java 订阅