黑马程序员_java_IO流_FileInputStream_FileOutputStream_File_递归_Properties_ByteArrayInputStream_ByteArrayOut

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您


交流！ ----------




一、FileInputStream和FileOutputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


class FileStream 
{
	public static void main(String[] args) 
	{
		//xieRu();
		//duQu_1();
		//duQu_2();
		duQu_3();
	}


	//读取方式一
	public static void duQu_1()
	{
		FileInputStream fis = null;
		try
		{
			//关联一个文件
			fis = new FileInputStream("aaa.txt");
			int num = 0;
			while((num = fis.read()) != -1) //判断只要流中有元素就输出
			{
				System.out.println((char)num);
			}
		}
		catch (IOException e) //捕获并处理异常
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			if(fis != null) //判断是否被初始化过
				try
				{
					if(fis != null)
						fis.close(); //关闭资源
				}
				catch (IOException e) //捕获并处理异常
				{
					throw new RuntimeException("读取关闭失败");
				}
		}
	}


	//读取方式二
	public static void duQu_2()
	{
		FileInputStream fis = null;
		try
		{
			//写一个读取字节流
			fis = new FileInputStream("aaa.txt");
			byte[] by = new byte[1024]; //定义一个字节数组
			int len = 0;
			while((len = fis.read(by)) != -1) //判断只要流中有元素就输出
			{
				System.out.println(new String(by, 0, len)); //把字节转成字符串形式在控制台上打印
			}
		}
		catch (IOException e) //捕获并处理异常
		{
			throw new RuntimeException("读取失败"); 
		}
		finally
		{
			if(fis != null) //判断是否被实例化过
				try
				{
					fis.close(); //关闭资源
				}
				catch (IOException e)
				{
					throw new RuntimeException("读取关闭失败");
				}
		}
	}


	//读取方式三
	public static void duQu_3()
	{
		FileInputStream fis = null;
		//声明异常
		try
		{
			//写一个读取字节流
			fis = new FileInputStream("aaa.txt");
			byte[] by = new byte[fis.available()]; //定义一个字节数组
			fis.read(by); //读取字节数组
			System.out.println(new String(by)); //把读取到的字节数组
		} 
		catch (IOException e) //捕获并处理异常
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			if(fis != null) //判断fis是否别初始化过。
				try
				{
					fis.close(); //关闭资源
				}
				catch (IOException e) //捕获并处理异常
				{
					throw new RuntimeException("读取关闭失败");
				}
		}
	}


	public static void xieRu()
	{
		FileOutputStream fos = null;
		try
		{
			//创建一个文件
			fos = new FileOutputStream("aaa.txt");
			fos.write("abcdefagsd".getBytes()); //往文件中输入字符
		}
		catch (IOException e) //捕获并处理异常
		{
			throw new RuntimeException("写入失败");
		}
		finally
		{
			try
			{
				if(fos != null) //判读是否被实例化过
					fos.close(); //关闭资源
			}
			catch (IOException e) //捕获并处理异常
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}

二、读取转换流和写入转换流

import java.io.InputStream;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


class ZhuanHuanStream 
{
	public static void main(String[] args) throws IOException
	{
		/*
		//获取键盘录入对象。
		InputStream it = System.in;


		//将字节流对象转成字符流对象，使用转换流，InputStreamReader
		InputStreamReader isr = new InputStreamReader(it);


		//为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
		BufferedReader bis = new BufferedReader(isr);
		*/
		//读取流简写格式
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//写入流简写格式
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		String s = null;
		while((s = br.readLine()) != null)
		{
			if("over".equals(s))
				break;
			bw.write(s.toUpperCase());
			bw.newLine(); //换行
			bw.flush(); //刷新一下
		}
	}
}

三、File类的应用


/*
File常见方法，
1、创建。
boolean createNewFile(); 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件，而且文件已经存在，会覆盖
boolean mkdir();创建单级文件夹
boolean mkdirs();创建多级文件夹


2、删除。
boolean delete();删除失败返回false。
void deleteOnExit();在程序退出时删除指定文件


3、判断
boolean exists();文件是否存在
ifFile(); 判断是否是一个标准文件
isDirectory();是否在同一个目录
isHidden(); 判断是否是隐藏文件
isAbsolute();是否为绝对路径


4、获取信息。
getParent(); 该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null.如果相对路径中有上一层目录，那么该
目录就是返回结果


renameTo(); 修改文件名。类似于电脑中的剪切
*/

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


class FileDemo 
{
	public static void main(String[] args) throws IOException
	{
		mothed_1();
	}


	public static void mothed_1()
	{
		File f1 = new File("c:\\aaa.txt");
		File f2 = new File("c:\\bbb.java");
		p(f1.renameTo(f2));
	}


	public static void mothed() throws IOException
	{
		File f = new File("a\\a.txt");
		//f.mkdirs();
		//f.mkdir(); //创建文件夹
		//f.deleteOnExit(); //程序结束就删除文件
		//p(f.createNewFile()); //创建文件
		//p(f.delete()); //删除文件
		//p(f.isFile()); //判断是否是一个标准文件
		//p(f.isDirectory()); //是否在同一个目录
		//p(f.isHidden()); //判断是否为隐藏文件
		//p(f.isAbsolute()); //是否为绝对路径
		p(f.getParent());
	}


	//创建File对象
	public static void duiXiang()
	{
		//将a.txt封装成file对象。可以将已有的和未出现的文件或者文件封装成对象
		File f1 = new File("a.txt");
		File f2 = new File("c:\\aaa\\bbb\\ccc\\a.txt");


		File f = new File("c:\\abc");
		File f3 = new File(f, "a.txt");


		File f4 = new File("c:\\" + File.separator + "aaa\\" + File.separator + "a.txt");
		p(f1);
		p(f2);
		p(f3);
		p(f4);
	}


	public static void p(Object obj)
	{
		System.out.println(obj);
	}


}

四、递归


/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
因为目录下还有目录，只要使用同一个列出目录功能的函数完成即可。
也在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。这种表现形式，或者变成手法，称为递归。


递归要注意：
1、限定条件。


2、要注意递归的次数，尽量避免内存溢出。
*/

import java.io.File;


class FileDemo3
{
	public static void main(String[] args) 
	{
		//File f = new File("c:\\EditPlus");
		//diGui(f);
		int n = 320;
		System.out.println(mothed(n));
	}


	//计算和
	public static int mothed(int n)
	{
		if(n == 1)
			return 1;
		return n + mothed(n - 1);
	}


	//写一个关于递归的函数
	public static void diGui(File f)
	{
		File[] f1 = f.listFiles(); //把木木传递给变量f1
		for(int i = 0; i < f1.length; i++) //遍历数组
		{
			if(f1[i].isDirectory()) //判断f1[i]是父目录吗
				diGui(f1[i]);
			else
				System.out.println(f1[i]);
		}
	}


}

五、Properties类的基本应用


/*
Properties是hashtable的子类。
也就是说他具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO想集合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。


那么在加载数据时，需要数据有固定格式：键=值
*/

import java.util.Set;
import java.util.Properties;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.FileOutputStream;


class PropertiesDemo 
{
	public static void main(String[] args) 
	{
		//setGet();
		//mothed();
		mothed_1();
	}


	//运用Properties类中的方法将流中的数据存储到集合中。
	public static void mothed_1()
	{
		Properties pro = null;
		BufferedReader br = null;
		try
		{
			pro = new Properties(); //实例化集合
			br = new BufferedReader(new FileReader("into.txt")); //关联一个文件
			pro.load(br); //把读取的文件存储到集合中
	
			//修改文件
			pro.setProperty("wangwu", "2d3");
			//新建一个写入流
			FileOutputStream fos = new FileOutputStream("into.txt");
			//调用store方法改变文本中的数据
			pro.store(fos, "heihei");


			//System.out.println(pro); //打印集合中的文件
			pro.list(System.out); //调用list方法，打印集合中的文件
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			try
			{
				if(br != null)
					br.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}
	}


	/*
	演示，如何将流中的数据存储到集合中。
	想要将info.txt中键值数据存到集合中进行操作。


	步骤：
	1，用一个流和into.txt文件关联
	2，读取一行数据，将改行数据用"="进行切割。
	3，等号左边作为键，右边作为值，存入到Properties集合中即可
	*/
	public static void mothed()
	{
		BufferedReader br = null;
		Properties pt = new Properties();
		try
		{
			br = new BufferedReader(new FileReader("into.txt"));
			String s = null;
			while((s = br.readLine()) != null)
			{
				String[] ss = s.split("="); //对文本中读取到的数据进行切割
				pt.setProperty(ss[0], ss[1]);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取文件失败");
		}
		finally
		{
			try
			{
				if(br != null)
					br.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取文件关闭失败");
			}
		}
		System.out.println(pt);
	}


	//设置和获取元素
	public static void setGet()
	{
		Properties pt = new Properties(); //建一个Properties容器
		pt.setProperty("zhangsan", "23");
		pt.setProperty("lisi", "32");
		//System.out.println(pt);
		pt.setProperty("lisi", "2444");
		Set<String> ss = pt.stringPropertyNames();
		for(String s : ss)
		{
			System.out.println(s + pt.getProperty(s));
		}
	}


}

六、ByteArrayInputStream和ByteArrayOutputStream的基本应用


/*
用于操作字节数据的流对象。
ByteArrayInputStream: 在构造的时候，需要接收数据源，而且数据源是一个字节数组。
ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地


因为这两个流对象都操作的数组，并没有使用系统资源
所以，不用进行close关闭。


在流操作归路讲解时，
源设备：
键盘(System.in),硬盘(FileStream),内存(ArrayStream).
目的设备：
控制台(System.out),硬盘(FileStream),内存(ArrayStream).
用流的读写思想来操作数据
*/

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;


class ByteArrayStream 
{
	public static void main(String[] args) 
	{
		//数据源
		ByteArrayInputStream bais = new ByteArrayInputStream("asdfsadfassdfasdfwefa".getBytes());
		//数据目的
		ByteArrayOutputStream baos = new ByteArrayOutputStream();


		int b = 0;
		while((b = bais.read()) != -1)
		{
			baos.write(b);
		}


		System.out.println(baos.size());
		System.out.println(baos.toString());
	}
}

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训


</a>、期待与您交流！ ----------------------


详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>