论坛的小伙伴，天天敲课堂代码有意思吗？难道我们不应该用代码来实现自己各种脑洞大开的想法吗？我想以后多想些奇奇怪怪但是实用的想法，放到上面供大家一起参考学习，当然，代码范围也在我们力所能及的范围！！！
先上一个题，明天正好自习，把代码撸上来，欢迎各位参与，这样，大家才能进步啊




功能需求:实现文档备份需求
要求:1:被备份文档一定不旧于备份档，具体参考指标包括但不限于mtime,size
          2.每天备份一次
          3.尽量优化备份速度


上述需求也是我临时想起来的，真心欢迎大家也多贡献点好的原创并且合理的需求，废话不多说，明天起来撸代码

可以可以666

我不管了，不知道怎么上交好，直接贴代码来水点经验，各位贴吧大佬帮忙指正
目前只能运行这个线程不停，能实现指定文档之间的自动备份
public class Beifen {
        public static void main(String[] args) {
                new Thread() {
                       
                        @Override
                        public void run() {
                                BufferedReader br = null;
                                BufferedWriter bw = null;
                                System.out.println("11");
                                try {
                                        while (true) {
                                                File start = new File("a.txt");
                                                File end = new File("b.txt");
                                                System.out.println("22");
                                                Date s = new Date(start.lastModified());
                                                Date e = new Date(end.lastModified());
                                                if (start.lastModified() - end.lastModified() <= 0) {
                                                        Thread.sleep(1000 * 60);
                                                        continue;
                                                }
                                                System.out.println(start.lastModified());
                                                System.out.println(end.lastModified());
                                                System.out.println(start.lastModified() - end.lastModified());
                                                System.out.println("33");
                                                if (end.length() >= start.length()) {
                                                        Thread.sleep(1000 * 60);
                                                        continue;
                                                }
                                                System.out.println("44");
                       
                                                br = new BufferedReader(new FileReader(start));
                                                bw = new BufferedWriter(new FileWriter(end));
                       
                                                String line;
                                                while ((line = br.readLine()) != null) {
                                                        bw.write(line);
                                                        bw.flush();
                                                        System.out.println(line);
                                                        bw.newLine();
                                                }
                                                System.out.println("55");
                                                Thread.sleep(1000 * 60);
                                                System.out.println("66");
                                        }
                                } catch (Exception e) {
                                        e.printStackTrace();
                                } finally {
                                        if (br != null) {
                                                try {
                                                        br.close();
                                                } catch (IOException e) {
                                                        e.printStackTrace();
                                                } finally {
                                                        if (bw != null) {
                                                                try {
                                                                        bw.close();
                                                                } catch (IOException e) {
                                                                        e.printStackTrace();
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }.start();
        }
}

我来贴下自己的代码,还有很多不完善的地方,先这样吧

/*
功能需求:实现文档的备份需求
1.被备份文档一定不旧于备份档,具体参考指标包括但不限于文件的mtime,size
2.每天备份一次
3.尽量优化备份速速
*/
import java.io.*;
import java.util.*;
import java.text.*;
public class BackUp
{
        public static void main(String[] args) throws Exception
        {
                 File OLD = new File("d:\\oracle.txt");                //原始档
                 File NEW = new File("d:\\oracle_backup.txt");                //备份档
                 ArrayList<Attr> al_new =        new ArrayList<>();                //创建放值Attr的容器                                               
                 while(true)                                //用于完成每天自动备份的功能
                 {
                         int count_old = al_new.size();                                //备份之前的大小
                        int count_new = action(OLD,NEW,al_new).size();                                //备份之后的大小
                         if(count_new == count_old)
                         {
                                 System.out.println("今天的备份工作已经完成!!!!!!");
                                 continue;
                         }
                                 action(OLD,NEW,al_new);
                                 System.out.println("备份成功!!!!");                //提示备份数据传输完毕         
                                 Thread.sleep(86400000);                                //进程休眠24小时
                 }
        }
       
        public static ArrayList<Attr> action(File OLD,File NEW,ArrayList<Attr> al_new) throws IOException
        {
                /*获得被备份文档的属性*/
                Date date_old = new Date();
                date_old.setTime(OLD.lastModified());
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                String mtime_old = sdf.format(date_old);                        //获取备份档的mtime
                long size_old = OLD.length();
                Attr temp_old = new Attr(mtime_old,size_old);
               
                if(al_new.size() > 1 && temp_old.equals(al_new.get(al_new.size() - 1)))
                {
                        return al_new;                                       
                }
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(OLD));                //将旧文档于读取流相关联
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(NEW,true));
                byte[] buf = new byte[1024 * 1024 * 4];                //缓冲区设置为4M
                int len_new = 0;
                while((len_new = bis.read(buf)) != -1)                                //备份数据过程
                {
                        bos.write(buf,0,len_new);
                }
                bis.close();                                //关闭流,释放资源
                bos.close();                        //关闭流,释放资源
               
                /*第一次备份完毕之后开始记录backup档的文件属性*/
                Date date_new = new Date();
                date_new.setTime(NEW.lastModified());
                SimpleDateFormat sdfx = new SimpleDateFormat("yyyy-MM-dd");
                String mtime_new = sdfx.format(date_new);                        //获取备份档的mtime
                //System.out.println(mtime);
                long size_new = NEW.length();
                //System.out.println(size);                                //获取备份档的size
               
                /*将文档属性添加进入Attr容器中,该容器使用ArrayList*/
                //        ArrayList<Attr> al_new = new ArrayList<>();
                Attr temp_new = new Attr(mtime_new,size_new);
                        al_new.add(temp_new);
        //                /*测试al_new中的对象是否符合预期*/
        //                for(Attr a : al_new)
        //                                System.out.println(a);
                        //int num = al_new.size();
                        //System.out.println(num);
                        return al_new;
        }
}
class Attr<String,Long>                                //定义一个对象,用于存放mtime和size
{
        private String mtime;
        private long size;
        Attr(){}
        Attr(String mtime,long size)
        {
                this.mtime = mtime;
                this.size = size;
        }
        public String getMtime()
        {
                return mtime;
        }
        public long getSize()
        {
                return size;
        }
        public boolean equals(Object obj)
        {
                Attr a = (Attr)obj;
                return this.mtime.equals(a.getMtime()) || this.size == a.getSize();
        }
}



/*
软件整体结构也就上面那样了,我想说说功能可以改进的地方:
1.该软件在运行之后会一直占用内存,主程序不会退出,所以我想能否另外在做一个线程,通过监控服务器时间来达到时间到通过线程启动主程序的目的,该想法暂时没有办法实现(还没学多线程)
2.代码结构不够漂亮,说明基本功不扎实
3.Attr使用内部类实现可能效果更好
PS:欢迎讨论并提出宝贵意见(逃匿)
*/

otherhy 发表于 2017-3-16 19:31
我不管了，不知道怎么上交好，直接贴代码来水点经验，各位贴吧大佬帮忙指正
目前只能运行这个线程不停，能 ...

刚回来,用电脑看了下(手机看分不清楚嵌套的包含关系),不错,能实现功能你就可以和客户去要钱了我初略看了下大概有一下几个问题:
1.mtime的取值粒度太小,精确到了默认值(毫秒),如果没有sleep,程序将会一直进行备份动作,建议将mtime扩大到客户要求范围内(使用天作为最小计量单位)
2.使用字符流进行备份不太合适,并没有普遍性,如果客户想要备份图片,直接备份数据挂掉
3.sleep睡眠过多,代码看上去重复性的东西太多.

明天去了不要打我,我先逃了