java基础复习总结7

一个File类的对象，表示了磁盘上的文件或目录 当无法操作，要操作要用到后面学到的类

file 的构造方法

File myFile = new File(" myfile. txt");
File myDir = new File(" MyDocs");
File  myFile = new File( myDir, "myfile. 
txt");

public class FileTest6
{
	public static void main(String[] args)
	{
		File file = new File("C:\\abc\\xyz\\hello");
		
		String[] names = file.list();
		
		for(String name : names)
		{
			if(name.endsWith(".java"))
			{
				System.out.println(name);
			}
		}

 一个用来显示目录结构的。java文件

public class ListAllTest
{
	//用于判断目录或文件所处的层次
	private static int time;
	
	// 递归的方法
	public static void deepList(File file)
	{
		if (file.isFile() || 0 == file.listFiles().length)
		{
			return;
		}
		else
		{
			File[] files = file.listFiles();
			
			files = sort(files);
			
			for(File f : files)
			{
				StringBuffer output = new StringBuffer();
				
				if(f.isFile())
				{
					output.append(getTabs(time));
					output.append(f.getName());
				}
				else
				{
					output.append(getTabs(time));
					output.append(f.getName());
					output.append("\\");
				}
				
				System.out.println(output);
				
				if(f.isDirectory())
				{
					time++;
					
					deepList(f);
					
					time--;
				}
			}
		}
	}

	// 整理文件数组，使得目录排在文件之前
	private static File[] sort(File[] files)
	{
		ArrayList<File> sorted = new ArrayList<File>();

		// 寻找到所有的目录
		for (File f : files)
		{
			if (f.isDirectory())
			{
				sorted.add(f);
			}
		}
		// 寻找到所有的文件
		for (File f : files)
		{
			if (f.isFile())
			{
				sorted.add(f);
			}
		}

		return sorted.toArray(new File[files.length]);
	}
	
	//判断需要加多少 tab的方法
	private static String getTabs(int time)
	{
		StringBuffer buffer = new StringBuffer();
		
		for(int i = 0; i < time; i++)
		{
			buffer.append("\t");
		}
		
		return buffer.toString();
	}
	
	
	public static void main(String[] args)
	{
		File file = new File("C:\\Projects\\wsclient");
		
		deepList(file);
	}
	
}

 

 FilenameFilter 

仅定义了一个方法，accept( )。该方法被列表中的每个文件调用一次。它的通常形式如下：boolean accept(File directory, String filename)

 

public class FileTest7
{
	public static void main(String[] args)
	{
		File file = new File("C:\\abc\\xyz\\hello");

		String[] names = file.list(new FilenameFilter()
		{
			public boolean accept(File dir, String name)
			{
				if(name.endsWith(".txt"))
				{
					return true;
				}
				
				return false;
			};
		});
		
		for(String name : names)
		{
			System.out.println(name);
		}
		
	}
}

    数据读取逻辑 ：

open a stream
while more information
read information
close the stream

 

public class InputStreamTest1
{
	public static void main(String[] args) throws Exception
	{
		InputStream is = new FileInputStream("c:/hello.txt");
		
		byte[] buffer = new byte[200];
		
		int length = 0;
		
		while(-1 != (length = is.read(buffer, 0, 200)))
		{
			String str = new String(buffer,0, length);
			
			System.out.println(str);
		}
			
		is.close();	
			
	}
}

 

    写数据的逻辑为：
open a stream
while more information
write information
close the stream

public class OutputStreamTest1
{
	public static void main(String[] args) throws Exception
	{
		OutputStream os = new FileOutputStream("c:\\out.txt", true);
		
		String str = "aaaaa";
		
		byte[] buffer = str.getBytes();
		
		os.write(buffer);
		
		os.close();
	}
}

 

• FileInputStream和FileOutputStream
节点流，用于从文件中读取或往文件中写入字节流。如果在构造
FileOutputStream时，文件已经存在，则覆盖这个文件。
• BufferedInputStream和 BufferedOutputStream
过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读
写的效率。
• DataInputStream和DataOutputStream 过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数 据类型的功能。
• PipedInputStream和PipedOutputStream
管道流，用于线程间的通信。一个线程的PipedInputStream对象
从另一个线程的PipedOutputStream对象读取输入。要使管道流有 用，必须同时构造管道输入流和管道输出流。

• 过滤流的主要特点是在输入输出数据的同时能对所传输的
数据做指定类型或格式的转换，即可实现对二进制字节数
据的理解和编码转换。
• 数据输入流DataInputStream中定义了多个针对不同类型
数 据 的 读 方 法 ， 如 readByte() 、 readBoolean() 、
readShort()、readChar()、readInt()、readLong()、
readFloat()、readDouble()、readLine()等。
• 数据输出流DataOutputStream中定义了多个针对不同类型
数据的 写 方法 ， 如 writeByte() 、writeBoolean() 、
writeShort()、writeChar()、writeInt()、writeLong()、
writeFloat()、writeDouble()、writeChars()等。

public class DataStream1
{
	public static void main(String[] args) throws Exception
	{
		DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(
				new FileOutputStream("data.txt")));

		byte b = 3;
		int i = 12;
		char ch = 'a';
		float f = 3.3f;

		dos.writeByte(b);
		dos.writeInt(i);
		dos.writeChar(ch);
		dos.writeFloat(f);

		dos.close();

		DataInputStream dis = new DataInputStream(new BufferedInputStream(
				new FileInputStream("data.txt")));
		
		//读和写的顺序要保持一致
		System.out.println(dis.readByte());
		System.out.println(dis.readInt());
		System.out.println(dis.readChar());
		System.out.println(dis.readFloat());
		
		dis.close();
	}
}

 

缓冲输入/输出是一个非常普通的性能优化。Java
的BufferedInputStream 类允许把任何InputStream
类“包装”成缓冲流并使它的性能提高
BufferedInputStream 有两个构造方法
– BufferedInputStream(InputStream inputStream)
– BufferedInputStream(InputStream inputStream, int bufSize)
– 第一种形式创建BufferedInputStream流对象并为以后
的使用保存InputStream参数in，并创建一个内部缓冲
区数组来保存输入数据。
– 第二种形式用指定的缓冲区大小size创建
BufferedInputStream流对象，并为以后的使用保存
InputStream参数in。

 

public class BufferedOutputStreamTest1
{
	public static void main(String[] args) throws Exception
	{
		OutputStream os = new FileOutputStream("1.txt");
		
		BufferedOutputStream bos = new BufferedOutputStream(os);
		
		bos.write("http://www.google.com".getBytes());
		
		bos.close();
		os.close();
	}
}

 

• ByteArrayOutputStream是一个把字节数组当作输
出流的实现。ByteArrayOutputStream 有两个构造
方法
– ByteArrayOutputStream( )
– ByteArrayOutputStream(int numBytes)
– 在第一种形式里，一个32位字节的缓冲区被生成。第
二个构造方法生成一个numBytes大小的缓冲区。缓冲
区保存在ByteArrayOutputStream的受保护的buf成员里。
缓冲区的大小在需要的情况下会自动增加。缓冲区保
存的字节数是由ByteArrayOutputStream的受保护的
count域保存的

public class ByteArrayInputStreamTest1
{
	public static void main(String[] args)
	{
		String temp = "abc";
		
		byte[] b = temp.getBytes();
		
		ByteArrayInputStream in = new ByteArrayInputStream(b);
		
		for(int i = 0; i < 2; i++)
		{
			int c;
			
			while(-1 != (c = in.read()))
			{
				if(0 == i)
				{
					System.out.println((char)c);
				}
				else
				{
					System.out.println(Character.toUpperCase((char)c));
				}
			}
					
			System.out.println();
			
			in.reset();
			
			
		}
		
	}
}

 字符流的使用 先使用 inputstreamreader 类 和 outputstreamwriter 包装一个 file 输入输出流 通过这两个类搭建字符 到 字节 转换的桥梁 包装成一个可以用来 做字符 输入输出流

public class StreamTest
{
	public static void main(String[] args) throws Exception
	{
		FileOutputStream fos = new FileOutputStream("file.txt");
		
		OutputStreamWriter osw = new OutputStreamWriter(fos);
		
		BufferedWriter bw = new BufferedWriter(osw);
		
		bw.write("http://www.google.com");
		bw.write("\n");
		bw.write("http://www.baidu.com");
		
		bw.close();
		
		FileInputStream fis = new FileInputStream("file.txt");
		InputStreamReader isr = new InputStreamReader(fis);
		BufferedReader br = new BufferedReader(isr);
		
		
		String str = br.readLine();
		
		while(null != str)
		{
			System.out.println(str);
			
			str = br.readLine();
		}
		
		br.close();
		
		
	}

 

将标准的输入设备包装成输入流

public class StreamTest2
{	
	public static void main(String[] args) throws IOException
	{
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		
		String str;
		
		while(null != (str = br.readLine()))
		{
			System.out.println(str);
		}
		
		br.close();
	}
}