• io遍历读取linux服务器文件


    package com.fyun.common.utils.util;

    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;

    public class ReadFromFile {

    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static byte[] readFileByBytes(String fileName) {
    File file = new File(fileName);
    InputStream in = null;
    // try {
    // System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    // // 一次读一个字节
    // in = new FileInputStream(file);
    // int tempbyte=0;
    // while ((tempbyte = in.read()) != -1) {
    // System.out.write(tempbyte);
    // }
    // in.close();
    // } catch (IOException e) {
    // e.printStackTrace();
    // return;
    // }
    try {
    System.out.println("以字节为单位读取文件内容,一次读多个字节:");
    // 一次读多个字节
    byte[] tempbytes = new byte[1024];
    int byteread = 0;
    in = new FileInputStream(fileName);
    ReadFromFile.showAvailableBytes(in);
    // 读入多个字节到字节数组中,byteread为一次读入的字节数
    while ((byteread = in.read(tempbytes)) != -1) {
    System.out.write(tempbytes, 0, byteread);
    return tempbytes;
    }
    } catch (Exception e1) {
    e1.printStackTrace();
    } finally {
    if (in != null) {
    try {
    in.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }

    /**
    * 以字符为单位读取文件,常用于读文本,数字等类型的文件
    */
    public static byte[] readFileByChars(String fileName) {
    File file = new File(fileName);
    Reader reader = null;
    // try {
    // System.out.println("以字符为单位读取文件内容,一次读一个字节:");
    // // 一次读一个字符
    // reader = new InputStreamReader(new FileInputStream(file));
    // int tempchar;
    // while ((tempchar = reader.read()) != -1) {
    // // 对于windows下, 这两个字符在一起时,表示一个换行。
    // // 但如果这两个字符分开显示时,会换两次行。
    // // 因此,屏蔽掉 ,或者屏蔽 。否则,将会多出很多空行。
    // if (((char) tempchar) != ' ') {
    // System.out.print((char) tempchar);
    // }
    // }
    // reader.close();
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    try {
    System.out.println("以字符为单位读取文件内容,一次读多个字节:");
    // 一次读多个字符
    char[] tempchars = new char[1024];
    int charread = 0;
    reader = new InputStreamReader(new FileInputStream(fileName));
    // 读入多个字符到字符数组中,charread为一次读取字符数
    while ((charread = reader.read(tempchars)) != -1) {
    // 同样屏蔽掉 不显示
    if ((charread == tempchars.length)
    && (tempchars[tempchars.length - 1] != ' ')) {
    return getBytes(tempchars);

    } else {
    for (int i = 0; i < charread; i++) {
    if (tempchars[i] == ' ') {
    continue;
    } else {
    System.out.print(tempchars[i]);
    }
    }
    }
    }

    } catch (Exception e1) {
    e1.printStackTrace();
    }
    finally {
    if (reader != null) {
    try {
    reader.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }
    public static byte[] getBytes(char[] chars) {
    Charset cs = Charset.forName("UTF-8");
    CharBuffer cb = CharBuffer.allocate(chars.length);
    cb.put(chars);
    cb.flip();
    ByteBuffer bb = cs.encode(cb);
    return bb.array();
    }
    /**
    * 以行为单位读取文件,常用于读面向行的格式化文件
    */
    public static void readFileByLines(String fileName) {
    File file = new File(fileName);
    BufferedReader reader = null;
    try {
    System.out.println("以行为单位读取文件内容,一次读一整行:");
    reader = new BufferedReader(new FileReader(file));
    String tempString = null;
    int line = 1;
    // 一次读入一行,直到读入null为文件结束
    while ((tempString = reader.readLine()) != null) {
    // 显示行号
    System.out.println("line " + line + ": " + tempString);
    line++;
    }
    reader.close();
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    if (reader != null) {
    try {
    reader.close();
    } catch (IOException e1) {
    }
    }
    }
    }

    /**
    * 随机读取文件内容
    */
    public static void readFileByRandomAccess(String fileName) {
    RandomAccessFile randomFile = null;
    try {
    System.out.println("随机读取一段文件内容:");
    // 打开一个随机访问文件流,按只读方式
    randomFile = new RandomAccessFile(fileName, "r");
    // 文件长度,字节数
    long fileLength = randomFile.length();
    // 读文件的起始位置
    int beginIndex = (fileLength > 4) ? 4 : 0;
    // 将读文件的开始位置移到beginIndex位置。
    randomFile.seek(beginIndex);
    byte[] bytes = new byte[10];
    int byteread = 0;
    // 一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。
    // 将一次读取的字节数赋给byteread
    while ((byteread = randomFile.read(bytes)) != -1) {
    System.out.write(bytes, 0, byteread);
    }
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    if (randomFile != null) {
    try {
    randomFile.close();
    } catch (IOException e1) {
    }
    }
    }
    }

    /**
    * 显示输入流中还剩的字节数
    */
    private static void showAvailableBytes(InputStream in) {
    try {
    System.out.println("当前字节输入流中的字节数为:" + in.available());
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static byte[] getpdfinputsteam(String fileName) throws FileNotFoundException {
    File file = new File(fileName);
    InputStream in = new FileInputStream(file);
    OutputStream out=null;
    byte[] bytes1 = new byte[2048];
    try {
    System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    // 一次读一个字节
    byte[] bytes = new byte[2048];
    int a=0;
    while ((a=in.read(bytes))!=-1){

    }
    return bytes;
    } catch (Exception e1) {
    e1.printStackTrace();
    } finally {
    if (in != null) {
    try {
    in.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }
    public static void main(String[] args) throws IOException {
    // String fileName = "C:/temp/newTemp.txt";
    // ReadFromFile.readFileByBytes(fileName);
    // ReadFromFile.readFileByChars(fileName);
    // ReadFromFile.readFileByLines(fileName);
    // ReadFromFile.readFileByRandomAccess(fileName);
    readfileBypdf("D:\test", "11.pdf");
    }
    /**
    * zr遍历循环查找文件
    *
    */

    public static byte[] readfileBypdf(String filepath, String pdfsource) throws FileNotFoundException, IOException {
    try {

    File file = new File(filepath);
    if (!file.isDirectory()) {
    System.out.println("文件");
    System.out.println("path=" + file.getPath());
    System.out.println("absolutepath=" + file.getAbsolutePath());
    System.out.println("name=" + file.getName());

    } else if (file.isDirectory()) {
    System.out.println("文件夹");
    String[] filelist = file.list();
    for (int i = 0; i < filelist.length; i++) { File readfile =
    new File(filepath + filelist[i]);
    if (!readfile.isDirectory()) { System.
    out.println("path=" + readfile.getPath());
    System.out.println("absolutepath="
    + readfile.getAbsolutePath());
    System.out.println("name=" + readfile.getName());
    //读取文件
    if (StringUtils.isNotEmpty(pdfsource) && (filelist[i].equals(pdfsource))){ System.
    out.println("readfile.getAbsolutePath()====>" + readfile.getAbsolutePath());
    return FileHelper.getPdf(readfile.getAbsolutePath());
    // return readFileByBytes(readfile.getAbsolutePath());
    } }

    else if (readfile.isDirectory()) {
    readfileBypdf(filepath + "\" + filelist[i], pdfsource);
    } } } }




    catch (FileNotFoundException e) { System.
    out.println("readfile() Exception:" + e.getMessage());
    }
    return null;
    }

    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static void readFileBypdf(String fileName) { File file =
    new File(fileName);
    InputStream in = null;
    try { System.
    out.println("以字节为单位读取文件内容,一次读一个字节:");
    // 一次读一个字节
    in = new FileInputStream(file);
    int tempbyte;
    while ((tempbyte = in.read()) != -1) { System.
    out.write(tempbyte);
    } in.close()
    ;
    } catch (IOException e) { e.printStackTrace()
    ;
    return;
    }
    try { System.
    out.println("以字节为单位读取文件内容,一次读多个字节:");
    // 一次读多个字节
    byte[] tempbytes = new byte[100];
    int byteread = 0;
    in = new FileInputStream(fileName);
    ReadFromFile.showAvailableBytes(in);
    // 读入多个字节到字节数组中,byteread为一次读入的字节数
    while ((byteread = in.read(tempbytes)) != -1) { System.
    out.write(tempbytes, 0, byteread);
    } }
    catch (Exception e1) { e1.printStackTrace()
    ;
    } finally {
    if (in != null) {
    try { in.close()
    ;
    } catch (IOException e1) { } } } }




    /**
    *本地路径转字节数组
    */
    public static byte[] getPhoto(String imgPath) { File img =
    new File(imgPath);
    ByteArrayOutputStream img_stream = new ByteArrayOutputStream();
    try { BufferedImage bi = ImageIO.
    read(img);
    ImageIO.write(bi, "png", img_stream);
    byte[] bytes = img_stream.toByteArray();
    img_stream.close();
    return bytes;
    } catch (IOException e) { e.getStackTrace()
    ;
    }
    return new byte[0];
    }

    public static byte[] getPdf(String imgPath) { ByteArrayOutputStream img_stream =
    new ByteArrayOutputStream();
    try { File file =
    new File(imgPath);
    InputStream inputStream = new FileInputStream(file);
    BufferedInputStream bis = new BufferedInputStream(inputStream);
    int a=0;
    while ((a=bis.read())!=-1){ img_stream.write(a)
    ;
    }
    byte[] bytes = img_stream.toByteArray();
    img_stream.close();
    return bytes;
    } catch (IOException e) { e.getStackTrace()
    ;
    }
    return new byte[0];
    }
    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /**
    *zr 下载网络url byte[]
    *
    */
    public void saveToFile(String destUrl) { FileOutputStream fos =
    null;
    BufferedInputStream bis = null;
    HttpURLConnection httpUrl = null;
    URL url = null;
    int BUFFER_SIZE = 1024;
    byte[] buf = new byte[BUFFER_SIZE];
    int size = 0;
    try { url =
    new URL(destUrl);
    httpUrl = (HttpURLConnection) url.openConnection();
    httpUrl.connect();
    bis = new BufferedInputStream(httpUrl.getInputStream());
    fos = new FileOutputStream("c:\haha.gif");
    while ((size = bis.read(buf)) != -1) { fos.write(buf
    , 0, size);
    } fos.flush()
    ;
    } catch (IOException e) { }
    catch (ClassCastException e) { }
    finally {
    try { fos.close()
    ;
    bis.close();
    httpUrl.disconnect();
    } catch (IOException e) { }
    catch (NullPointerException e) { } } }





    public static InputStream DownpdfnetUrl(String url) throws Exception { String body =
    "pdf为您签署的todayefinance合同";
    String mongodbUrl="192.168.1.1";
    try { URL urlpath =
    null;
    HttpURLConnection httpUrl = null;
    System.out.println("mongodbUrl=====>>>>>>>"+mongodbUrl);
    if(StringUtils.isEmpty(mongodbUrl)){ } urlpath =


    new URL("http://47.96.111.214/pics/" + url);
    httpUrl = (HttpURLConnection) urlpath.openConnection();
    httpUrl.connect();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    BufferedInputStream bis = new BufferedInputStream(httpUrl.getInputStream());
    int a = 0;
    while ((a = bis.read()) != -1) { outputStream.write(a)
    ;
    }
    byte[] bytes = outputStream.toByteArray();
    InputStream sbs = new ByteArrayInputStream(bytes);
    return sbs;
    } catch (FileNotFoundException e) { e.printStackTrace()
    ;
    } catch (IOException e) { e.printStackTrace()
    ;
    } finally { }


    return null;
    }}

    package com.fyun.common.utils.util;
    
    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;
    
    public class ReadFromFile {
    
        /**
         * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
         */
        public static byte[] readFileByBytes(String fileName) {
            File file = new File(fileName);
            InputStream in = null;
    //        try {
    //            System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    //            // 一次读一个字节
    //            in = new FileInputStream(file);
    //            int tempbyte=0;
    //            while ((tempbyte = in.read()) != -1) {
    //                System.out.write(tempbyte);
    //            }
    //            in.close();
    //        } catch (IOException e) {
    //            e.printStackTrace();
    //            return;
    //        }
            try {
                System.out.println("以字节为单位读取文件内容,一次读多个字节:");
                // 一次读多个字节
                byte[] tempbytes = new byte[1024];
                int byteread = 0;
                in = new FileInputStream(fileName);
                ReadFromFile.showAvailableBytes(in);
                // 读入多个字节到字节数组中,byteread为一次读入的字节数
                while ((byteread = in.read(tempbytes)) != -1) {
                    System.out.write(tempbytes, 0, byteread);
                    return tempbytes;
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e1) {
                    }
                }
            }
            return null;
        }
    
        /**
         * 以字符为单位读取文件,常用于读文本,数字等类型的文件
         */
        public static byte[] readFileByChars(String fileName) {
            File file = new File(fileName);
            Reader reader = null;
    //        try {
    //            System.out.println("以字符为单位读取文件内容,一次读一个字节:");
    //            // 一次读一个字符
    //            reader = new InputStreamReader(new FileInputStream(file));
    //            int tempchar;
    //            while ((tempchar = reader.read()) != -1) {
    //                // 对于windows下,
    这两个字符在一起时,表示一个换行。
    //                // 但如果这两个字符分开显示时,会换两次行。
    //                // 因此,屏蔽掉
    ,或者屏蔽
    。否则,将会多出很多空行。
    //                if (((char) tempchar) != '
    ') {
    //                    System.out.print((char) tempchar);
    //                }
    //            }
    //            reader.close();
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
            try {
                System.out.println("以字符为单位读取文件内容,一次读多个字节:");
                // 一次读多个字符
                char[] tempchars = new char[1024];
                int charread = 0;
                reader = new InputStreamReader(new FileInputStream(fileName));
                // 读入多个字符到字符数组中,charread为一次读取字符数
                while ((charread = reader.read(tempchars)) != -1) {
                    // 同样屏蔽掉
    不显示
                    if ((charread == tempchars.length)
                            && (tempchars[tempchars.length - 1] != '
    ')) {
                      return   getBytes(tempchars);
    
                    } else {
                        for (int i = 0; i < charread; i++) {
                            if (tempchars[i] == '
    ') {
                                continue;
                            } else {
                                System.out.print(tempchars[i]);
                            }
                        }
                    }
                }
    
            } catch (Exception e1) {
                e1.printStackTrace();
            }
            finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
            return null;
        }
        public static byte[] getBytes(char[] chars) {
            Charset cs = Charset.forName("UTF-8");
            CharBuffer cb = CharBuffer.allocate(chars.length);
            cb.put(chars);
            cb.flip();
            ByteBuffer bb = cs.encode(cb);
            return bb.array();
        }
        /**
         * 以行为单位读取文件,常用于读面向行的格式化文件
         */
        public static void readFileByLines(String fileName) {
            File file = new File(fileName);
            BufferedReader reader = null;
            try {
                System.out.println("以行为单位读取文件内容,一次读一整行:");
                reader = new BufferedReader(new FileReader(file));
                String tempString = null;
                int line = 1;
                // 一次读入一行,直到读入null为文件结束
                while ((tempString = reader.readLine()) != null) {
                    // 显示行号
                    System.out.println("line " + line + ": " + tempString);
                    line++;
                }
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }
    
        /**
         * 随机读取文件内容
         */
        public static void readFileByRandomAccess(String fileName) {
            RandomAccessFile randomFile = null;
            try {
                System.out.println("随机读取一段文件内容:");
                // 打开一个随机访问文件流,按只读方式
                randomFile = new RandomAccessFile(fileName, "r");
                // 文件长度,字节数
                long fileLength = randomFile.length();
                // 读文件的起始位置
                int beginIndex = (fileLength > 4) ? 4 : 0;
                // 将读文件的开始位置移到beginIndex位置。
                randomFile.seek(beginIndex);
                byte[] bytes = new byte[10];
                int byteread = 0;
                // 一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。
                // 将一次读取的字节数赋给byteread
                while ((byteread = randomFile.read(bytes)) != -1) {
                    System.out.write(bytes, 0, byteread);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (randomFile != null) {
                    try {
                        randomFile.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }
    
        /**
         * 显示输入流中还剩的字节数
         */
        private static void showAvailableBytes(InputStream in) {
            try {
                System.out.println("当前字节输入流中的字节数为:" + in.available());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        /**
         * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
         */
        public static byte[] getpdfinputsteam(String fileName) throws FileNotFoundException {
            File file = new File(fileName);
            InputStream in = new FileInputStream(file);
            OutputStream out=null;
            byte[] bytes1 = new byte[2048];
            try {
                System.out.println("以字节为单位读取文件内容,一次读一个字节:");
                // 一次读一个字节
                byte[] bytes = new byte[2048];
                int a=0;
                while ((a=in.read(bytes))!=-1){
    
                }
                return bytes;
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e1) {
                    }
                }
            }
            return null;
        }
        public static void main(String[] args) throws IOException {
    //        String fileName = "C:/temp/newTemp.txt";
    //        ReadFromFile.readFileByBytes(fileName);
    //        ReadFromFile.readFileByChars(fileName);
    //        ReadFromFile.readFileByLines(fileName);
    //        ReadFromFile.readFileByRandomAccess(fileName);
            readfileBypdf("D:\test", "11.pdf");
        }
        /**
         *  zr遍历循环查找文件
         *
         */
    
        public static byte[] readfileBypdf(String filepath, String pdfsource) throws FileNotFoundException, IOException {
            try {
    
                File file = new File(filepath);
                if (!file.isDirectory()) {
                    System.out.println("文件");
                    System.out.println("path=" + file.getPath());
                    System.out.println("absolutepath=" + file.getAbsolutePath());
                    System.out.println("name=" + file.getName());
    
                } else if (file.isDirectory()) {
                    System.out.println("文件夹");
                    String[] filelist = file.list();
                    for (int i = 0; i < filelist.length; i++) {
                        File readfile = new File(filepath  + filelist[i]);
                        if (!readfile.isDirectory()) {
                            System.out.println("path=" + readfile.getPath());
                            System.out.println("absolutepath="
                                    + readfile.getAbsolutePath());
                            System.out.println("name=" + readfile.getName());
                            //读取文件
                            if (StringUtils.isNotEmpty(pdfsource) && (filelist[i].equals(pdfsource))){
                                System.out.println("readfile.getAbsolutePath()====>" + readfile.getAbsolutePath());
                         return    FileHelper.getPdf(readfile.getAbsolutePath());
    //                            return    readFileByBytes(readfile.getAbsolutePath());
                            }
    
                        } else if (readfile.isDirectory()) {
                            readfileBypdf(filepath + "\" + filelist[i], pdfsource);
                        }
                    }
    
                }
    
            } catch (FileNotFoundException e) {
                System.out.println("readfile()   Exception:" + e.getMessage());
            }
                  return null;
        }
    
        /**
         * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
         */
        public static void readFileBypdf(String fileName) {
            File file = new File(fileName);
            InputStream in = null;
            try {
                System.out.println("以字节为单位读取文件内容,一次读一个字节:");
                // 一次读一个字节
                in = new FileInputStream(file);
                int tempbyte;
                while ((tempbyte = in.read()) != -1) {
                    System.out.write(tempbyte);
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
            try {
                System.out.println("以字节为单位读取文件内容,一次读多个字节:");
                // 一次读多个字节
                byte[] tempbytes = new byte[100];
                int byteread = 0;
                in = new FileInputStream(fileName);
                ReadFromFile.showAvailableBytes(in);
                // 读入多个字节到字节数组中,byteread为一次读入的字节数
                while ((byteread = in.read(tempbytes)) != -1) {
                    System.out.write(tempbytes, 0, byteread);
                }
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e1) {
                    }
                }
            }
        }
        /**
         *本地路径转字节数组
         */
        public static byte[] getPhoto(String imgPath) {
            File img = new File(imgPath);
            ByteArrayOutputStream img_stream = new ByteArrayOutputStream();
            try {
                BufferedImage bi = ImageIO.read(img);
                ImageIO.write(bi, "png", img_stream);
                byte[] bytes = img_stream.toByteArray();
                img_stream.close();
                return bytes;
            } catch (IOException e) {
                e.getStackTrace();
            }
            return new byte[0];
        }
    
        public static byte[] getPdf(String imgPath) {
            ByteArrayOutputStream img_stream = new ByteArrayOutputStream();
            try {
                File file = new File(imgPath);
                InputStream inputStream = new FileInputStream(file);
                BufferedInputStream bis = new BufferedInputStream(inputStream);
                int a=0;
                while ((a=bis.read())!=-1){
                    img_stream.write(a);
                }
                byte[] bytes = img_stream.toByteArray();
                img_stream.close();
                return bytes;
            } catch (IOException e) {
                e.getStackTrace();
            }
            return new byte[0];
        }
        //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
        /**
         *zr 下载网络url 转byte[]
         *
         */
        public void saveToFile(String destUrl) {
            FileOutputStream fos = null;
            BufferedInputStream bis = null;
            HttpURLConnection httpUrl = null;
            URL url = null;
            int BUFFER_SIZE = 1024;
            byte[] buf = new byte[BUFFER_SIZE];
            int size = 0;
            try {
                url = new URL(destUrl);
                httpUrl = (HttpURLConnection) url.openConnection();
                httpUrl.connect();
                bis = new BufferedInputStream(httpUrl.getInputStream());
                fos = new FileOutputStream("c:\haha.gif");
                while ((size = bis.read(buf)) != -1) {
                    fos.write(buf, 0, size);
                }
                fos.flush();
            } catch (IOException e) {
            } catch (ClassCastException e) {
            } finally {
                try {
                    fos.close();
                    bis.close();
                    httpUrl.disconnect();
                } catch (IOException e) {
                } catch (NullPointerException e) {
                }
            }
        }
    
    
        public static InputStream DownpdfnetUrl(String url) throws Exception {
            String body = "此pdf为您签署的todayefinance合同";
            String mongodbUrl="192.168.1.1";
            try {
                URL urlpath = null;
                HttpURLConnection httpUrl = null;
                System.out.println("mongodbUrl是=====>>>>>>>"+mongodbUrl);
                if(StringUtils.isEmpty(mongodbUrl)){
    
                }
                urlpath = new URL("http://47.96.111.214/pics/" + url);
                httpUrl = (HttpURLConnection) urlpath.openConnection();
                httpUrl.connect();
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                BufferedInputStream bis = new BufferedInputStream(httpUrl.getInputStream());
                int a = 0;
                while ((a = bis.read()) != -1) {
                    outputStream.write(a);
                }
                byte[] bytes = outputStream.toByteArray();
                InputStream sbs = new ByteArrayInputStream(bytes);
                return sbs;
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
    
            }
            return null;
        }
    }
    
    
    
     
    package com.fyun.common.utils.util;

    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;

    public class ReadFromFile {

    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static byte[] readFileByBytes(String fileName) {
    File file = new File(fileName);
    InputStream in = null;
    // try {
    // System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    // // 一次读一个字节
    // in = new FileInputStream(file);
    // int tempbyte=0;
    // while ((tempbyte = in.read()) != -1) {
    // System.out.write(tempbyte);
    // }
    // in.close();
    // } catch (IOException e) {
    // e.printStackTrace();
    // return;
    // }
    try {
    System.out.println("以字节为单位读取文件内容,一次读多个字节:");
    // 一次读多个字节
    byte[] tempbytes = new byte[1024];
    int byteread = 0;
    in = new FileInputStream(fileName);
    ReadFromFile.showAvailableBytes(in);
    // 读入多个字节到字节数组中,byteread为一次读入的字节数
    while ((byteread = in.read(tempbytes)) != -1) {
    System.out.write(tempbytes, 0, byteread);
    return tempbytes;
    }
    } catch (Exception e1) {
    e1.printStackTrace();
    } finally {
    if (in != null) {
    try {
    in.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }

    /**
    * 以字符为单位读取文件,常用于读文本,数字等类型的文件
    */
    public static byte[] readFileByChars(String fileName) {
    File file = new File(fileName);
    Reader reader = null;
    // try {
    // System.out.println("以字符为单位读取文件内容,一次读一个字节:");
    // // 一次读一个字符
    // reader = new InputStreamReader(new FileInputStream(file));
    // int tempchar;
    // while ((tempchar = reader.read()) != -1) {
    // // 对于windows下, 这两个字符在一起时,表示一个换行。
    // // 但如果这两个字符分开显示时,会换两次行。
    // // 因此,屏蔽掉 ,或者屏蔽 。否则,将会多出很多空行。
    // if (((char) tempchar) != ' ') {
    // System.out.print((char) tempchar);
    // }
    // }
    // reader.close();
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    try {
    System.out.println("以字符为单位读取文件内容,一次读多个字节:");
    // 一次读多个字符
    char[] tempchars = new char[1024];
    int charread = 0;
    reader = new InputStreamReader(new FileInputStream(fileName));
    // 读入多个字符到字符数组中,charread为一次读取字符数
    while ((charread = reader.read(tempchars)) != -1) {
    // 同样屏蔽掉 不显示
    if ((charread == tempchars.length)
    && (tempchars[tempchars.length - 1] != ' ')) {
    return getBytes(tempchars);

    } else {
    for (int i = 0; i < charread; i++) {
    if (tempchars[i] == ' ') {
    continue;
    } else {
    System.out.print(tempchars[i]);
    }
    }
    }
    }

    } catch (Exception e1) {
    e1.printStackTrace();
    }
    finally {
    if (reader != null) {
    try {
    reader.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }
    public static byte[] getBytes(char[] chars) {
    Charset cs = Charset.forName("UTF-8");
    CharBuffer cb = CharBuffer.allocate(chars.length);
    cb.put(chars);
    cb.flip();
    ByteBuffer bb = cs.encode(cb);
    return bb.array();
    }
    /**
    * 以行为单位读取文件,常用于读面向行的格式化文件
    */
    public static void readFileByLines(String fileName) {
    File file = new File(fileName);
    BufferedReader reader = null;
    try {
    System.out.println("以行为单位读取文件内容,一次读一整行:");
    reader = new BufferedReader(new FileReader(file));
    String tempString = null;
    int line = 1;
    // 一次读入一行,直到读入null为文件结束
    while ((tempString = reader.readLine()) != null) {
    // 显示行号
    System.out.println("line " + line + ": " + tempString);
    line++;
    }
    reader.close();
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    if (reader != null) {
    try {
    reader.close();
    } catch (IOException e1) {
    }
    }
    }
    }

    /**
    * 随机读取文件内容
    */
    public static void readFileByRandomAccess(String fileName) {
    RandomAccessFile randomFile = null;
    try {
    System.out.println("随机读取一段文件内容:");
    // 打开一个随机访问文件流,按只读方式
    randomFile = new RandomAccessFile(fileName, "r");
    // 文件长度,字节数
    long fileLength = randomFile.length();
    // 读文件的起始位置
    int beginIndex = (fileLength > 4) ? 4 : 0;
    // 将读文件的开始位置移到beginIndex位置。
    randomFile.seek(beginIndex);
    byte[] bytes = new byte[10];
    int byteread = 0;
    // 一次读10个字节,如果文件内容不足10个字节,则读剩下的字节。
    // 将一次读取的字节数赋给byteread
    while ((byteread = randomFile.read(bytes)) != -1) {
    System.out.write(bytes, 0, byteread);
    }
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    if (randomFile != null) {
    try {
    randomFile.close();
    } catch (IOException e1) {
    }
    }
    }
    }

    /**
    * 显示输入流中还剩的字节数
    */
    private static void showAvailableBytes(InputStream in) {
    try {
    System.out.println("当前字节输入流中的字节数为:" + in.available());
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static byte[] getpdfinputsteam(String fileName) throws FileNotFoundException {
    File file = new File(fileName);
    InputStream in = new FileInputStream(file);
    OutputStream out=null;
    byte[] bytes1 = new byte[2048];
    try {
    System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    // 一次读一个字节
    byte[] bytes = new byte[2048];
    int a=0;
    while ((a=in.read(bytes))!=-1){

    }
    return bytes;
    } catch (Exception e1) {
    e1.printStackTrace();
    } finally {
    if (in != null) {
    try {
    in.close();
    } catch (IOException e1) {
    }
    }
    }
    return null;
    }
    public static void main(String[] args) throws IOException {
    // String fileName = "C:/temp/newTemp.txt";
    // ReadFromFile.readFileByBytes(fileName);
    // ReadFromFile.readFileByChars(fileName);
    // ReadFromFile.readFileByLines(fileName);
    // ReadFromFile.readFileByRandomAccess(fileName);
    readfileBypdf("D:\test", "11.pdf");
    }
    /**
    * zr遍历循环查找文件
    *
    */

    public static byte[] readfileBypdf(String filepath, String pdfsource) throws FileNotFoundException, IOException {
    try {

    File file = new File(filepath);
    if (!file.isDirectory()) {
    System.out.println("文件");
    System.out.println("path=" + file.getPath());
    System.out.println("absolutepath=" + file.getAbsolutePath());
    System.out.println("name=" + file.getName());

    } else if (file.isDirectory()) {
    System.out.println("文件夹");
    String[] filelist = file.list();
    for (int i = 0; i < filelist.length; i++) {
    File readfile = new File(filepath + filelist[i]);
    if (!readfile.isDirectory()) {
    System.out.println("path=" + readfile.getPath());
    System.out.println("absolutepath="
    + readfile.getAbsolutePath());
    System.out.println("name=" + readfile.getName());
    //读取文件
    if (StringUtils.isNotEmpty(pdfsource) && (filelist[i].equals(pdfsource))){
    System.out.println("readfile.getAbsolutePath()====>" + readfile.getAbsolutePath());
    return FileHelper.getPdf(readfile.getAbsolutePath());
    // return readFileByBytes(readfile.getAbsolutePath());
    }

    } else if (readfile.isDirectory()) {
    readfileBypdf(filepath + "\" + filelist[i], pdfsource);
    }
    }

    }

    } catch (FileNotFoundException e) {
    System.out.println("readfile() Exception:" + e.getMessage());
    }
    return null;
    }

    /**
    * 以字节为单位读取文件,常用于读二进制文件,如图片、声音、影像等文件。
    */
    public static void readFileBypdf(String fileName) {
    File file = new File(fileName);
    InputStream in = null;
    try {
    System.out.println("以字节为单位读取文件内容,一次读一个字节:");
    // 一次读一个字节
    in = new FileInputStream(file);
    int tempbyte;
    while ((tempbyte = in.read()) != -1) {
    System.out.write(tempbyte);
    }
    in.close();
    } catch (IOException e) {
    e.printStackTrace();
    return;
    }
    try {
    System.out.println("以字节为单位读取文件内容,一次读多个字节:");
    // 一次读多个字节
    byte[] tempbytes = new byte[100];
    int byteread = 0;
    in = new FileInputStream(fileName);
    ReadFromFile.showAvailableBytes(in);
    // 读入多个字节到字节数组中,byteread为一次读入的字节数
    while ((byteread = in.read(tempbytes)) != -1) {
    System.out.write(tempbytes, 0, byteread);
    }
    } catch (Exception e1) {
    e1.printStackTrace();
    } finally {
    if (in != null) {
    try {
    in.close();
    } catch (IOException e1) {
    }
    }
    }
    }
    /**
    *本地路径转字节数组
    */
    public static byte[] getPhoto(String imgPath) {
    File img = new File(imgPath);
    ByteArrayOutputStream img_stream = new ByteArrayOutputStream();
    try {
    BufferedImage bi = ImageIO.read(img);
    ImageIO.write(bi, "png", img_stream);
    byte[] bytes = img_stream.toByteArray();
    img_stream.close();
    return bytes;
    } catch (IOException e) {
    e.getStackTrace();
    }
    return new byte[0];
    }

    public static byte[] getPdf(String imgPath) {
    ByteArrayOutputStream img_stream = new ByteArrayOutputStream();
    try {
    File file = new File(imgPath);
    InputStream inputStream = new FileInputStream(file);
    BufferedInputStream bis = new BufferedInputStream(inputStream);
    int a=0;
    while ((a=bis.read())!=-1){
    img_stream.write(a);
    }
    byte[] bytes = img_stream.toByteArray();
    img_stream.close();
    return bytes;
    } catch (IOException e) {
    e.getStackTrace();
    }
    return new byte[0];
    }
    //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /**
    *zr 下载网络url byte[]
    *
    */
    public void saveToFile(String destUrl) {
    FileOutputStream fos = null;
    BufferedInputStream bis = null;
    HttpURLConnection httpUrl = null;
    URL url = null;
    int BUFFER_SIZE = 1024;
    byte[] buf = new byte[BUFFER_SIZE];
    int size = 0;
    try {
    url = new URL(destUrl);
    httpUrl = (HttpURLConnection) url.openConnection();
    httpUrl.connect();
    bis = new BufferedInputStream(httpUrl.getInputStream());
    fos = new FileOutputStream("c:\haha.gif");
    while ((size = bis.read(buf)) != -1) {
    fos.write(buf, 0, size);
    }
    fos.flush();
    } catch (IOException e) {
    } catch (ClassCastException e) {
    } finally {
    try {
    fos.close();
    bis.close();
    httpUrl.disconnect();
    } catch (IOException e) {
    } catch (NullPointerException e) {
    }
    }
    }


    public static InputStream DownpdfnetUrl(String url) throws Exception {
    String body = "pdf为您签署的todayefinance合同";
    String mongodbUrl="192.168.1.1";
    try {
    URL urlpath = null;
    HttpURLConnection httpUrl = null;
    System.out.println("mongodbUrl=====>>>>>>>"+mongodbUrl);
    if(StringUtils.isEmpty(mongodbUrl)){

    }
    urlpath = new URL("http://47.96.111.214/pics/" + url);
    httpUrl = (HttpURLConnection) urlpath.openConnection();
    httpUrl.connect();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    BufferedInputStream bis = new BufferedInputStream(httpUrl.getInputStream());
    int a = 0;
    while ((a = bis.read()) != -1) {
    outputStream.write(a);
    }
    byte[] bytes = outputStream.toByteArray();
    InputStream sbs = new ByteArrayInputStream(bytes);
    return sbs;
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    } finally {

    }
    return null;
    }
    }


  • 相关阅读:
    04: Dom
    03: JavaScript基础
    02: css常用属性
    01: html常用标签
    03: Memcached
    01: Redis缓存系统
    01: RabbitMQ
    04: 事件驱动、五种I/O操作、I/O多路复用select和epoll
    03: 进程、线程、协程
    [Android] 任意时刻从子线程切换到主线程的实现
  • 原文地址:https://www.cnblogs.com/zrboke/p/12566045.html
Copyright © 2020-2023  润新知