Java基础知识二

1 TreeMap、LinkedHashMap、HashMap的区别

1）HashMap底层实现是散列表，因此它内部存储的元素是无序的。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力。

2）treeMap底层是红黑树，所以它内部的元素是有序的，排序的依据是自然序或者创建TreeMap时所提供的比较器（comparator）对象。

3）LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,能够记住插入元素的顺序。

2 Collection和Collections的区别

1）Collection<E>是Java集合框架的基本接口，Collection接口实现了Iterable<E>接口，这意味着所有实现了Collection接口的具体集合类都是可迭代的。那么既然要迭代，我们就需要一个迭代器来遍历相应集合中的对象，所以Iterable<E>接口要求我们实现iterator方法，这个方法要返回一个迭代器对象。一个迭代器对象也就是实现了Iterator<E>接口的对象，这个接口要求我们实现hasNext()、next()、remove()这三个方法。其中hasNext方法判断是否还有下一个元素（即是否遍历完对象了），next方法会返回下一个元素（若没有下一个元素了调用它会引起抛出一个NoSuchElementException异常）

Collection<String> c = ...;
Iterator<String> iter = c.iterator();
while (iter.hasNext()) {
    String element = iter.next();
    do something with element;
}

Java SE 5.0提供了以上方法更简洁的版本

for (String element : c) {
    do something with element;
}

Java类库中并未提供任何对这个接口的直接实现，而是提供了对于它的更具体的子接口的实现（比如Set接口和List接口）。

Collection接口定义了以下方法

boolean    add(E e) //向集合中添加一个元素，若添加元素后集合发生了变化就返回true，若没有发生变化，就返回false。(optional operation).
boolean    addAll(Collection<? extends E> c) //添加给定集合c中的所有元素到该集合中(optional operation).
void    clear()  //(optional operation).
boolean    contains(Object o) //判断该集合中是否包含指定对象
boolean    containsAll(Collection<?> c)
boolean    equals(Object o)
int    hashCode()
boolean    isEmpty()
Iterator<E>    iterator()
boolean    remove(Object o) //移除给定对象的一个实例（有的具体集合类型允许重复元素） (optional operation).
boolean    removeAll(Collection<?> c) //(optional operation).
boolean    retainAll(Collection<?> c)   //仅保留给定集合c中的元素(optional operation).
int    size()
Object[]    toArray()//返回这个集合的对象数组
<T> T[]    toArray(T[] a)

Collection接口的直接子接口主要有三个：List接口、Set接口和Queue接口。

Java类库中常见的实现了List<E>接口的类有：ArrayList， LinkedList，Stack，Vector，AbstractList，AbstractSequentialList等等。

Java类库中实现了Set接口的具体类主要有：AbstractSet，HashSet，TreeSet，EnumSet，LinkedHashSet等等。其中，HashSet与TreeSet都是AbstractSet的子类。那么，为什么Java类库要提供AbstractSet这个抽象类呢？答案是为了让我们在自定义实现Set接口的类时不必“从零开始”，AbstractSet这个抽象类已经为我们实现了Set接口中的一些常规方法，而一些灵活性比较强的方法可以由我们自己来定义，我们只需要继承AbstractSet这个抽象类即可。

实现Queue接口的类主要有：AbstractQueue， ArrayQeque， LinkedList，PriorityQueue，DelayQueue等等。

2）Collections是Java集合框架提供的一个工具类，其中包含了大量用于操作或返回集合的静态方法,此类不能实例化，原因是Collections的构造方法是被私有化了的，以此来达到不被实例化的目的。就像一个工具类，服务于Java的Collection框架。

java.util.Collections
public class Collections extends Object{
}

sort  

public static <T extends Comparable<? super T>> void sort(List<T> list)

根据元素的 自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此外，列表中的所有元素都必须是 可相互比较的（也就是说，对于列表中的任何 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）

public static <T> void sort(List<T> list,
                            Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器 相互比较（也就是说，对于列表中的任意 e1 和 e2 元素， c.compare(e1, e2) 不得抛出 ClassCastException）。

此排序方法是稳定的，不改变相等元素的相对顺序。

reverse

public static void reverse(List<?> list)

反转指定列表中元素的顺序。

min

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

根据元素的 自然顺序 返回给定 collection 的最小元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是 可相互比较的（也就是说，对于 collection 中的任意 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）。

此方法在整个 collection 上进行迭代，所以它需要的时间与 collection 的大小成正比。

public static <T> T min(Collection<? extends T> coll,
                        Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须可通过指定比较器 相互比较（也就是说，对于 collection 中的任意 e1 和 e2 元素， comp.compare(e1, e2) 不得抛出 ClassCastException）。

max

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

根据元素的 自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable 接口。此外，collection 中的所有元素都必须是 可相互比较的（也就是说，对于 collection 中的任意 e1 和 e2 元素， e1.compareTo(e2) 不得抛出 ClassCastException）。

public static <T> T max(Collection<? extends T> coll,
                        Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器 相互比较（也就是说，对于 collection 中的任意 e1 和 e2 元素， comp.compare(e1, e2) 不得抛出 ClassCastException）。

3 接口与抽象类的区别

接口是一种约定，实现接口的类要遵循这种约定；抽象类本质上是一个类，使用抽象类的代价要比使用接口大。接口与抽象类的对比如下：

1）抽象类中可以包含属性、方法（包含抽象方法和有具体实现的方法）、常量，而接口中只能包含常量和方法的声明。

2）抽象类中的方法和成员变量可以定义可见性（如public、private），而接口中的方法只能是public（缺省是public）。

3）一个子类只能有一个父类（具体类或抽象类），而一个接口可以继承多个接口，一个类可以实现多个接口。

4）子类中实现父类的抽象方法时，可见性可以大于等于父类中的；而接口实现类中的接口方法只能使public。

4 静态内部类与非静态内部类的区别

1）静态内部类不会持有外围类的引用，而非静态内部类会持有外围对象的引用。

2）静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)，只能直接访问外部类的静态成员；非静态内部类的非静态成员可以访问外部类的非静态变量。

3）静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

5 Java中进行线程同步的方法

1）volatile：Java Memery Model 保证了对一个volatile变量写发生要早于它的读；Volatile字段是用于线程间通讯的特殊字段。每次读volatile字段都会看到其它线程写入该字段的最新值；实际上，程序员之所以要定义volatile字段是因为在某些情况下由于缓存和重排序所看到的陈旧的变量值是不可接受的。编译器和运行时禁止在寄存器里面分配它们。它们还必须保证，在它们写好之后，它们被从缓冲区刷新到主存中，因此，它们立即能够对其他线程可见。相同地，在读取一个volatile字段之前，缓冲区必须失效，因为值是存在于主存中而不是本地处理器缓冲区。在重排序访问volatile变量的时候还有其他的限制。

2）synchronized：可以对一个代码块或是对一个方法加锁，被锁住的地方称为临界区，进入临界区的线程会获取对象的monitor，这样其它尝试进入临界区的线程会因无法获取monitor而被阻塞，由于等待另一个线程释放monitor而被阻塞的线程不能被中断；

3）ReentrantLock：实现了Lock接口，lock()获取锁，unlock()释放锁，尝试获取锁的线程可以被中断并可以设置超时参数。

6 ThreadLocal的设计理念和作用

ThreadLocal是提供线程内部的局部变量，在多线程环境下访问时能够保证各个线程内部的ThreadLocal变量相互独立。也就是说每个线程内部的ThreadLocal变量是自己专用的，其他线程是访问不到的，ThreadLocal最常用于以下这个场景：多线程环境下存在对非线程安全对象的并发访问，而且该对象不需要在线程间共享，但是我们不想加锁，这时候可以用ThreadLocal来使得每个线程都持有一个该对象的副本。最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。

private static ThreadLocal<Connection> connectionHolder
= new ThreadLocal<Connection>() {
public Connection initialValue() {
    return DriverManager.getConnection(DB_URL);
}
};
 
public static Connection getConnection() {
return connectionHolder.get();
}

private static final ThreadLocal threadSession = new ThreadLocal();
 
public static Session getSession() throws InfrastructureException {
    Session s = (Session) threadSession.get();
    try {
        if (s == null) {
            s = getSessionFactory().openSession();
            threadSession.set(s);
        }
    } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
    }
    return s;
}

部分内容转自 http://www.cnblogs.com/absfree/p/5568849.html