java之IO

IO
1、对象流：是功能流，读写对象类型的数据
（1）ObjectOutputStream 序列化：将对象数据转换为可存储或可传输状态的数据
（2）ObjectInputStream 反序列化 有新增功能 readObject
注意：
（1）对象流有新增功能不能发生多态
（2）序列化和反序列化顺序要一致
（3）父类实现序列化，子类没有实现的，子类内容可以进行序列化
（4）子类有实现序列化，而父类没有，子类只能序列化子类内容，父类内容使用默认值
（5）需要序列化的对象，类需要实现序列化接口java.io.Serializable
（6）对不需要序列化的属性，可以使用关键字transient

import java.io.*;

import entity.Person;

public class ObjectStream {

	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		out("test02.txt");
		in("test02.txt");
	}
	//写出
	public static void out(String path) throws FileNotFoundException, IOException {
		//创建流
		ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
		//写出数据
		Person p = new Person("张三",23);
		String str = "上海佘山";
		out.writeObject(p);
		out.writeObject(str);
		//刷流
		out.flush();
		//关闭
		out.close();
	}
	
	//读入
	public static void in(String path) throws FileNotFoundException, IOException, ClassNotFoundException {
		//创建流
		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
		//读入
		Person p = (Person)in.readObject();
		String str = (String)in.readObject();
		System.out.println(p);
		System.out.println(str);
		//关闭
		in.close();
	}
}

2、数据流：是功能流，读写作基本数据类型和String数据
（1）DataInputStream 基本数据类型输入流 有新增功能
（2）DataOutputStream 基本数据类型输出流 有新增功能
有新增功能，不能发生多态

public class DataStream {
	public static void main(String[] args) throws IOException {
		write("test01.txt");
		read("test01.txt");
	}
	//读入
	public static void read(String path) throws IOException {
		//创建流
		DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
		//读入
		System.out.println(in.readInt());
		System.out.println(in.readBoolean());
		System.out.println(in.readUTF());
		//关闭
		in.close();
	}
	
	public static void write(String path) throws IOException {
		DataOutputStream out = new DataOutputSt

ream(new BufferedOutputStream(new FileOutputStream(path)));

	int i = 12;
	boolean flag = true;
	String str = "上海";
	
	out.writeInt(i);
	out.writeBoolean(flag);
	out.writeUTF(path);
	
	out.flush();
	out.close();
}

}

Commons-io
1、IO工具类 FileUtils 进行文件操作
2、IO工具类 FilenameUtils 操作文件名

public class CommomcIoDemo01 {

	public static void main(String[] args) throws IOException {
		File file = new File("test01.txt");
		//读写文件
		System.out.println(FileUtils.readFileToString(file, "utf-8"));
		System.out.println(FileUtils.readLines(file, "utf-8"));
		//写出
		FileUtils.writeStringToFile(file, "测试写出字符串", "utf-8", true);
		
		System.out.println("=========================================");
		//操作文件名
		System.out.println(FilenameUtils.getName("test01.txt"));
		System.out.println(FilenameUtils.getExtension("test01.txt"));
		System.out.println(FilenameUtils.isExtension("test01.txt", "txt"));
		
		File fileSrc = new File("test01.txt");
		File fileDes = new File("test03.txt");
		File src = new File("lib");
		File des = new File("lib01");
		//操作文件夹 复制
		FileUtils.copyFile(fileSrc, fileDes);
		FileUtils.copyDirectory(src, des);
		//删除文件夹
		FileUtils.deleteDirectory(des);
		FileUtils.forceDeleteOnExit(des);
	}
}

Collection
容器体系的上层接口
1、set：无序，不可重复
2、list：有序，可重复
（1）ArrayList：底层实现是数组，查询效率高，插入删除效率低

//自定义容器  实现ArrayList 底层使用数组
class MyArrayList{
	private String[] arr;
	private int size;//数组中元素的个数
	
	public MyArrayList() {
		arr = new String[0];
	}
	
	@Override
	public String toString() {
		return "MyArrayList [arr=" + Arrays.toString(arr) + ", size=" + size + "]";
	}

	//添加
	public void add(String str) {
		//1、拷贝原数组
		String[] temp = arr;
		//创建新数组
		arr = new String[size+1];
		//2、将原数组数据复制到新数组
		for(int i=0;i<size;i++) {
			arr[i] = temp[i];
		}
		//3、将新增数据赋值给新数组
		arr[size] = str;
		size++;
	}
	
	//添加到指定位置
	public void add(int index,String str) {
		if(index<0||index>=size) {
			return;
		}
		if(null==str||"".equals(str)) {
			return;
		}
		//创建数组，存储原数组
		String[] temp = arr;
		arr = new String[size+1];
		//遍历原数组,判断索引
		for(int i = 0;i<size;i++) {
			if(i<index) {
				arr[i]=temp[i];
			}else if(i==index) {
				arr[i]=str;
				arr[i+1]=temp[i];
			}else {
				arr[i+1]=temp[i];
			}
		}
		size++;
	}
	//删除
	public void delete(int index) { 
		String[] temp = arr;
		arr = new String[size-1];
		//判断索引是否合法
		if(index>0&&index<size) {
			//遍历原数组
			for(int i=0;i<size;i++) {
				//判断当前索引位置与要删除位置
				if(i==index) {
					arr[i]=temp[i+1];
				}else if(i<index) {
					arr[i]= temp[i];
				}else {
					arr[i-1]=temp[i];
				}
			}
			size--;
		}else {
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}

	//更新
	public void update(int index,String str) {
		if(null==str || "".equals(str)) {
			return;
		}
		if(index<0 || index>=size) {
			return;
		}
		arr[index]=str;
	}
	//查询
	public String get(int index) {
		if(index<0 || index>=size) {
			return "数组下标越界";
		}
		return arr[index];
	}
	
	public int size() {
		return this.size;
	}
}

（2）LinkedList：底层实现是双向链表，插入删除效率高，查询效率低

（3）Vector：底层是数组，相对与ArrayList是安全的
3、遍历：Collection下的所有实现类都可以使用增强for,iterator遍历

public class List03 {
	public static void main(String[] args) {
		//增强程序的稳定性和可读性
		List<String> list = new ArrayList();
		list.add("绿巨人");
		list.add("钢铁侠");
		list.add("灭霸");
		list.add("黑豹");
	
		for(int i=0;i<list.size();i++) {
			if("灭霸".equals(list.get(i))){
				list.add("惊奇队长");
			}
		}
		//list独有的迭代器 ListIterator
		ListIterator<String> lit = list.listIterator();
		while(lit.hasNext()) {
			if("灭霸".equals(lit.next())){
				lit.add("惊奇队长");
			}
		}
		System.out.println(list);
	}
}