JavaSE知识点查漏补缺（3）

7、现在开始，就是我们以后软件开发中常用的知识点。集合、泛型、IO、线程、反射...

集合（JavaSE中又一个比较重要的部分）

Collection<E> : 存放无序可以重复单个对象方法：

boolean add(E e);
boolean remove(E e);
int size();
boolean contains(E e);
void clear();
boolea isEmpty();
Iterator iterator();

Set<E> : 存放无序不可重复单个对象
HashSet 使用哈希算法实现的Set集合
TreeSet 基于树实现的Set集合
List<E> : 存放有序可重复的单个对象

void add(int index, E e); // index不可以越界 大于等于size也不行
E set(int index, E e);
E remove(int index); 
E get(int index);

ArrayList 使用数组实现的List集合
LinkedList 基于链表实现的List集合
集合的遍历:
增强型for循环
迭代器
使用 : 要在使用时才获取, 在目标集合对象上调用iterator()
询问和迭代 : while (迭代器.hasNext()) {
元素 = 迭代器.next(); // 返回当前指针的下一个元素, 返回后再把指针向下移动
}
Map<K, V> : 存放具有映射关系的两个对象

V put(K key, V value);
	int size(); 
	V get(K key);
	Set<K> keySet();
	
	HashMap
	Hashtable
		Properties
	TreeMap
	
	Map<Integer, String> map = ?;
	map.put(1, "one");
	map.put(9, "nine");
	map.put(1, "ONE");	
	....
	map.remove(9);
	String value = map.get(1);
	// 遍历
	//1) 先获取所有键的Set集合
	Set<Integer> set = map.keySet();
	//2) 遍历所有的键的时候, 根据键再获取值
	for (Integer num : set) {
		String v = map.get(num);	
	}

泛型 : 解决数据类型安全问题

类中使用泛型

class A<T> { // T在类中作为某种类型来用,和对象相关, 所以静态环境中不能使用T 
	T t;
	public T getT() {
		return t;	
	}
}


main() {
	A a1 = new A<String>();
	A a2 = new A<Integer>();
}

方法中使用泛型

class A {
	
	public <T> T getData(T t) {
		return t;
	}
}


main() {
	Integer obj = new A().getData(300);
}

IO（很重要的一部分知识）

源结点 --------------------> 目标结点

四种
字节流(8bit) 字符流(16bit)
输入流 InputStreamReader
输出流 OutputStreamWriter

处理文件步骤 :
1) 打开文件,建立流通道对象
2) 使用流通道对象处理数据
3) 关闭流通道

流的分类
1) 节点流
FileReader 文本文件输入流

int read(); // 从输入流中读一个字符, 用非法数据-1表示流结束.
int read(char[] buf); // 从流中读一些字符, 读入到数组中, 返回值就是实际读了多少个字符

 
FileWriter 文本文件输出流

void write(int ch); // 把参数中的字符写入输出流中
void write(char[] buf); // 把参数中的字符数组中的全部字符写入输出流中
void write(char[] buf, int offset, int count); // 把参数中的字符数组的一部分写入输出流
void flush(); // 把数据刷入硬盘

FileInputStream

int read(); // 从流中读一个字节0~255 用-1表示非法数据
int read(byte[] buf); // 从流中读一些字节, 返回值就是实际读到的字节数

FileOutputStream

void write(int by); 
void write(byte[] buf);
void write(byte[] buf, int offset, int count);

2) 处理流 : 把节点流或其他流包装起来, 用以获取更强大的处理能力
缓冲流 
BufferedReader
String readLine();
BufferedWriter
void write(String line)
void newLine()
BufferedInputStream
BufferedOutputStream
对象流 : 只处理字节流
ObjectOutputStream

void writeXxx(xxx value); // Xxx代表的是8种基本数据类型 writeInt,writeFloat,writeBoolean
//writeInt(n); // write(n >>> 24); write(n >> 16 & 0x000000FF); write(n >> 8 & 0x000000FF); write(n & 0x000000FF)
void writeUTF(String str); // 把字符串按照UTF8方式进行编码, 编码 : 把字符串变成字节数组的过程

ObjectInputStream

<pre name="code" class="java">xxx readXxx(); // 从流中把8种基本数据类型读出来				
String readUTF(); // 把流中的字节数组以UTF8编码方式解码成字符串

转换流 : 只能把字节流转成字符流 InputStreamReader OutputStreamWriter 打印流 : PrintStream PrintWriter 数据流 : DataInputStream DataOutputStream 随机访问(文件) RandomAccessFile.  文件指针. long getFilePointer(); // 获取文件当前指针 void seek(long pos); read(); read(byte[] buf) readXxx() readUTF() write(int by); write(byte[] buf) writeXxx(xxx value); writerUTF(String str)工具类 : File 可以代表具体的文件或目录 long length() long lastModified() boolean exists() boolean createNewFile() String getName() String getAbsolutePath() boolean mkdir();  boolean mkdirs();// 可以创建多层目录(aa/bb/cc/dd/ee) String[] list(); File[] listFiles();

多线程 : Thread 类的对象代表一个线程, 可以直接被CPU执行.

进程 : 由多个线程构成.创建线程的两种方式 :1) 实现接口1) 写一个具体类, 实现Runnable接口, 并且实现接口中的run方法, 这个run()方法相当于线程的入口2) 创建具体类的对象,构造器中以它为实参, 被关联于Thread对象中, Thread对象就是线程对象, 创建标志着栈的建立3) 调用Thread类对象的start()方法, 激活栈, 把Thread的run()方法压入栈底.2) 继承类1) 写一个具体类, 继承自Thread类, 因为Thread类实现了Runnable接口,在具体类中重写父类的run()方法, 是真的入口方法2) 创建具体类对象, 相当于创建了Thread对象3) 调用Thread对象的start()方法, 激活栈, 把子类中的run()方法压入栈底.Thread中的方法static Thread currentThread(); // 返回执行此方法的栈所属的线程对象String getName();void setName(String name);static void sleep(long millis); // 使执行此方法的栈所属的线程进入睡眠(阻塞) 不抢夺CPU. 不会释放锁..void join(); // 使得别的线程在调用本方法后, 进入睡眠, 本线程继续执行完毕后, 别的线程解除阻塞.void setDaemon(boolean flag); // 守护线程只用于为用户线程服务, 必须在线程start()方法前设置才管用.void interrupt(); // 只能被别的线程调用此方法, 使得本线程结束睡眠, 同时抛出异常线程的同步安全问题 :多个线程同时修改同一个共享资源.

把对共享资源的修改的代码部分加上同步锁.synchronized(同步锁对象) {代码块; // 具有原子性}

反射 : 对象的创建及使用延迟到了运行时.

工作机制 : 干预类的加载和对象的创建类的自动加载1) Class clazz = 类名.class;2) Class clazz = 对象.getClass();类的手工加载 1) Class clazz = Class.forName(类的全限定名); // 加载类时对类进行初始化, 执行静态语句块.2) Class clazz = this.getClass().getClassLoader().loadClass(类的全限定名);对象的创建依据类模板对象创建实体对象

Object obj = clazz.newInstance();  // 执行的类的无参构造器
	
Constructor con = clazz.getConstructor(形参列表);
con.newInstance();
	
Constructor[] conArr = clazz.getDeclaredConstructors();
// 实参的获取
conArr[0].newInstance(实参);

访问对象的属性

Field field = clazz.getDeclaredField(属性名);
field.setAccessable(true);
field.set(obj, 新值);
Object value = field.get(obj); 

调用对象的方法

Method method = clazz.getDeclaredMethod(方法名, 形参的类型的类模板对象的列表);
method.setAccessable(true);
Object ret = method.invoke(this对象, 实参的列表);

动态代理

以上是JavaSE知识点的查漏补缺，若是有什么的不解的或者不是特别清楚的，可以在Java语言的学习中查看复习，那里有完整知识和大量的练习题...