java基础8

File:文件和目录路径名的抽象表现形式.

package basic;

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.Closure;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.IterableMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.bag.HashBag;
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
import org.apache.commons.collections4.functors.ChainedClosure;
import org.apache.commons.collections4.functors.IfClosure;
import org.apache.commons.collections4.functors.NotNullPredicate;
import org.apache.commons.collections4.functors.WhileClosure;
import org.apache.commons.collections4.iterators.ArrayListIterator;
import org.apache.commons.collections4.iterators.FilterIterator;
import org.apache.commons.collections4.iterators.LoopingIterator;
import org.apache.commons.collections4.iterators.UniqueFilterIterator;
import org.apache.commons.collections4.map.HashedMap;
import org.apache.commons.collections4.queue.CircularFifoQueue;
import org.apache.commons.collections4.queue.PredicatedQueue;
import org.apache.commons.collections4.queue.UnmodifiableQueue;
public class Basic {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws ParseException, FileNotFoundException, IOException {
		//两个常量,尽量使用它们,因为跨平台嘛
		//路径分隔符
		System.out.println(File.pathSeparator); //;
		//文件分隔符
		System.out.println(File.separator); // \(windows)       /(linux)
		
		//路径的表示形式
		String pathString="E:\\a\\b.txt";
		pathString="E:"+File.separator+"a"+File.separator+"b.txt";//适合动态生成
		//第三种推荐的方式
		pathString="E:/a/b.txt";//在其它平台上也适用
		
		//绝对路径与相对路径
		String parentPath="E:/a";
		String name="2.jpg";
		File src=new File(parentPath,name);
		src=new File(new File(parentPath),name);
		System.out.println(src.getName());
		System.out.println(src.getPath());
		
		//没有盘符,以user.dir构建:E:myeclipse2014\basic
		src=new File("test.txt");
		System.out.println(src.getPath());
		System.out.println(src.getAbsolutePath());
		src=new File(".");
}
	public static void method(){
		//常用的方法
		File src=new File("./test.txt");
		src.getName();//返回名称
		src.getAbsolutePath();//返回绝对路径
		src.getPath();//如果是绝对路径,返回绝对路径,否则返回相对路径.
		src.getParent();//返回上级目录,如果是相对没有上一级,返回null
		src.exists();//文件是否存在
		src.canRead();//文件是否可读
		src.canWrite();//文件是否可写
		src.isFile();//是否为文件
		src.isDirectory();//是否为目录
		src.isAbsolute();//是否为绝对路径
		src.length();//只有文件才能读出长度,目录读出的长度为0
		src.createNewFile();//创建新文件,如果不存在返回false
		src.delete();//删除文件
		//创建临时文件
		File temp=File.createTempFile("aaa");//默认临时空间,程序退出则删除.
		temp.deleteOnExit();//退出即删除
		//
		src.mkdir();//创建目录,必须保证父目录的存在,如果不存在,创建失败.
		src.mkdirs();//创建目录,如果父目录不存在则一同创建
		src.list();//返回文件|目录的字符串形式
		src.listFiles();//返回File[] 
		//命令设计模式
		src.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				return name.endsWith("java") && new File(dir,name).isFile();
			}
		});
		//
		File.listRoots();//静态方法,输出所有的根目录,即所有的盘符,这样即能遍历所有的文件
		
	}
	
	public static void stream() {
		流:
		数据源:文件,数组,网络,数据库.以程序为中心
		IO流分类:
			流向:输出流与输入流.
			数据:字节流:二进制,可以包括所有文件,包括音频,视频,文档等等
				字符流:只能处理文本文件,纯字符文本
			功能:节点流:包裹源头的.
				处理流:增加功能,提高性能.
		重点:面向File
			字节流:
				输入流:InputStream read方法+Close()                     FileInputStream
				输出流:OutputStream write方法+flush()+close()			FileOutputStream
			字符流:
				输入流:Reader read方法+close							Filereader
				输出流:Writer write方法+close							FileWriter
		操作:建立联系,选择流,数据大小+read+write	关闭资源
		
		
		
	}
}

文件拷贝 :::

 

	public static void main(String[] args) throws ParseException, FileNotFoundException, IOException {
		File file=new File("e:/a/b.txt");
		InputStream is=null;
		try {
			is=new FileInputStream(file);
			byte[] car=new byte[10];
			int len=0;
			while(-1!=(len=is.read(car))){
				String info=new String(car,0,len);
				System.out.println(info); //按字节读取部分输出来肯定会有乱码.待后面解决
			}
		} catch (Exception e) {
			// TODO: handle exceptions读出来肯定是有乱码
		}finally{
			if(null!=is){
				is.close();
			}
		}
	}
	public static void write(){
		File desc=new File("e:/a/b.txt");
		OutputStream os=null;
		try {
			os=new FileOutputStream(desc,true);//追加的方式,false表示覆盖
			String str="this is a java file a java file a java file";
			byte[] data=str.getBytes();
			os.write(data,0,data.length);
			os.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	//文件的拷贝
	public static void copy() throws IOException{
		File src=new File("E:/a/b.txt");
		File desc=new File("E:/a/c.doc");
		InputStream is=new FileInputStream(src);
		OutputStream os=new FileOutputStream(desc);
		byte[] data=new byte[1024];
		int len=0;
		while(-1!=(len=is.read(data))){
			os.write(data,0,len);
		}
		os.flush();
		
		os.close();
		is.close();
	}

文件夹的复制与拷贝:

package basic;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;


import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.Closure;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.IterableMap;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.bag.HashBag;
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
import org.apache.commons.collections4.functors.ChainedClosure;
import org.apache.commons.collections4.functors.IfClosure;
import org.apache.commons.collections4.functors.NotNullPredicate;
import org.apache.commons.collections4.functors.WhileClosure;
import org.apache.commons.collections4.iterators.ArrayListIterator;
import org.apache.commons.collections4.iterators.FilterIterator;
import org.apache.commons.collections4.iterators.LoopingIterator;
import org.apache.commons.collections4.iterators.UniqueFilterIterator;
import org.apache.commons.collections4.map.HashedMap;
import org.apache.commons.collections4.queue.CircularFifoQueue;
import org.apache.commons.collections4.queue.PredicatedQueue;
import org.apache.commons.collections4.queue.UnmodifiableQueue;
public class Basic {
@SuppressWarnings("unchecked")
public static void main(String[] args) throws ParseException, FileNotFoundException, IOException {



}
public static void a(){
字符流:只能处理纯文本,全部为可见字符.Reader-->FileReader       Writer------>FileWriter
File src=new File("E:/a/b.txt");
Reader reader=null;
reader=new FileReader(src); 
char[] flush=new char[10];
int len=0;
while(-1!=(len=reader.read(flush))){
String str=new String(flush,0,len);
System.out.println(str);
}
reader.close();
//
//文件读取
File dest=new File("E:/a/b/c.txt");
Writer wr=null;
wr=new FileWriter(dest);//增加第二个参数表示添加或覆盖,true表示添加
String msgString="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
wr.write(msgString);
wr.append("aaa");
wr.flush();

wr.close();
/
节点流与处理流的关系:节点流位于IO流操作的第一线,所有操作必须通过它们进行操作.处理流可以对其它流进行处理,以增加性能.推荐使用.
字节缓冲流:BufferedInputStream   BufferedOutputStream
字符缓冲流:BufferedReader      BufferedWriter
建议大家在操作的时候都加上缓冲流,以提高性能.
InputStream is=new BufferedInputStream(new FileInputStream(new File("E:/a/b.txt")));
OutputStream os=new BufferedOutputStream(new FileOutputStream(new File("E:/a/b.txt")));
BufferedReader reader2=new BufferedReader(new FileReader(new File("E:/a/b.txt")));
BufferedWriter bWriter=new BufferedWriter(new FileWriter(new File("E:/a/b.txt")));
新增方法
reader2.readLine();一行一行的读取
bWriter.newLine();

转换流:字节流----->字符流      处理编码集,处理乱码
编码:字符---编码集=----二进制
解码:二进制----解码集-----字符
乱码的原因:解码字符集与编码字符集不统一.  字节缺少
String str="中国";//gbk
byte[] data=str.getBytes();
System.out.println(new String(data));
data=str.getBytes("utf-8");
System.out.println(new String(data)); //乱码,因为编码集与解码集不 统一

转换流:OutputStreamWriter     InputStreamReader
BufferedReader bReader=new BufferedReader(new InputStreamReader(new FileReader(new File("")),"utf-8"));
BufferedWriter bufferedWriter2=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(""))));


/
其它流
字节数据输入流 ByteArrayInputStream
字节数组输出流;ByteArrayOutputStream

String msg="我是中国人";
byte[] src=msg.getBytes();
InputStream isInputStream=new BufferedInputStream(new ByteArrayInputStream(src));
byte[] flush=new byte[1024];
int len=0;
while(-1!=(len=isInputStream.read(flush))){
System.out.println(new String(flush,0,len));
}
//字符数组输出流与文件输出流有些不一样,有新增方法,不能使用多态
byte[]desc;
ByteArrayOutputStream bos=new ByteArrayOutputStream();
String msgString2="ddddddddddddddddddddddddddddddd";
byte[] info=msgString2.getBytes();
bos.write(info, 0, info.length);
dest=bos.toByteArray();//当它当成网上的与客户端之间的传递.
bos.close();
数组的长度有限,数据不会太大.
文件---->程序------>字节数组
字节数组----->程序------>文件


///
字节数组流与文件流对接
File src=new File("E:/a/b.txt");
byte[] dest=null;
InputStream is=new BufferedInputStream(new FileInputStream(src));
ByteArrayOutputStream bos=new ByteArrayOutputStream();
byte[] flush=new byte[1024];
int len=0;
while (-1!=(len=is.read(flush))) {
bos.write(flush,0,len);
}
bos.flush();
dest=bos.toByteArray();


//基本数据类型处理流
1.基本类型+String   保留数据加类型.DataInputStream        DataOutputStream
double poing=2.5;
long num=100L;
String string="数据类型";
File dest=new File("E:/a/b.txt");
java.io.DataOutputStream dos=new java.io.DataOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
//按顺序来,为读取做准备
dos.writeDouble(poing);
dos.writeLong(num);
dos.writeUTF(string);//写字符串
dos.flush();
dos.close();
//读取使用DataInputStream
将我们的数据输出到字节数组当中
byte[] desc=null;
ByteArrayOutputStream bos=new ByteArrayOutputStream();
DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(bos));

desc=bos.toByteArray();


其它流,对象处理流,序列化,反序列化
反序列化:输入流  ObjectInputStream
序列化:输出流  ObjectOutputStream
注意:
先序列化后反序列化,反序列化顺序必须与序列化一致
不是所有的对象都可以序列化 java.io.Serializable
不是所有的属性都需要序列化,不想序列化的属性使用transient
//序列化
Employee emp=new Employee("Aaa", 22.1);
ObjectOutputStream oos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
oos.writeObject(emp);
oos.close();
//反序列化
ObjectInputStream dis=new ObjectInputStream(new BufferedInputStream(new FileInputStream(dest)));
Object o=dis.readObject();
if(o instanceof Employee){
Employee employee=(Employee)o;
}
//数组也可以序列化.

关闭流方法,jdk1.7  try with resource
它会自动给你关的,声明的时候使用try

//打印流 PrintStream


}


}

//printStream打印流
System.out.println("test");
PrintStream ps=System.out;
ps.println("abcddefg");
ps.println(false);

//输出到文件
File file=new File("E:/a/b/c.txt");
ps=new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
ps.println("io is so easy......");

ps.close();

//三个常量
System.out.print("");
System.err.print("");
System.in.read();

//封装输入