001    /*
002     * Copyright (c) 2009 The openGion Project.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *     http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
013     * either express or implied. See the License for the specific language
014     * governing permissions and limitations under the License.
015     */
016    package org.opengion.fukurou.util;
017    
018    import java.io.BufferedInputStream;
019    import java.io.BufferedOutputStream;
020    import java.io.BufferedReader;
021    import java.io.BufferedWriter;
022    import java.io.File;
023    import java.io.InputStream;
024    import java.io.FileInputStream;
025    import java.io.FileNotFoundException;
026    import java.io.FileOutputStream;
027    import java.io.IOException;
028    import java.io.InputStreamReader;
029    import java.io.OutputStream;
030    import java.io.OutputStreamWriter;
031    import java.io.PrintWriter;
032    import java.io.UnsupportedEncodingException;
033    import java.io.Writer;
034    import java.util.Collections;
035    import java.util.List;
036    
037    // import java.nio.ByteBuffer;
038    import java.nio.channels.FileChannel;
039    
040    /**
041     * FileUtil.java 縺ｯ縲∝?騾夂噪縺ｫ菴ｿ逕ｨ縺輔ｌ繧?File髢｢騾｣繝｡繧ｽ繝?ラ繧帝寔邏?＠縺溘?繧ｯ繝ｩ繧ｹ縺ｧ縺吶?
042     *
043     * 蜈ｨ螟画焚縺ｯ縲｝ublic static final 螳｣險?＆繧後※縺翫ｊ縲∝?繝｡繧ｽ繝?ラ縺ｯ縲｝ublic static synchronized 螳｣險?＆繧後※縺?∪縺吶?
044     *
045     * @og.group 繝ｦ繝ｼ繝?ぅ繝ｪ繝?ぅ
046     *
047     * @version  4.0
048     * @author       Kazuhiko Hasegawa
049     * @since    JDK5.0,
050     */
051    public final class FileUtil {
052            private static final NonClosePrintWriter outWriter = new NonClosePrintWriter( System.out );
053            private static final NonClosePrintWriter errWriter = new NonClosePrintWriter( System.err );
054    
055            /**
056             * 縺吶∋縺ｦ縺?static繝｡繧ｽ繝?ラ縺ｪ縺ｮ縺ｧ縲√さ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繧貞他縺ｳ蜃ｺ縺輔↑縺上＠縺ｦ縺翫″縺ｾ縺吶?
057             *
058             */
059            private FileUtil() {}
060    
061            /** 繧ｷ繧ｹ繝?Β萓晏ｭ倥?謾ｹ陦瑚ｨ伜捷繧偵そ繝?ヨ縺励∪縺吶?     */
062            private static final String CR = System.getProperty("line.separator");
063    
064            /** 5.6.1.2 (2013/02/22) UNIX邉ｻ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｒ陦ｨ縺吶そ繝代Ξ繝ｼ繧ｿ譁?ｭ?*/
065            private static final char UNIX_SEPARATOR = '/';
066    
067            /** 5.6.1.2 (2013/02/22) Windwos邉ｻ縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｒ陦ｨ縺吶そ繝代Ξ繝ｼ繧ｿ譁?ｭ?*/
068            private static final char WINDOWS_SEPARATOR = '\\';
069    
070            /** 5.6.1.2 (2013/02/22) 繝輔ぃ繧､繝ｫ縺ｮ諡｡蠑ｵ蟄舌?蛹ｺ蛻?ｊ繧定｡ｨ縺呎枚蟄?*/
071            public static final char EXTENSION_SEPARATOR = '.';
072    
073            /**
074             * File繧ｪ繝悶ず繧ｧ繧ｯ繝医→繧ｨ繝ｳ繧ｳ繝ｼ繝峨ｈ繧?PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈?縺励∪縺吶?
075             *
076             * @param       file    蜃ｺ蜉帙☆繧九ヵ繧｡繧､繝ｫ繧ｪ繝悶ず繧ｧ繧ｯ繝?
077             * @param       encode  繝輔ぃ繧､繝ｫ縺ｮ繧ｨ繝ｳ繧ｳ繝ｼ繝?
078             *
079             * @return      PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝?
080             * @throws RuntimeException 菴輔ｉ縺九?繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷?蜷?
081             */
082            public static PrintWriter getPrintWriter( final File file,final String encode ) {
083                    return getPrintWriter( file,encode,false );
084            }
085    
086            /**
087             * File繧ｪ繝悶ず繧ｧ繧ｯ繝医→繧ｨ繝ｳ繧ｳ繝ｼ繝峨ｈ繧?PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈?縺励∪縺吶?
088             *
089             * @param       file    蜃ｺ蜉帙☆繧九ヵ繧｡繧､繝ｫ繧ｪ繝悶ず繧ｧ繧ｯ繝?
090             * @param       encode  繝輔ぃ繧､繝ｫ縺ｮ繧ｨ繝ｳ繧ｳ繝ｼ繝?
091             * @param       append  繝輔ぃ繧､繝ｫ繧定ｿｽ蜉?Δ繝ｼ繝?true)縺ｫ縺吶ｋ縺九←縺?°
092             *
093             * @return      PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝?
094             * @throws RuntimeException 菴輔ｉ縺九?繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷?蜷?
095             */
096            public static PrintWriter getPrintWriter( final File file,final String encode,final boolean append ) {
097                    final PrintWriter writer ;
098    
099                    try {
100                            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
101                                            new FileOutputStream(file,append) ,encode )));
102                    }
103                    catch( UnsupportedEncodingException ex ) {
104                            String errMsg = "謖?ｮ壹＆繧後◆繧ｨ繝ｳ繧ｳ繝ｼ繝?ぅ繝ｳ繧ｰ縺後し繝昴?繝医＆繧後※縺?∪縺帙ｓ縲? + CR
105                                                            + ex.getMessage() + CR
106                                                            + "File=[" + file + " , encode=[" + encode + "]" ;
107                            throw new RuntimeException( errMsg,ex );
108                    }
109                    catch( FileNotFoundException ex ) {             // 3.6.1.0 (2005/01/05)
110                            String errMsg = "繝輔ぃ繧､繝ｫ蜷阪′繧ｪ繝ｼ繝励Φ蜃ｺ譚･縺ｾ縺帙ｓ縺ｧ縺励◆縲? + CR
111                                                            + ex.getMessage() + CR
112                                                            + "File=[" + file + " , encode=[" + encode + "]" ;
113                            throw new RuntimeException( errMsg,ex );
114                    }
115    
116                    return writer ;
117            }
118    
119            /**
120             * 繝輔ぃ繧､繝ｫ蜷阪ｈ繧翫?PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈?縺吶ｋ邁｡譏薙Γ繧ｽ繝?ラ縺ｧ縺吶?
121             *
122             * 縺薙ｌ縺ｯ縲√ヵ繧｡繧､繝ｫ蜷阪?縲√ヵ繝ｫ繝代せ縺ｧ縲∬ｿｽ蜉?Δ繝ｼ繝峨〒縲ゞTF-8 繧ｨ繝ｳ繧ｳ繝ｼ繝峨?
123             * 繝ｭ繧ｰ繝輔ぃ繧､繝ｫ繧貞?蜉帙☆繧句?蜷医↓菴ｿ逕ｨ縺励∪縺吶?
124             * 縺ｾ縺溘?繝輔ぃ繧､繝ｫ蜷阪↓縲?System.out" 縺ｨ縲?System.err" 繧呈欠螳壹〒縺阪∪縺吶?
125             * 縺昴?蝣ｴ蜷医?縲∵ｨ呎ｺ門?蜉帙?縺ｾ縺溘?縲∵ｨ呎ｺ悶お繝ｩ繝ｼ蜃ｺ蜉帙↓蜃ｺ蜉帙＆繧後∪縺吶?
126             * "System.out" 縺ｨ縲?System.err" 繧呈欠螳壹＠縺溷?蜷医?縲¨onClosePrintWriter
127             * 繧ｪ繝悶ず繧ｧ繧ｯ繝医′霑斐＆繧後∪縺吶?縺薙ｌ縺ｯ縲…lose() 蜃ｦ逅?′蜻ｼ縺ｰ繧後※繧ゅ?菴輔ｂ縺励↑縺?
128             * 繧ｯ繝ｩ繧ｹ縺ｧ縺吶?縺ｾ縺溘?蟶ｸ縺ｫ蜀?Κ繧ｭ繝｣繝?す繝･縺ｮ蜷後§繧ｪ繝悶ず繧ｧ繧ｯ繝医′霑斐＆繧後∪縺吶?
129             *
130             * @param       file    蜃ｺ蜉帙☆繧九ヵ繧｡繧､繝ｫ蜷?
131             *
132             * @return      PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝?
133             * @throws RuntimeException 菴輔ｉ縺九?繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷?蜷?
134             * @throws IllegalArgumentException 繝輔ぃ繧､繝ｫ蜷阪′ null 縺ｮ蝣ｴ蜷?
135             */
136            public static PrintWriter getLogWriter( final String file ) {
137                    if( file == null ) {
138                            String errMsg = "繝輔ぃ繧､繝ｫ蜷阪↓縲］ull 縺ｯ謖?ｮ壹〒縺阪∪縺帙ｓ縲?;
139                            throw new IllegalArgumentException( errMsg );
140                    }
141    
142                    final PrintWriter writer ;
143                    if( "System.out".equalsIgnoreCase( file ) ) {
144                            writer = outWriter ;
145                    }
146                    else if( "System.err".equalsIgnoreCase( file ) ) {
147                            writer = errWriter ;
148                    }
149                    else {
150                            writer = getPrintWriter( new File( file ),"UTF-8",true );
151                    }
152    
153                    return writer ;
154            }
155    
156            /**
157             * OutputStream縺ｨ繧ｨ繝ｳ繧ｳ繝ｼ繝峨ｈ繧?PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈?縺励∪縺吶?
158             *
159             * @og.rev 5.5.2.0 (2012/05/01) 譁ｰ隕剰ｿｽ蜉?
160             *
161             * @param       os              蛻ｩ逕ｨ縺吶ｋOutputStream
162             * @param       encode  繝輔ぃ繧､繝ｫ縺ｮ繧ｨ繝ｳ繧ｳ繝ｼ繝?
163             *
164             * @return      PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝?
165             * @throws RuntimeException 菴輔ｉ縺九?繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷?蜷?
166             */
167            public static PrintWriter getPrintWriter( final OutputStream os,final String encode ) {
168                    final PrintWriter writer ;
169    
170                    try {
171                            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
172                                            os ,encode )));
173                    }
174                    catch( UnsupportedEncodingException ex ) {
175                            String errMsg = "謖?ｮ壹＆繧後◆繧ｨ繝ｳ繧ｳ繝ｼ繝?ぅ繝ｳ繧ｰ縺後し繝昴?繝医＆繧後※縺?∪縺帙ｓ縲? + CR
176                                                            + ex.getMessage() + CR
177                                                            + "encode=[" + encode + "]" ;
178                            throw new RuntimeException( errMsg,ex );
179                    }
180                    return writer ;
181            }
182    
183            /**
184             * PrintWriter 繧堤ｶ呎価縺励◆縲゛spWriter縺ｪ縺ｩ縺ｮ Writer 逕ｨ縺ｮ繧ｯ繝ｩ繧ｹ繧貞ｮ夂ｾｩ縺励∪縺吶?
185             *
186             * 萓九∴縺ｰ縲゛spWriter縺ｪ縺ｩ縺ｮ JSP/Servlet遲峨?繝輔Ξ繝ｼ繝?Ρ繝ｼ繧ｯ縺ｧ菴ｿ逕ｨ縺輔ｌ繧?
187             * Writer 縺ｧ縺ｯ縲’lush 繧?close 蜃ｦ逅??縲√ヵ繝ｬ繝ｼ繝?Ρ繝ｼ繧ｯ蜀?〒陦後ｏ繧後∪縺吶?
188             * 縺昴?蝣ｴ蜷医?騾壼ｸｸ縺ｮ繝輔ぃ繧､繝ｫ縺ｨ蜷後§逕ｨ縺ｫ縲’lush 繧?close 繧偵い繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ蛛ｴ縺ｧ
189             * 陦後≧縺ｨ縲∝?驛ｨ蜃ｦ逅?噪縺ｫ荳肴紛蜷医′逋ｺ逕溘＠縺溘ｊ縲∵怙謔ｪ縺ｮ蝣ｴ蜷医お繝ｩ繝ｼ縺ｫ縺ｪ繧翫∪縺吶?
190             * 縺薙?繧ｯ繝ｩ繧ｹ縺ｯ縲¨onFlushPrintWriter 繧ｯ繝ｩ繧ｹ縺ｮ繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ霑斐＠縺ｾ縺吶?
191             * 縺薙ｌ縺ｯ縲??蟶ｸ縺ｮ縲］ew PrintWriter( Writer ) 縺ｧ縲∵ｱゅａ繧九?縺ｨ縲√⊇縺ｨ繧薙←蜷梧ｧ倥?
192             * 蜃ｦ逅?ｒ陦後＞縺ｾ縺吶′縲…lose() 縺ｨ flush() 繝｡繧ｽ繝?ラ縺悟他縺ｰ繧後※繧ゅ?菴輔ｂ縺励∪縺帙ｓ縲?
193             *
194             * @param       writer  蜃ｺ蜉帙☆繧妓rite繧ｪ繝悶ず繧ｧ繧ｯ繝?NonFlushPrintWriter繧ｯ繝ｩ繧ｹ)
195             *
196             * @return      PrintWriter繧ｪ繝悶ず繧ｧ繧ｯ繝?
197             */
198            public static PrintWriter getNonFlushPrintWriter( final Writer writer ) {
199                    return new NonFlushPrintWriter( writer );
200            }
201    
202            /**
203             * File繧ｪ繝悶ず繧ｧ繧ｯ繝医→繧ｨ繝ｳ繧ｳ繝ｼ繝峨ｈ繧?BufferedReader繧ｪ繝悶ず繧ｧ繧ｯ繝医ｒ菴懈?縺励∪縺吶?
204             *
205             * @param       file    蜈･蜉帙☆繧九ヵ繧｡繧､繝ｫ繧ｪ繝悶ず繧ｧ繧ｯ繝?
206             * @param       encode  繝輔ぃ繧､繝ｫ縺ｮ繧ｨ繝ｳ繧ｳ繝ｼ繝?
207             *
208             * @return      BufferedReader繧ｪ繝悶ず繧ｧ繧ｯ繝?
209             * @throws RuntimeException 菴輔ｉ縺九?繧ｨ繝ｩ繝ｼ縺檎匱逕溘＠縺溷?蜷?
210             */
211            public static BufferedReader getBufferedReader( final File file,final String encode ) {
212                    final BufferedReader reader ;
213    
214                    try {
215                            reader = new BufferedReader(new InputStreamReader(
216                                                            new FileInputStream( file ) ,encode ));
217                    }
218                    catch( UnsupportedEncodingException ex ) {
219                            String errMsg = "謖?ｮ壹＆繧後◆繧ｨ繝ｳ繧ｳ繝ｼ繝?ぅ繝ｳ繧ｰ縺後し繝昴?繝医＆繧後※縺?∪縺帙ｓ縲? + CR
220                                                            + ex.getMessage() + CR
221                                                            + "FIle=[" + file + " , encode=[" + encode + "]" ;
222                            throw new RuntimeException( errMsg,ex );
223                    }
224                    catch( FileNotFoundException ex ) {
225                            String errMsg = "繝輔ぃ繧､繝ｫ蜷阪′繧ｪ繝ｼ繝励Φ蜃ｺ譚･縺ｾ縺帙ｓ縺ｧ縺励◆縲? + CR
226                                                            + ex.getMessage() + CR
227                                                            + "FIle=[" + file + " , encode=[" + encode + "]" ;
228                            throw new RuntimeException( errMsg,ex );
229                    }
230    
231                    return reader ;
232            }
233    
234            /**
235             * 謖?ｮ壹?繝輔ぃ繧､繝ｫ蜷阪′縲∝ｮ滄圀縺ｫ蟄伜惠縺励※縺?ｋ縺九←縺?°繧偵メ繧ｧ繝?け縺励∪縺吶?
236             * 蟄伜惠縺励↑縺??蜷医?縲?ｼ堤ｧ呈ｯ弱↓縲?ｼ灘屓遒ｺ隱阪＠縺ｾ縺吶?
237             * 縺昴ｌ縺ｧ繧ょｭ伜惠縺励↑縺??蜷医?縲√お繝ｩ繝ｼ繧定ｿ斐＠縺ｾ縺吶?
238             * return 縺輔ｌ繧祈ile繧ｪ繝悶ず繧ｧ繧ｯ繝医?縲∵ｭ｣隕上?蠖｢蠑?CanonicalFile)縺ｧ縺吶?
239             *
240             * @param       dir                     繝輔か繝ｫ繝?錐
241             * @param       filename        繝輔ぃ繧､繝ｫ蜷?
242             *
243             * @return      蟄伜惠繝√ぉ繝?け(縺ｪ縺代ｌ縺ｰ null/縺ゅｌ縺ｰ縲，anonicalFile)
244             */
245            public static File checkFile( final String dir, final String filename ) {
246                    return checkFile( dir,filename,3 );
247            }
248    
249            /**
250             * 謖?ｮ壹?繝輔ぃ繧､繝ｫ蜷阪′縲∝ｮ滄圀縺ｫ蟄伜惠縺励※縺?ｋ縺九←縺?°繧偵メ繧ｧ繝?け縺励∪縺吶?
251             * 蟄伜惠縺励↑縺??蜷医?縲?ｼ堤ｧ呈ｯ弱↓縲∵欠螳壹?蝗樊焚蛻?｢ｺ隱阪＠縺ｾ縺吶?
252             * 縺昴ｌ縺ｧ繧ょｭ伜惠縺励↑縺??蜷医?縲√お繝ｩ繝ｼ繧定ｿ斐＠縺ｾ縺吶?
253             * return 縺輔ｌ繧祈ile繧ｪ繝悶ず繧ｧ繧ｯ繝医?縲∵ｭ｣隕上?蠖｢蠑?CanonicalFile)縺ｧ縺吶?
254             *
255             * @param       dir                     繝輔か繝ｫ繝?錐
256             * @param       filename        繝輔ぃ繧､繝ｫ蜷?
257             * @param       count           蝗樊焚謖?ｮ?
258             *
259             * @return      蟄伜惠繝√ぉ繝?け(縺ｪ縺代ｌ縺ｰ null/縺ゅｌ縺ｰ縲，anonicalFile)
260             */
261            public static File checkFile( final String dir, final String filename,final int count ) {
262                    File file = null;
263    
264                    int cnt = count;
265                    while( cnt > 0 ) {
266                            file = new File( dir,filename );
267                            if( file.exists() ) { break; }
268                            else {
269                                    if( cnt == 1 ) { return null; }         // 谿九ｊ?大屓縺ｮ蝣ｴ蜷医?縲?ｼ堤ｧ貞ｾ?ｩ溘○縺壹↓蜊ｳ謚懊￠繧九?
270                                    try { Thread.sleep( 2000 );     }       // ?堤ｧ貞ｾ?ｩ?
271                                    catch ( InterruptedException ex ) {
272                                            System.out.println( "InterruptedException" );
273                                    }
274                                    System.out.println();
275                                    System.out.print( "CHECK File Error! CNT=" + cnt );
276                                    System.out.print( " File=" + file.getAbsolutePath() );
277                            }
278                            cnt--;
279                    }
280    
281                    // 繝輔ぃ繧､繝ｫ縺ｮ豁｣蠑上ヱ繧ｹ蜷阪?蜿門ｾ?
282                    try {
283                            return file.getCanonicalFile() ;
284                    }
285                    catch( IOException ex ) {
286                            String errMsg = "繝輔ぃ繧､繝ｫ縺ｮ豁｣蠑上ヱ繧ｹ蜷阪′蜿門ｾ励〒縺阪∪縺帙ｓ縲?" + file.getAbsolutePath() + "]";
287                            throw new RuntimeException( errMsg,ex );
288                    }
289            }
290    
291            /**
292             * 繝輔ぃ繧､繝ｫ縺ｮ繝舌う繝翫Μ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
293             *
294             * copy( File,File,false ) 繧貞他縺ｳ蜃ｺ縺励∪縺吶?
295             *
296             * @og.rev 5.1.6.0 (2010/05/01) 謌ｻ繧雁?縺ｫ縲》rue/false 謖?ｮ壹＠縺ｾ縺吶?
297             *
298             * @param       fromFile        繧ｳ繝斐?蜈?ヵ繧｡繧､繝ｫ蜷?
299             * @param       toFile          繧ｳ繝斐?蜈医ヵ繧｡繧､繝ｫ蜷?
300             *
301             * @return      繝舌う繝翫Μ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
302             * @see         #copy( File,File,boolean )
303             */
304            public static boolean copy( final String fromFile,final String toFile ) {
305                    return copy( new File( fromFile ), new File( toFile ), false );
306            }
307    
308            /**
309             * 繝輔ぃ繧､繝ｫ縺ｮ繝舌う繝翫Μ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
310             *
311             * copy( File,File,boolean ) 繧貞他縺ｳ蜃ｺ縺励∪縺吶?
312             * 隨ｬ?灘ｼ墓焚縺ｮ縲〔eepTimeStamp=true 縺ｧ縲√さ繝斐?蜈??繝輔ぃ繧､繝ｫ縺ｮ繧ｿ繧､繝?せ繧ｿ繝ｳ繝励ｒ縲?
313             * 繧ｳ繝斐?蜈医↓繧ゅそ繝?ヨ縺励∪縺吶?
314             *
315             * @og.rev 5.1.6.0 (2010/05/01) 謌ｻ繧雁?縺ｫ縲》rue/false 謖?ｮ壹＠縺ｾ縺吶?
316             *
317             * @param       fromFile        繧ｳ繝斐?蜈?ヵ繧｡繧､繝ｫ蜷?
318             * @param       toFile          繧ｳ繝斐?蜈医ヵ繧｡繧､繝ｫ蜷?
319             * @param       keepTimeStamp   繧ｿ繧､繝?せ繧ｿ繝ｳ繝礼ｶｭ謖ーtrue/false]
320             *
321             * @return      繝舌う繝翫Μ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
322             * @see         #copy( File,File,boolean )
323             */
324    //      public static boolean copy( final String fromFile,final String toFile,final boolean changeCrLf ) {
325            public static boolean copy( final String fromFile,final String toFile,final boolean keepTimeStamp ) {
326                    return copy( new File( fromFile ), new File( toFile ), keepTimeStamp );
327            }
328    
329            /**
330             * 繝輔ぃ繧､繝ｫ縺ｮ繝舌う繝翫Μ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
331             *
332             * copy( File,File,false ) 繧貞他縺ｳ蜃ｺ縺励∪縺吶?
333             *
334             * @og.rev 5.1.6.0 (2010/05/01) 謌ｻ繧雁?縺ｫ縲》rue/false 謖?ｮ壹＠縺ｾ縺吶?
335             *
336             * @param       fromFile        繧ｳ繝斐?蜈?ヵ繧｡繧､繝ｫ
337             * @param       toFile          繧ｳ繝斐?蜈医ヵ繧｡繧､繝ｫ
338             *
339             * @return      繝舌う繝翫Μ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
340             * @see         #copy( File,File,boolean )
341             */
342            public static boolean copy( final File fromFile,final File toFile ) {
343                    return copy( fromFile, toFile, false );
344            }
345    
346            /**
347             * 繝輔ぃ繧､繝ｫ縺ｮ繝舌う繝翫Μ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
348             *
349             * 隨ｬ?灘ｼ墓焚縺ｮ縲〔eepTimeStamp=true 縺ｧ縲√さ繝斐?蜈??繝輔ぃ繧､繝ｫ縺ｮ繧ｿ繧､繝?せ繧ｿ繝ｳ繝励ｒ縲?
350             * 繧ｳ繝斐?蜈医↓繧ゅそ繝?ヨ縺励∪縺吶?
351             * toFile 縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲’romFile 縺ｮ繝輔ぃ繧､繝ｫ蜷阪ｒ縺昴?縺ｾ縺ｾ繧ｳ繝斐?縺励∪縺吶?
352             * fromFile 縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√お繝ｩ繝ｼ縺ｫ縺励∪縺吶?
353             * copyDirectry( File,Fileboolean )繧剃ｽｿ逕ｨ縺励※縺上□縺輔＞縲?閾ｪ蜍募?逅??縺励※縺?∪縺帙ｓ)
354             *
355             * @og.rev 5.1.6.0 (2010/05/01) 譁ｰ隕剰ｿｽ蜉?
356             * @og.rev 5.6.5.2 (2013/06/21) ByteBuffer繧貞茜逕ｨ縺励◆譁ｹ蠑上°繧峨?transferTo 繧剃ｽｿ逕ｨ縺吶ｋ譁ｹ蠑上↓螟画峩
357             *
358             * @param       fromFile        繧ｳ繝斐?蜈?ヵ繧｡繧､繝ｫ
359             * @param       toFile          繧ｳ繝斐?蜈医ヵ繧｡繧､繝ｫ
360             * @param       keepTimeStamp 繧ｿ繧､繝?せ繧ｿ繝ｳ繝礼ｶｭ謖ーtrue/false]
361             *
362             * @return      繝舌う繝翫Μ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
363             * @see         #copyDirectry( File,File,boolean )
364             */
365            public static boolean copy( final File fromFile,final File toFile,final boolean keepTimeStamp ) {
366                    FileInputStream  inFile  = null;
367                    FileOutputStream outFile = null;
368                    FileChannel  fin  = null;
369                    FileChannel  fout = null;
370    
371                    File tempToFile = toFile ;
372                    try {
373                            // fromFile縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√お繝ｩ繝ｼ
374                            if( fromFile.isDirectory() ) {
375                                    System.err.println( fromFile + " 縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ縺溘ａ縲∝?逅?〒縺阪∪縺帙ｓ縲? );
376                                    return false;
377                            }
378                            // toFile縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√◎縺ｮ繝代せ縺ｧ繝輔ぃ繧､繝ｫ蜷阪ｒfromFile縺九ｉ蜿悶ｊ蜃ｺ縺吶?
379                            if( toFile.isDirectory() ) {
380                                    tempToFile = new File( toFile,fromFile.getName() );
381                            }
382                            inFile  = new FileInputStream( fromFile );
383                            outFile = new FileOutputStream( tempToFile );
384    
385                            fin  = inFile.getChannel();
386                            fout = outFile.getChannel();
387    
388                            // 5.6.5.2 (2013/06/21) ByteBuffer繧貞茜逕ｨ縺励◆譁ｹ蠑上°繧峨?transferTo 繧剃ｽｿ逕ｨ縺吶ｋ譁ｹ蠑上↓螟画峩
389    //                      ByteBuffer buffer = ByteBuffer.allocateDirect( BUFSIZE );
390    //                      while ( (fin.read(buffer) != -1) || buffer.position() > 0) {
391    //                              buffer.flip();
392    //                              fout.write( buffer );
393    //                              buffer.compact();
394    //                      }
395    
396                            fin.transferTo(0, fin.size(), fout );
397    
398                    }
399                    catch ( IOException ex ) {
400                            System.out.println(ex.getMessage());
401                            return false;
402                    }
403                    finally {
404                            Closer.ioClose( inFile  ) ;
405                            Closer.ioClose( outFile );
406                            Closer.ioClose( fin  ) ;
407                            Closer.ioClose( fout );
408                    }
409    
410                    if( keepTimeStamp ) {
411                            return tempToFile.setLastModified( fromFile.lastModified() );
412                    }
413    
414                    return true;
415            }
416    //      public static boolean copy( final File fromFile,final File toFile,final boolean keepTimeStamp ) {
417    //              BufferedInputStream     fromStream = null;
418    //              BufferedOutputStream    toStream   = null;
419    //              File tempToFile = toFile ;
420    //              try {
421    //                      // fromFile縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√お繝ｩ繝ｼ
422    //                      if( fromFile.isDirectory() ) {
423    //                              System.err.println( fromFile + " 縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｮ縺溘ａ縲∝?逅?〒縺阪∪縺帙ｓ縲? );
424    //                              return false;
425    //                      }
426    //                      // toFile縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√◎縺ｮ繝代せ縺ｧ繝輔ぃ繧､繝ｫ蜷阪ｒfromFile縺九ｉ蜿悶ｊ蜃ｺ縺吶?
427    //                      if( toFile.isDirectory() ) {
428    //                              tempToFile = new File( toFile,fromFile.getName() );
429    //                      }
430    //
431    //                      fromStream = new BufferedInputStream( new FileInputStream( fromFile ) );
432    //                      toStream   = new BufferedOutputStream( new FileOutputStream( tempToFile ) );
433    //
434    //                      boolean isOK = copy( fromStream,toStream );
435    //                      if( !isOK ) { return false; }
436    //
437    //              }
438    //              catch ( IOException ex ) {
439    //                      System.out.println(ex.getMessage());
440    //                      return false;
441    //              }
442    //              finally {
443    //                      Closer.ioClose( fromStream ) ;
444    //                      Closer.ioClose( toStream ) ;
445    //              }
446    //
447    //              if( keepTimeStamp ) {
448    //                      tempToFile.setLastModified( fromFile.lastModified() );
449    //              }
450    //
451    //              return true;
452    //      }
453    
454            private static final byte B_CR = (byte)0x0d ;   // '\r'
455            private static final byte B_LF = (byte)0x0a ;   // '\n'
456            private static final int  BUFSIZE = 8192 ;              // 5.1.6.0 (2010/05/01)
457    
458            /**
459             * 繝輔ぃ繧､繝ｫ縺ｮ繝舌う繝翫Μ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
460             *
461             * 縺薙?繝輔ぃ繧､繝ｫ繧ｳ繝斐?縺ｯ縲√ヰ繧､繝翫Μ繝輔ぃ繧､繝ｫ縺ｮ 謾ｹ陦後さ繝ｼ繝峨ｒ
462             * CR+LF 縺ｫ邨ｱ荳?＠縺ｾ縺吶?縺ｾ縺溘?UTF-8 縺ｮ BOM(0xef,0xbb,0xbf) 縺後≠繧後?縲?
463             * 蜿悶ｊ髯､縺阪∪縺吶?
464             *
465             * @og.rev 5.1.6.0 (2010/05/01) 譁ｰ隕剰ｿｽ蜉?
466             *
467             * @param       fromFile        繧ｳ繝斐?蜈?ヵ繧｡繧､繝ｫ
468             * @param       toFile          繧ｳ繝斐?蜈医ヵ繧｡繧､繝ｫ
469             *
470             * @return      繝舌う繝翫Μ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
471             */
472            public static boolean changeCrLfcopy( final File fromFile,final File toFile ) {
473                    BufferedInputStream     fromStream = null;
474                    BufferedOutputStream    toStream   = null;
475                    File tempToFile = toFile ;
476                    try {
477                            // 繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√◎縺ｮ繝代せ縺ｧ繝輔ぃ繧､繝ｫ蜷阪ｒfromFile縺九ｉ蜿悶ｊ蜃ｺ縺吶?
478                            if( toFile.isDirectory() ) {
479                                    tempToFile = new File( toFile,fromFile.getName() );
480                            }
481                            fromStream = new BufferedInputStream( new FileInputStream( fromFile ) );
482                            toStream   = new BufferedOutputStream( new FileOutputStream( tempToFile ) );
483    
484    //                      int BUFSIZE = 8192 ;            // 5.1.6.0 (2010/05/01) static final螳夂ｾｩ
485                            byte[] buf = new byte[BUFSIZE];
486                            int len ;
487                            // 4.2.3.0 (2008/05/26) changeCrLf 螻樊?蟇ｾ蠢?
488    
489                            boolean bomCheck = true;        // 譛??縺ｮ荳?屓縺?￠縲?ｼ｢?ｯ?ｭ繝√ぉ繝?け繧定｡後≧縲?
490                            byte    bt = (byte)0x00;        // 繝舌ャ繝輔ぃ縺ｮ譛?ｾ後→譛??縺ｮ豈碑ｼ?凾縺ｫ菴ｿ逕ｨ
491                            while( (len = fromStream.read(buf,0,BUFSIZE)) != -1 ) {
492                                    int st = 0;
493                                    if( bomCheck && len >= 3 &&
494                                            buf[0] == (byte)0xef &&
495                                            buf[1] == (byte)0xbb &&
496                                            buf[2] == (byte)0xbf  ) {
497                                                    st = 3;
498                                    }
499                                    else {
500                                            // 繝舌ャ繝輔ぃ縺ｮ譛?ｾ後′ CR 縺ｧ縲∝?鬆ｭ縺?LF 縺ｮ蝣ｴ蜷医?LF 繧偵ヱ繧ｹ縺励∪縺吶?
501                                            if( bt == B_CR && buf[0] == B_LF ) {
502                                                    st = 1 ;
503                                            }
504                                    }
505                                    bomCheck = false;
506    
507                                    for( int i=st;i<len;i++ ) {
508                                            bt = buf[i] ;
509                                            if( bt == B_CR || bt == B_LF ) {
510                                                    toStream.write( (int)B_CR );            // CR
511                                                    toStream.write( (int)B_LF );            // LF
512                                                    // CR+LF 縺ｮ蝣ｴ蜷?
513                                                    if( bt == B_CR && i+1 < len && buf[i+1] == B_LF ) {
514                                                            i++;
515                                                            bt = buf[i] ;
516                                                    }
517                                            }
518                                            else {
519                                                    toStream.write( (int)bt );
520                                            }
521                                    }
522                            }
523                            // 譛?ｾ後′謾ｹ陦後さ繝ｼ繝峨〒縺ｪ縺代ｌ縺ｰ縲∵隼陦後さ繝ｼ繝峨ｒ霑ｽ蜉?＠縺ｾ縺吶?
524                            // 繝?く繧ｹ繝医さ繝斐?縺ｨ縺ｮ莠呈鋤諤ｧ縺ｮ縺溘ａ
525                            if( bt != B_CR && bt != B_LF ) {
526                                    toStream.write( (int)B_CR );            // CR
527                                    toStream.write( (int)B_LF );            // LF
528                            }
529                    }
530                    catch ( IOException ex ) {
531                            System.out.println(ex.getMessage());
532                            return false;
533                    }
534                    finally {
535                            Closer.ioClose( fromStream ) ;
536                            Closer.ioClose( toStream ) ;
537                    }
538    
539                    return true;
540            }
541    
542            /**
543             * 蜈･蜃ｺ蜉帙せ繝医Μ繝ｼ繝?俣縺ｧ繝??繧ｿ縺ｮ霆｢騾√ｒ陦後＞縺ｾ縺吶?
544             *
545             * 縺薙％縺ｧ縺ｯ縲√☆縺ｧ縺ｫ菴懈?縺輔ｌ縺溘せ繝医Μ繝ｼ繝?↓蝓ｺ縺･縺阪?繝??繧ｿ縺ｮ蜈･蜃ｺ蜉帙ｒ陦後＞縺ｾ縺吶?
546             * 繧医▲縺ｦ縲∝?縺ｫ繝輔か繝ｫ繝?ｽ懈?繧??蟄伜惠繝√ぉ繝?け縲√ヵ繧｡繧､繝ｫ縺ｮ蜑企勁縺ｪ縺ｩ縺ｮ蠢?ｦ√↑蜃ｦ逅??
547             * 貂医∪縺励※鄂ｮ縺?※縺上□縺輔＞縲?
548             * 縺ｾ縺溘?縺薙?繝｡繧ｽ繝?ラ蜀?〒縲√せ繝医Μ繝ｼ繝??繧ｯ繝ｭ繝ｼ繧ｹ蜃ｦ逅??陦後▲縺ｦ縺?∪縺帙ｓ縲?
549             *
550             * @og.rev 5.1.6.0 (2010/05/01) 譁ｰ隕剰ｿｽ蜉?
551             *
552             * @param       input   蜈･蜉帙せ繝医Μ繝ｼ繝?
553             * @param       output  蜃ｺ蜉帙せ繝医Μ繝ｼ繝?
554             *
555             * @return      繝??繧ｿ霆｢騾√′豁｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
556             */
557            public static boolean copy( final InputStream input,final OutputStream output ) {
558                    if( input == null ) {
559                            System.err.println( "蜈･蜉帙せ繝医Μ繝ｼ繝?′ 菴懈?縺輔ｌ縺ｦ縺?∪縺帙ｓ縲? );
560                            return false;
561                    }
562    
563                    if( output == null ) {
564                            System.err.println( "蜃ｺ蜉帙せ繝医Μ繝ｼ繝?′ 菴懈?縺輔ｌ縺ｦ縺?∪縺帙ｓ縲? );
565                            return false;
566                    }
567    
568                    try {
569                            byte[] buf = new byte[BUFSIZE];
570                            int len;
571                            while((len = input.read(buf)) != -1) {
572                                    output.write(buf, 0, len);
573                            }
574                    }
575                    catch ( IOException ex ) {
576                            System.out.println( ex.getMessage() );
577                            return false;
578                    }
579            //      finally {
580            //              Closer.ioClose( input );
581            //              Closer.ioClose( output );
582            //      }
583                    return true ;
584            }
585    
586            /**
587             * 蜀榊ｸｰ蜃ｦ逅?〒繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ繧ｳ繝斐?繧定｡後＞縺ｾ縺吶?
588             *
589             * 謖?ｮ壹＆繧後◆繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺九▲縺溘ｊ蟄伜惠縺励↑縺?→縺阪?  false繧定ｿ斐＠縺ｾ縺吶?
590             *
591             * @og.rev 4.3.0.0 (2008/07/24) 霑ｽ蜉?
592             * @og.rev 5.1.6.0 (2010/05/01) 謌ｻ繧雁?縺ｫ縲》rue/false 謖?ｮ壹＠縺ｾ縺吶?
593             *
594             * @param       fromDir 繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ蜷?
595             * @param       toDir   繧ｳ繝斐?蜈医ョ繧｣繝ｬ繧ｯ繝医Μ蜷?
596             *
597             * @return      繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
598             */
599            public static boolean copyDirectry( final String fromDir, final String toDir ) {
600                    return copyDirectry( new File( fromDir ), new File( toDir ),false );
601            }
602    
603            /**
604             * 蜀榊ｸｰ蜃ｦ逅?〒繝?ぅ繝ｬ繧ｯ繝医Μ繧偵さ繝斐?縺励∪縺吶?
605             *
606             * 謖?ｮ壹＆繧後◆繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺九▲縺溘ｊ蟄伜惠縺励↑縺?→縺阪?  false繧定ｿ斐＠縺ｾ縺吶?
607             *
608             * @og.rev 4.3.0.0 (2008/07/24) 霑ｽ蜉?
609             * @og.rev 5.1.6.0 (2010/05/01) 蜀?Κ蜃ｦ逅?ｒ闍･蟷ｲ螟画峩縺励∪縺吶?
610             *
611             * @param       fromDir   繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ
612             * @param       toDir     繧ｳ繝斐?蜈医ョ繧｣繝ｬ繧ｯ繝医Μ
613             *
614             * @return      繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
615             */
616            public static boolean copyDirectry( final File fromDir, final File toDir ) {
617                    return copyDirectry( fromDir, toDir, false );
618            }
619    
620            /**
621             * 蜀榊ｸｰ蜃ｦ逅?〒繝?ぅ繝ｬ繧ｯ繝医Μ繧偵さ繝斐?縺励∪縺吶?
622             *
623             * 謖?ｮ壹＆繧後◆繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ縺後ョ繧｣繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺九▲縺溘ｊ蟄伜惠縺励↑縺?→縺阪?  false繧定ｿ斐＠縺ｾ縺吶?
624             *
625             * @og.rev 4.3.0.0 (2008/07/24) 霑ｽ蜉?
626             * @og.rev 5.1.6.0 (2010/05/01) 蜀?Κ蜃ｦ逅?ｒ闍･蟷ｲ螟画峩縺励∪縺吶?
627             * @og.rev 5.3.7.0 (2011/07/01) 繝輔か繝ｫ繝?↓繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪↑縺??蜷医?縲√お繝ｩ繝ｼ繧定ｿ斐＠縺ｾ縺吶?
628             *
629             * @param       fromDir 繧ｳ繝斐?蜈?ョ繧｣繝ｬ繧ｯ繝医Μ
630             * @param       toDir   繧ｳ繝斐?蜈医ョ繧｣繝ｬ繧ｯ繝医Μ
631             * @param       keepTimeStamp 繧ｿ繧､繝?せ繧ｿ繝ｳ繝礼ｶｭ謖ーtrue/false]
632             *
633             * @return      繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ繧ｳ繝斐?縺梧ｭ｣蟶ｸ縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
634             */
635            public static boolean copyDirectry( final File fromDir, final File toDir, final boolean keepTimeStamp ) {
636                    // 繧ｳ繝斐?蜈?′繝?ぅ繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺??蜷医?false繧定ｿ斐☆
637                    // 4.3.4.4 (2009/01/01)
638                    if( !fromDir.exists() || !fromDir.isDirectory() ) {
639                            System.err.println( fromDir + " 縺?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺?°縲∝ｭ伜惠縺励∪縺帙ｓ縲? );
640                            return false;
641                    }
642    
643                    // 4.3.4.4 (2009/01/01)
644                    if( !toDir.exists() ) {
645                            // 繝?ぅ繝ｬ繧ｯ繝医Μ繧剃ｽ懈?縺吶ｋ
646                            if( !toDir.mkdirs() ) {
647                                    System.err.println( toDir + " 縺ｮ 繝?ぅ繝ｬ繧ｯ繝医Μ菴懈?縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲? );
648                                    return false;
649                            }
650                    }
651    
652                    // 繝?ぅ繝ｬ繧ｯ繝医Μ蜀??繝輔ぃ繧､繝ｫ繧偵☆縺ｹ縺ｦ蜿門ｾ励☆繧?
653                    File[] files = fromDir.listFiles();
654    
655                    // 5.3.7.0 (2011/07/01) 繝輔か繝ｫ繝?↓繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪↑縺??蜷医?縲√お繝ｩ繝ｼ
656                    if( files == null ) {
657                            System.err.println( fromDir + " 縺ｯ繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪∪縺帙ｓ縲? );
658                            return false;
659                    }
660    
661                    // 繝?ぅ繝ｬ繧ｯ繝医Μ蜀??繝輔ぃ繧､繝ｫ縺ｫ蟇ｾ縺励さ繝斐?蜃ｦ逅?ｒ陦後≧
662                    boolean flag = true;
663                    for( int i = 0; files.length>i; i++ ){
664                            if( files[i].isDirectory() ){ // 繝?ぅ繝ｬ繧ｯ繝医Μ縺?▲縺溷?蜷医?蜀榊ｸｰ蜻ｼ縺ｳ蜃ｺ縺励ｒ陦後≧
665                                    flag = copyDirectry( files[i], new File( toDir, files[i].getName()),keepTimeStamp );
666                            }
667                            else{ // 繝輔ぃ繧､繝ｫ縺?▲縺溷?蜷医?繝輔ぃ繧､繝ｫ繧ｳ繝斐?蜃ｦ逅?ｒ陦後≧
668                                    flag = copy( files[i], new File( toDir, files[i].getName()),keepTimeStamp );
669                            }
670                            if( !flag ) { return false; }
671                    }
672                    return true;
673            }
674    //      public static boolean copyDirectry( final File fromDirectry, final File toDirectry ) {
675    //              // 繧ｳ繝斐?蜈?′繝?ぅ繝ｬ繧ｯ繝医Μ縺ｧ縺ｪ縺??蜷医?false繧定ｿ斐☆
676    //              // 4.3.4.4 (2009/01/01)
677    //              if( !fromDirectry.exists() || !fromDirectry.isDirectory() ) { return false; }
678    //
679    //              // 4.3.4.4 (2009/01/01)
680    //              boolean flag = true;
681    //              if( !toDirectry.exists() ) {
682    //                      // 繝?ぅ繝ｬ繧ｯ繝医Μ繧剃ｽ懈?縺吶ｋ
683    //                      flag = toDirectry.mkdirs();
684    //                      if( ! flag ) { System.err.println( toDirectry.getName() + " 縺ｮ 繝?ぅ繝ｬ繧ｯ繝医Μ菴懈?縺ｫ螟ｱ謨励＠縺ｾ縺励◆縲? ); }
685    //              }
686    //
687    //              // 繝?ぅ繝ｬ繧ｯ繝医Μ蜀??繝輔ぃ繧､繝ｫ繧偵☆縺ｹ縺ｦ蜿門ｾ励☆繧?
688    //              File[] files = fromDirectry.listFiles();
689    //
690    //              // 繝?ぅ繝ｬ繧ｯ繝医Μ蜀??繝輔ぃ繧､繝ｫ縺ｫ蟇ｾ縺励さ繝斐?蜃ｦ逅?ｒ陦後≧
691    //              for( int i = 0; files.length>i; i++ ){
692    //                      if( files[i].isDirectory() ){ // 繝?ぅ繝ｬ繧ｯ繝医Μ縺?▲縺溷?蜷医?蜀榊ｸｰ蜻ｼ縺ｳ蜃ｺ縺励ｒ陦後≧
693    //                              copyDirectry(
694    //                              new File( fromDirectry.toString(), files[i].getName() ),
695    //                              new File( toDirectry.toString(), files[i].getName()));
696    //                      }
697    //                      else{ // 繝輔ぃ繧､繝ｫ縺?▲縺溷?蜷医?繝輔ぃ繧､繝ｫ繧ｳ繝斐?蜃ｦ逅?ｒ陦後≧
698    //                              copy(
699    //                              new File( fromDirectry.toString(), files[i].getName() ),
700    //                              new File( toDirectry.toString(), files[i].getName()) );
701    //                      }
702    //              }
703    //              return true;
704    //      }
705    
706            /**
707             * 謖?ｮ壹＆繧後◆繝輔ぃ繧､繝ｫ蜿翫?繝?ぅ繝ｬ繧ｯ繝医ｒ蜑企勁縺励∪縺吶?
708             * 繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?繧ｵ繝悶ヵ繧ｩ繝ｫ繝?所縺ｳ繝輔ぃ繧､繝ｫ繧ょ炎髯､縺励∪縺吶?
709             * ?代▽縺ｧ繧ゅヵ繧｡繧､繝ｫ縺ｮ蜑企勁縺ｫ螟ｱ謨励＠縺溷?蜷医?縺昴?譎らせ縺ｧ蜃ｦ逅?ｒ荳ｭ譁ｭ縺庸alse繧定ｿ斐＠縺ｾ縺吶?
710             *
711             * @og.rev 5.3.7.0 (2011/07/01) 繝輔か繝ｫ繝?↓繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪↑縺??蜷医?縲√お繝ｩ繝ｼ繧定ｿ斐＠縺ｾ縺吶?
712             *
713             * @param       file 蜑企勁繝輔ぃ繧､繝ｫ/繝?ぅ繝ｬ繧ｯ繝医Μ
714             *
715             * @return      繝輔ぃ繧､繝ｫ/繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蜑企勁縺ｫ邨ゆｺ?＠縺溘°縺ｩ縺?°[true:謌仙粥/false:螟ｱ謨余
716             */
717            public static boolean deleteFiles( final File file ) {
718                    if( file.exists() ) {
719                            if( file.isDirectory() ) {
720                                    File[] list = file.listFiles();
721    
722                                    // 5.3.7.0 (2011/07/01) 繝輔か繝ｫ繝?↓繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪↑縺??蜷医?縲√お繝ｩ繝ｼ
723                                    if( list == null ) {
724                                            System.err.println( file + " 縺ｯ繧｢繧ｯ繧ｻ繧ｹ縺ｧ縺阪∪縺帙ｓ縲? );
725                                            return false;
726                                    }
727    
728                                    for( int i=0; i<list.length; i++ ) {
729                                            deleteFiles( list[i] );
730                                    }
731                            }
732                            if( !file.delete() ) { return false; }
733                    }
734                    return true;
735            }
736    
737            /**
738             * 謖?ｮ壹＆繧後◆繝?ぅ繝ｬ繧ｯ繝医Μ繧貞渕轤ｹ縺ｨ縺励◆繝輔ぃ繧､繝ｫ蜷?繝代せ繧貞性繧?縺ｮ荳?ｦｧ繧定ｿ斐＠縺ｾ縺吶?
739             *
740             * @og.rev 4.3.6.6 (2009/05/15) 譁ｰ隕丈ｽ懈?
741             * @og.rev 5.4.3.2 (2012/01/06) 蠑墓焚isCopy霑ｽ蜉?
742             *
743             * @param dir 蝓ｺ轤ｹ縺ｨ縺ｪ繧九ョ繧｣繝ｬ繧ｯ繝医Μ
744             * @param sort 繝輔ぃ繧､繝ｫ蜷阪〒繧ｽ繝ｼ繝医☆繧九°
745             * @param list 繝輔ぃ繧､繝ｫ蜷堺ｸ?ｦｧ繧呈?邏阪☆繧記ist
746             * @param isCopy 繧ｳ繝斐?荳ｭ繝輔ぃ繧､繝ｫ繧帝勁螟悶☆繧九° [true:蜷ｫ繧?false:髯､螟望
747             */
748            public static void getFileList( final File dir, final boolean sort, final List<String> list, boolean isCopy ) {
749                    if( list == null ) { return; }
750                    if( dir.isFile() ) {
751                            // 繧ｳ繝斐?荳ｭ蛻､螳壹?rename縺ｧ陦後≧
752                            if( !isCopy && !dir.renameTo( dir ) ){
753                                    return;
754                            }
755                            else{
756                                    list.add( dir.getAbsolutePath() );
757                            }
758                    }
759                    else if( dir.isDirectory() ) {
760                            File[] files = dir.listFiles();
761                            for( int i=0; i<files.length; i++ ) {
762                                    getFileList( files[i], sort, list, isCopy );
763                            }
764                    }
765                    if( sort ) {
766                            Collections.sort( list );
767                    }
768            }
769    
770            /**
771             * 謖?ｮ壹＆繧後◆繝?ぅ繝ｬ繧ｯ繝医Μ繧貞渕轤ｹ縺ｨ縺励◆繝輔ぃ繧､繝ｫ蜷?繝代せ繧貞性繧?縺ｮ荳?ｦｧ繧定ｿ斐＠縺ｾ縺吶?
772             * 莠呈鋤諤ｧ縺ｮ縺溘ａ縲√さ繝斐?荳ｭ繝輔ぃ繧､繝ｫ繧ょ性縺ｿ縺ｾ縺吶?
773             *
774             * @og.rev 5.4.3.2 (2012/01/06) 繧ｳ繝斐?荳ｭ蟇ｾ蠢懊?縺溘ａ蠑墓焚?斐▽繧剃ｽ懈?縺吶ｋ
775             *
776             * @param dir 蝓ｺ轤ｹ縺ｨ縺ｪ繧九ョ繧｣繝ｬ繧ｯ繝医Μ
777             * @param sort 繝輔ぃ繧､繝ｫ蜷阪〒繧ｽ繝ｼ繝医☆繧九°
778             * @param list 繝輔ぃ繧､繝ｫ蜷堺ｸ?ｦｧ繧呈?邏阪☆繧記ist
779             */
780            public static void getFileList( final File dir, final boolean sort, final List<String> list ) {
781                            getFileList( dir, sort, list, true );
782            }
783    
784            /**
785             * 謖?ｮ壹＆繧後◆繝輔ぃ繧､繝ｫ蜷?繝代せ繧貞性繧?縺九ｉ縲√ヱ繧ｹ繧よ僑蠑ｵ蟄舌ｂ縺ｪ縺?ヵ繧｡繧､繝ｫ蜷阪ｒ霑斐＠縺ｾ縺吶?
786             *
787             * @og.rev 5.6.1.2 (2013/02/22) 譁ｰ隕丈ｽ懈?
788             *
789             * @param filename 繝輔ぃ繧､繝ｫ蜷?繝代せ繧貞性繧?
790             * @return 繝代せ繧ゅ?諡｡蠑ｵ蟄舌ｂ縺ｪ縺?ヵ繧｡繧､繝ｫ蜷?
791             */
792            public static String getBaseName( final String filename ) {
793    
794                    if (filename == null) {
795                            return null;
796                    }
797    
798                    // 繧ｻ繝代Ξ繝ｼ繧ｿ縺ｮ菴咲ｽｮ繧貞叙蠕励?
799                    int lastUnixPos    = filename.lastIndexOf(UNIX_SEPARATOR);
800                    int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
801                    int lastSepPos = Math.max( lastUnixPos , lastWindowsPos );
802    
803                    // 諡｡蠑ｵ蟄舌?菴咲ｽｮ繧貞叙蠕励?
804                    int extPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
805                    if( lastSepPos > extPos ) { extPos = -1; }   // 蠢ｵ縺ｮ縺溘ａ縲∵怙蠕後?繧ｻ繝代Ξ繝ｼ繧ｿ繧医ｊ蜑阪↓縺ゅｋ諡｡蠑ｵ蟄舌?蛹ｺ蛻?ｊ譁?ｭ励?辟｡蜉ｹ縲?
806    
807                    if( extPos < 0 ) {
808                            // SEPARATOR 縺後↑縺代ｌ縺ｰ縲〕astSepPos + 1 = 0 縺ｨ縺ｪ繧翫?蜈磯?縺九ｉ蜿門ｾ励〒縺阪ｋ縲?
809                            return filename.substring( lastSepPos + 1 );
810                    } else {
811                            return filename.substring( lastSepPos + 1 , extPos );
812                    }
813            }
814    
815            /**
816             * PrintWriter 繧堤ｶ呎価縺励◆縲ヾystem.out/System.err 逕ｨ縺ｮ繧ｯ繝ｩ繧ｹ繧貞ｮ夂ｾｩ縺励∪縺吶?
817             *
818             * 騾壼ｸｸ縺ｮ縲］ew PrintWriter( OutputStream ) 縺ｧ縲∵ｱゅａ繧九?縺ｨ縲√⊇縺ｨ繧薙←蜷梧ｧ倥?
819             * 蜃ｦ逅?ｒ陦後＞縺ｾ縺吶?
820             * 縺溘□縲…lose() 繝｡繧ｽ繝?ラ縺悟他縺ｰ繧後※繧ゅ?菴輔ｂ縺励∪縺帙ｓ縲?
821             *
822             */
823            private static final class NonClosePrintWriter extends PrintWriter {
824                    /**
825                     * 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ
826                     *
827                     * new PrintWriter( OutputStream ) 繧定｡後＞縺ｾ縺吶?
828                     *
829                     * @param out OutputStream
830                     */
831                    public NonClosePrintWriter( final OutputStream out ) {
832                            super( out );
833                    }
834    
835                    /**
836                     * close() 繝｡繧ｽ繝?ラ繧偵が繝ｼ繝舌?繝ｩ繧､繝峨＠縺ｾ縺吶?
837                     *
838                     * 菴輔ｂ縺励∪縺帙ｓ縲?
839                     *
840                     */
841                    public void close() {
842                            // 縺薙％縺ｧ縺ｯ蜃ｦ逅?ｒ陦後＞縺ｾ縺帙ｓ縲?
843                    }
844            }
845    
846            /**
847             * PrintWriter 繧堤ｶ呎価縺励◆縲゛spWriter縺ｪ縺ｩ縺ｮ Writer 逕ｨ縺ｮ繧ｯ繝ｩ繧ｹ繧貞ｮ夂ｾｩ縺励∪縺吶?
848             *
849             * 萓九∴縺ｰ縲゛spWriter縺ｪ縺ｩ縺ｮ JSP/Servlet遲峨?繝輔Ξ繝ｼ繝?Ρ繝ｼ繧ｯ縺ｧ菴ｿ逕ｨ縺輔ｌ繧?
850             * Writer 縺ｧ縺ｯ縲’lush 繧?close 蜃ｦ逅??縲√ヵ繝ｬ繝ｼ繝?Ρ繝ｼ繧ｯ蜀?〒陦後ｏ繧後∪縺吶?
851             * 縺昴?蝣ｴ蜷医?騾壼ｸｸ縺ｮ繝輔ぃ繧､繝ｫ縺ｨ蜷後§逕ｨ縺ｫ縲’lush 繧?close 繧偵い繝励Μ繧ｱ繝ｼ繧ｷ繝ｧ繝ｳ蛛ｴ縺ｧ
852             * 陦後≧縺ｨ縲∝?驛ｨ蜃ｦ逅?噪縺ｫ荳肴紛蜷医′逋ｺ逕溘＠縺溘ｊ縲∵怙謔ｪ縺ｮ蝣ｴ蜷医お繝ｩ繝ｼ縺ｫ縺ｪ繧翫∪縺吶?
853             * 縺薙?繧ｯ繝ｩ繧ｹ縺ｯ縲∝腰縺ｫ縲??蟶ｸ縺ｮ縲］ew PrintWriter( Writer ) 縺ｧ縲∵ｱゅａ繧九?縺ｨ縲?
854             * 縺ｻ縺ｨ繧薙←蜷梧ｧ倥?蜃ｦ逅?ｒ陦後＞縺ｾ縺吶?
855             * 縺溘□縲…lose() 縺ｨ flush() 繝｡繧ｽ繝?ラ縺悟他縺ｰ繧後※繧ゅ?菴輔ｂ縺励∪縺帙ｓ縲?
856             *
857             */
858            private static final class NonFlushPrintWriter extends PrintWriter {
859                    /**
860                     * 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ繝ｼ
861                     *
862                     * new PrintWriter( Writer ) 繧定｡後＞縺ｾ縺吶?
863                     *
864                     * @param writer Writer
865                     */
866                    public NonFlushPrintWriter( final Writer writer ) {
867                            super( writer );
868                    }
869    
870                    /**
871                     * close() 繝｡繧ｽ繝?ラ繧偵が繝ｼ繝舌?繝ｩ繧､繝峨＠縺ｾ縺吶?
872                     *
873                     * 菴輔ｂ縺励∪縺帙ｓ縲?
874                     *
875                     */
876                    public void close() {
877                            // 縺薙％縺ｧ縺ｯ蜃ｦ逅?ｒ陦後＞縺ｾ縺帙ｓ縲?
878                    }
879    
880                    /**
881                     * flush() 繝｡繧ｽ繝?ラ繧偵が繝ｼ繝舌?繝ｩ繧､繝峨＠縺ｾ縺吶?
882                     *
883                     * 菴輔ｂ縺励∪縺帙ｓ縲?
884                     *
885                     */
886                    public void flush() {
887                            // 縺薙％縺ｧ縺ｯ蜃ｦ逅?ｒ陦後＞縺ｾ縺帙ｓ縲?
888                    }
889            }
890    
891            /**
892             * 繝輔ぃ繧､繝ｫ繧偵さ繝斐?縺励∪縺吶?
893             *
894             * 蠑墓焚縺ｫ <file1> <file2> [<encode1> <encode2>] 繧呈欠螳壹＠縺ｾ縺吶?
895             * file1 繧定ｪｭ縺ｿ霎ｼ縺ｿ縲’ile2 縺ｫ繧ｳ繝斐?縺励∪縺吶?繧ｳ繝斐?蜑阪↓縲’ile2 縺ｯ縲’ile2_backup 縺ｫ繧ｳ繝斐?縺励∪縺吶?
896             * file1 縺後?繝?ぅ繝ｬ繧ｯ繝医Μ縺ｮ蝣ｴ蜷医?縲√ョ繧｣繝ｬ繧ｯ繝医Μ縺斐→繧ｳ繝斐?縺励∪縺吶?
897             * encode1縲‘ncode2 繧呈欠螳壹☆繧九→縲√お繝ｳ繧ｳ繝ｼ繝牙､画鋤縺励↑縺後ｉ繧ｳ繝斐?縺ｫ縺ｪ繧翫∪縺吶?
898             * 縺薙?蝣ｴ蜷医?縲√ヵ繧｡繧､繝ｫ蜷悟｣ｫ縺ｮ繧ｳ繝斐?縺ｮ縺ｿ縺ｫ縺ｪ繧翫∪縺吶?
899             *
900             * @og.rev 4.0.0.0 (2007/11/28) 繝｡繧ｽ繝?ラ縺ｮ謌ｻ繧雁?繧偵メ繧ｧ繝?け縺励∪縺吶?
901             * @og.rev 5.1.6.0 (2010/05/01) 蠑墓焚縺ｮ荳ｦ縺ｳ鬆??蜃ｦ逅?ｒ螟画峩縺励∪縺吶?
902             *
903             * @param       args 蠑墓焚驟榊?  file1 file2 [encode1 encode2]
904             */
905            public static void main( final String[] args ) throws Throwable {
906                    if( args.length != 2 && args.length != 4 ) {
907                            LogWriter.log("Usage: java FileUtil <file1> <file2> [<encode1> <encode2>]" );
908                            return ;
909                    }
910    
911                    File file1 = new File( args[0] );
912                    File file2 = new File( args[1] );
913    
914                    File tempFile = new File( args[1] + "_backup" );
915    
916                    if( args.length < 3 ) {
917                            if( file1.isDirectory() ) {
918                                    FileUtil.copyDirectry( file1, file2, true );
919                            }
920                            else {
921                                    FileUtil.copy( file2,tempFile );
922                                    FileUtil.copy( file1,file2, true );
923                            }
924                    }
925                    else {
926                            String encode1 = args[2];
927                            String encode2 = args[3];
928    
929                            FileUtil.copy( file2,tempFile );
930    
931                            BufferedReader reader = FileUtil.getBufferedReader( file1 ,encode1 );
932                            PrintWriter    writer = FileUtil.getPrintWriter(    file2 ,encode2 );
933    
934                            try {
935                                    String line1;
936                                    while((line1 = reader.readLine()) != null) {
937                                            writer.println( line1 );
938                                    }
939                            }
940                            finally {
941                                    Closer.ioClose( reader ) ;
942                                    Closer.ioClose( writer ) ;
943                            }
944                    }
945            }
946    }