面试-java基础

1.collection和collections

2.linkedlist和arraylist

4.set  不含重复元素   list可重复

    hashset存储add()：依赖hashcode()  equals()

先比较hash值，不同就添加到集合中，相同时再比较地址值，相同equal（）则为重复元素，不添加。不同就添加到集合中

3.hashmap：hash值是逻辑值，地址值是实际值，有hash值相同地址值不同的情况

hash表： 一个元素是链表的数组

 * HashSet:存储字符串并遍历
 * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
 * 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
 * 步骤：
 * 首先比较哈希值
 * 如果相同，继续走，比较地址值或者走equals()
 * 如果不同,就直接添加到集合中
 * 按照方法的步骤来说：
 * 先看hashCode()值是否相同
 * 相同:继续走equals()方法
 * 返回true： 说明元素重复，就不添加
 * 返回false：说明元素不重复，就添加到集合
 * 不同：就直接把元素添加到集合
 * 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

源码：

<code>

interface Collection {
...
}


interface Set extends Collection {
...
}


class HashSet implements Set {
private static final Object PRESENT = new Object();
private transient HashMap<E,Object> map;

public HashSet() {
map = new HashMap<>();
}

public boolean add(E e) { //e=hello,world
        return map.put(e, PRESENT)==null;
    }
}


class HashMap implements Map {
public V put(K key, V value) { //key=e=hello,world

//看哈希表是否为空，如果空，就开辟空间
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        
        //判断对象是否为null
        if (key == null)
            return putForNullKey(value);
        
        int hash = hash(key); //算一个hash值，和对象的hashCode()方法相关
        
        //在哈希表中查找hash值
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //这次的e其实是第一次的world
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
                //走这里其实是没有添加元素
            }
        }


        modCount++;
        addEntry(hash, key, value, i); //把元素添加
        return null;
    }
    
    transient int hashSeed = 0;
    //算哈希值
    final int hash(Object k) { //k=key=e=hello,
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }


        h ^= k.hashCode(); //这里调用的是对象的hashCode()方法


        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
}




hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("world");

</code>

推荐一个：

http://www.cnblogs.com/ITtangtang/p/3948406.html

short s=1;s=s+1; short s=1;s+=1; 有区别么？？ 如果有的话区别是什么？ 没有的话值是多少？


short s=1; 
s=s+1; 
自然是编译不通过的 提示损失精度 
那么 
short s=1; 
s+=1; 
为什么能编译通过那? 
还有一个问题 


隐式类型转换可以从小到大自动转，即byte->short->int->long如果反过来会丢失精度，必须进行显示类型转换 
s+=1的意思与s=s+1不同，
s=s+1这句先执行s+1然后把结果赋给s，由于1为int类型，所以s+1的返回值是int，
                 编译器自动进行了隐式类型转换所以将一个int类型赋给short就会出错，
而s+=1不同由于是+=操作符，在解析时候s+=1就等价于s = (short)(s+1),翻番来讲就是 
                 s+=1 <=> s =  (s的类型)(s+1)

异常：

异常分类:
编译时被检查异常; ---> Checked异常，在程序中必须使用try...catch处理；

Java编译器会检查它,也就说程序中一旦出现这类异常,要么是没有try-catch语句捕获,或throws语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.

编译时不被检测的异常; ---> Runtime异常，可以不使用try...catch处理，但一旦出现异常就将由JVM处理。

  这种异常Java编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.   

String  不可变类，一旦String对象被创建，包含在对象中的字符序列(内容)是不可变的，直到对象被销毁；
常量池:JVM中一块独立的区域存放字符串常量和基本类型常量（public static final）。
String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的.
String对象比较:
单独使用""引号创建的字符串都是常量,编译期就已经确定存储到常量池中；
使用new String("")创建的对象会存储到堆内存中,是运行期新创建的；
使用只包含常量的字符串连接符如"aa" + "bb"创建的也是常量,编译期就能确定,已经确定存储到常量池中；
使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在堆中；StringBuffer 与 StringBuilder对象则是可变的！