黑马程序员---Java基础学习笔记(IO-前篇)

------------Android培训 、Java培训、期待与您交流------------

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。

流的操作规律：

1，明确源和目的。

数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

如果是：数据源：Reader

    数据汇：Writer

如果不是：数据源：InputStream

      数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

明确操作的数据设备。

数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

如果需要就进行装饰。

转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：

InputStreamReader

|--FileReader

OutputStreamWriter

|--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

FileReader fr = new FileReader("a.txt");

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 = 字节流+编码表。

转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

public class IOTest 
{
	/*
	public static void main(String[] args) throws IOException 
	{
		//创建一个FileWriter对象，该对象一旦被初始化就必须要明确被操作的文件
		//而且该文件会被创建到指定的目录下，如果该目录下已有同名文件，将被覆盖。
		FileWriter fw = new FileWriter("iojava.txt");
		//调用write方法，将字符串写入到流中
		fw.write("abcde");
		//刷新流对象中的缓冲流中的数据，将数据刷到目的文件中
		//fw.flush();
		//关闭流资源，但是关闭之前会刷新一次内部缓冲流中的数据，将数据刷到目的文件
		//flush刷新后，流可以继续使用，close刷新后，流将关闭无法使用。
		fw.close();
	}
	*/
	/*
	//标准的IO异常处理程序
	public static void main(String[] args)
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("iojava01.txt");
			fw.write("abcdefg");//仅仅是写到数据流中，还没有写到目的文件中
		}
		catch (IOException e) 
		{
			System.out.println(e.toString());
		}
		finally
		{
			try 
			{
				if(fw!=null)//避免空指针异常
				fw.close();
			} 
			catch (IOException e) 
			{
				System.out.println(e.toString());
			}
		}
	}
	*/
	
	//对已有文件的数据续写
	public static void main(String[] args) throws IOException 
	{
		//传递true参数，代表不覆盖已存在的文件，并在已有文件末尾处续写数据
		FileWriter fw = new FileWriter("iojava.txt" , true);
		fw.write("haha\r\njava");// \r\n为Win中回车符
		fw.close();
	}
}

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

File类常见方法：

1：创建。

boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

boolean mkdir()：创建此抽象路径名指定的目录。

boolean mkdirs()：创建多级目录。

2：删除。

boolean delete()：删除此抽象路径名表示的文件或目录。

void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

long length()：获取文件大小。

String getName()：返回由此抽象路径名表示的文件或目录的名称。

String getPath()：将此抽象路径名转换为一个路径名字符串。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。

long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。

4：判断：

boolean exists()：判断文件或者文件夹是否存在。

boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

 boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;

public class FileClassDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) throws IOException 
	{
		//consMethod();
		//createFile();
		//deleteFile();
		//executeFile();
		//judgeFile();
		//listRoots();
		//listDemo();
		//listDemo1();
		//listFiles();
		/*
		//递归调用
		File dir = new File("C:\\A");
		showDir(dir , 0);
		*/
		toBinary(6);
		//sop("num="+getSum(10));
	}
	//创建File对象
	public static void consMethod()
	{
		//将iojava06.txt封装成为file对象，可以将已有的和未出现的
		//文件或者文件夹封装成对象
		File f = new File("iojava06.txt");
		//File ff = new File("C:\\A\\ff.txt");
		//将文件和目录分为两个参数来传递，好处是第二参数可变
		File ff = new File("C:\\A" , "ff.txt");
		
		File d = new File("C:\\A");
		File fff = new File(d,"fff.txt");
		
		File ffff = new File("C:"+File.separator+"A"+File.separator+"ffff.txt");
		sop("f:"+f);
		sop("ff:"+ff);
		sop("fff:"+fff);
		sop("ffff:"+ffff);
	}
	
	public static void createFile() throws IOException
	{
		File f = new File("file.txt");
		sop("creat:"+f.createNewFile());
		//在指定位置创建文件，若存在，则不创建返回false，和输出流不一样，后者对象
		//一建立就会创建文件，而且若文件已存在则会覆盖。
	}
	
	public static void deleteFile() throws IOException
	{
		File f = new File("file.txt");
		f.deleteOnExit();//在程序退出时删除指定文件
		sop("delete:"+f.delete());
	}
	
	public static void executeFile() throws IOException
	{
		File f = new File("iojava04.txt");
		sop("execute:"+f.canExecute());
	}
	
	public static void judgeFile() throws IOException
	{
		File f = new File("file.txt");
		sop("creat:"+f.createNewFile());
		sop("file:"+f.exists());//判断之前要明确是否存在
		sop("dir:"+f.isDirectory());
		sop("file:"+f.isFile());
		sop(f.isAbsolute());//判断是否是绝对路径
		sop(f.isHidden());//是否是隐藏文件
		
		File ff = new File("C:\\A\\filecopy.txt");
		sop("rename:"+f.renameTo(ff));
	}
	
	public static void listRoots()
	{
		File[] files = File.listRoots();//显示所有盘符
		for(File f : files)
		{
			sop(f);
		}
	}
	
	public static void listDemo()
	{
		File f = new File("C:\\");//C盘目录下所有的文件或者文件夹以及隐藏文件
		String[] filenames = f.list();//当list访问的是一个文件是，则会返回null
		for(String names : filenames)
		{
			sop(names);
		}
	}
	
	public static void listDemo1()
	{
		File f = new File("C:\\A\\");
		String[] filenames = f.list(new FilenameFilter() 
		{
			public boolean accept(File dir, String name) 
			{
				return name.endsWith(".txt");
			}
		});
		for(String names : filenames)
		{
			sop(names);
		}
	}
	
	public static void listFiles()
	{
		File dir = new File("C:\\A");
		File[] files = dir.listFiles();
		for(File f : files)
		{
			sop(f.getName()+"::"+f.length()+"K");
		}
	}
	
	public static void showDir(File dir , int lv)
	{
		/*
		 * 列出指定目录下文件或者文件夹，包含子目录中的内容。
		 * 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可
		 * 在列出工程中出现的还是目录的话，还可以再次调用本功能。
		 * 也就是函数自身调用自身，这就是递归
		 * 递归需要注意：
		 * 1.限定条件：需要有条件判断是程序能够停止
		 * 2.注意递归的次数，以防内存溢出。
		 */
		sop(getLevel(lv)+dir.getName());
		lv++;
		File[] files = dir.listFiles();
		for(int i = 0 ; i < files.length ; i++)
		{
			if(files[i].isDirectory())
				showDir(files[i] , lv);
			else
				sop(getLevel(lv)+files[i]);
		}
	}
	public static String getLevel(int lv)
	{
		StringBuilder sbr = new StringBuilder();
		sbr.append("|--");
		for(int i = 0 ; i < lv ; i++)
		{
			sbr.insert(0 , "|  ");
		}
		return sbr.toString();
	}
	
	public static void toBinary(int num)
	{
		//递归打印二进制
		if(num>0)
		{
			toBinary(num/2);
			System.out.print(num%2);
		}
	}
	public static int getSum(int num)
	{
		//求和
		if(num == 1)
			return 1;
		else
		{
			return num+getSum(num-1);
		}
	}
}

------------Android培训 、Java培训、期待与您交流----------