Java学习笔记六

1 InputStream和OutputStream:

所有跟输入相关的都需要继承与Inputstream，输出相关的则需要继承OutputStream:

InputStream类结构图：转自别人的博客，觉得挺有用，拿过来学习了。

也许看了上面的图和下面的列表会有疑问，为什么fillterInputstream在下面只有四个继承的子类，而上面有七个，

原因是因为上图中有一些类，比如checkedInputstream是在util包中。如java.util.zip.CheckedInputStream，而下面的列表列出的是io包的相关内容。

class java.io.InputStream

• class java.io.ByteArrayInputStream
• class java.io.FileInputStream
• class java.io.FilterInputStream
  • class java.io.BufferedInputStream
  • class java.io.DataInputStream (implements java.io.DataInput)
  • class java.io.LineNumberInputStream
  • class java.io.PushbackInputStream
• class java.io.ObjectInputStream (implements java.io.ObjectInput, java.io.ObjectStreamConstants)
• class java.io.PipedInputStream
• class java.io.SequenceInputStream
• class java.io.StringBufferInputStream

class java.io.OutputStream

• class java.io.ByteArrayOutputStream
• class java.io.FileOutputStream
• class java.io.FilterOutputStream
  • class java.io.BufferedOutputStream
  • class java.io.DataOutputStream (implements java.io.DataOutput)
  • class java.io.PrintStream
• class java.io.ObjectOutputStream (implements java.io.ObjectOutput, java.io.ObjectStreamConstants)
• class java.io.PipedOutputStream

 

 

The most important reason for the ReaderandWriterhierarchies is for internationalization

 

 

附上File相关的例子：

列出目录中所有的文件和目录名：

类PPrint

import java.util.*;
public class PPrint {
public static String pformat(Collection<?> c) {
    if(c.size() == 0) return "[]";
    StringBuilder result = new StringBuilder("[");
    for(Object elem : c) {
        if(c.size() != 1)
            result.append("\n ");
            result.append(elem);
    }
    if(c.size() != 1)
        result.append("\n");
        result.append("]");
        return result.toString();
}
public static void pprint(Collection<?> c) {
    System.out.println(pformat(c));
}
public static void pprint(Object[] c) {
    System.out.println(pformat(Arrays.asList(c)));
}
} ///:~

类Directory：

import java.util.regex.*;
import java.io.*;
import java.util.*;
public final class Directory {
public static File[]local(File dir, final String regex) {
    return dir.listFiles(new FilenameFilter() {
        private Pattern pattern = Pattern.compile(regex);
        public boolean accept(File dir, String name) {
            return pattern.matcher(new File(name).getName()).matches();
        }
        });
        }
        public static File[] local(String path, final String regex) { // Overloaded
            return local(new File(path), regex);
        }
        // A two-tuple for returning a pair of objects:
        public static class TreeInfo implements Iterable<File> {
            public List<File> files = new ArrayList<File>();
            public List<File> dirs = new ArrayList<File>();
            // The default iterable element is the file list:
            public Iterator<File> iterator() {
                return files.iterator();
            }
            void addAll(TreeInfo other) {
                files.addAll(other.files);
                dirs.addAll(other.dirs);
            }
            public String toString() {
            return "dirs: " + PPrint.pformat(dirs) +
            "\n\nfiles: " + PPrint.pformat(files);
            }
        }
        public static TreeInfo walk(String start, String regex) { // Begin recursion
            return recurseDirs(new File(start), regex);
        }
        public static TreeInfo walk(File start, String regex) { // Overloaded
            return recurseDirs(start, regex);
        }
        public static TreeInfo walk(File start) { // Everything
            return recurseDirs(start, ".*");
        }
        public static TreeInfo walk(String start) {
            return recurseDirs(new File(start), ".*");
        }
        static TreeInfo recurseDirs(File startDir, String regex){
        TreeInfo result = new TreeInfo();
            for(File item : startDir.listFiles()) {
                if(item.isDirectory()) {
                    result.dirs.add(item);
                    result.addAll(recurseDirs(item, regex));
                } else  if(item.getName().matches(regex))
                    result.files.add(item);
            }
        return result;
        }
        // Simple validation test:
        public static void main(String[] args) {
            if(args.length == 0)
                System.out.println(walk("."));
            else
                for(String arg : args)
                    System.out.println(walk(arg));
        }
} ///:~

类File的构造函数：

File(File parent,String child)
          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。File(String pathname)
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。File(String parent,String child)
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。File(URI uri)
          通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

一些有用的方法：
canExecute()
          测试应用程序是否可以执行此抽象路径名表示的文件。
canRead()
          测试应用程序是否可以读取此抽象路径名表示的文件。
canWrite()
          测试应用程序是否可以修改此抽象路径名表示的文件。
delete()
          删除此抽象路径名表示的文件或目录。
exists()
          测试此抽象路径名表示的文件或目录是否存在。
getName()
          返回由此抽象路径名表示的文件或目录的名称。
getParent()
          返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
isDirectory()
          测试此抽象路径名表示的文件是否是一个目录。
length()
          返回由此抽象路径名表示的文件的长度。
list()
          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
listFiles()
          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
mkdir()
          创建此抽象路径名指定的目录。
renameTo(File dest)
          重新命名此抽象路径名表示的文件。

When you are using a DataOutputStream, the only reliable way to write a String so that it can be recovered by a DataInputStream is to use UTF-8 encoding, accomplished in this example using writeUTF( ) and readUTF( ).

can use System.out and System.err right away, System.in must be wrapped before you can read from it.

System.in通常需要用InputStreamReader进行wrapper。

You’ll typically read input a line at a time using readLine( ). To do this, wrap System.in in a BufferedReader, which requires you to convert System.in to a Reader using InputStreamReader. Here’s an example that simply echoes each line that you type in:
//: io/Echo.java
// How to read from standard input.
// {RunByHand}
import java.io.*;
public class Echo {
public static void main(String[] args)
throws IOException {
BufferedReader stdin = new BufferedReader(
new InputStreamReader(System.in));
String s;
while((s = stdin.readLine()) != null && s.length()!= 0)
System.out.println(s);
// An empty line or Ctrl-Z terminates the program
}
}

Java I/o 重定向：

import java.io.*;
public class Redirecting {
public static void main(String[] args)
throws IOException {
PrintStream console = System.out;
BufferedInputStream in = new BufferedInputStream(
new FileInputStream("TextFile.java"));
PrintStream out = new PrintStream(
new BufferedOutputStream(
new FileOutputStream("test.out")));
System.setIn(in);
System.setOut(out);
System.setErr(out);
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
String s;
while((s = br.readLine()) != null)
System.out.println(s);
out.close(); // Remember this!
System.setOut(console);
}
} ///:~