精华内容
下载资源
问答
  • 这个文件处理的实现具备的功能有:文件读取,文件写入,文件复制,文件加密以及文件解密。 其实在平时文件加密的操作中,我们可以简单的通过修改文件的后缀名来改变文件的打开方式,也就是常说的:“一定我打开的...


    这个文件处理的实现具备的功能有:文件读取,文件写入,文件复制,文件加密以及文件解密。

      其实在平时文件加密的操作中,我们可以简单的通过修改文件的后缀名来改变文件的打开方式,也就是常说的:“一定是我打开的方式不对。。。”,但是这样的操作方法就比较low(低端)。

    所以下面我们来一些比较高大上的。
       整个实例的难点应该还是在于文件的加密以及解密,对于PC里的一些不想为人知的文件往往需要加密处理。通过对文件输入流的方法调用得到文件的字节流:

        FileInputStream  fis = new FileInputStream(from);  
        int n = fis.read();  
    然后在调用文件输出流方法时对读取到的字节流进行一定的按特定意愿的处理后并输出:

        //循环写入  
                while(n!=-1){//加密算法,可行定义,与解密算法相逆  
                    if(day%height*n != 1){  
                        fos.write(n+height);  
        //day和height为密码           
                                     }else{  
                        fos.write(n);  
                    }  
                    n=fis.read();  
                }  

     这样就可以在文件输出时出现字节流的“误差”,原文本被“错乱”的解码方式所还原,便会生成乱码或者一堆看不懂的文件。其中的参数day和height是密码和校验码,可以是生日和身高的整型数据组合。

    加密和解密的方法:

        /** 
             * 文件加密传输的方法 
             * @param from原文件(带绝对路径) 
             * @param to复制后文件(带绝对路径) 
             * @throws Exception抛出异常 
             */  
            public void JiaMi(String from,String to,int day,int height) throws Exception{  
                FileInputStream  fis = new FileInputStream(from);  
                FileOutputStream fos = new FileOutputStream(to,false);  
                int n = fis.read();  
                int count=0;  
                //循环写入  
                while(n!=-1){//加密算法,可行定义,与解密算法相逆  
                    if(day%height*n != 1){  
                        fos.write(n+height);  
                    }else{  
                        fos.write(n);  
                    }  
                    n=fis.read();  
                }  
                fis.close();  
                fos.close();  
            }  
            /** 
             * 文件解密接收的方法 
             * @param from原文件(带绝对路径) 
             * @param to复制后文件(带绝对路径) 
             * @throws Exception抛出异常 
             */  
            public void JieMi(String from,String to,int day,int height) throws Exception{  
                FileInputStream  fis = new FileInputStream(from);  
                FileOutputStream fos = new FileOutputStream(to,false);  
                int n = fis.read();  
                //循环写入  
                while(n!=-1){//解密算法,可行定义,与解密算法相逆  
                    if(day%height*n != 1){  
                        fos.write(n-height);  
                    }else{  
                        fos.write(n);  
                    }  
                    n=fis.read();  
                }  
                //关闭输入输出流  
                fis.close();  
                fos.close();  
            }  
    下面上产品实例代码:

    UI类:

        package czj_javaIO;  
          
        import java.awt.FlowLayout;  
        import java.awt.Font;  
          
        import javax.swing.ImageIcon;  
        import javax.swing.JButton;  
        import javax.swing.JFrame;  
        import javax.swing.JLabel;  
        import javax.swing.JPanel;  
        import javax.swing.JTextArea;  
        import javax.swing.JTextField;  
          
        public class MainUI extends JFrame{  
          
            public static void main(String[] args) {  
                MainUI mu = new MainUI();  
                mu.init();  
            }  
            /** 
             * 初始化界面的方法 
             */  
            private void init() {  
                this.setTitle("文件处理");  
                this.setSize(395, 850);  
                this.setLocationRelativeTo(null);  
                this.setDefaultCloseOperation(3);  
                this.setLayout(new FlowLayout());  
                this.setResizable(false);  
                addBackground();  
                JLabel j1 = new JLabel("    文件名 :        ");  
                JTextArea jp1  = new JTextArea(2, 30);  
                jp1.setText("测试用文件.txt");  
                  
                JLabel j2 = new JLabel("文件绝对路径:");  
                JTextArea jp2  = new JTextArea(2, 30);  
                jp2.setText("E://");  
                  
                JLabel j3 = new JLabel("     内容  :          ");  
                JTextArea jp3  = new JTextArea(5, 30);  
                jp3.setText("这是测试文件的具体内容。");  
                  
                this.add(j1);  
                this.add(jp1);  
                this.add(j2);  
                this.add(jp2);  
                this.add(j3);  
                this.add(jp3);  
                  
                JButton jb_write = new JButton("写入文件");  
                jb_write.setBorderPainted(false);  
                jb_write.setFocusable(false);  
                this.add(jb_write);  
                  
                JButton jb_read = new JButton("读取文件");  
                jb_read.setBorderPainted(false);  
                jb_read.setFocusable(false);  
                this.add(jb_read);  
                  
                JLabel j4 = new JLabel("(必须已有该文件)");  
                this.add(j4);  
          
                  
                JLabel jfore = new JLabel("  文件原地址  :");  
                JTextArea jtfore  = new JTextArea(2, 30);  
                jtfore.setText("E://测试用文件.txt");  
                this.add(jfore);  
                this.add(jtfore);  
                  
                JLabel jafter = new JLabel("文件目标地址:");  
                JTextArea jtafter  = new JTextArea(2, 30);  
                jtafter.setText("D://复制过来的测试用文件.txt");  
                this.add(jafter);  
                this.add(jtafter);  
                  
                JButton jb_copy = new JButton("  复  制            文  件  ");  
                jb_copy.setBorderPainted(false);  
                jb_copy.setFocusable(false);  
                this.add(jb_copy);  
                  
                JLabel jjiami = new JLabel("***************************要加密的文件目标地址 :        ");  
                JTextArea jtjiami  = new JTextArea(2, 30);  
                jtjiami.setText("E://测试用文件.txt");  
                this.add(jjiami);  
                this.add(jtjiami);  
                  
                JLabel jjiaafter = new JLabel("***************************加密后的文件目标地址 :        ");  
                JTextArea jtjiaafter  = new JTextArea(2, 30);  
                jtjiaafter.setText("D://加密后的测试用文件.txt");  
                this.add(jjiaafter);  
                this.add(jtjiaafter);  
                  
                JLabel jiami = new JLabel("加密密码:");  
                this.add(jiami);  
                //设置加密密码  
                JTextArea jtdayjia  = new JTextArea(2,6);  
                jtdayjia.setText("19940805");  
                this.add(jtdayjia);  
                //校验码  
                JTextArea jtheightjia  = new JTextArea(2, 4);  
                jtheightjia.setText("185");  
                this.add(jtheightjia);  
                  
                JButton jb_jiami = new JButton("  文  件            加  密  ");  
                jb_jiami.setBorderPainted(false);  
                jb_jiami.setFocusable(false);  
                this.add(jb_jiami);  
                  
                JLabel jjiemi = new JLabel("***************************要解密的文件目标地址 :        ");  
                JTextArea jtjiemi  = new JTextArea(2, 30);  
                jtjiemi.setText("D://加密后的测试用文件.txt");  
                this.add(jjiemi);  
                this.add(jtjiemi);  
                  
                JLabel jjieafter = new JLabel("***************************解密后的文件目标地址 :        ");  
                JTextArea jtjieafter  = new JTextArea(2, 30);  
                jtjieafter.setText("E://解密后的测试用文件.txt");  
                this.add(jjieafter);  
                this.add(jtjieafter);  
                  
                JLabel jiemi = new JLabel("解密密码:");  
                this.add(jiemi);  
                //设置解密密码  
                JTextArea jtdayjie  = new JTextArea(2, 6);  
                jtdayjie.setText("19940805");  
                this.add(jtdayjie);  
                //校验码  
                JTextArea jtheightjie  = new JTextArea(2, 4);  
                jtheightjie.setText("185");  
                this.add(jtheightjie);  
                  
                JButton jb_jiemi = new JButton("  文  件            解  密  ");  
                jb_jiemi.setBorderPainted(false);  
                jb_jiemi.setFocusable(false);  
                this.add(jb_jiemi);  
                  
                //用以反馈当前文件处理状态  
                JLabel now = new JLabel();  
                this.add(now);  
                  
                //给按钮添加监听器  
                MainIOListener il = new MainIOListener(jp1,jp2,jp3,jtfore,jtafter,jtjiami,jtjiaafter,jtjiemi,jtjieafter,jtdayjia,  
                        jtheightjia,jtdayjie,jtheightjie,now);  
                jb_write.addActionListener(il);  
                jb_read.addActionListener(il);  
                jb_copy.addActionListener(il);  
                jb_jiami.addActionListener(il);  
                jb_jiemi.addActionListener(il);  
                  
                this.setVisible(true);  
            }  
            /** 
             * 添加背景的方法 
             */  
            private void addBackground(){  
                ImageIcon image=new ImageIcon(this.getClass().getResource("123.jpg"));  
                JLabel jlaImage=new JLabel(image);  
                jlaImage.setBounds(0, -35, image.getIconWidth(), image.getIconHeight());  
                this.getLayeredPane().add(jlaImage,new Integer(Integer.MIN_VALUE));  
                JPanel contentpane=(JPanel)this.getContentPane();  
                contentpane.setOpaque(false);  
                }  
          
        }  
     监听器类:

        package czj_javaIO;  
          
        import java.awt.event.ActionEvent;  
        import java.awt.event.ActionListener;  
          
        import javax.swing.JLabel;  
        import javax.swing.JTextArea;  
          
        public class MainIOListener implements ActionListener{  
          
            private JTextArea jp1,jp2,jp3,jtfore,jtafter,jtjiami,jtjiaafter,jtjiemi,jtjieafter;  
            private int jtdayjia,jtheightjia,jtdayjie,jtheightjie;  
            private JLabel now;  
            public MainIOListener(JTextArea jp1, JTextArea jp2, JTextArea jp3,  
                    JTextArea jtfore, JTextArea jtafter, JTextArea jtjiami,  
                    JTextArea jtjiaafter, JTextArea jtjiemi, JTextArea jtjieafter,JTextArea jtdayjia,  
                    JTextArea jtheightjia,JTextArea jtdayjie,JTextArea jtheightjie,JLabel now) {  
                this.jp1 = jp1;  
                this.jp2 = jp2;  
                this.jp3 = jp3;  
                this.jtfore = jtfore;  
                this.jtafter =jtafter;  
                this.jtjiami = jtjiami;  
                this.jtjiaafter = jtjiaafter;  
                this.jtjiemi = jtjiemi;  
                this.jtjieafter = jtjieafter;  
                //String装换为int  
                this.jtdayjia = Integer.parseInt(jtdayjia.getText());  
                this.jtdayjie =Integer.parseInt(jtdayjie.getText());  
                this.jtheightjia = Integer.parseInt(jtheightjia.getText());  
                this.jtheightjie = Integer.parseInt(jtheightjie.getText());  
                  
                this.now = now;  
            }  
            @Override  
            public void actionPerformed(ActionEvent e) {  
                if(e.getActionCommand().equals("写入文件")){  
                    JavaIO jio = new JavaIO();  
                    try {  
                        jio.writeFile(jp3.getText(),jp2.getText()+jp1.getText());  
                        now.setText("文件已写入");  
                    } catch (Exception e1) {  
                        e1.printStackTrace();  
                    }  
                }else if(e.getActionCommand().equals("读取文件")){  
                    JavaIO jio = new JavaIO();  
                    jio.readFile(jp2.getText()+jp1.getText());  
                    now.setText("文件已读取");  
                      
                }else if(e.getActionCommand().equals("  复  制            文  件  ")){  
                    JavaIO jio = new JavaIO();  
                    try {  
                        jio.copy(jtfore.getText(), jtafter.getText());  
                        now.setText("文件已复制");  
                    } catch (Exception e1) {  
                        e1.printStackTrace();  
                    }  
                }else if(e.getActionCommand().equals("  文  件            加  密  ")){  
                    JavaIO jio = new JavaIO();  
                    try {  
                        jio.JiaMi(jtjiami.getText(), jtjiaafter.getText(),jtdayjia,jtheightjia);  
                        now.setText("文件已加密");  
                    } catch (Exception e1) {  
                        e1.printStackTrace();  
                    }  
                }else if(e.getActionCommand().equals("  文  件            解  密  ")){  
                    JavaIO jio = new JavaIO();  
                    try {  
                        jio.JieMi(jtjiemi.getText(), jtjieafter.getText(),jtdayjie,jtheightjie);  
                        now.setText("文件已解密");  
                    } catch (Exception e1) {  
                        e1.printStackTrace();  
                    }  
                }  
            }  
        }  
    主要实现方法类:
        package czj_javaIO;  
          
        import java.io.File;  
        import java.io.FileInputStream;  
        import java.io.FileNotFoundException;  
        import java.io.FileOutputStream;  
          
        public class JavaIO {  
              
            private File currentFile;  
            public static void main(String[] args) throws Exception {  
                JavaIO ja = new JavaIO();  
                ja.findFiles("E:/");  
        //      ja.readFile("E://类与对象总结.txt");  
        //      ja.writeFile("这是写入文件的内容。","E://类与对象总结11.txt");  
        //      ja.JiaMi("E://类与对象总结.txt", "D://加密后的类与对象总结.png");  
        //      ja.JieMi("D://加密后的类与对象总结.png","E://解密后类与对象总结.txt" );  
        //      ja.copy("E://类与对象总结.txt", "E://类与对象总结的复制文件.txt");  
            }  
            /** 
             * 查找文件 
             * @param 查找目录 
             */  
            public void findFiles(String s){  
                File file = new File(s);  
                File[] f = file.listFiles();  
        //      System.out.println(f);  
                for(int i = 0;i<f.length;i++){  
                     currentFile = f[i];  
                     if(currentFile.isDirectory()){  
                        findFiles(currentFile.getAbsolutePath());  
                    }  
                    if(currentFile.getName().endsWith("txt"))  
                    System.out.println(currentFile);  
                }  
            }  
            /** 
             * 读取文件 
             * @param s文件名(带绝对路径) 
             */  
            public void readFile(String s){  
                try {  
                    FileInputStream  fis = new FileInputStream(s);  
                    int n=fis.read();  
                    while(n!=-1){  
                        System.out.println("字节:"+n);  
                        n = fis.read();  
                    }  
                    fis.close();  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
            /** 
             * 写文件的方法 
             * @param msg写入的内容 
             * @param s文件绝对路径 
             * @throws Exception抛出异常 
             */  
            public void writeFile(String msg,String s) throws Exception{  
                try {  
                    FileOutputStream fos = new FileOutputStream(s,false);  
                    byte[] b = msg.getBytes();//得到组成字符串的字节  
                    fos.write(b);  
                    fos.close();//关闭输出流   
                } catch (FileNotFoundException e) {  
                    e.printStackTrace();  
                }  
            }  
            /** 
             * 复制文件 
             * @param from原文件(带绝对路径)  
             * @param to 复制后文件(带绝对路径) 
             * @throws Exception 
             */  
            public void copy(String from,String to) throws Exception{  
                FileInputStream  fis = new FileInputStream(from);  
                FileOutputStream fos = new FileOutputStream(to,false);  
                int n = fis.read();  
                //循环写入  
                while(n!=-1){  
                        fos.write(n);  
                    n=fis.read();  
                }  
                //关闭输入输出流  
                fis.close();  
                fos.close();  
            }  
            /** 
             * 文件加密传输的方法 
             * @param from原文件(带绝对路径) 
             * @param to复制后文件(带绝对路径) 
             * @throws Exception抛出异常 
             */  
            public void JiaMi(String from,String to,int day,int height) throws Exception{  
                FileInputStream  fis = new FileInputStream(from);  
                FileOutputStream fos = new FileOutputStream(to,false);  
                int n = fis.read();  
                int count=0;  
                //循环写入  
                while(n!=-1){//加密算法,可行定义,与解密算法相逆  
                    if(day%height*n != 1){  
                        fos.write(n+height);  
                    }else{  
                        fos.write(n);  
                    }  
                    n=fis.read();  
                }  
                fis.close();  
                fos.close();  
            }  
            /** 
             * 文件解密接收的方法 
             * @param from原文件(带绝对路径) 
             * @param to复制后文件(带绝对路径) 
             * @throws Exception抛出异常 
             */  
            public void JieMi(String from,String to,int day,int height) throws Exception{  
                FileInputStream  fis = new FileInputStream(from);  
                FileOutputStream fos = new FileOutputStream(to,false);  
                int n = fis.read();  
                //循环写入  
                while(n!=-1){//解密算法,可行定义,与解密算法相逆  
                    if(day%height*n != 1){  
                        fos.write(n-height);  
                    }else{  
                        fos.write(n);  
                    }  
                    n=fis.read();  
                }  
                //关闭输入输出流  
                fis.close();  
                fos.close();  
            }  
              
        }  
    在测试时需要注意的是必须先写入文件,否则后面的操作都将因为找不到对象而报这样的错:java.io.FileNotFoundException: E:\测试用文件.txt (系统找不到指定的文件。)

       总体来说代码量还是不少的,监听器类的构建主要还是涉及到许多参数的传递会比较麻烦。UI类在布局的调整上下了很大的功夫。。。

        加解密文件的方法里的算法可以根据自己的设定进行修改哦。








    展开全文
  • NPOI其实已经介绍的...亮点其实Server.MapPath 这个东西,可以找到MVC工程下的文件夹,找路径还是很方便的。 /// <summary> /// 设备导出Excel表格 /// </summary> public FileResult Ex...

      NPOI其实已经介绍的差不多了,再贴一个方便以后复制粘贴。

    亮点其实是 Server.MapPath 这个东西,可以找到MVC工程下的文件夹,找路径还是很方便的。

       /// <summary>
            /// 设备导出Excel表格
            /// </summary>
            public FileResult ExportExcel()
            {
                string fileDir = Server.MapPath("~/ReportTemplate/我的模板.xls");
                FileStream Dir = new FileStream(fileDir, FileMode.Open, FileAccess.Read);
                HSSFWorkbook workbook = new HSSFWorkbook(Dir);
                ISheet sheet = workbook.GetSheet("sheet1");
                MemoryStream ms = new MemoryStream();
           
    
                DataTable table = EQEquipmentBLL.GetInstance().GetListForExport("");
    
                for (int i = 2; i < table.Rows.Count; i++)
                {    
                    sheet.GetRow(i).GetCell(0).SetCellValue(table.Rows[i-2]["EqID"].ToString());
                    sheet.GetRow(i).GetCell(1).SetCellValue(table.Rows[i-2]["EqName"].ToString());
                    sheet.GetRow(i).GetCell(2).SetCellValue(table.Rows[i-2]["ProduceFactory"].ToString());
                    sheet.GetRow(i).GetCell(3).SetCellValue(table.Rows[i-2]["Model"].ToString());
                }
    
                sheet.ForceFormulaRecalculation = true;  //强制计算Excel中的公式
    
    
                workbook.Write(ms);
                ms.Flush();
                ms.Seek(0, SeekOrigin.Begin);
                return File(ms, "application/ms-excel", $"我的模板{DateTime.Now.ToString("D")}.xls");
            }

     

      

     

    转载于:https://www.cnblogs.com/yunquan/p/9319134.html

    展开全文
  • 本来不打算写这篇的,但是网上复制几个demo,多多少少都有问题,有的不能读取AA,BB开头的,有的数据读取不全的,所以就改了一下,分享给大家,这个demo能把我这7000多行,110多列的数据都读取出来,写入到数组...

    一、前言

          本来是不打算写这篇的,但是网上复制几个demo,多多少少都有问题,有的是不能读取AA,BB开头的,有的是数据读取不全的,所以就改了一下,分享给大家,这个demo能把我这7000多行,110多列的数据都读取出来,写入到数组。

    下面是excel的截图,能看出来还是比较大的文件:
    在这里插入图片描述

    二、读取demo以及比较

    1、php读取exceldemo

    /**
     * @param $file
     * @param array $params
     * @return array
     * @throws PHPExcel_Exception
     * @throws PHPExcel_Reader_Exception
     * @params:获取全部的excel数据,已经加上表头,是完整的获取了
     * @author:ljf
     * @date:2019/12/6
     * @time:18:14
     */
    function getData($file,$params = array())
    {
        $path = __DIR__.'/vendor/PHPExcel_1.8.0/PHPExcel.php';
        require_once($path);
    //获取文件类型
        $file_suffix = pathinfo($file)['extension'];
    //设置模板根据不同的excel版本
        $excel_temple = array('xls'=>'Excel5','xlsx'=>'Excel2007');
        $excelReader = \PHPExcel_IOFactory::createReader($excel_temple[$file_suffix]);//配置成2003版本,因为office版本可以向下兼容
        $sheet = $excelReader->load($file)->getSheet(2); //sheet1操作
        $excelCont = array(
            'highestCol' => $sheet->getHighestColumn(), //列
            'highestRow' => $sheet->getHighestRow(), //行
            'highestColumnIndex' => PHPExcel_Cell::columnIndexFromString($sheet->getHighestColumn()) // 几列
        );
        $countCol = isset($params['count_col']) ? $params['count_col'] : $excelCont['highestColumnIndex'];//有效列的数目,读取时只取前$countCol列
        $startRow = isset($params['need_head']) && $params['need_head'] ? 1 : 2;//从第1行开始读,读取表头
        $rightArr = array();
        //获取多少行
        $row = $excelCont['highestRow'];
        $emptyLine = 0;
        for ($j = $startRow; $j < intval($row) + 1; $j++) {
            $retArr = array();//该行的各个单元格的数据
            $emptyCol = 0;
            for($i = 0; $i < $countCol;$i++){//循环该行的单元格
                $val = $sheet->getCellByColumnAndRow($i, 1)->getValue();//假设表头在第一行,所以仅获取第一行的所有列的信息
                //根据获取的表头内容,存入到新数组中
                $retArr[$val] = $sheet->getCellByColumnAndRow($i, $j)->getValue(); //根据坐标获取内容
                $retArr[$val] = isset($retArr[$val]) ? trim($retArr[$val]) : $retArr[$val];
                if($retArr[$val] === null){
                    $emptyCol++;
                }
            }
            if($emptyCol == $countCol){//这行为空行,不放入任何数组
                $emptyLine++;
            }else {
                $rightArr[] = $retArr;
            }
        }
        unset($sheet);
        if(empty($rightArr)){
            $result = array(
                'errcode' =>1004,
                'errmsg' =>"上传文件内没有有效数据",
            );
        }else{
            $result = array(
                'errcode' =>0,
                'errmsg' =>"",
                'data' =>$rightArr,
            );
        }
        return $result;
    }
    
    // 调用方法
    $start = time();
    $start1 = memory_get_usage();
    $file  = "./devices.xlsx";
    //$result = _get_excel_metainfo($file);
    $result = getData($file);
    $end1 = memory_get_usage(true); //10k elements array;
    $end = time();
    var_dump(convert($end1)); //获取占用内存
    var_dump($end - $start);
    

          以上就是读取部分的代码,具体的逻辑看注释就行,大意就是引入phpexcel类,然后通过这个类打开文件,获取列长度,行长度,然后循环给数组赋值。

    在测试的时候,发现速度有点慢,因此这里打印了下耗时以及内存耗费:

    php耗时以及占用内存:
    
    string(6) "178 mb" int(13)
    

          可以看到耗时13s,内存也耗费不少。一直以来都听说phpexcel性能不大好,这次算是彻底见识到了,13s的读取时间在程序里面是不能接受的,如果一定要用php读取的话,建议是选择异步调用的方式读取吧,最起码不阻塞进程不是。

    异步轮询可以参考:php实现异步轮询

    2、python读取这个excel文件

    博主测试玩php之后,感觉速度有点慢,所以又用pythonpandas读取了一下,顺带测试下速度,读取代码大致如下:

    pandas.DataFrame(pandas.read_excel('excel文件路径'))
    耗时如下:
    cost mem: 2850   占用内存大概3M
    cost time:  2.47637677192688
    

          不比不知道,一比吓一跳,python耗时只需要2.5s,内存占用也极小,这。。。

          内存方面可能会因为php没有及时释放一些变量加上赋值给数组造成内存比较大,python的操作少一些,所以内存方面对比不准确,不过也能看出来确实是python耗费内存更小一些。时间上就不提了,phpexcel是比较辣鸡的。

    3、php调用python代码

    关于php如何调用python代码,这部分很多博主都写的有,博主这里就不多写了,大家有兴趣的话可以去百度下,此类文章很多。

    如何实现在PHP中调用Python并获取运行结果?

    注意:

          这里调用python用的方法是exec()或者system(),这两个函数其实危险性还是很高的,有些配置比较严谨的环境都会禁用掉着两个函数,大家在用之前,可以打开php.ini,查询disable_functions,看看被禁用的函数里面是否会有这两个函数。同时也要考虑好是否要用这两个函数,毕竟是比较危险的。

    三、总结

          不知道从什么时候开始,博主会在选择一个方案的时候对比其他的方案,就比如这里的对比phppython读取excel的性能,不过对比是对比,我们要做的是稳中择优,而不是对比某个语言的好坏。有时候就很烦那些对比语言的,动不动就是xxx语言就是垃圾,我觉得这种对比语言的人呐,水平也就那个样子了,编程语言只是工具,不是你装逼的背景。

    马蜂窝裁php换java,php又又又凉凉了吗

          尺有所长,寸有所短。前段时间和朋友讨论的时候,他说php的优点就是敏捷开发,web开发,这是php擅长的地方,如果你非得拿php不擅长的部分和其他语言擅长的部分去比较,结果肯定是会失望的。说来也是,现在的编程语言百花齐放,某种意义上还是因为各个语言的侧重点不同,如果真的有哪个语言各方面都很优秀,那么恐怕早就一统江湖了哈哈。

    大家加油!
    end

    展开全文
  • 在java中文件的操作 主要是读取 写入 创建 和删除这些基本的操作,复制、移动、都是基于这些基本操作上面的流(io)操作;这里简单的说明下这几个基本操作,然后再以代码示例; 复制 复制是通过被复制路径和复制...

    在java中文件的操作 主要是读取 写入 创建 和删除这些基本的操作,复制、移动、都是基于这些基本操作上面的流(io)操作;这里简单的说明下这几个基本操作,然后再以代码示例;

    • 复制
      复制是通过被复制路径和复制路径才读取和写入相同的文件,涉及到几个需要注意的是:
      复制路径是否存在,复制的是文件还是文件夹,复制的是空文件夹还是非空,这些在我们做运算处理时一定要注意,否则会复制失败;
      //下面是一个文件的复制,只需要对内容进行读取和写入;
       public   void  copyfile(String oldfile,String newfolder){
             File  fileold=new File(oldfile);
    
             if(fileold.exists()){
                 System.out.println("文件存在继续操作");
                 try {
    
                    InputStream   is=new FileInputStream(fileold);//读取源文件
                    FileOutputStream os=new FileOutputStream(newfolder);
                    byte[]bu=new byte[1022];//每次读取大小
                        int  lenth=0;
                     try {
                        while ((lenth=is.read(bu))!=-1) {
                            os.write(bu);
    
                        }
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
    
             }
        }

    关于文件夹的复制就相对麻烦一些,同样会给出两个相同的文件夹的,不同的是还要对文件夹下的文件进行判断处理,关于这一点和文件夹的删除很相似,所以给出大家文件夹的删除,大家自行拓展;

    • 文件夹的删除
      文件夹的删除,java中只能对空文件夹和文件进行删除,所以对于包含了的文件夹,以及子文件夹下面还有文件夹等各种复杂情况,听起来很想循环的感觉有木有,单不推荐去使用for 很复杂,我们这里使用递归;如果对递归的不了解的,可以自己各种百度,我这里就简单给你们说下递归是怎么使用的 很简单也很容易理解:
      递归就是一个对方法的自身反复调用,在删除中我们结合if来判断是否再次进行调用,如何对方法自身反复调用下面给大家看一个例子,大家就明白了:
      private int recursion() {
    
            return recursion();
    
    
        }

    这就是一个基本的递归调用,返回类型可以是什么都可以,通常是基本类型吧, 参数类型我图简单,也没用总之基本结果就是这样,别的都不多说了;
    下面看删除文件夹的代码:

     public  void  deletefolder(String pathandname){
               File file=new File(pathandname);
               if(file.exists()){//不知道里面装的是什么 比如说有文件   文件夹  等
                 //进型判定
                   if(file.isDirectory()){//是否有下级属性 
                       String []filename_list=file.list();//打包的是文件的名称
                       System.out.println("改文件下含有文件列表为:"+filename_list.toString());
                       //   我们还需要做的是判断这里面的每个文件下面是否还有文件,文件等 
                       //这里就需要递归了
                       //先删除了空文件和文件
                      File   infile=null; 
                       for (int i = 0; i < filename_list.length; i++) {
                           //
                                if(pathandname.endsWith(File.separator)){
                                    infile=new File(pathandname+filename_list[i]);
                                }else {
                                       infile=new File(pathandname+File.separator+filename_list[i]);
                                }
                                if(infile.isFile()){
                                    //是文件直接删除
                                    System.out.println("删除了文件"+pathandname+File.separator+filename_list[i]);
                                    infile.delete();
                                }
                                if(infile.isDirectory()){//表示的是是否有下级 也就是是否是文件夹
                                    deletefolder(pathandname+File.separator+filename_list[i]);
                                    infile.delete();
                                    System.out.println("删除了文件夹"+pathandname+File.separator+filename_list[i]);
    
                                }
    
                    }
    
                   }else {
                    file.delete();
                    System.out.println("删除了文件夹"+pathandname);
                }
               }
        }

    关于文件的删除直接调用delete()就可以了 就不做说明了;

    • 文件夹的创建
      这个简单说明就可以了 通常文件夹的创建要结合该文件夹是否存在 否则文件夹会创建失败,希望大家能够保持逻辑的完整性;
    public  void newfolder(String path) {
            File file=new File(path);
            if(!file.exists()){
                boolean f=file.mkdirs();
                if(f){
                    System.out.println("创建文件目录成功!"+file.toString());
                }else {
                    System.out.println("创建文件目录失败!"+file.toString());
                }
            }else {
            System.out.println("文件路径已经存在,请重新创建一个文件"+path);
            }
    
        }
    • 文件的创建和写入:
      直接给他家看代码了,不做过多解释;
    public void  newfile(String  pathandname,String filecontext){
            File  file=new File(pathandname);
            if(!file.exists()){
                try {
                    boolean f=file.createNewFile();
                    if(f){
                        System.out.println("创建文件成功!"+file.toString());
                    }else {
                        System.out.println("创建文件失败!"+file.toString());
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }//
                try {
                    FileWriter writer=new FileWriter(file);//
                    PrintWriter   pw=new PrintWriter(writer);
                    writer.write(filecontext);
                    pw.close();
                    writer.close();//关闭输入
    
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
    
    
            }else {
                System.out.println("文件已经存在,请重新命名文件"+pathandname);
            }
    
    
        }
    展开全文
  • 有时候执行cmd命令需要把结果记录下来,虽然可以直接复制粘贴,但是总归还是麻烦些,其实可以通过重定向cmd的输出流 来将输出写入到一个txt中 > 与 >> 熟悉c++的小伙伴肯定对这玩意相当熟悉 int a; cin>...
  • 如果要批量复制大量的数据,用ado.net或者其他orm框架逐条读取写入,有时会耗时太长,满足不了要求,此时SqlBulkCopy就可以出来大显身手了,相信许多人了解或使用过它。但实际使用时,还是会遇上些问题,这里做些...
  • 如果对数据库的读写都在同一块数据库服务器中操作,无论在安全性、高可用性,还是高并发等各个方面都完全不能满足实际需求的解决方案一般都通过主从复制(Master- Slave) 的方式来同步数据,再通过读取分离来...
  • Mysql数据库主从复制

    2018-09-10 22:43:55
    解决方案一般都通过主从复制(Master- Slave) 的方式来同步数据,再通过读取分离来提升数据库的并发负载能力 主从复制原理 1.在每个事务更新数据完成之前,主服务器在二进制文件记录这些改变,写入二进制日志文件...
  • 不管DLSN还是TransactionID都能用来定位Reader,使其从特定的日志记录开始读取。Log分段(Log Segments)Log会被分解为Log分段,每个分段中包含了其记录的子集。Log分段分布式的,应该放到Log分段存储中(如...
  • 在实际的生产环境中,如果对MySQL数据库的读与写都在一台服务器上进行操作,无论在安全性,高可用性、还是高并发性等诸多方面都无法满足的;而这就需要对MySQL数据库进行主从复制与读写分离。 我们使用一个架构...
  • 这个程序非常简单,但是在写程序时要注意,在实现复制的过程中,无论是复制的文件还是复制的文件都应该打开状态,复制完成后再分别关闭。1. int fgetc(FILE * stream)从 stream 所指的文件中读取一个字符,函数...
  • 文件复制首先我们要考虑的用字符流还是文件流操作呢? 若我们考虑的仅仅文本之类的复制,字符流要好些。但是不可能总是文本文件吧,有可能声音,图像,视频等等,所以使用字节流操作比较好。 [b] [color=...
  • 首先,感谢腾讯面试官提出的非常好的问题,mysql主从复制...2.主从复制io线程读取binlog顺序读,速度非常快,但是到了sql线程回放relaylog的操作时变成了随机读取,如过还是单线程就会变得很慢。 3.当主库的tps并发
  • 例1:以下是复制cd.dll文件至windows\system32的bat文件内容: copy cd.dll %windir%\system32 例2:下面一行卸载windows\system32目录中的cd.dll,即把上面复制的文件删除: del %windir%\system32\cd....
  • 这里涉及一个基础的知识: read系统调用,并不直接从物理设备把数据读取到内存中,write系统调用,也不是把数据直接写入到物理设备上层应用无论调用操作系统的read,还是调用操作系统的write,都会涉及缓冲区。...
  • 因为缓冲流先将数据缓存起来,然后一起写入读取出来。所以说,缓冲流还是很重要的,在IO操作时记得加上缓冲流提升性能。 上述我引用别人的话。其实缓冲流最重要的作用还是提升效率。给大...
  • 无论文件的复制粘贴,还是上传下载,无论文本的读取写入还是音视频的播放,都离不开I/O流的加持。I/O流如此重要,怎么能不了解它!本文将带你了解在Java里,如何自如的操控各种流。2、理解网上教程千千万,...
  • 在计算机中,每条指令的运行依靠cpu的,指令执行的过程中会涉及到临时数据的读取写入,这些数据的读取写入是发生在计算机主存中的。cpu的指令执行很快的,但是发生在主存中的数据读取写入却没有这么快,所以就...
  • DynamoDB 中的限制

    2019-07-22 17:35:00
    从 DynamoDB 读取数据时,用户可以指定希望读取最终一致性读取还是强一致性读取: 最终一致性读取(默认)– 最终一致性选项可以最大程度地提高读取吞吐量。但是,最终一致性读取可能不会反映最近完成的一次...
  • 硬盘IO性能测试

    2015-01-21 10:34:04
    dd if=/dev/zero of=test bs=512k count=4k oflag=dsync 这网上流行的代码,一般我们都直接拿来用了。作为Linux超级新手来说,还是应该弄清每...bs 一次读取写入的bytes字节数 count 写入数据块的次数 oflag=dsyn
  • Hadoop 可靠性

    2020-06-29 11:25:15
    Hadoop 可靠性 HDFS - 可靠性 ... 无论是写入还是硬盘本身的问题,只要数据有问题(读取时通过校验码来检测),都可以通过其他的复制节点读取,同时还会再复制一份到健康的节点中 NameNode不可靠 ...
  • Kafka 允许生产者等待确认,以便直到完全复制并确保即使写入服务器失败的情况下写入也不会完成。 Kafka 的磁盘结构可以很好地扩展使用-无论服务器上有 50KB 还是 50TB 的持久数据,Kafka 都将执行相同的操作。 ...
  • hadoop 可靠性

    2020-05-20 09:15:26
    HDFS-可靠性 1. DataNode 可以失效 ...无论是写入还是硬盘本身的问题,只要数据有问题(读取时通过校验码来检测),都可以通过其他的复制节点读取,同时还会再复制一份到健康的节点中 3.NameNode 不可靠。 ...
  • 1:mysql在进行主从同步,主库针对写的操作,顺序的写入binlog,从库单线程的去主库顺序的读取 主库写入的binlog,从库取到主库的binlog在本地执行,来保证主从数据的一致性,mysql的主从复制单线程操作的,由于...
  • 因为写和读并发的,没法保证顺序,如果删除了缓存,还没有来得及写库,另一个线程就来读取,发现缓存为空,则去数据库中读取数据写入缓存,此时缓存中为脏数据。如果先写了库,在删除缓存前,写库的线程宕机了,...
  • 高可用性有没有想过你的应用是否该兼容只读模式呢?这个问题有多重要?...所以在数据库架构放弃兼容写入能力的时候,无论由于传统的MySQL复制拓扑放弃主服务器,还是Galera集群放弃其quorum,为什么...
  • 因为写和读并发的,没法保证顺序,如果删了缓存,还没有来得及写库,另一个线程就来读取,发现缓存为空,则去数据库中读取数据写入缓存,此时缓存中为脏数据。如果先写了库,再删除缓存前,写库的线程宕机了,没有...

空空如也

空空如也

1 2 3 4 5 6
收藏数 109
精华内容 43
关键字:

复制是读取还是写入