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语言的学习中查看复习,那里有完整知识和大量的练习题...