String类使用final来修饰，所以不可以被继承。 字符串是不可变对象，字符串内容一旦创建，就不可变，只要改变字符串内容，就会创建新的字符串对象。 int length(); // 返回此字符串的长度 int indexOf(String str); // 返回给定字符串在此字符串中第一次出现处的索引 int indexOf(String str, int fromIndex); // 返回给定字符串在此字符串中从给定位置后第一次出现处的索引 int lastIndexOf(String str); // 返回给定字符串在此字符串中最后一次出现的索引 String substring(int beginIndex, int endIndex); // 返回此字符串指定索引范围之间的子字符串 String substring(int beginIndex); // 返回此字符串指定开始索引到末尾之间的子字符串 String trim(); // 返回此字符串去除前后空白后的字符串 char charAt(int index); // 返回此字符串指定索引处的字符 boolean startsWith(String str); // 测试此字符串是否以指定的前缀开始 boolean endsWith(String str); // 测试此字符串是否以指定的后缀结束 String toUpperCase(); // 将此字符串中的所有字符转换为大写 String toLowerCase(); // 将此字符串中的所有字符转换为小写 static String valueOf(T t); // 返回给定参数的字符串表示形式 boolean matches(String regex); // 测试此字符串是否匹配给定的正则表达式 String[] split(String regex); // 将此字符串按照满足正则表达式的部分进行拆分 String replaceAll(String regex, String str); // 将当前字符串中所有满足给定的正则表达式的部分替换为给定的字符串 String replace(String str1, String str2);
StringBuilder和StringBuffer是可变的字符序列，解决String字符串操作时会创建新对象的效率问题。 StringBuilder是从JDK1.5版本后才有的，不是线程安全的，效率比StringBuffer要快。 StringBuilder append(T t); // 将指定的内容追加到此字符串的末尾 StringBuilder replace(int start, int end, String str); // 将此字符串中指定范围的字符串替换为给定的字符串 StringBuilder insert(int offset, T t); // 在此字符串中指定的位置开始插入给定的内容 StringBuilder delete(int start, int end); // 删除此字符串中指定范围的子字符串 StringBuilder reverse(); // 将此字符串反转
注意： StringBuilder 和 StringBuffer 都没有重写equals方法，所以我们要比较它们的字符序列是否一样，要先转为String后再用e quals比较。
正则表达式就是使用一系列预定义的特殊字符来描述一个字符串的格式规则，然后使用该格式规则匹配某个字符串是否符合格式要求。 3.1)字符集合： [] //用来描述单一字符，方括号内部可以定义这个字符的内容，也可以描述一个范围 [abc] //a、b、c中任意一个字符 [^abc] //除了a、b、c的任意字符 [a-z] //a~z之间的任意一个字符 [a-z0-9A-Z] //az、09、A~Z中任意一个字符 [a-z&&[^bc]] //a~z中除了b、c外的任意一个字符，&&表示与 3.2)预定义字符集合： . //表示任意一个字符 \d //表示任意一个数字，相当于[0-9] \w //表示单词字符，相当于[a-zA-Z0-9_] \s //表示空白字符，相当于[\t\n\f\r\x0b] \D //表示非数字字符 \W //表示非单词字符 \S //表示非空白字符 3.3)数量词 ? //表示0个或1个 * //表示0个或多个 + //表示1个或多个 {n} //表示n个 {n, } //表示n个或多个 {n, m} //表示n个到m个 3.4)分组 () //将括号中的内容看做一个整体，()中可以使用"|"来表示或关系 3.5)匹配 ^ //表示字符串开始 $ //表示字符串结束 ^regex$ //要求字符串必须从头到尾都满足该格式规则 &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&到 12月17日
Object类是java中所有类的顶级父类。若我们定义的一个类没有显式的使用extends继承某个类时，默认就是继承自Object的。 4.1)方法 String toString(); //用一个字符串来描述当前对象 boolean equals(Object obj); //判断两个对象间的内容比较是否一致 int hashCode(); //返回当前对象的hash值，重写该方法时建议同时重写equals方法 void wait(); //让线程进入等待状态 void notify(); //唤醒对于等待状态的线程 void notifyAll(); //唤醒该对象全部等待的线程 void finalize(); //GC回收该对象前会调用该方法 4.2)equals 与 == 的区别 "“是值比较，对于引用类型变量而言，该变量保存的是对象的地址，所以使用”"比较时，意思为两个变量的地址是否相等，换句话说就是看两个变量引用的是否为同一个对象 equals是内容比较，对于两个引用变量而言，是比较两个变量所引用的对象内容是否相同。 4.3)final, finally, finalize 的区别？ final是修饰词，可以修饰类、方法、变量，修饰类时该类不能被继承，修饰方法时该方法不能被重写，修饰变量时初始化后值不可被改变，与static一起修饰变量时称为常量； finally是异常处理机制中的一个关键词，可以在try或catch后面使用，表示无论try里面的代码不管是否有异常，finally中的代码都会执行； finalize是Object中的一个方法，在GC回收该对象前会调用该方法，一般在该方法中做一些资源释放工作，但是一般不用。 4.4)wait() 和 sleep() 的区别？ wait()是Object中的方法，sleep()是Thread中的方法； wait()可以让线程进入等待状态，需要调用notify或notifyAll方法来唤醒才能重新回到可运行状态；sleep()可以让线程进入睡眠状态，睡眠时间一到自动回到可运行状态； wait()方法在阻塞期间，会释放对象锁；sleep()方法在阻塞期间不会释放对象锁。
5.1)包装类解决的问题是基本类型不能参与面向对象开发，解决办法就是把基本类型转换成引用类型。 基本类型 包装类型 byte java.lang.Byte short java.lang.Short int java.lang.Integer long java.lang.Long float java.lang.Float double java.lang.Double char java.lang.Character boolean java.lang.Boolean 5.2)想将一个基本类型当做引用类型使用时，编译器会自动加上代码，使得基本类型转换为引用类型，这个过程称为"自动装箱" 5.3)当编译器发现我们需要将一个引用类型转换为基本类型时，自动添加代码进行转换，这种从引用类型转换为基本类型的过程称之为"自动拆箱" 5.4)那么java是如何实现的自动拆装箱呢? 事实上JVM不支持该特性，自动拆装箱只是编译器在编译过程中的"预处理"操作。编译器在看到需要在包装类与基本类型之间转换时，会在编译为字节码时进行改变: 源代码中 编译后的字节码中 Integer a = 100 => Integer a = Integer.valueOf(100); Integer b = 200 => Integer b = Integer.valueOf(200); Integer c = a+b => Integer c = Integer.valueOf(a.intValue() + b.intValue()); double d = c => double d = c.doubleValue(); 5.5)常量/方法 int Integer.MAX_VALUE // 获取int类型的最大值 int Integer.MIN_VALUE // 获取int类型的最小值 static int parseInt(String str); // 将给定的字符串转换为int基本类型 static Integer valueOf(int n); // 将给定的int基本类型转换为对应的包装类型(自动装箱调用的方法) int intValue(); // 将当前包装类型整数转换成对应的int基本类型(自动拆箱调用的方法) 5.6)int 和 Integer 的区别？ int是基本数据类型，Integer是引用类型； int不能赋值为null，Integer可以； int作为成员变量时默认值为0，Integer作为成员变量时默认值为null； int没有方法，Integer中提供了一些对整数操作的方法； int可以进行运算，Integer不可以直接运算。
Date 日期类，可以表示日期，默认为当前系统的日期 long getTime(); // 获取此日期的毫秒值 void setTime(long millisecond); // 将给定毫秒值转换为日期格式
SimpleDateFormat 简单日期格式化类，可以将一个日期对象格式化为指定格式的字符串，也可以将一个指定格式的字符串解析为一个日期对象 String format(Date date); // 将给定的日期转换成指定格式的字符串 Date parse(String str); // 解析字符串的文本，生成 Date
Calendar 日历类，可以方便对日期进行操作 Calendar getInstance(); // 根据当前系统所在地区，获得Calendar的实际类型对象 Date getTime(); // 返回Calendar的日期格式 void setTime(Date date); // 将给定日期设置到Calendar中 int get(int field); // 返回给定日历字段的值 void set(int field, int value); // 将指定的日历字段设置为给定值 void add(int field, int value); // 根据日历的规则，为指定的日历字段添加或减去指定的时间量
List 列表集合类，是有序的，可以对列表中每个元素的插入位置进行精确地控制，可以根据元素的整数索引访问元素、并搜索列表中的元素。 通常允许重复的元素，更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。 常用的实现类： ArrayList, LinkedList 常用的方法： void add(int index, T e); // 在此集合中的指定位置插入指定元素，原位置及后续元素顺序向后移动 T remove(int index); // 移除列表中指定位置的元素，返回从列表中移除的元素 T get(int index); // 返回集合中指定位置的元素 T set(int index, T t); // 用指定元素替换集合中指定位置的元素 int indexOf(Object o); // 返回此集合中第一次出现指定元素的索引，若不存在该元素返回-1 List subList(int fromIndex, int toIndex); // 返回此集合中指定位置(fromIndex到toIndex)之间的部分视图
Set Set 是不包含重复元素的集合，也就是不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。 常用的实现类： HashSet, LinkedHashSet, TreeSet 常用的方法： 参考 Collection 接口。
Map Map 接口没有继承Collection接口，Map提供key到value的映射。 常用的实现类： HashMap, LinkedHashMap, TreeMap 常用的方法有： boolean containsKey(Object key); //如果此映射包含指定键的映射关系，则返回 true。 boolean containsValue(Object value); //如果此映射将一个或多个键映射到指定值，则返回 true。 Set<Map.Entry<K,V>> entrySet(); //返回此映射中包含的映射关系的 Set 视图。 V get(Object key); //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 Set keySet(); //返回此映射中包含的键的 Set 视图。 V put(K key, V value); //将指定的值与此映射中的指定键关联（可选操作） void putAll(Map<? extends K, ? extends V> m); //从指定映射中将所有映射关系复制到此映射中（可选操作）。 V remove(Object key); //如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 int size(); //返回此映射中的键-值映射关系数。 Collection values(); //返回此映射中包含的值的 Collection 视图。 使用案例： //创建一个Map实例 Map<String, Integer> map = new HashMap<String, Integer>(); map.put(“java”, 99); map.put(“c++”, 98); map.put(“android”, 88); //从map中获取指定key(键)相应的value(值) System.out.println(map.get(“java”)); //99 //判断map中是否包含指定的key(键) System.out.println(map.containsKey(“c++”)); //true //遍历1：键值对 Set<Entry<String, Integer>> entries = map.entrySet(); for (Entry<String, Integer> entry : entries) { System.out.println(entry.getKey() + “:” + entry.getValue()); } //遍历2：键 Set keys = map.keySet(); for (String key : keys) { System.out.println(key + “:” + map.get(key)); } //遍历3：值 Collection values = map.values(); for (Integer val : values) { System.out.println(“value:” + val); }
编程案例： 统计一个字符串中每个字符的个数，要求按照统计字符出现的顺序输出。 String str = “abcdabcdabcdefgabcdefghij”; Map<Character, Integer> counter = new LinkedHashMap<Character, Integer>(); for(int i = 0, len = str.length(); i < len; i ++){ Character c = str.charAt(i); if (counter.containsKey©){ counter.put(c, counter.get© + 1); } else { counter.put(c, 1); } } System.out.println(counter);
###################################################################################02 13. Comparable 和 Comparator 的区别 Comparable & Comparator 都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序, Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法 compare() 或在集合内实现 Comparable 接口的方法 compareTo()。 Comparable 是一个对象本身就已经支持自比较所需要实现的接口(如 String Integer 自己就可以完成比较大小操作) Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。
ArrayList, Vector, LinkedList 的存储性能和特性 ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢, Vector 由于使用了 synchronized 方法（线程安全）, 通常性能上较 ArrayList 差； 而 LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
List, Map, Set 三个接口存储元素时各有什么特点？
List 是有序的 Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，这类似于 Java 的数组。Set 是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有 e1.equals(e2)=false，Set最多有一个null元素。Map 接口没有继承Collection接口，Map提供key到value的映射。你是怎么理解 java 的泛型的？ 在 Java SE 1.5 之前，没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型 可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 泛型是 Java SE 1.5 的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
Queue 队列，通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者按 LIFO（后进先出）的方式对元素进行排序。 常用的实现类有：LinkedList、 常用方法： boolean offer(E e); //将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。 E peek(); //获取但不移除此队列的头；如果此队列为空，则返回 null。 E poll(); //获取并移除此队列的头，如果此队列为空，则返回 null。 使用案例： Queue queue = new LinkedList(); queue.offer(“one”); queue.offer(“two”); queue.offer(“three”); System.out.println(queue.peek()); //one [“one”, “two”, “three”] System.out.println(queue.poll()); //one [“two”, “three”] //遍历队列，peek for (int i = 0; i < queue.size(); i++) { System.out.println(queue.peek()); } //遍历队列，poll while (queue.size() > 0) { System.out.println(queue.poll()); }
Deque 双端队列，一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。 常用的实现类有：LinkedList、LinkedBlockingDeque 当用于双端队列时的常用方法： boolean offer(E e); //将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用的空间，则返回 false。 E peek(); //获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。 E poll(); //获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。 当用于堆栈时的常用方法： void push(E e); //将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。 E pop(); //从此双端队列所表示的堆栈中弹出一个元素。 使用案例： Deque stack = new LinkedList(); stack.push(“one”); stack.push(“two”); stack.push(“three”); System.out.println(stack.peek()); //three [“one”, “two”, “three”] System.out.println(stack.pop()); //three [“one”, “two”] //遍历堆栈，pop while (stack.size() > 0) { System.out.println(stack.pop()); }
String getName(); // 返回此抽象路径名表示的文件或目录的名称 long length(); // 返回由此抽象路径名表示的文件的长度(占用的字节) boolean exists(); // 判断此抽象路径名表示的文件或目录是否存在 boolean isFile(); // 判断此抽象路径名表示的是否为一个文件 boolean isDirectory(); // 判断此抽象路径名表示的是否为一个目录 boolean createNewFile(); // 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件 boolean mkdir(); // 创建此抽象路径名指定的目录 boolean mkdirs(); // 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录 boolean delete(); // 删除此抽象路径名表示的文件或目录 File[] listFiles(); // 返回此抽象路径名表示的目录中的子项数组 + 2. RandomAccessFile (开发几乎不用) RandomAccessFile(File file, String mode); // 创建从中读取和向其中写入的随机访问文件流，该文件由 File 参数指定（mode=“r”:只读/“rw”:读写） RandomAccessFile(String name, String mode); // 创建从中读取和向其写入的随机访问文件流，该文件具有指定名称 void write(int d); // 根据当前指针所在位置处写入一个字节，是将参数 d 的"低8位"写出 void write(byte[] d); // 根据当前文件指针所在位置处连续写出给定数组中的所有字节 void write(byte[] d, int offset, int length); // 根据当前文件指针所在位置处连续写出给定数组中的所有字节，从数组的offset处开始，连续length个字节 int read(); // 从文件中读取一个byte(8位)填充到int的低8位，高24位为0，返回值范围正数：0~255，返回-1表示读取到了文件末尾，每次读取后自动移动文件指针，准备下次读取 int read(byte[] b); // 从指针位置处尝试最多读取给定数组的长度的字节量，并从给定的字节数组的第一个位置开始，将持续读取到的字节顺序存放至数组中，返回值为实际读取到的字节量 void close(); // 用于释放与其关联的所有系统资源 long getFilePointer(); // 返回当前RandomAccessFile的指针位置 void seek(long pos); // 用于移动当前RandomAccessFile的指针位置 int skipBytes(int n); // 用于尝试跳过指定n个字节以丢弃跳过的字节
InputStream InputStream 是所有字节输入流的父类，定义了基础的读取方法 int read(); // 读取一个字节，以int形式返回，该int值的低8位有效，若返回-1则表示EOF int read(byte[] d); // 尝试读取给定字节数组的长度个字节并存入该数组，返回值为实际读取到的字节量
OutputStream OutputStream 是所有字节输出流的父类，定义了基础的写出方法 void write(int d); // 写出一个字节，写出的是给定的int的低8位 void write(byte[] d); // 将给定的字节数组中的所有字节全部写出
FileInputStream FileInputStream 是文件的字节输入流，可以以字节为单位从文件中读取数据 FileInputStream(File file) // 创建一个从给定File对象表示的文件中读取数据的文件输入流 FileInputStream(String filename) // 创建一个从给定文件名指向的文件的文件输入流
FileOutputStream FileOutputStream 是文件的字节输出流，可以以字节为单位将数据写入文件 FileOutputStream(File file) //创建一个向给定File对象表示的文件中写出数据的文件输出流 FileOutputStream(String filename) // 创建一个向具有指定名称的文件中写出数据的文件输出流 FileOutputStream(File file, boolean append) // 创建一个向给定File对象表示的文件中写出数据的文件输出流，append为true则向文件末尾追加 FileOutputStream(String filename, boolean append) // 创建一个向具有指定名称的文件中写出数据的文件输出流
BufferedInputStream BufferedInputStream 缓冲字节输入流，其内部维护着一个缓冲区(字节数组)，在读取一个字节时，会尽可能多的一次性读取若干字节并存入缓冲区，然后逐一的将字节返回，知道缓冲区的数据全部被读取完毕，会再次读取若干字节从而反复。
BufferedOutputStream BufferedOutputStream 缓冲输出流，其内部维护着一个缓冲区，当向该流写出数据时，都会先将数据存入缓冲区，当缓冲区已满时，缓冲流会将数据一次性全部写出 void flush(); // 清空缓冲区，将缓冲区中的数据强制写出
ObjectInputStream ObjectInputStream 将对象进行反序列化的输入流 Object readObject(); // 从流中读取字节并转换为对应的对象
ObjectOutputStream ObjectOutputStream 将对象进行序列化的输出流 void writeObject(Object o); // 将给定的对象转换为一个字节序列后写出
注意：对象进行序列化或反序列化，该对象所属的类必须要实现Serializable接口。 序列化：对象转换为二进制的过程 反序列化：二进制转换回对象的过程
字节流结构： |- InputStream |- FileInputStream |- ObjectInputStream |- FilterInputStream |- BufferedInputStream |- OutputStream |- FileOutputStream |- ObjectOutputStream |- FilterOutputStream |- BufferedOutputStream
Reader Reader 是字符输入流的顶级父类 字符流是以字符(char)为单位读写数据的，一次处理一个unicode，底层仍然是基本的字节流，字符流只能读取文本数据 int read(); // 读取一个字符，返回int值低16位有效 int read(char[] chs); // 从该流中读取指定字符数组的长度个字符并存入数组，返回值为实际读取到的字符量
Writer Writer 是字符输出流的顶级父类 void write(int c); // 写出一个字符，写出给定int值的低16位表示的字符 void write(char[] chs); // 将给定的字符数组中所有字符写出 void write(String str); // 将给定的字符串写出 void write(char[] chs, int offset, int length); // 将给定的字符数组从给定的位置offset处连续的length个字符写出
InputStreamReader InputStreamReader 字符输入流，可以设置字符集，并按照指定的字符集从流中按照该编码将字节数据转换为字符并读取 InputStreamReader(InputStream in) // 创建指定字节流的字符输入流，采用系统默认编码 InputStreamReader(InputStream in, String charsetName) // 创建指定字节流和字符编码的字符输入流
OutputStreamWriter OutputStreamWriter 字符输出流，可以设置字符集，并按照指定的字符集将字符转换为对应的字节后通过该流写出 OutputStreamWriter(OutputStream out) // 创建指定字节输出流的字符输出流，采用系统默认编码 OutputStreamWriter(OutputStream out, String charsetName) // 创建指定字节输出流和字符编码的字符输出流
BufferedReader BufferedReader 是缓冲字符输入流，内部提供了缓冲区，可以提高读取效率 BufferedReader(Reader reader) String readLine(); // 连续读取一行字符串，直到读取到换行符为止，返回的字符串中不包含该换行符
BufferedWriter
PrintWriter PrintWriter 是具有自动行刷新的缓冲字符输出流 PrintWriter(File file) PrintWriter(String fileName) PrintWriter(OutputStream out) PrintWriter(OutputStream out, boolean autoFlush) PrintWriter(Writer writer) PrintWriter(Writer writer, boolean autoFlush) void print(T t); // 打印但不换行 void println(T t); // 打印并换行字符流结构： |-Reader |-InputStreamReader |-BufferedReader |-Writer |-OutputStreamWriter |-BufferedWriter //*******************************************************************************************3 【异常处理】 17. Throwable, Error, Exception Java异常处理结构中定义有Throwable类，Exception和Error是其派生的两个子类 其中Exception表示由于网络故障、文件损坏、设备错误、用户输入非法等情况导致的异常 而Error表示Java运行时环境出现的错误，例如JVM内存资源耗尽等
try{ }catch( ){ } try{…} 语句指定了一段代码，该段代码就是一次捕获并处理例外的范围 catch(…){…} 语句块中是对异常进行处理的代码
finally finally 语句为异常处理提供一个统一的出口，使得在控制流程转到程序其它部分之前，能够对程序的状态做统一管理 无论 try 所指定的程序块中是否抛出异常， finally 所指的代码都要被执行 通常在 finally 语句中可以进行资源的释放工作，如关闭打开的文件，删除临时文件等 final, finally, finalize的区别及作用 final 是一个关键字，可以用来修饰类、属性、方法。当修饰类时，该类不能被继承；修饰属性时，该属性初始化后不能第二次赋值；当修饰方法时，该方法在子类中不能被重写 finally 是异常捕获机制中的一个语句块，无论 try 所指定的程序块中是否抛出异常， finally 所指的代码都要被执行。常用来进行资源的释放工作，如关闭打开的文件，删除临时文件等 finalize 是Object类中定义的一个方法，该方法由JVM调用。当GC回收没有任何引用指向的对象时，该对象会调用自己的 finalize 方法
throw 当程序发生错误而无法处理的时候，会抛出相应的异常对象，在某些时刻，可能会想要自行抛出异常，可以使用 throw 关键词，并生成指定的异常对象后抛出
throws throws 关键词用来声明这个方法将会抛出异常 如果使用继承时，在父类的某个方法上声明了 throws 某些异常，在子类中重写该方法时可以： 1)不处理异常(重写时不声明 throws) 2)可仅 throws 父类中声明的部分异常 3)可 throws 父类方法中抛出异常的子类异常 不可以： throws 出额外的异常 throws 父类方法中抛出异常的父类异常
可检测异常 与 非检测异常 1)可检测异常：可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译 2)非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常 RuntimeException ：运行时异常属于非检查异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中频繁出现。因此它们不受编译器检查与处理或声明规则的限制。 常见 RuntimeException ： IllegalArgumentException // 向方法传递了一个不合法或不正确的参数 NullPointerException // 空指针异常 ArrayIndexOutOfBoundsException // 数组下标越界异常 ClassCastException // 类造型异常 NumberFormatException // 数字格式化异常
Exception 常见 API void printStackTrace(); // 跟踪异常事件发生时执行堆栈的内容，输出错误信息 String getMessage(); // 返回此异常事件的信息 Throwable getCause(); // 获取此异常出现的原因
【多线程】 进程和线程 一般操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序被称为一个进程，当一个程序运行时，内部可能包含多个顺序执行流，每个顺序执行流就是一个线程。
什么是进程(process)？ 1)进程是操作系统中运行的一个任务(一个应用程序运行在一个进程中) 2)进程是一块包含了某些资源的内存区域。操作系统利用进程把它的工作划分为一些功能单元 3)进程中所包含的一个或多个执行单元称为线程。进程拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问 4)线程只能归属于一个进程并且它只能访问该进程所拥有的资源。当操作系统创建一个进程后，该进程会自动申请一个名为主线程或首要进程的线程
什么是线程(thread)？ 1)一个线程是进程的一个顺序执行流 2)同类的多个线程共享一块内存空间和一组系统资源，线程本身有一个供程序执行时的堆栈。线程在切换时负荷小，因此线程也被称为轻负荷进程。一个进程可以包含多个线程
进程与线程的区别 线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程的区别在于每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑的角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用来实现进程的调度和管理以及资源分配。
并发原理 多个线程“同时”运行只是感官上的一种表现。事实上线程是并发运行的，OS将时间划分为很多时间段，尽可能均匀分配给每一个线程，获取时间片段的线程被CPU运行，而其他线程全部等待。所以微观上是走走停停，宏观上都在运行。这种现象叫并发，但不是绝对意义上的"同时发生"
线程状态 new ->start()-> Runnable --> Running --> Dead Running -sleep(long l)/wait()/yield()-> Runnable
Thread void run(); // 定义该线程要执行的逻辑 void start(); // 将当前线程纳入线程调度 static Thread currentThread(); // 获取运行当前代码片段的线程 long getId(); // 返回该线程的表示符 String getName(); // 返回该线程的名称 int getPriority(); // 返回该线程的优先级 Thread.state getState(); // 获取线程的状态 boolean isAlive(); // 测试线程是否处于活动状态 boolean isDaemon(); // 测试线程是否为守护线程 boolean isInterrupted(); // 测试线程是否已经中断 static void sleep(long ms); // 使当前线程进入阻塞状态 static void yield(); // 使当前线程主动让出当此CPU时间片回到Runnable状态，等待重新分配时间片 void join(); // 用于等待当前线程结束
Runnable 1)实现 Runnable 接口并重写run方法来定义线程体，然后在创建线程的时候将 Runnable 的实例传入并启动线程。 2)这样做的好处在于可以将线程与线程要执行的任务分离开减少耦合，同时java是单继承的，定义一个类实现 Runnable 接口这样的做法可以更好的去实现其他父类或接口，因为接口是多继承关系。
synchronized synchronized 关键字是java中的同步锁 1)异步：多线程并发的操作，各干各的 2)同步：有先后顺序的操作，你干完我再干 3)可以修饰方法，例如： public synchronized void methodName(){…} 4)可以修饰代码快，例如： synchronized (同步监视器 - 锁对象引用) {…}
静态方法锁 public synchronized static void methodName(){…} 1)静态方法锁的对象是类对象，类对象可以通过 类名.class 来获取 2)静态方法于非静态方法同时声明了 synchronized ，它们之间是非互斥关系，因为静态方法锁的是类对象而非静态方法锁的是当前方法所属的对象
ExecutorService // 线程池 ExecutorService 是Java提供用于管理线程池的类，主要有2个作用： 1)控制线程数量 2)线程重用 当一个程序中若创建大量线程，并在任务结束后销毁，会给系统带来过度消耗资源，以及过度切换线程的危险，从而可能导致系统崩溃，因此可以使用线程池来解决这个问题 线程池的实现策略： 1)Executors.newCachedThreadPool() // 创建一个可根据需要创建新线程的线程池，可以重用以前创建的线程 2)Executors.newFixedThreadPool(int size) // 创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程 3)Executors.newScheduledThreadPool(int corePoolSize) // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行 4)Executors.newSingleThreadExecutor() // 创建一个使用单个worker线程的Executor，以无界队列方式来运行该线程
【TCP通信】 34. Socket 1)Socket 称为"套接字"，用于描述IP地址和端口，是一个通信链的句柄。在Internet上的主机一般都运行了多个服务软件，同时提供多种服务。每种服务都打开一个Socket，绑定到一个端口上，不同的端口对应于不同的服务器。 2)应用程序中通常同过"套接字"向网络发出请求或者应答网络请求。ServerSocket用于服务端，Socket用于建立网络连接时使用。
http://www.42xz.com/nba2k16/32110.html
