Java第四周总结

public class Demo1 {
	public static void main(String[] args) {
		/*
		 * 因为Collection<E>是一个接口，接口没有自己的类对象
		 * 这里使用Collection接口的实现类来完成演示过程 ArrayList<E>
		 */
		Collection<String> c = new ArrayList<String>();
		
		c.add("82年的拉菲");
		c.add("82年的雪碧");
		c.add("82年的可乐");
		c.add("82年的老雪");
		
		System.out.println(c);
		
		Collection<String> c1 = new ArrayList<String>();
		
		c1.add("百威");
		c1.add("福佳白");
		c1.add("精酿啤酒");
		c1.add("修道院啤酒");
		
		c.addAll(c1);
		
		System.out.println(c);
		
		c.remove("82年的雪碧");
		System.out.println(c);
		
		//c.removeAll(c1);
		//System.out.println(c);
		
		//c.retainAll(c1);
		//System.out.println(c);
		
		System.out.println("size:" + c.size());
		System.out.println(c.isEmpty());
		
		System.out.println(c.contains("百威"));
		System.out.println(c.contains("哈尔滨"));
		
		System.out.println(c.containsAll(c1));
		
		c1.add("野格");
		System.out.println(c.containsAll(c1));
	}
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo1 {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		
		c.add("星期一");
		c.add("星期二");
		c.add("星期三");
		c.add("星期四");
		c.add("星期五");
		c.add("星期六");
		c.add("星期日");
		
		System.out.println(c);
		
		/*
		 * 获取当前集合对应的Iterator迭代器对象
		 */
		Iterator<String> iterator = c.iterator();
		/*
		System.out.println("当前Iterator是否可以继续运行:" +iterator.hasNext());
		System.out.println("获取当Iterator指向元:" + iterator.next());
		System.out.println("获取当Iterator指向元:" + iterator.next());
		
		iterator.remove();
		System.out.println(c);
		iterator.remove();
		System.out.println(c);
		*/
		
		while (iterator.hasNext()) {
			iterator.next();
			iterator.remove();
		}
		
		System.out.println(c.isEmpty());
		
		
	}
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo2 {
	public static void main(String[] args) {
		ArrayList<String> c = new ArrayList<String>();

		c.add("烤羊排");
		c.add("油焖大虾");
		c.add("土豆牛肉");
		c.add("黄焖鸡米饭");
		c.add("麻辣香锅");
		c.add("孜然肉片");
		c.add("酸汤肥牛");
		
		Iterator<String> iterator = c.iterator();
		
		/*
		 * ConcurrentModificationException
		 * Iterator在创建的过程中，会对整个集合所有元素打招呼，记录每一个元素位置。
		 * Iterator在执行next方法过程中，会按照初始条件一个一个遍历
		 * 当前集合通过remove方法，删除已经被Iterator记录的元素时，是有可能导致
		 * Iterator一脸懵逼！！！元素不见了！！！
		 * 
		 * 这里就会发生冲突！
		 * 
		 * 这里因为集合中元素，对于集合本身和当前Iterator而言是一个共享资源
		 * 不管是哪一方操作元素，都存在影响对方操作的情况。【共享资源冲突问题】
		 * 
		 * ArrayList存储元素不是连续的吗，土豆牛肉删除了，他的位置不是会被后面的元素顶上来吗

		 */
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
			
			// 这里通过集合删除土豆牛肉元素
			// 后期代码中会出现很多相同名字方法，这里一定要注意！！！
			// 调用当前方法的是哪一个
			c.remove("酸汤肥牛");
		}
	}
}

import java.util.Arrays;

/**
 * 自定义实现MyArraylist
 * @author Anonymous
 *
 * @param <E> 自定义泛型
 */
public class MyArrayList<E> {
	/**
	 * 准备一个底层数组，用于存储数据内容
	 */
	private Object[] elements;
	
	/**
	 * 初始化默认容量
	 */
	private static final int DEFAULT_CAPACITY = 10;
	
	/**
	 * 最大数组容量, -8是为了腾出一定的空间，保存数组的必要内容
	 */
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
	
	/**
	 * 当前底层数组中保存的有效元素个数
	 */
	private int size = 0;
	
	/**
	 * 无参数构造方法，但是需要提供给用户一个初始化容量来保存必要的数据
	 */
	public MyArrayList() {
		elements = new Object[DEFAULT_CAPACITY];
	}
	
	/**
	 * 用户指定保存元素容量的初始化过程，要求用户指定的容量范围是有效的
	 * 
	 * @param initCapacity 用户指定的初始化容量，但是不能小于等于0 ，不能大于
	 * 						MAX_ARRAY_SIZE
	 */
	public MyArrayList(int initCapacity) {
		// 用户传入参数的合法性判断过程
		if (initCapacity < 0 || initCapacity > MAX_ARRAY_SIZE) {
			// 抛出异常
			// IllegalArgumentException 是一个RuntimeException运行时异常的子类
			// 不需要强制声明抛出异常
			throw new IllegalArgumentException("IllegalArgumentException : " + initCapacity);
		}
		
		elements = new Object[initCapacity];
	}
	
	/*
	 * 增加方法
	 */
	/**
	 * 添加元素到当前集合的末尾
	 * 
	 * @param e 要求是符合泛型约束的指定数据类型
	 * @return 添加成功返回true， 否则返回false
	 */
	public boolean add(E e) {
		// 直接调用在指定下标位置添加元素的方法，只不过这里指定下标位置就是
		// 尾插法下标位置
		return add(size, e);
	}
	
	/**
	 * 在底层数组的指定下标位置保存对应的元素
	 * 
	 * @param index 指定下标位置，不能超出有效范围，0<= index <= size
	 * @param e 符合泛型约束的数据类型
	 * @return 添加成功返回true， 否则返回false
	 */
	public boolean add(int index, E e) {
		if (index < 0 || index > size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		
		ensureCapacity(size + 1);
		
		for (int i = size; i > index; i--) {
			elements[i] = elements[i - 1];
		}
		
		elements[index] = e;
		size += 1;
		
		return true;
	}
	
	/*
	 * addAll方法
	 * 		1. 需要得到添加集合中元素内容，有效元素个数
	 * 		2. 确认容量问题
	 * 		3. size = srcSize + newSize
	 */
	/**
	 * 添加另一个集合到当前集合的末尾
	 * 
	 * @param list MyArrayList类型，自定义ArrayList，要求存储元素和当前集合一致，或者
	 * 				是其子类
	 * @return 添加成功返回true，添加失败返回false
	 */
	public boolean addAll(MyArrayList<? extends E> list) {
		Object[] array = list.toArray();
		int newSize = array.length;
		
		ensureCapacity(size + newSize);
		
		for (int i = 0; i < newSize; i++) {
			elements[i + size] = array[i];
		}
		
		size += newSize;
		return true;
	}
	
	/**
	 * Do yourself 作业
	 * @param index
	 * @param list
	 * @return
	 */
	public boolean addAll(int index, MyArrayList<? extends E> list) {
		return true;
	}
	
	/**
	 * 删除指定元素 
	 * 
	 * @param obj 指定删除的元素
	 * @return 删除成功返回true
	 */
	public boolean remove(Object obj) {
		int index = indexOf(obj);
		
		return null != remove(index);
	}
	
	/**
	 * 删除下标元素
	 * 
	 * @param index 指定的下标范围
	 * @return 删除成功返回对应元素，失败返回null
	 */
	public E remove(int index) {
		if (-1 == index) {
			return null;
		}
		
		E e = get(index);
		
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		
		// 原本最后一个有效元素位置上的内容赋值为null
		elements[size - 1] = null;
		size -= 1;
		
		return e;
	}
	
	/**
	 * 获取集合中指定下标的元素
	 * 
	 * @param index 指定下标的范围，但是不能超出有效下标范围
	 * @return 返回对应的元素
	 */
	@SuppressWarnings("unchecked")
	public E get(int index) {
		if (index < 0 || index > size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		
		return (E) elements[index];
	}
	
	/**
	 * 查询指定元素在集合中的第一次出现下标位置
	 * @param obj 指定的元素
	 * @return 返回值大于等于0表示找到元素，否则返回-1
	 */
	public int indexOf(Object obj) {
		int index = -1;

		for (int i = 0; i < size; i++) {
			// equals 判断对象是否一致地方的方法
			if (obj.equals(elements[i])) {
				index = i;
				break;
			}
		}
		
		return index;
	}
	
	/**
	 * 查询指定元素在集合中的最后一次出现下标位置
	 * 
	 * @param obj 指定的元素
	 * @return 返回值大于等于0表示找到元素，否则返回-1
	 */
	public int lastIndexOf(Object obj) {
		int index = -1;

		for (int i = size - 1; i >= 0; i--) {
			// equals 判断对象是否一致地方的方法
			if (obj.equals(elements[i])) {
				index = i;
				break;
			}
		}
		
		return index;
	}
	
	/**
	 * 返回MyArrayList集合中所有有效元素的Object数组
	 * 
	 * @return 包含所有集合元素的Object类型数组
	 */
	public Object[] toArray() {
		// size是有效元素个数，通过该方法可以获取到一个只有当前数组中有效元素的数组
		return Arrays.copyOf(elements, size);
	}
	
	
	/**
	 * 替换指定下标的元素
	 * 
	 * @param index 指定下标元素，但是必须在有效范围以内
	 * @param e 符合泛型约束的对应数据类型
	 * @return 被替换的元素
	 */
	public E set(int index ,E e) {
		if (index < 0 || index >= size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		
		E temp = get(index);
		elements[index] = e;
		
		return temp;
	}
	
	/**
	 * 判断指定元素是否存在 
	 * 
	 * @param obj 指定元素
	 * @return 存在返回true，不存在返回false
	 */
	public boolean contains(Object obj) {
		return indexOf(obj) > -1; 
	}
	
	/**
	 * 
	 * @param list
	 * @return
	 */
	public boolean containsAll(MyArrayList<?> list) {
		return false;
	}
	
	/**
	 * 判断集合是否是空的
	 * 
	 * @return 如果为空，返回true， 否则返回false
 	 */
	public boolean isEmpty() {
		return size == 0;
	}
	
	/**
	 * 获取当前集合中有效元素个数
	 * 
	 * @return 有效元素个数
	 */
    public int size() {
    	return size;
    }
    
    /**
     * 获取当前集合的子集合，截取范围是fromIndex <= n < endIndex
     * 
     * @param fromIndex fromIndex <= endIndex 不得小于0
     * @param endIndex endIndex >= fromIndex 小于等于size
     * @return 截取得到的一个MyArrayList子集合对象
     */
    public MyArrayList<E> subList(int fromIndex, int endIndex) {
    	if (fromIndex > endIndex || fromIndex < 0 || endIndex > size) {
    		throw new ArrayIndexOutOfBoundsException();
    	}
    	
    	MyArrayList<E> listTemp = new MyArrayList<E>(endIndex - fromIndex);
    	
    	for (int i = fromIndex; i < endIndex; i++) {
			listTemp.add(this.get(i));
		}
    	
    	return listTemp;
    }

    @Override
    public String toString() {
    	String str = "[";
    	for (int i = 0; i < size - 1; i++) {
			str += elements[i] + ", ";
		}
    	
    	return str + elements[size - 1] + "]";
    	
    }
	/*
	 * 这里需要类内使用的可以用于判定当前容量是否满足添加要求的方法
	 * 如果满足直接进入添加模式，如果不满足，需要执行grow方法，完成
	 * 底层数组的扩容问题。
	 */
	/**
	 * 每一次添加元素，都需要进行容量判断，如果满足可以进行添加操作
	 * 不满足需要制定grow方法
	 * 
	 * @param minCapacity 要求的最小容量
	 */
	private void ensureCapacity(int minCapacity) {
		if (minCapacity > elements.length) {
			// 完成一个底层数组的扩容方法
			grow(minCapacity);
		}
	}
	
	
	/**
	 * 底层数组的扩容方法，原理是创建新数组，移植数据，保存新数组地址
	 * 
	 * @param minCapacity 要求的最小容量
	 */
	private void grow(int minCapacity) {
		// 1. 获取原数组容量
		int oldCapacity = elements.length;
		
		// 2. 计算得到新数组容量
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		
		// 3. 判断新数组容量是否满足要求
		if (newCapacity < minCapacity) {
			newCapacity = minCapacity;
		}
		// 新数组容量是大于允许的最大数组容量
		if (newCapacity > MAX_ARRAY_SIZE) {
			// 二次判断minCapacity是否小于MAX_ARRAY_SIZE
			if (minCapacity < MAX_ARRAY_SIZE) {
				// 最小要求是不大于MAX_ARRAY_SIZE，代码可以运行
				newCapacity = minCapacity;
			} else {
				throw new OutOfMemoryError("Overflow MAX_ARRAY_SIZE");
			}
		}
		
		/*
		 * 4. 使用数组工具类方法完成操作
		 * Arrays.copyOf(源数据数组，可以是任意类型，采用泛型约束, 指定的新数组容量);
		 * 		a. 根据指定的新数组容量创建对应泛型数据类型的新数组
		 *      b. 从源数据数组中拷贝内容到新数组中
		 *      c. 返回新数组首地址
		 */
		elements = Arrays.copyOf(elements, newCapacity);
	}

}

import java.util.HashSet;

public class Demo2 {
	public static void main(String[] args) {
		HashSet<Person> hashSet = new HashSet<Person>();
		
		Person p1 = new Person(1, "寝室长", 10);
		Person p2 = new Person(2, "队长", 15);
		Person p3 = new Person(3, "宇哥", 2);
		Person p4 = new Person(4, "老康", -5);
		Person p5 = new Person(5, "港儿子", 11);
		
		/*
		 * 当前这里两个元素，ID一样 ==> hashCode值是一致，会通过底层哈希表运算
		 * 保存到同一个单元格位置。
		 * 这里会通过equals方法，比较两个对象是否一致，来决定是否能够保存。
		 * 如果两个对象一致，无法保存。
		 * 
		 * 期望每一个哈希表单元格内保存的数据是唯一
		 */
		Person p6 = new Person(6, "康爷", 8);
		Person p7 = new Person(6, "康牙", 10);
		
		
		hashSet.add(p4);
		hashSet.add(p6);
		hashSet.add(p3);
		hashSet.add(p5);
		hashSet.add(p2);
		hashSet.add(p1);
		hashSet.add(p7);
		
		System.out.println(hashSet);
	}
}

下列方法之后再介绍：
线程有关方法
void wait();
void notify();
void notifyAll();

反射有关方法
Class<?> getClass();

/*                                                                   
 * 重写equals方法                                                        
 * 		1. 判断两个对象是不是同一个对象。如果调用方法的类对象和传入参数类对象    
 * 		地址一致，那就是同一个对象，返回true，搞定！！！         
 *                                                                   
 * 		2. equals方法参数是Object类型，那也就是说任何类型的数据都可以作为参数。   
 * 		两个数据类型不一致，是否需要进行比较操作。                               
 * 		判断数据类型是否一致                                                   
 * 		使用关键字 instanceOf，同数据类型继续运行，非同类型，结束判断返回false   
 * 		格式:                                                          
 * 			类对象 instanceOf 类名                                        
 *                                                                   
 * 		3. 判断对象中保存的数据                                                
 * 			Student中我们比较id, name, age, gender就可以了                    
 * 		                                                             
 */                                                                  
@Override                                                            
public boolean equals(Object obj) {                                  
	// 1. 判断是不是同地址对象                                                 
	if (this == obj) {                                               
		return true;                                                 
	}                                                                
	                                                                 
	// 2. 类型是否一致                                                     
	if (!(obj instanceof Student)) {                                 
		return false;                                                
	}                                                                
                                                            
	// 数据类型强制转换                                                      
	Student stu = (Student) obj;                                     
	return this.id == stu.id                                         
			// this.name.equals(stu.name) 该equals方法是String类equals方法  
			&& this.name.equals(stu.name)                            
			&& this.age == stu.age                                   
			&& this.gender == stu.gender;                            
	                                                                 
}   

@Override
public int hashCode() {
	// 这里通过Objects 工具类内的hash方法，传入所有参与equals比较的成员变量
	// 得到对应的hashCode值
	return Objects.hash(id, name, age, gender);
}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo2 {
	public static void main(String[] args) {
		HashMap<String, String> map = new HashMap<String, String>();
		
		map.put("吴京", "谢楠");
		map.put("邓超", "娘娘");
		map.put("黄磊", "孙莉");
		map.put("王宝强", "XX");
		
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		
		System.out.println(entrySet);
	}
}

import java.util.Comparator;
import java.util.TreeMap;

public class Demo3 {
	public static void main(String[] args) {
		TreeMap<String,String> map = new TreeMap<String, String>();
		
		map.put("李四", "1");
		map.put("王五", "1");
		map.put("赵六", "1");
		map.put("张三", "1");
		
		System.out.println(map);
		
		TreeMap<Dog,String> map2 = new TreeMap<Dog, String>(new Comparator<Dog>() {

			@Override
			public int compare(Dog o1, Dog o2) {
				return o1.getAge() - o2.getAge();
			}
		});
		
		map2.put(new Dog("王可可", 1), "111"); 
		map2.put(new Dog("八公", 2), "111"); 
		map2.put(new Dog("豆豆", 3), "111"); 
		map2.put(new Dog("老黄", 4), "111"); 
		map2.put(new Dog("旺财", 5), "111"); 
		
		System.out.println(map2);
		
	}
}

import java.io.File;

/*
 * 创建File类对象
 */
public class Demo1 {
	public static void main(String[] args) {
		/*
		 * 1. 路径分隔符 \\ or / or File.separator
		 * 2. 操作文件必须带有文件的后缀名 1.txt 2.java ...
		 */
		File file = new File("C:\\aaa");
		File file1 = new File("C:" + File.separator + "aaa");
		File file2 = new File("C:/aaa", "1.txt");
		File file3 = new File(file, "bbb");
			
	}
}

@FunctionalInterface
public interface FilenameFilter {
    /**
     * Tests if a specified file should be included in a file list.
     *
     * @param   dir    the directory in which the file was found.
     * @param   name   the name of the file.
     * @return  <code>true</code> if and only if the name should be
     * included in the file list; <code>false</code> otherwise.
     */
    boolean accept(File dir, String name);
}

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

/*
 * FilenameFilter过滤器演示
 */
public class Demo8 {
	public static void main(String[] args) {
		File file = new File("C:\\aaa\\ddd");
		
		// 使用匿名内部类的匿名对象直接作为方法的参数
		File[] listFiles = file.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				/*
				 * dir是当前操作的文件夹类对象
				 * name是当前文件夹下的子文件或者子文件夹名字
				 * 
				 * 获取对应的java文件
				 * 		1. 判断是不是普通文件
				 * 		2. 判断当前文件名是不是.java结尾
				 */

				return new File(dir, name).isFile()
						// endsWith字符串方法，判断当前字符串是不是已指定要求结尾
						&& name.endsWith(".java");
			}
		});
		
		// Lambda表达式 JDK1.8新特征 
		File[] listFile = file.listFiles((dir, name) -> 
			new File(dir, name).isFile() 
			&& name.endsWith(".java")
		);
		
		for (File file2 : listFile) {
			
			System.out.println(file2.getName());
		}
		
	}
}

String str = "孜然肉片";
str += "麻辣香锅";
str += "番茄鸡蛋";
str += "土豆牛肉";
str += "烤羊排";
str += "金汤肥牛";
str += "蒜蓉油麦菜";

System.out.println("这里有几个字符串");

FileInputStream 文件操作输入字节流

Constructor 构造方法
	FileInputStream(File file);
		这里是根据提供的File类对象创建对应的文件操作输入字节流。

	FileInputStream(String pathName);	
		这里是根据提供的String类型文件路径，创建对应的文件操作输入字节流。
	都会抛出异常：
		FileNotFoundException 文件未找到异常。

Method 成员方法	
	int read();
		从文件中读取一个字节数据返回到方法外。
		虽然返回值是一个int类型，但是在整个int类型当中存储的数据是一个byte类型，有
		且只有低8位数据有效
		
	int read(byte[] buf);
		读取文件的内容是存储在byte类型数组中，返回值是读取到的字节个数
		
	int read(byte[] buf, int offset, int count);
		读取文件的内容是存储在byte类型数组中，要求从byte数组offset位置开始，到
		count长度结束，返回值是读取到的字节个数
	
	以上三个方法如果读取到文件末尾，返回值都是 -1 EOF End Of File
	而且以上方法都要异常抛出
		IOException IO异常

 	import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /*
     * 文件操作输入字节流
     * 	1. 确认读取哪一个文件
     * 	2. 创建对应文件的FileInputStream
     * 	3. 读取数据
     * 	4. 关闭资源 【重点】
     */
    public class Demo1 {
    	public static void main(String[] args) {
    		long start = System.currentTimeMillis();
    		
    		readTest1();
    		
    		long end = System.currentTimeMillis();
    		System.out.println("Time : " + (end - start));
    	}
    
    	public static void readTest2() {
    		// 1. 确定操作文件
    		File file = new File("C:\\aaa\\1.txt");
    
    		// 2. 字节输入流读取文件对象
    		FileInputStream fileInputStream = null;
    		
    		try {
    			// 3. 根据File类对象创建对应的字节输入流
    			fileInputStream = new FileInputStream(file);
    			
    			// 4. 准备一个8KB字节缓冲数组
    			byte[] buf = new byte[1024 * 8];
    			int length = -1;
    			
    			// 5. 读取数据
    			while ((length = fileInputStream.read(buf)) != -1) {
    				System.out.println(new String(buf, 0, length));
    			}
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			// 在finally代码块中关闭资源
    			if (fileInputStream != null) {
    				try {
    					fileInputStream.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	/*
    	 * low!!!
    	 */
    	public static void readTest1() {
    		// 1. 确定操作文件
    		File file = new File("C:\\aaa\\1.txt");
    		
    		// 2. 字节输入流读取文件对象 
    		FileInputStream fileInputStream = null;
    	
    		try {
    			// 3. 根据File类对象创建对应的字节输入流
    			fileInputStream = new FileInputStream(file);
    			
    			// 4. 读取文件 
    			int content = -1;
    			
    			while ((content = fileInputStream.read()) != -1) {
    				System.out.println((char)content);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			// 用于处理代码中使用到资源，无法发生什么样的错误，finally中的代码一定会执行
    			// 这里发现fileInputStream不是null，证明已经打开了文件资源，关闭资源，捕获异常
    			if (fileInputStream != null) {
    				try {
    					fileInputStream.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /*
     * 文件操作输出字节流
     * 		1. 确定文件
     * 		2. 创建FileOutputStream
     * 		3. 写入数据到文件中
     * 		4. 关闭资源 
     */
    public class Demo2 {
    	public static void main(String[] args) {
    		writeTest2();
    	}
    
    	public static void writeTest2() {
    		// 1. 确定文件
    		File file = new File("C:/aaa/中国加油.txt");
    		
    		// 2. 文件操作字节输出流对象
    		FileOutputStream fileOutputStream = null;
    		
    		try {
    			// 3. 创建FileOutputStream 
    			fileOutputStream = new FileOutputStream(file);
    			
    			// 4. 准备byte类型数组
    			byte[] bytes = "武汉加油！中国加油！".getBytes();
    			byte[] arr = {65, 66, 67, 68, 69, 70, 71};
    			
    			fileOutputStream.write(bytes);
    			fileOutputStream.write(arr, 2, 3);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			// 关闭资源
    			if (fileOutputStream != null) {
    				try {
    					fileOutputStream.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	public static void wrietTest1() {
    		// 1. 确定文件
    		File file = new File("C:/aaa/武汉加油.txt");
    		
    		// 2. 文件操作字节输出流对象
    		FileOutputStream fileOutputStream = null;
    		try {
    			// 3. 创建FileOutputStream
    			fileOutputStream = new FileOutputStream(file, true);
    			
    			// 4. 写入数据
    			fileOutputStream.write('D');
    			fileOutputStream.write('D');
    			fileOutputStream.write('D');
    			fileOutputStream.write('D');
    			fileOutputStream.write('D');
    			fileOutputStream.write('D');
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			// 关闭资源
    			if (fileOutputStream != null) {
    				try {
    					fileOutputStream.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	} 
    }

  import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class Demo4 {
    	public static void main(String[] args) {
    		long start = System.currentTimeMillis();
    		
    		readTest2();
    		
    		long end = System.currentTimeMillis();
    		System.out.println("Time : " + (end - start));
    	}
    
    	// 10
    	public static void readTest2() {
    		FileReader fileReader = null;
    		try {
    			fileReader = new FileReader(new File("C:/aaa/3.txt"));
    			
    			char[] buf = new char[1024 * 4];
    			int length = -1;
    			
    			while ((length = fileReader.read(buf)) != -1) {
    				System.out.println(new String(buf, 0, length));
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (fileReader != null) {
    				try {
    					fileReader.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    	// 300
    	public static void readTest1() {
    		FileReader fileReader = null;
    		try {
    			fileReader = new FileReader(new File("C:/aaa/3.txt"));
    			
    			int content = -1;
    			
    			while ((content = fileReader.read()) != -1) {
    				System.out.println((char) content);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (fileReader != null) {
    				try {
    					fileReader.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

FileWriter文件操作输出字符流

Constructor 构造方法
	FileWriter(File file);
		根据File类对象创建对应文件的文件操作输出字符流
	FileWriter(String pathName);
		根据String类型文件路径创建对应文件的文件操作输出字符流
	FileWriter(File file, boolean append);
		根据File类对象创建对应文件的文件操作输出字符流，并要求为追加写
	FileWriter(String pathName, boolean append);
		根据String类型文件路径创建对应文件的文件操作输出字符流，并要求为追加写
	
	如果创建FileWrite对象时，这里文件不存在，路径合法，这里会创建对应的操作文件。如果路径不合法，抛出异常 FileNotFoundException 
	
Method 成员方法	
	void write(int ch);
		写入一个char类型数据到文件中
	void write(char[] arr);
		写入一个char类型数组到文件中
	void write(char[] arr, int offset, int length);	
		写入一个char类型数组到文件中，要求从offset下标位置开始读取数组数据，长度为
		length
	void write(String str);
		写入一个字符串到文件中
	void write(String str, int offset, int lenght);
		写入一个字符串到文件中，要求从指定字符串offset下标位置开始，长度为length
	如果写入数据操作过程中，发生问题，这里会有一个IOException

 import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 文件操作字符输出流
     */
    public class Demo1 {
    	public static void main(String[] args) {
    		FileWriter fileWriter = null;
    		
    		try {
    			fileWriter = new FileWriter(new File("D:/aaa/5.txt"), true);
    			
    			char[] charArray = "现在美国全国缺少口罩2.7亿".toCharArray();
    			
    			fileWriter.write(charArray);
    			fileWriter.write("韩国目前疫情情况不容乐观");
    			fileWriter.write("\r\n");
    			fileWriter.write(charArray, 0, 5);
    			fileWriter.write("韩国目前疫情情况不容乐观", 0, 5);
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (fileWriter != null) {
    				try {
    					fileWriter.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    		
    	}
    
    	private static void writeTest1() {
    		FileWriter fileWriter = null;
    		try {
    			fileWriter = new FileWriter(new File("D:/aaa/4.txt"), true);
    			
    			fileWriter.write('武');
    			fileWriter.write('汉');
    			fileWriter.write('加');
    			fileWriter.write('油');
    			fileWriter.write('，');
    			fileWriter.write('中');
    			fileWriter.write('国');
    			fileWriter.write('加');
    			fileWriter.write('油');
    			fileWriter.write(',');
    			fileWriter.write('世');
    			fileWriter.write('界');
    			fileWriter.write('加');
    			fileWriter.write('油');
    			
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (fileWriter != null) {
    				try {
    					fileWriter.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /*
     * 使用文件操作字符流量拷贝非文本文件问题
     * 【要求】
     * 		禁止使用字符流操作非文本文件，记事本打开乱码文件都不可以
     */
    public class Demo2 {
    	public static void main(String[] args) {
    		FileReader fileReader = null;
    		FileWriter fileWriter = null;
    		
    		
    		try {
    			fileReader = new FileReader(new File("D:/aaa/logo桌面.jpg"));
    			fileWriter = new FileWriter(new File("D:/aaa/temp.jpg"));
    			
    			char[] buf = new char[1024 * 4];
    			int length = -1;
    			
    			while ((length = fileReader.read(buf)) != -1) {
    				fileWriter.write(buf, 0, length);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (fileWriter != null) {
    				try {
    					fileWriter.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    			
    			if (fileReader != null) {
    				try {
    					fileReader.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

 import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Demo3 {
    	public static void main(String[] args) {
    		long start = System.currentTimeMillis();
    
    		copy();
    		
    		long end = System.currentTimeMillis();
    		// 总耗时
    		System.out.println("Time:" + (end - start));
    	}
    	
    	// 1716 ms
    	public static void useBuffered() {
    		BufferedInputStream bis = null;
    		BufferedOutputStream bos = null;
    		
    		try {
    			bis = new BufferedInputStream(new FileInputStream(new File("D:/aaa/2.txt")));
    			bos = new BufferedOutputStream(new FileOutputStream(new File("D:/aaa/buffered.txt")));
    			
    			int content = -1;
    			
    			while ((content = bis.read()) != -1) {
    				bos.write(content);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (bos != null) {
    				try {
    					bos.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    			
    			if (bis != null) {
    				try {
    					bis.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
     	}
    	
        // 531000
    	public static void copy() {
    		FileInputStream fis = null;
    		FileOutputStream fos = null;
    		
    		try {
    			fis = new FileInputStream("D:/aaa/2.txt");
    			fos = new FileOutputStream("D:/aaa/copy.txt");
    			
    			int content = -1;
    			
    			while ((content = fis.read()) != -1) {
    				fos.write(content);
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (fos != null) {
    				try {
    					fos.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    			
    			if (fis != null) {
    				try {
    					fis.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

将对象数据序列化，保存到文件中

构造方法 Constructor
	ObjectOutputStream(OutputStream out);
		输出字节流对象作为当前方法的参数

  import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class Demo1 {
    	public static void main(String[] args) {
    		
    		ObjectOutputStream objectOutputStream = null;
    		
    		try {
    			objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:/aaa/person.txt"));
    			
    			// 序列化对象，并且写入到文件中
    			objectOutputStream.writeObject(new Person(1, "骚磊", 16));
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			if (objectOutputStream != null) {
    				try {
    					objectOutputStream.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

从文件中读取被序列化之后的字节数据，提供反序列化操作，得到一个对象。

构造方法 Constructor
	ObjectInputStream(InputStream in);
	需要提供一个字节输入流对象来进行操作

package com.qfedu.b_math;

/*
 * Math工具类方法
 */
public class Demo1 {
	public static void main(String[] args) {
		// 绝对值
		System.out.println(Math.abs(1.5));
		System.out.println(Math.abs(-1.5));
		System.out.println(Math.abs(5));
		System.out.println(Math.abs(-5));
	
		System.out.println("--------------------------------");
		
		// 向上取整
		System.out.println(Math.ceil(1.5));
		System.out.println(Math.ceil(1.1));
		System.out.println(Math.ceil(-1.9));
		System.out.println(Math.ceil(-2.9));
		
		System.out.println("--------------------------------");
		
		// 向下取整
		System.out.println(Math.floor(10.5));
		System.out.println(Math.floor(10.1));
		System.out.println(Math.floor(-10.5));
		System.out.println(Math.floor(-10.1));
		
		System.out.println("--------------------------------");
		
		// 四舍五入
		System.out.println(Math.round(3.5)); // 4
		System.out.println(Math.round(3.4)); // 3
		System.out.println(Math.round(-2.5)); // -2
		System.out.println(Math.round(-2.4)); // -2
		System.out.println(Math.round(-2.6)); // -3
	}
}

package com.qfedu.b_math;

public class Demo2 {
	public static void main(String[] args) {
		for (int i = 0; i < 20; i++) {
			double num = Math.random() * 100;
			
			if (0.0 <= num && num < 50) {
				System.out.println("绿色普通卡");
			} else if (50 <= num && num < 80) {
				System.out.println("蓝色高端卡");
			} else if (80 <= num && num < 98) {
				System.out.println("紫色传说卡");
			} else {
				System.err.println("黄金史诗卡");
			}	
		}
	}
}