编程小知识点范例-1

• long startTime = System.currentTimeMillis(); 
• //....... 
• if (logger.isInfoEnabled()) { 
•                 long elapsedTime = System.currentTimeMillis() - startTime; 
•                 logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms"); 
•             } 

1. File directory = new File("");//设定为当前文件夹 
2.        try{ 
3.            System.out.println(directory.getCanonicalPath());//获取标准的路径 
4.            System.out.println(directory.getAbsolutePath());//获取绝对路径 
5.        }catch(Exception e){} 

1. private static File getFileAbsolutePath(String filename) { 
2.       String basePath = new File("").getAbsolutePath(); 
3.       String filePath = "src/test/java"; 
4.       String packagePath = "com/alibaba/panama/qdox"; 
5.       return new File(basePath, File.separator + filePath + File.separator + packagePath 
6.               + File.separator + filename); 
7.   } 

String filename="d:\\upload\\133.jpg";
String name[] = filename.split("\\\\");/
应该这样才对，本身\只是一个转义符，当要用做字符是需要\\，所以如果只有一个\就出错了哦

1. /** 
2.      * 取得某目录下面的文件,增加过滤功能，例如：去掉.svn隐藏文件 
3.      *  
4.      * @param dir 
5.      * @return 
6.      */ 
7.     public static List<File> getSubFiles(File dir, String filter) { 
8.  
9.         if (dir == null || "".equals(dir)) 
10.             return null; 
11.         CopyOnWriteArrayList<File> subFiles = new CopyOnWriteArrayList<File>(); 
12.         for (File file : getAllSubFiles(dir)) { 
13.             subFiles.add(file); 
14.         } 
15.         for (File file : subFiles) { 
16.             String tmp = file.toString(); 
17.             String[] subBlocks = tmp.split("\\\\"); 
18.             for (String subBlock : subBlocks) { 
19.                 if (subBlock.startsWith(filter)) { 
20.                     subFiles.remove(file); 
21.                     break; 
22.                 } 
23.             } 
24.         } 
25.         return subFiles; 
26.     } 
27.  
28.     /** 
29.      * 取得目录下面的所有文件,包含隐藏文件 
30.      *  
31.      * @param dir 
32.      * @return 
33.      */ 
34.     public static List<File> getAllSubFiles(File dir) { 
35.         if (dir == null || "".equals(dir)) 
36.             return null; 
37.         if (dir.isDirectory()) { 
38.             File[] subFiles = dir.listFiles(); 
39.             for (File file : subFiles) { 
40.                 if (file.isDirectory()) { 
41.  
42.                     getAllSubFiles(new File(dir + File.separator + file.getName())); 
43.                 } else { 
44.                     allSubFiles.add(file); 
45.                 } 
46.             } 
47.         } else { 
48.             allSubFiles.add(dir); 
49.         } 
50.         return allSubFiles; 
51.     } 

1. File file = new File(System.getProperty("user.dir")); 
2.  
3.         FilenameFilter filter = new FilenameFilter() { 
4.  
5.             @Override 
6.             public boolean accept(File dir, String name) { 
7.                 return !name.startsWith("."); 
8.             } 
9.         }; 
10.  
11.         for (String filename : file.list(filter)) { 
12.             System.out.println(filename); 
13.         } 

    节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经存在，则覆盖这个文件。针对字节（byte）进行操作，常用的方式为：

读入：【注意】将new String(b,off,len)将字节数组转换为字符串

1. FileInputStream fis = new FileInputStream("1.txt"); 
2.         byte[] b = new byte[100]; 
3.         int len = fis.read(b); 
4.         System.out.println(new String(b,0, len)); 
5.         fis.close(); 

1. FileOutputStream fos = new FileOutputStream("1.txt"); 
2.     fos.write("hello alibaba".getBytes()); 
3.     fos.close(); 

    过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。没有增加额外的读写功能。

      过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。增强了八种基本类型的读写，读取的时候需要知道写入时的顺序，否则读取的内容出错。

1. import java.io.*; 
2. class PipedStreamTest 
3. { 
4.     public static void main(String[] args) 
5.     { 
6.         PipedOutputStream pos=new PipedOutputStream(); 
7.         PipedInputStream pis=new PipedInputStream(); 
8.         try 
9.         { 
10.             pos.connect(pis); 
11.             new Producer(pos).start(); 
12.             new Consumer(pis).start(); 
13.         } 
14.         catch(Exception e) 
15.         { 
16.             e.printStackTrace(); 
17.         } 
18.          
19.     } 
20. } 
21.  
22. class Producer extends Thread 
23. { 
24.     private PipedOutputStream pos; 
25.     public Producer(PipedOutputStream pos) 
26.     { 
27.         this.pos=pos; 
28.     } 
29.     public void run() 
30.     { 
31.         try 
32.         { 
33.             pos.write("Hello,welcome you!".getBytes()); 
34.             pos.close(); 
35.         } 
36.         catch(Exception e) 
37.         { 
38.             e.printStackTrace(); 
39.         } 
40.     } 
41. } 
42.  
43. class Consumer extends Thread 
44. { 
45.     private PipedInputStream pis; 
46.     public Consumer(PipedInputStream pis) 
47.     { 
48.         this.pis=pis; 
49.     } 
50.     public void run() 
51.     { 
52.         try 
53.         { 
54.             byte[] buf=new byte[100]; 
55.             int len=pis.read(buf); 
56.             System.out.println(new String(buf,0,len)); 
57.             pis.close(); 
58.         } 
59.         catch(Exception e) 
60.         { 
61.             e.printStackTrace(); 
62.         } 
63.     } 
64. } 

1. FileOutputStream fos = new FileOutputStream("1.txt"); 
2.         OutputStreamWriter osw = new OutputStreamWriter(fos); 
3.         BufferedWriter bw = new BufferedWriter(osw); 
4.         bw.write("hi, alibaba"); 
5.         bw.close(); 
6.          
7.         FileInputStream fis = new FileInputStream("1.txt"); 
8.         InputStreamReader isr = new InputStreamReader(fis); 
9.         BufferedReader br = new BufferedReader(isr); 
10.         String line = br.readLine(); 
11.         System.out.println(line); 

1. String filename = Sample01.class.getResource("/demo.txt").getFile(); 
2.         FileOutputStream outputStream = new FileOutputStream(filename); 
3.  
4.         FileChannel channel = outputStream.getChannel(); 
5.         FileLock fileLock = channel.tryLock(); 
6.         if (fileLock != null) { 
7.             Thread.sleep(20000); 
8.             System.out.println("file lock release"); 
9.         } 
10.         if (fileLock != null) { 
11.             fileLock.release(); 
12.         } 
13.         channel.close(); 
14.         outputStream.close();