JAVA基础2(代码剖析)

代码摘录尚学堂

Date和DateFormat转换

<span style="font-size:14px;">import java.text.DateFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;public class TestDateFormat {public static void main(String[] args) {DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss,属于本月的第W周");Date d = new Date(12321314323L);String str = df.format(d);   //将时间对象按照格式化字符串，转化成字符串System.out.println(str);System.out.println("####################");String str2 = "1977-7-7";DateFormat df2 = new SimpleDateFormat("yyyy-MM-dd");try {Date d2 = df2.parse(str2);System.out.println(d2);} catch (ParseException e) {e.printStackTrace();}}}</span>

子类的异常不能超父类

<span style="font-size:14px;">import java.io.FileNotFoundException;import java.io.IOException;import java.text.ParseException;class A {public void method() throws IOException {}}//class D extends A {public void method() throws Exception {}     //超过父类异常的范围，会报错！//}class E extends A {public void method() throws IOException, FileNotFoundException {    }}</span>

自己编写equals：

<span style="font-size:14px;">public boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;Student other = (Student) obj;if (id != other.id)return false;return true;}</span>

 Set:无序不可重复(equals)

 List：有序可重复。
  Map：key不可重复

<span style="font-size:14px;">public class TestSet {public static void main(String[] args) {Set set = new HashSet();set.add("aaa");set.add("bbb");set.add(new String("aaa"));System.out.println(set.size());System.out.println(set.contains("aaa"));set.remove("aaa");}}</span>

//ArrayList:底层实现时数组,线程不安全，效率高。所以，查询快。修改、插入、删除慢。
//LinkedList:底层实现是链表,线程不安全，效率高。所以，查询慢。修改、插入、删除快。
//Vector:线程安全的，效率低。

/** * 自己实现一个ArrayList，帮助我们更好的理解ArrayList类的底层结构！ * */public class SxtArrayList /*implements List*/ {private Object[] elementData;private int size;public int size(){return size;}public boolean isEmpty(){return size==0;}public SxtArrayList(){this(10);}public SxtArrayList(int initialCapacity){if(initialCapacity<0){try {throw new Exception();} catch (Exception e) {e.printStackTrace();}}elementData = new Object[initialCapacity];}public void add(Object obj){//数组扩容和数据的拷贝if(size==elementData.length){Object[] newArray = new Object[size*2+1];System.arraycopy(elementData, 0, newArray, 0, elementData.length);//for(int i=0;i<elementData.length;i++){//newArray[i] = elementData[i];//}elementData = newArray;}elementData[size++]=obj;//size++;}public Object get(int index){rangeCheck(index);return elementData[index];}public void remove(int index){rangeCheck(index);//删除指定位置的对象//a b d eint numMoved = size - index - 1;if (numMoved > 0){System.arraycopy(elementData, index+1, elementData, index,numMoved);}elementData[--size] = null; // Let gc do its work}public void remove(Object obj){for(int i=0;i<size;i++){if(get(i).equals(obj)){  //注意：底层调用的equals方法而不是==.remove(i);}}}public Object set(int index,Object obj){rangeCheck(index);Object oldValue =  elementData[index];elementData[index] = obj;return oldValue;}public void add(int index,Object obj){rangeCheck(index);ensureCapacity();  //数组扩容System.arraycopy(elementData, index, elementData, index + 1, size - index);elementData[index] = obj;size++;}private void ensureCapacity(){//数组扩容和数据的拷贝if(size==elementData.length){Object[] newArray = new Object[size*2+1];System.arraycopy(elementData, 0, newArray, 0, elementData.length);elementData = newArray;}}private void rangeCheck(int index){if(index<0||index>=size){try {throw new Exception();} catch (Exception e) {e.printStackTrace();}}}public static void main(String[] args) {SxtArrayList list = new SxtArrayList(3);list.add("333");list.add("444");list.add("5");list.add("344433");list.add("333");list.add("333");System.out.println(list.size()); list.remove("444");System.out.println(list.size());}}

 自实现linkedList

public class Node { Node previous;   //上一个节点 Object obj; Node next;        //下一个节点public Node() {}public Node(Node previous, Object obj, Node next) {super();this.previous = previous;this.obj = obj;this.next = next;}public Node getPrevious() {return previous;}public void setPrevious(Node previous) {this.previous = previous;}public Object getObj() {return obj;}public void setObj(Object obj) {this.obj = obj;}public Node getNext() {return next;}public void setNext(Node next) {this.next = next;}}public class SxtLinkedList /*implements List*/ {private Node first;private Node last;private int size;public void add(Object obj){Node n = new Node();if(first==null){n.setPrevious(null);n.setObj(obj);n.setNext(null);first = n;last = n;}else{//直接往last节点后增加新的节点n.setPrevious(last);n.setObj(obj);n.setNext(null);last.setNext(n);last = n;}size++;}public int size(){return size;}private void rangeCheck(int index){if(index<0||index>=size){try {throw new Exception();} catch (Exception e) {e.printStackTrace();}}}public Object get(int index){   //2rangeCheck(index);// 0 1 2 3 4Node temp = node(index);if(temp!=null){return temp.obj;}return null;}public Node node(int index){Node temp = null;if(first!=null){if (index < (size >> 1)) {temp = first;for(int i=0;i<index;i++){temp = temp.next;}}else{temp = last;            for (int i = size - 1; i > index; i--){            temp = temp.previous;            }}}//LinkedList l;return temp;}public void remove(int index){Node temp = node(index);if(temp!=null){Node up = temp.previous;Node down = temp.next;up.next = down;down.previous = up;size--;}}public void add(int index,Object obj){Node temp = node(index);Node newNode = new Node();newNode.obj = obj;if(temp!=null){Node up = temp.previous;up.next = newNode;newNode.previous = up;newNode.next = temp;temp.previous = newNode;size++;}}public static void main(String[] args) {SxtLinkedList list = new SxtLinkedList();list.add("aaa");list.add("bbb");//list.add(1,"BBBB");list.add("ccc");list.add("ddd");list.add("eee");//list.remove(1);System.out.println(list.get(3)); }}

自实现MAP

class  SxtEntry {Object key;Object value;public SxtEntry(Object key, Object value) {super();this.key = key;this.value = value;}}public class SxtMap002 {LinkedList[]  arr  = new LinkedList[9]; //Map的底层结构就是：数组+链表!int size;public void put(Object key,Object value){SxtEntry  e = new SxtEntry(key,value);int hash = key.hashCode();hash = hash<0?-hash:hash;int a = hash%arr.length;if(arr[a]==null){LinkedList list = new LinkedList();arr[a] = list;list.add(e);}else{LinkedList list = arr[a];for(int i=0;i<list.size();i++){SxtEntry e2 = (SxtEntry) list.get(i);if(e2.key.equals(key)){e2.value = value;  //键值重复直接覆盖！return;}}arr[a].add(e);}//a:1000-->1   b:10000-->13}public Object get(Object key){int a = key.hashCode()%arr.length;if(arr[a]!=null){LinkedList list = arr[a];for(int i=0;i<list.size();i++){SxtEntry e = (SxtEntry) list.get(i);if(e.key.equals(key)){return e.value;}}}return null;}public static void main(String[] args) {SxtMap002 m = new SxtMap002();m.put("高琪", new Wife("杨幂"));m.put("高琪", new Wife("李四"));Wife w = (Wife) m.get("高琪");System.out.println(w.name); }}

/** * 自定义自己的HashSet * @author Administrator * */public class SxtHashSet {HashMap map;private static final Object PRESENT = new Object();public SxtHashSet(){map = new HashMap();}public int size(){return map.size();}public void add(Object o){map.put(o, PRESENT);   //set的不可重复就是利用了map里面键对象的不可重复！}public static void main(String[] args) {SxtHashSet s = new SxtHashSet();s.add("aaa");s.add(new String("aaa"));System.out.println(s.size());}}

迭代器

public class Test01 {public static void main(String[] args) {List list = new ArrayList();list.add("aaa");list.add("bbb");list.add("ccc");//通过索引遍历Listfor(int i=0;i<list.size();i++){System.out.println(list.get(i));}//通过迭代器遍历Listfor(Iterator iter2 = list.iterator();iter2.hasNext();){String str = (String) iter2.next();System.out.println(str);iter2.remove();iter2.remove();}System.out.println(list.size()+"******");Set set = new HashSet();set.add("高1");set.add("高2");set.add("高3");//通过迭代器遍历Set//Iterator iter = set.iterator();//while(iter.hasNext()){for(Iterator iter = set.iterator();iter.hasNext();){String str = (String) iter.next();System.out.println(str);}}}public class Test02 {public static void main(String[] args) {Map map = new HashMap();map.put("aa", "aaaa");map.put("bb", "bbbb");//遍历Map的第一种方式Set keys = map.keySet();for(Iterator iter = keys.iterator();iter.hasNext();){String keyStr = (String) iter.next();System.out.println(keyStr+"---"+map.get(keyStr)); }//遍历Map的第二种方式Set<Entry> set2 = map.entrySet();for(Iterator iter = set2.iterator();iter.hasNext();){Entry e = (Entry) iter.next();System.out.println(e.getKey()+"---"+e.getValue());}}}

排序的两种方式：

1、实体类  java.lang.Comparable +compareTo
2、业务排序类 java.util.Comparator +compare

方式1：

 class Worker implements java.lang.Comparable<Worker> {//工种private String type;//工资private double salary;public Worker() {// TODO Auto-generated constructor stub}public Worker(String type, double salary) {super();this.type = type;this.salary = salary;}public String getType() {return type;}public void setType(String type) {this.type = type;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}/** * 按工资升序 */@Overridepublic int compareTo(Worker o) {return this.salary>o.salary?1:( this.salary==o.salary?0:-1);}@Overridepublic String toString() {return "工种:"+this.type+",工资:"+this.salary+"\n";}}public class TreeMapDemo02 {/** * @param args */public static void main(String[] args) {Worker w1 =new Worker("垃圾回收员",12000);Worker w2 =new Worker("农民工",8000);Worker w3 =new Worker("程序猿",5000);TreeMap<Worker,String > employees =new TreeMap<Worker,String >();employees.put(w1,"bjsxt");employees.put(w2,"bjsxt");employees.put(w3,"bjsxt");System.out.println(employees.keySet());}}

方式2:

 class Person {private final String name;//名称private final int handsome;//帅气指数public Person() {name =null;handsome =0;}public Person(String name, int handsome) {super();this.name = name;this.handsome = handsome;}public String getName() {return name;}public int getHandsome() {return handsome;}@Overridepublic String toString() {return "姓名:"+this.name+",帅气指数:"+this.handsome+"\n";}}public class TreeMapDemo {/** * @param args */public static void main(String[] args) {Person p1 =new Person("您",100);Person p2 =new Person("刘德华",1000);Person p3 =new Person("梁朝伟",1200);Person p4 =new Person("老裴",50);TreeMap<Person,String> map =new TreeMap<Person,String>(new java.util.Comparator<Person>(){@Overridepublic int compare(Person o1, Person o2) {return -(o1.getHandsome()-o2.getHandsome());}} );map.put(p1, "bjsxt");map.put(p2, "bjsxt");map.put(p3, "bjsxt");map.put(p4, "bjsxt");//查看键Set<Person> persons =map.keySet();System.out.println(persons);}}

1、TreeSet:数据元素可以排序且不可重复
 对比:Set接口:HashSet,元素必须重写 hashcode和equals方法。
 去重:比较等于0即重复
 1)、元素可以排序  java.lang.Comparable +compareTo
new TreeSet()
 2)、排序业务类 java.util.Comparator +compare
new TreeSet(Comparator<? super E> comparator)
注意:在添加数据时排序，数据更改不会影响原来的顺序，不要修改数据，否则可能重复
2、TreeMap:要求键 可以排序，与上TreeSet同理

/** * 泛型类:声明时使用泛型 * 字母： * T  Type 表示类型。 K V 分别代表键值中的Key Value。 E 代表Element。  使用时确定类型 注意： 1、泛型只能使用引用类型，不能基本类型 2、泛型声明时字母不能使用 静态属性|静态方法上 * @author Administrator * * @param <T> */public class Student<T1,T2> {private T1 javaScore;private T2 oracleScore;//泛型声明时不能使用 静态属性|静态方法上//private static T1 test;public T1 getJavaScore() {return javaScore;}public void setJavaScore(T1 javaScore) {this.javaScore = javaScore;}public T2 getOracleScore() {return oracleScore;}public void setOracleScore(T2 oracleScore) {this.oracleScore = oracleScore;}/** * @param args */public static void main(String[] args) {//使用时指定类型(引用类型)Student<String,Integer> stu = new Student<String,Integer> ();//1、安全：类型检查stu.setJavaScore("优秀");//2、省心:类型转换int it =stu.getOracleScore(); //自动拆箱}}

泛型 ：

/** * 父类为泛型类 * 1、属性 * 2、方法 *  * 要么同时擦除，要么子类大于等于父类的类型, * 不能子类擦除，父类泛型 * 1、属性类型 *  父类中，随父类而定 *  子类中，随子类而定 * 2、方法重写: *  随父类而定 *  *  * @author Administrator * * @param <T> */public abstract class Father<T,T1> {T name;public abstract void test(T t);}/** * 子类声明时指定具体类型 * 属性类型为具体类型 * 方法同理 */class Child1 extends Father<String,Integer>{String t2;@Overridepublic void test(String t) {}}/** * 子类为泛型类 ,类型在使用时确定 * @author Administrator * */class Child2<T1,T,T3> extends Father<T,T1>{T1 t2;@Overridepublic void test(T t) {}}/** * 子类为泛型类，父类不指定类型 ,泛型的擦除，使用Object替换 */class Child3<T1,T2> extends Father{T1 name2;@Overridepublic void test(Object t) {// TODO Auto-generated method stub}}/** * 子类与父类同时擦除 */class Child4 extends Father{String name;@Overridepublic void test(Object t) {}}/** *错误:子类擦除，父类使用泛型class Child5 extends Father<T,T1>{String name;@Overridepublic void test(T t) {}*/

/***泛型的擦除*1、继承|实现声明 不指定类型*2、使用时 不指定类型 *统一Object 对待 *1、编译器警告 消除使用Object*2、不完全等同于Object ,编译不会类型检查 * @author Administrator * * @param <T> */public class Student<T> {private T javaScore;private T oracleScore;//泛型声明时不能使用 静态属性|静态方法上//private static T1 test;public T getJavaScore() {return javaScore;}public void setJavaScore(T javaScore) {this.javaScore = javaScore;}public T getOracleScore() {return oracleScore;}public void setOracleScore(T oracleScore) {this.oracleScore = oracleScore;}/** * @param args */public static void main(String[] args) {Student stu1 = new Student(); //消除警告 使用 ObjectStudent<Object> stu = new Student<Object>(); stu.setJavaScore("af"); //以Object对待test(stu1); //stu1 相当于Object 但是不完全等同Object//擦除，不会类型检查//test(stu);--报错test1(stu1);test1(stu);}public static  void test(Student<Integer> a){}public static  void test1(Student<?> a){}}

/** * 泛型接口:与继承同理 * 重写方法随父类而定 * * @param <T> */public interface Comparable<T> {void compare(T t);}//声明子类指定具体类型class Comp implements Comparable<Integer>{@Overridepublic void compare(Integer t) {// TODO Auto-generated method stub}}//擦除class Comp1 implements Comparable{@Overridepublic void compare(Object t) {// TODO Auto-generated method stub} }//父类擦除，子类泛型class Comp2<T> implements Comparable{@Overridepublic void compare(Object t) {// TODO Auto-generated method stub} }//子类泛型>=父类泛型class Comp3<T> implements Comparable<T>{@Overridepublic void compare(T t) {// TODO Auto-generated method stub} }//父类泛型，子类擦除 错误

泛型木有多态

//泛型类 class A<T> {}public  Fruit {}class Apple extends Fruit{}public class App {/** * @param args */public static void main(String[] args) {A<Fruit> f1 = new A<Apple>(); //没有多态 报错A<Fruit> f =new A<Fruit>();test(new A<Apple>()); // 形参没有多态 报错 }//形参使用多态public static void test(A<Fruit> f){}//返回类型使用多态 报错public static A<Fruit>  test2(){return (A<Fruit>)(new A<Apple>());}}

/** * 通配符 * ?类型不定，使用时确定类型 * ?使用:声明类型|声明方法上，不能声明类或使用时 * ? extends : <= 上限  指定类型 子类或自身 * ? super :>=下限   指定类型 为自身或父类 * @author Administrator * *///泛型类 class A<T> {} class Fruit {}class Apple extends Fruit{}public class Student<T> {T score;public static void main(String[] args) {Student<?> stu = new Student<String>();test(new Student<Integer>());test2(new Student<Apple>());//test3(new Student<Apple>()); //泛型没有多态//test4(new Student<Apple>()); //< stu  = new Student<Fruit>();;//test4(stu); //使用时确定类型test4(new Student<Object>());test4(new Student<Fruit>());}public static void test(Student<?> stu){}public static void test3(Student<Fruit> stu){}// <=public static void test2(Student<? extends Fruit> stu){}//>=public static void test4(Student<? super Fruit> stu){}}

/** * 没有泛型数组 * 声明可以使用，但是创建失败 * @author Administrator * */public class Array {/** * @param args */public static void main(String[] args) {Integer[]  arr = new Integer[4]; //Student<String>[] arr2 = new Student<String>[10];Student<?>[] arr2 = new Student[10];MyArrayList<String> strList =new MyArrayList<String>();strList.add(0, "a");String elem =strList.getElem(0);System.out.println(elem);}}class MyArrayList<E>{//E[] cap =new E[10]; 没有泛型数组Object[] cap = new Object[10];public void add(int idx,E e){cap[idx] =e;}@SuppressWarnings("unchecked")public E[] getAll(){return (E[]) cap;}@SuppressWarnings("unchecked")public E getElem(int idx){return (E) cap[idx];}}

一、Hashtable 与HashMap的区别 （面试题）
1、主要:Hashtable线程安全，同步，效率相对低下
 HashMap 线程不安全，非同步，效率相对高
2、父类:Hashtable  是 Dictionary  HashMap 是 AbstractMap
3、null: Hashtable键与值不能为null
 HashMap 键最多一个null,值可以多个null
二、Properties
1、作用:读写资源配置文件
2、键与值只能为字符串
3、方法:
setProperty(String key, String value)
getProperty(String key)
getProperty(String key, String defaultValue) 

后缀:.properties
store(OutputStream out, String comments)
store(Writer writer, String comments)
load(InputStream inStream)
load(Reader reader)
.xml
storeToXML(OutputStream os, String comment)  :UTF-8字符集
storeToXML(OutputStream os, String comment, String encoding)
loadFromXML(InputStream in)
三、相对路径与绝对路径
1、绝对路径 :    盘符:  /
2、相对路径 : 当前项目、工程

四、类路径加载资源文件
类所在的根路径
1、类.class.getResourceAsStream("/")
2、Thread.currentThread().getContextClassLoader().getResourceAsStream("")

一、引用分类(面试)
强引用:StrongReference:引用指向对象，gc (Garbage collection)运行时不回收
软引用:SoftReference gc运行时可能回收(jvm内存不够)
弱引用:WeakReference gc运行时立即回收
虚引用:PhantomReference  类似于无引用，主要跟踪对象被回收的状态，不能单独使用，必须与引用队列(ReferenceQueue) 联合使用
二、三个Map接口实现类
1、WeakHashMap:键为弱引用
2、IdentityHashMap:键比较地址去重，注意常量池的对象
3、EnumMap:枚举map,要求键为枚举的值

一、同步控制：多线程并发访问集合的线程安全。
常用容器 ArrayList HashSet HashMap 等都是线程不安全的
Collections提供了synchronizedXxx()方法，将指定容器包装成同步
synchronizedList()
synchronizedSet()
synchronizedMap()
二、不可变设置：“只读”访问， Collections提供了三种方法
emptyXxx()  空的不可变的集合
singletonXxx() 一个元素不可变的集合
unmodifiableXxx() 不可变容器

二、三个知识点
1、迭代器
1)、java.util.Iterator + hasNext() next() remove()
2)、foreach :java.lang.Iterable +iterator()
2、比较器
1)、实体类可以排序  java.lang.Comparable +compareTo
2)、排序比较器(解耦、多种排序规则) java.util.Comparator +compare
  List+Collections.sort()
  TreeSet
  TreeMap
3、泛型: <> 泛型类、泛型方法、泛型接口、泛型擦除、通配符 ? extends super 泛型嵌套
三、六个接口
Collection Set List Map Iterator Comparable
四、九个常用类  添加、删除、修改、查看 +遍历
1、ArrayList:数组 查看多于修改
   add(元素) add(索引，元素) remove(元素) remove(索引) set(索引，元素) get(索引)
   for+get  foreach() Iterator ListIterator
2、LinkedList :链表，修改多于查看 ，多了些链头与链尾的方法
3、HashSet: 重写 hashcode +equals
   add(元素)  remove(元素)
 foreach() Iterator
4、TreeSet :元素可以排序 或者提供排序的业务类
5、HashMap: 键不能重复 必须重写 hashcode +equals ，值可以重复
     put(k,v) remove(k) get(K) containsKey containsValue
    获取值:values()  keySet()+get entrySet()+getValue()
    获取键:keySet  entrySet() +getKey()
    获取键与值: keySet()+get  entrySet() +getKey() getValue()
6、Properties :资源配置文件  相对路径获取文件
7、Hashtable:键与值都不能为null 线程安全
8、Stack:栈
9、Collections:工具类

写配置文件：

import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.util.Properties;/** * 使用Properties 输出到文件 * 资源配置文件: *  * 1、.properties * store(OutputStream out, String comments) store(Writer writer, String comments)    2、.xml   storeToXML(OutputStream os, String comment)  :UTF-8字符集   storeToXML(OutputStream os, String comment, String encoding)  * @author Administrator * */public class Demo02 {/** * @param args * @throws IOException  * @throws FileNotFoundException  */public static void main(String[] args) throws FileNotFoundException, IOException {//创建对象Properties pro =new Properties();//存储pro.setProperty("driver", "oracle.jdbc.driver.OracleDriver");pro.setProperty("url", "jdbc:oracle:thin:@localhost:1521:orcl");pro.setProperty("user", "scott");pro.setProperty("pwd", "tiger");//存储到e:/others  绝对路径  盘符://pro.store(new FileOutputStream(new File("e:/others/db.properties")), "db配置");//pro.storeToXML(new FileOutputStream(new File("e:/others/db.xml")), "db配置");//使用相对路径 当前的工程//pro.store(new FileOutputStream(new File("db.properties")), "db配置");//pro.store(new FileOutputStream(new File("src/db.properties")), "db配置");pro.store(new FileOutputStream(new File("src/com/bjsxt/others/pro/db.properties")), "db配置");}}

读配置文件：

import java.io.IOException;import java.util.Properties;/** * 使用类相对路径读取配置文件 *  bin   * @author Administrator * */public class Demo04 {/** * @param args * @throws IOException  */public static void main(String[] args) throws IOException {Properties pro =new Properties();//类相对路径的 / bin //pro.load(Demo04.class.getResourceAsStream("/com/bjsxt/others/pro/db.properties"));//"" bin pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("com/bjsxt/others/pro/db.properties"));System.out.println(pro.getProperty("user", "bjsxt"));}}

//队列应用例子

import java.util.ArrayDeque;import java.util.Deque;/** * 使用队列实现自定义堆栈 * 1、弹 * 2、压 * 3、获取头 * @author Administrator * * @param <E> */ class MyStack<E> {//容器private Deque<E> container =new ArrayDeque<E>();//容量private int cap;public MyStack(int cap) {super();this.cap = cap;}//压栈public boolean push(E e){if(container.size()+1>cap){return false;}return container.offerLast(e);}//弹栈public E pop(){return container.pollLast();}//获取public E peek(){return container.peekLast();}public int size(){return this.container.size();}}public class Demo02 {/** * @param args */public static void main(String[] args) {MyStack<String> backHistory =new MyStack<String>(3);backHistory.push("www.baidu.com");backHistory.push("www.google.com");backHistory.push("www.sina.com");backHistory.push("www.bjsxt.cn");System.out.println("大小："+backHistory.size());//遍历String item=null;while(null!=(item=backHistory.pop())){System.out.println(item);}}}

list,set,map支持线程同步的方法

/** * 使用Collections管理同步 容器 * synchronizedList()synchronizedSet()synchronizedMap() * @author Administrator * */public class Demo01 {/** * @param args */public static void main(String[] args) {List<String> list =new ArrayList<String>();list.add("a");list.add("b");//list可以同步List<String> synList =Collections.synchronizedList(list);System.out.println("线程安全的list制作完毕");}}

Collection对列表的支持

import java.util.Collections;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Set;/** * 只读设置 * emptyXxx()  空的不可变的集合  * 1、emptyList()  *    emptyMap() *    emptySet()2、singletonXxx() 一个元素不可变的集合singleton(T o) singletonList(T o) singletonMap(K key, V value) 3、unmodifiableXxx() 不可变容器unmodifiableList(List<? extends T> list) unmodifiableSet(Set<? extends T> s) unmodifiableMap(Map<? extends K,? extends V> m)  * @author Administrator * */public class Demo02 {/** * @param args */public static void main(String[] args) {Map<String,String> map =new HashMap<String,String>();map.put("test", "test");map.put("bjsxt", "bjsxt");//只读控制Map<String,String> map2 =Collections.unmodifiableMap(map);//map2.put("a", "a"); //不能操作System.out.println(map2.size());//一个元素的容器测试List<String> list =Collections.singletonList(new String());list.add("test");//list.add("bjsxt"); //只能包含一个元素的容器}public static Set<String> oper(Set<String> set){if(null==set){return Collections.EMPTY_SET; //外部获取避免NullPointerException}//操作return set;}}

import java.util.EnumMap;/** * EnumMap要求键为枚举 * @author Administrator * */public class EnumMapDemo {/** * @param args */public static void main(String[] args) {EnumMap<Season,String> map =new EnumMap<Season,String>(Season.class);//存放值map.put(Season.SPRING, "春困");map.put(Season.SUMMER, "夏无力");map.put(Season.AUTUMN, "秋乏");map.put(Season.WINTER, "冬眠");System.out.println(map.size());}}//季节enum Season{SPRING,SUMMER,AUTUMN,WINTER}

import java.util.WeakHashMap;/** * WeakHashMap 键为弱类型，gc运行立即回收 * @author Administrator * */public class WeakHashMapDemo {/** * @param args */public static void main(String[] args) {WeakHashMap<String,String> map =new WeakHashMap<String,String>();//测试数据//常量池对象，不会回收map.put("abc", "a");map.put("d", "test");//gc运行 已被回收map.put(new String("bjsxt"), "c");map.put(new String("dsf"), "d");//通知回收System.gc();System.runFinalization();System.out.println(map.size());}}

import java.util.IdentityHashMap;/** * IdentityHashMap 键比较地址去重 * @author Administrator * */public class A {/** * @param args */public static void main(String[] args) {IdentityHashMap<String ,String> map =new IdentityHashMap<String,String>();//常量池中的"a"map.put("a", "a1");map.put("a", "a2");System.out.println(map.size());  //1map.put(new String("a"), "a3");map.put(new String("a"), "a4");System.out.println(map.size()); //3}}

import java.lang.ref.WeakReference;/** * 引用分类:强、软、弱、虚 * 强与弱引用 * @author Administrator * */public class RefDemo {/** * @param args */public static void main(String[] args) {//字符串常量池 String str =new String("bjsxt is very good");//弱引用 管理 对象WeakReference<String> wr =new WeakReference<String>(str);System.out.println("gc运行前:"+wr.get());//断开引用str =null;//通知回收System.gc();System.runFinalization();//对象被回收System.out.println("gc运行后:"+wr.get()); }public static void testStrong(){//字符串常量池  共享(不能回收)String str ="bjsxt is very good";//弱引用 管理 对象WeakReference<String> wr =new WeakReference<String>(str);System.out.println("gc运行前:"+wr.get());//断开引用str =null;//通知回收System.gc();System.runFinalization();System.out.println("gc运行后:"+wr.get());}}