Top

JAVA SE02 Unit01

1. 输出一个目录中的内容
2. 输出一个目录中所有扩展名为.txt的文件
3. 测试RandomAccessFile的read()和write()方法
4. 测试RandomAccessFile的read(byte[])和write(byte[])方法
5. 测试文件指针的相关方法

1 输出一个目录中的内容

1.1 问题

输出当前目录下所有的内容。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

首先，新建TestFile类，并在类中新建测试方法testListFiles，代码如下所示：

import java.io.File;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
#cold_bold	@Test
#cold_bold	public void testListFiles() {
#cold_bold		
#cold_bold	}
}

步骤二：获取当前目录下的内容

首先，使用File类构建表示当前目录的file对象；然后，使用File类的listFiles方法获取到当前目录下所有的内容，包括文件和目录；最后，遍历listFiles方法返回的数组查看当前目录下的内容，代码如下所示：

import java.io.File;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
	@Test
	public void testListFiles() {
#cold_bold		File dir = new File(".");
#cold_bold		File[] subs = dir.listFiles();
#cold_bold		for (File sub : subs) {
#cold_bold			System.out.println(sub);
#cold_bold		}
	}
}

上述代码中，“.”表示的当前目录，本题案例的当前目录，就是当前工程下。

步骤三：运行

运行testListFiles方法，控制台输出结果如下所示：

.\.classpath
.\.project
.\a
.\bin
.\demo
.\doc
.\lib
.\myDir
.\src

1.3 完整代码

本案例的完整代码如下所示：

import java.io.File;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
	@Test
	public void testListFiles() {
		File dir = new File(".");
		File[] subs = dir.listFiles();
		for (File sub : subs) {
			System.out.println(sub);
		}
	}
}

2 输出一个目录中所有扩展名为.txt的文件

2.1 问题

输出当前目录下，所有扩展名为.txt的文件。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：构建测试方法

首先，在TestFile类中新建测试方法testFileFilter，代码如下所示：

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
#cold_bold	@Test
#cold_bold	public void testFileFilter() {
#cold_bold		
#cold_bold	}
}

步骤二：获取当前目录下的扩展名为.txt的文件

首先，使用File类构建表示当前目录的file对象；然后，使用File类的listFiles方法获取当前目录下的扩展名为.txt的文件；最后，遍历listFiles方法返回的数组查看当前目录下的内容，代码如下所示：

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
	@Test
	public void testFileFilter() {
#cold_bold		File dir = new File(".");
#cold_bold		File[] subs = dir.listFiles(new FileFilter() {
#cold_bold			public boolean accept(File file) {
#cold_bold				return file.getName().endsWith(".txt");
#cold_bold			}
#cold_bold		});
#cold_bold		for (File sub : subs) {
#cold_bold			System.out.println(sub);
#cold_bold		}
	}
}

此处使用了listFiles方法，该方法的参数为FileFilter类型，FileFilter是抽象路径名的过滤器。此接口的实例可传递给 File 类的 listFiles(FileFilter) 方法,实现过滤功能。

2.3 完整代码

本案例的完整代码如下所示：

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import org.junit.Test;

public class TestFile {
//...（之前案例的代码，略）

	@Test
	public void testFileFilter() {
		File dir = new File(".");
		File[] subs = dir.listFiles(new FileFilter() {
			public boolean accept(File file) {
				return file.getName().endsWith(".txt");
			}
		});
		for (File sub : subs) {
			System.out.println(sub);
		}
	}
}

3 测试RandomAccessFile的read()和write()方法

3.1 问题

使用RandomAccessFile类进行文件的读写，详细要求如下：

1）使用RandomAccessFile的write方法向文件raf.dat写入数字“1”。

2）使用RandomAccessFile的read方法从文件raf.dat中将数字“1”读取出来并打印到控制台。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：新建TestRandomAccessFile类，添加测试方法testWrite方法

首先，新建类TestRandomAccessFile；然后，在该类中添加测试方法testWrite，代码如下所示：

import org.junit.Test;

/**
 * 测试RandomAccessFile
 */
public class TestRandomAccessFile {
	/**
	 * 测试写出方法
	 * @throws Exception
	 */
	@Test
	public void testWrite()throws Exception{
	}
}

步骤二：使用RandomAccessFile类的write方法向文件写数据

首先，使用读写模式创建RandomAccessFile类的对象；然后，使用RandomAccessFile类的write方法向文件raf.dat写数字“1”。该方法写出一个字节，写出的是int值的低8位。代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
 */
public class TestRandomAccessFile {
	/**
	 * 测试写出方法
	 * @throws Exception
	 */
	@Test
	public void testWrite()throws Exception{
#cold_bold		RandomAccessFile raf = new RandomAccessFile("raf.dat","rw");
#cold_bold		//写出一个字节,写的是int值的低8位
#cold_bold		raf.write(1);
#cold_bold		raf.close();
	}
}

运行testWrite方法，在当前工程下生成文件raf.dat，该文件的大小为1个字节。

步骤三：添加测试方法testRead

在TestRandomAccessFile类中添加测试方法testRead，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;
/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试写出方法
	 * @throws Exception
	 */
	@Test
	public void testWrite()throws Exception{
		//...（代码略）
	}
	/**
	 * 测试读取方法
	 */
#cold_bold	@Test
#cold_bold	public void testRead()throws Exception{
#cold_bold	}
}

步骤四：使用TestRandomAccessFile类的read方法从文件读取数据

首先，使用只读模式创建RandomAccessFile类的对象；使用RandomAccessFile类的read方法从文件raf.dat读取数字“1”。该方法读取一个字节，读取的是int值的低8位。代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试写出方法
	 * @throws Exception
	 */
	@Test
	public void testWrite()throws Exception{
		//...（代码略）
	}
	/**
	 * 测试读取方法
	 */
	@Test
	public void testRead()throws Exception{
#cold_bold		RandomAccessFile raf = new RandomAccessFile("raf.dat","r");
#cold_bold		//读取一个字节
#cold_bold		int d = raf.read();
#cold_bold		System.out.println(d);
#cold_bold		raf.close();
	}
}

运行testRead方法，控制台输出结果如下：

1

从输出结果可以看出，已经将数字“1”读取出来。

3.3 完整代码

本案例的完整代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试写出方法
	 * @throws Exception
	 */
	@Test
	public void testWrite()throws Exception{
		RandomAccessFile raf = new RandomAccessFile("raf.dat","rw");
		//写出一个字节,写的是int值的低8位
		raf.write(1);
		raf.close();
	}
	/**
	 * 测试读取方法
	 */
	@Test
	public void testRead()throws Exception{
		RandomAccessFile raf = new RandomAccessFile("raf.dat","r");
		//读取一个字节
		int d = raf.read();
		System.out.println(d);
		raf.close();
	}
}

4 测试RandomAccessFile的read(byte[])和write(byte[])方法

4.1 问题

使用RandomAccessFile类进行文件的读写，详细要求如下：

1）使用RandomAccessFile的write(byte[])方法向文件raf.dat写入字符串“HelloWorld”。

2）使用RandomAccessFile的read(byte[])方法从文件raf.dat中将字符串“HelloWorld”读取出来并打印到控制台。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：在TestRandomAccessFile类中，添加测试方法testWriteByteArray方法

在TestRandomAccessFile类中添加测试方法testWriteByteArray，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试批量写出
	 */
#cold_bold	@Test
#cold_bold	public void testWriteByteArray() throws Exception {
#cold_bold	}
}

步骤二：使用RandomAccessFile类的write(byte[])方法向文件写数据

首先，使用读写模式创建RandomAccessFile类的对象；然后，使用RandomAccessFile类的write(byte[])方法向文件raf.dat中写字符串“HelloWorld”。该方法将字节数组中所有字节一次性写出。代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试批量写出
	 */
	@Test
	public void testWriteByteArray() throws Exception {
#cold_bold		RandomAccessFile raf = new RandomAccessFile("raf.dat", "rw");
#cold_bold		// 将字符串按照默认编码转换为字节数组
#cold_bold		byte[] buf = "HelloWorld".getBytes();
#cold_bold		// 将字节数组中所有字节一次性写出
#cold_bold		raf.write(buf);
#cold_bold		raf.close();
	}
}

运行testWriteByteArray方法，将当前工程下的raf.dat文件的大小变为10个字节。

步骤三：添加测试方法testReadByteArray

在TestRandomAccessFile类中添加测试方法testReadByteArray，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试批量写出
	 */
	@Test
	public void testWriteByteArray() throws Exception {
		//...（代码略）
	}
	/**
	 * 测试批量读取
	 */
#cold_bold	@Test
#cold_bold	public void testReadByteArray() throws Exception {
#cold_bold	}
}

步骤四：使用TestRandomAccessFile类的read（byte[]）方法从文件读取数据

首先，使用只读模式创建RandomAccessFile类的对象；使用RandomAccessFile类的read(byte[])方法从文件raf.dat读取字符串“HelloWord”。代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
*/
public class TestRandomAccessFile {
	/**
	 * 测试批量写出
	 */
	@Test
	public void testWriteByteArray() throws Exception {
		//...（代码略）
	}
	/**
	 * 测试批量读取
	 */
	@Test
	public void testReadByteArray() throws Exception {
#cold_bold		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
#cold_bold		// 创建长度为10的字节数组
#cold_bold		byte[] buf = new byte[10];
#cold_bold		// 尝试读取10个字节存入数组，返回值为读取的字节量
#cold_bold		int len = raf.read(buf);
#cold_bold		System.out.println("读取到了:" + len + "个字节");
#cold_bold		System.out.println(new String(buf));
#cold_bold		raf.close();
	}
}

运行testReadByteArray方法，控制台输出结果如下：

读取到了:10个字节
HelloWorld

从输出结果可以看出，已经将字符串“HelloWorld”读取出来了。

4.3 完整代码

本案例中，类TestRandomAccessFile的完整代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile
 */
public class TestRandomAccessFile {
//...（之前案例的代码，略）

	/**
	 * 测试批量写出
	 * 
	 * @throws Exception
	 */
	@Test
	public void testWriteByteArray() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("raf.dat", "rw");
		// 将字符串按照默认编码转换为字节
		byte[] buf = "HelloWorld".getBytes();
		// 将字节数组中所有字节一次性写出
		raf.write(buf);
		raf.close();
	}

	/**
	 * 测试批量读取
	 * 
	 * @throws Exception
	 */
	@Test
	public void testReadByteArray() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
		// 创建长度为10的字节数组
		byte[] buf = new byte[10];
		// 尝试读取10个字节存入数组，返回值为读取的字节量
		int len = raf.read(buf);
		System.out.println("读取到了:" + len + "个字节");
		System.out.println(new String(buf));
		raf.close();
	}
}

5 测试文件指针的相关方法

5.1 问题

使用RandomAccessFile类的对象操作文件指针，详细要求如下：

1）获取文件raf.dat的指针。

2）设置指针读取raf.dat中的字符串“World”。

3）将指针移动到raf.dat文件的开始。

5.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：添加测试方法testPointer方法

在TestRandomAccessFile类中添加测试方法testPointer，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile 
 */
public class TestRandomAccessFile {
	/**
	 * 测试指针相关方法
	 */
#cold_bold	@Test
#cold_bold	public void testPointer() throws Exception {
#cold_bold	
#cold_bold	}
}

步骤二：使用RandomAccessFile类的getFilePointer方法获取文件指针

使用RandomAccessFile类的getFilePointer方法获取raf.dat文件的指针，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile 
 */
public class TestRandomAccessFile {
	/**
	 * 测试指针相关方法
	 */
	@Test
	public void testPointer() throws Exception {
#cold_bold		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
#cold_bold		// 输出指针位置,默认从0开始(文件的第一个字节位置)
#cold_bold		System.out.println("指针位置:" + raf.getFilePointer());
#cold_bold
#cold_bold		raf.close();
	}
}

文件指针位置默认从0开始，即文件的第一个字节所在的位置。

运行testPointer方法，控制台输出结果如下：

指针位置:0

从输出结果可以看出，文件指针位置为0。

步骤三：读取字符串“World“

首先，使用RandomAccessFile类的skipBytes方法跳过“Hello”这5个字节并查看此时的文件指针位置；然后，使用RandomAccessFile类的read(byte[])方法读取“World”并输出；最后，再次获取此时指针的位置，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile 
 */
public class TestRandomAccessFile {
	/**
	 * 测试指针相关方法
	 */
	@Test
	public void testPointer() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
		// 输出指针位置,默认从0开始(文件的第一个字节位置)
		System.out.println("指针位置:" + raf.getFilePointer());

#cold_bold		// 读取world,需要将hello这5个字节跳过
#cold_bold		raf.skipBytes(5);
#cold_bold		System.out.println("指针位置:" + raf.getFilePointer());
#cold_bold		// 读取world这5个字节
#cold_bold		byte[] buf = new byte[5];
#cold_bold		raf.read(buf);
#cold_bold		System.out.println(new String(buf));
#cold_bold		System.out.println("指针位置:" + raf.getFilePointer());
raf.close();
	}
}

运行testPointer方法，控制台的输出结果如下：

指针位置:0
#cold_bold指针位置:5
#cold_boldWorld
#cold_bold指针位置:10

从输出结果可以看出，当使用skipBytes方法跳过5个字节时，文件指针位置为5；从指针位置5开始读取，读取到了字符串“World”；读取完字符串“World”后，文件的指针位置变为10。

步骤四：将指针移到文件开始

使用RandomAccessFile类的seek方法将文件指针移到raf.dat文件的开始，代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile 
 */
public class TestRandomAccessFile {
	/**
	 * 测试指针相关方法
	 */
	@Test
	public void testPointer() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
		// 输出指针位置,默认从0开始(文件的第一个字节位置)
		System.out.println("指针位置:" + raf.getFilePointer());

		// 读取World,需要将Hello这5个字节跳过
		raf.skipBytes(5);
		System.out.println("指针位置:" + raf.getFilePointer());
		// 读取World这5个字节
		byte[] buf = new byte[5];
		raf.read(buf);
		System.out.println(new String(buf));
		System.out.println("指针位置:" + raf.getFilePointer());

		// 将游标移动到文件开始
#cold_bold		raf.seek(0);
#cold_bold		System.out.println("指针位置:" + raf.getFilePointer());

		raf.close();
	}
}

运行testPointer方法，控制台输出结果如下：

指针位置:0
指针位置:5
world
指针位置:10
#cold_bold指针位置:0

从输出结果可以看出，已经将指针移到了文件的开始。

5.3 完整代码

本案例的完整代码如下所示：

import java.io.RandomAccessFile;
import org.junit.Test;

/**
 * 测试RandomAccessFile 
 */
public class TestRandomAccessFile {
//...（之前案例的代码，略）

	/**
	 * 测试指针相关方法
	 */
	@Test
	public void testPointer() throws Exception {
		RandomAccessFile raf = new RandomAccessFile("raf.dat", "r");
		// 输出指针位置,默认从0开始(文件的第一个字节位置)
		System.out.println("指针位置:" + raf.getFilePointer());

		// 读取world,需要将hello这5个字节跳过
		raf.skipBytes(5);
		System.out.println("指针位置:" + raf.getFilePointer());
		// 读取world这5个字节
		byte[] buf = new byte[5];
		raf.read(buf);
		System.out.println(new String(buf));
		System.out.println("指针位置:" + raf.getFilePointer());

		// 将游标移动到文件开始
		raf.seek(0);
		System.out.println("指针位置:" + raf.getFilePointer());

		raf.close();
	}
}