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

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

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

流的操作规律:

1,明确源和目的。

数据源:就是需要读取,可以使用两个体系:InputStreamReader

数据汇:就是需要写入,可以使用两个体系:OutputStreamWriter

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培训、期待与您交流----------

你可能感兴趣的:(Java代码)