ja

两者都是非线程安全，前者无排序，后者会自动排序

HashMap的原理介绍x0dx0ax0dx0a此乃老生常谈，不作仔细解说。x0dx0a一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。x0dx0ax0dx0aJava 7 中HashMap的源码分析x0dx0ax0dx0a首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.x0dx0a//代码块1x0dx0a public HashMap(int initialCapacity, float loadFactor) {x0dx0a if (initialCapacity < 0)x0dx0a throw new IllegalArgumentException("Illegal initial capacity: " +x0dx0a initialCapacity);x0dx0a if (initialCapacity > MAXIMUM_CAPACITY)x0dx0a initialCapacity = MAXIMUM_CAPACITY;x0dx0a if (loadFactor <= 0 || Float.isNaN(loadFactor))x0dx0a throw new IllegalArgumentException("Illegal load factor: " +loadFactor);x0dx0ax0dx0a this.loadFactor = loadFactor;x0dx0a threshold = initialCapacity;x0dx0a init();x0dx0a }x0dx0ax0dx0aJava7中对于的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。x0dx0a代码块2x0dx0apublic V put(K key, V value) {x0dx0a if (table == EMPTY_TABLE) {x0dx0a inflateTable(threshold);x0dx0a }x0dx0a if (key == null)x0dx0a return putForNullKey(value);x0dx0a int hash = hash(key);x0dx0a int i = indexFor(hash, table.length);x0dx0a for (Entry e = table[i]; e != null; e = e.next) {x0dx0a Object k;x0dx0a if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {x0dx0a V oldValue = e.value;x0dx0a e.value = value;x0dx0a e.recordAccess(this);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0ax0dx0a modCount++;x0dx0a addEntry(hash, key, value, i);x0dx0a return null;x0dx0a }x0dx0ax0dx0a//addEntry方法中会检查当前table是否需要resizex0dx0a void addEntry(int hash, K key, V value, int bucketIndex) {x0dx0a if ((size >= threshold) && (null != table[bucketIndex])) {x0dx0a resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。x0dx0a hash = (null != key) ? hash(key) : 0;x0dx0a bucketIndex = indexFor(hash, table.length);x0dx0a }x0dx0ax0dx0a createEntry(hash, key, value, bucketIndex);x0dx0a }x0dx0ax0dx0aJava7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，x0dx0a//代码块3 --JDK7中HashMap.resize()方法x0dx0avoid resize(int newCapacity) {x0dx0a Entry[] oldTable = table;x0dx0a int oldCapacity = oldTable.length;x0dx0a if (oldCapacity == MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;x0dx0a return;x0dx0a }x0dx0ax0dx0a Entry[] newTable = new Entry[newCapacity];x0dx0a transfer(newTable, initHashSeedAsNeeded(newCapacity));x0dx0a table = newTable;x0dx0a threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);x0dx0a }x0dx0ax0dx0a /**x0dx0a * 将当前table的Entry转移到新的table中x0dx0a */x0dx0a void transfer(Entry[] newTable, boolean rehash) {x0dx0a int newCapacity = newTable.length;x0dx0a for (Entry e : table) {x0dx0a while(null != e) {x0dx0a Entry next = e.next;x0dx0a if (rehash) {x0dx0a e.hash = null == e.key ? 0 : hash(e.key);x0dx0a }x0dx0a int i = indexFor(e.hash, newCapacity);x0dx0a e.next = newTable[i];x0dx0a newTable[i] = e;x0dx0a e = next;x0dx0a }x0dx0a }x0dx0a }x0dx0ax0dx0aHashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。x0dx0a根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。x0dx0a然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。x0dx0a在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。x0dx0a代码块4 -- JDK8中HashMap中常量定义x0dx0a static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; x0dx0a static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值x0dx0a static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值x0dx0a static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量x0dx0a static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子x0dx0ax0dx0a在Java 8 HashMap的put方法实现如代码块5所示，x0dx0a代码块5 --JDK8 HashMap.put方法x0dx0a public V put(K key, V value) {x0dx0a return putVal(hash(key), key, value, false, true);x0dx0a }x0dx0ax0dx0a final V putVal(int hash, K key, V value, boolean onlyIfAbsent,x0dx0a boolean evict) {x0dx0a Node[] tab; Node p; int n, i;x0dx0a if ((tab = table) == null || (n = tab.length) == 0)x0dx0a n = (tab = resize()).length; //table为空的时候，n为table的长度x0dx0a if ((p = tab[i = (n - 1) & hash]) == null)x0dx0a tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。x0dx0a else {x0dx0a // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同x0dx0a Node e; K k;x0dx0a if (p.hash == hash &&x0dx0a ((k = p.key) == key || (key != null && key.equals(k))))x0dx0a e = p;//相同则覆盖之x0dx0a else if (p instanceof TreeNode)x0dx0a // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。x0dx0a e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);x0dx0a else {x0dx0a // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。x0dx0a for (int binCount = 0; ; ++binCount) {x0dx0a if ((e = p.next) == null) {x0dx0a p.next = newNode(hash, key, value, null);x0dx0a if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1stx0dx0a treeifyBin(tab, hash);x0dx0a break;x0dx0a }x0dx0a if (e.hash == hash &&x0dx0a ((k = e.key) == key || (key != null && key.equals(k))))x0dx0a break;x0dx0a p = e;x0dx0a }x0dx0a }x0dx0a if (e != null) { // existing mapping for keyx0dx0a V oldValue = e.value;x0dx0a if (!onlyIfAbsent || oldValue == null)x0dx0a e.value = value;x0dx0a afterNodeAccess(e);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0a ++modCount;x0dx0a if (++size > threshold)x0dx0a resize();x0dx0a afterNodeInsertion(evict);x0dx0a return null;x0dx0a }x0dx0ax0dx0a再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,x0dx0a代码块6 -- JDK8的resize方法x0dx0a inal Node[] resize() {x0dx0a Node[] oldTab = table;x0dx0a int oldCap = (oldTab == null) ? 0 : oldTab.length;x0dx0a int oldThr = threshold;x0dx0a int newCap, newThr = 0;x0dx0a if (oldCap > 0) {x0dx0a if (oldCap >= MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充tablex0dx0a return oldTab;x0dx0a }x0dx0a else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&x0dx0a oldCap >= DEFAULT_INITIAL_CAPACITY)x0dx0a newThr = oldThr << 1; // threshold门槛扩大至2倍x0dx0a }x0dx0a else if (oldThr > 0) // initial capacity was placed in thresholdx0dx0a newCap = oldThr;x0dx0a else { // zero initial threshold signifies using defaultsx0dx0a newCap = DEFAULT_INITIAL_CAPACITY;x0dx0a newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);x0dx0a }x0dx0a if (newThr == 0) {x0dx0a float ft = (float)newCap * loadFactor;x0dx0a newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?x0dx0a (int)ft : Integer.MAX_VALUE);x0dx0a }x0dx0a threshold = newThr;x0dx0a @SuppressWarnings({"rawtypes","unchecked"})x0dx0a Node[] newTab = (Node[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

这两天在看 Reference 相关的东西，虽然接触到的场景不多，但感觉还是比较有用的。在非常关心内存的情况下，有可能能派上用场。在涉及到某一个对象被 GC，需要得到通知，然后再做某些相关处理的时候，有可能派得上用场。对于第一点，目前接触到的就是 WeakHahsMap。像我们平常写缓存的时候，最简单的就是在一个类中public static Map<String,String> user_map = new HashMap<String, String>();然后再在全局使用它。这里就可以参考下 Tomcat 实现的这个 LRU 缓存：tomcat/ConcurrentCache.java at trunk · apache/tomcat · GitHub，它就用到了 WeakHashMap，WeakHashMap也用到了 WeakReference，可以参考下。WeakHahsMap 的实现原理简单来说就是里面的 Entry 使用继承了 WeakReference，那么当 Entry 的 key 不再被使用的时候，也就是被 GC 的时候，那么该 Entry 就会进入到 ReferenceQueue 中， WeakHashMap 在你调用相关方法的时候，那么就会把这个 Entry 从 ReferenceQueue 中删除，并且做相关处理（也就是把这个 key 删除）。这时候你就会发现，你的一个键值对没有了。对于第二点，目前接触到的就是一个 FileCleaningTracker，它的作用是，把一个文件和一个对象关联起来，当这个对象被 GC 的时候，文件也帮我们删除掉。FileCleaningTracker 的实现简单来说就是用了一个虚引用。它里面有一个 Tracker 的内部类，他继承自 PhantomReference，你可以理解成 WeakHashMap中的 Entry（其实也很像了）。这个 Tracker 就和我们的关联对象 marker 关联起来（你可以理解成 WeakHashMap 中的 Entry 的 key），那么当 marker 被回收的时候，Tracker 就会被GC 弄到 ReferenceQueue 中，那么 FileCleaningTracker 就会把 Tracker 从 ReferenceQueue 移除出来，并且执行相关操作（delete file）。最后：自己理解的引用（强，软，弱虚）是和 GC 比较相关的，能够在一个 对象被 GC 的时候，应用程序得到通知，然后执行相关操作。像 WeakHashMap 就是这样，底层发现 key 没了，上层就把 entry 删了。ps：第6条：消除过期对象的引用（WeakHashMap的缓存应用）：愿无岁月可回首第6条：WeakHashMap扩展知识1（原理与Reference相关）：愿无岁月可回首第6条：Reference应用-FileCleaningTracker：愿无岁月可回首最后的最后补充。。。突然想起，之前自己在工作中涉及到这样一种情况，我需要对用户投资的钱进行一个每日的加息，有一天客户忘了把加息的数据给我，然后给了我一份 csv 文件，让我加上。我当时的做法是，让运维把文件放在固定的地方，程序读取，执行逻辑，然后运维再手动删除。 这个时候，其实也可以通过这种 FileCleaningTracker，当读取完之后，自动的删除这个文件，就不用运维来做了。（这可能是一种应用场景）

HashMap的原理介绍此乃老生常谈，不作仔细解说。一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。Java 7 中HashMap的源码分析首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.//代码块1 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " +loadFactor); this.loadFactor = loadFactor; threshold = initialCapacity; init(); }Java7中对于<key1,value1>的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。代码块2public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { 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; }//addEntry方法中会检查当前table是否需要resize void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); }Java7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，//代码块3 --JDK7中HashMap.resize()方法void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; transfer(newTable, initHashSeedAsNeeded(newCapacity)); table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); } /** * 将当前table的Entry转移到新的table中 */ void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } } }HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。代码块4 -- JDK8中HashMap中常量定义 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值 static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值 static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量 static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子在Java 8 HashMap的put方法实现如代码块5所示，代码块5 --JDK8 HashMap.put方法 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //table为空的时候，n为table的长度 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。 else { // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同 Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;//相同则覆盖之 else if (p instanceof TreeNode) // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,代码块6 -- JDK8的resize方法 inal Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充table return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // threshold门槛扩大至2倍 } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

什么是HashSetHashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。什么是HashMapHashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。public Object put(Object Key,Object value)方法用来将元素添加到map中。你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。HashSet和HashMap的区别*HashMap* *HashSet* HashMap实现了Map接口 HashSet实现了Set接口 HashMap储存键值对 HashSet仅仅存储对象 使用put()方法将元素放入map中 使用add()方法将元素放入set中 HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

http://blog.csdn.net/rickiyeat/article/details/52708794

面向对象软件开发的优点有哪些？答：开发模块化，更易维护和修改；代码之间可以复用；增强代码的可靠性、灵活性和可理解性。多态的定义？答：多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。继承的定义？答：继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性抽象的定义？抽象和封装的不同点？答：抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。Java支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。抽象和封装是互补的概念。一方面，抽象关注对象的行为。另一方面，封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装，因此，封装可以看成是用来提供抽象的一种策略。接口和抽象类的区别是什么？答：Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。类可以实现很多个接口，但是只能继承一个抽象类类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。抽象类可以在不提供接口方法实现的情况下实现接口。Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？答：上次电话面试被问到了这个问题，一脸蒙B。Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。 这里分享一个讲Java虚拟机的趣文，小说的形式。很有趣，读完你就明白虚拟机的工作原理：http://blog.jobbole.com/101114/”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？答：“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？答：这道题如果面试考概念，80%会被问到。太容易被混淆了，上次面试时候，一紧张就说反了。Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。Java支持的数据类型有哪些？什么是自动拆装箱？答：byte，short，int，long，float，double，boolean，char自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把int转化成Integer，double转化成Double，等等。反之就是自动拆箱。Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？答：当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的构造函数。Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java不会创建默认的复制构造函数。Java支持多继承么？答：Java中类不支持多继承，只支持单继承（即一个类只有一个父类）。 但是java中的接口支持多继承，或者说一个类可以实现多个接口。（接口的作用是用来扩展对象的功能，一个子接口继承多个父接口，说明子接口扩展了多个功能，当类实现接口时，类就扩展了相应的功能）。什么是值传递和引用传递？答：这个问题也比较经典。 值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 所以对引用对象进行操作会同时改变原对象。一般认为,java内的传递都是值传递。好像还是稀里糊涂这边有个例子：http://blog.csdn.net/yangjingyuan/article/details/5862944 大家看完应该就理解了创建线程有几种不同的方式？答：有三种方式可以用来创建线程： 继承Thread类 实现Runnable接口应用程序可以使用Executor框架来创建线程池实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。概括的解释下线程的几种可用状态。答：一句话说不明白这个问题，可以参考我的这篇文章：http://blog.csdn.net/zjwcdd/article/details/51517096同步方法和同步代码块的区别是什么？答：同步方法默认用this或者当前类class对象作为锁；同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；这篇文章的例子不错：http://blog.sina.com.cn/s/blog_4ae8f77f0101iifx.html在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？答：监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块，确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。Java集合类框架的基本接口有哪些？答：集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键，有些不允许。Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有： Collection：代表一组对象，每一个对象都是它的子元素。 Set：不包含重复元素的Collection。 List：有顺序的collection，并且可以包含重复元素。 Map：可以把键(key)映射到值(value)的对象，键不能重复。什么是迭代器(Iterator)？答：Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素,但是不可以直接调用集合的remove(Object Obj)删除，可以通过迭代器的remove()方法删除。Iterator和ListIterator的区别是什么？答：Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。Java中的HashMap的工作原理是什么？答：Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。hashCode()和equals()方法的重要性体现在什么地方？答：Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的时候也会用到这两个方法。如果没有正确的实现这两个方法，两个不同的键可能会有相同的hash值，因此，可能会被集合认为是相等的。而且，这两个方法也用来发现重复元素。所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。HashMap和Hashtable有什么区别？答：HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点： HashMap允许键和值是null，而Hashtable不允许键或者值是null。 Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。一般认为Hashtable是一个遗留的类。数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array而不是ArrayList？答：Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。Array大小是固定的，ArrayList的大小是动态变化的。ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。ArrayList和LinkedList有什么区别？答：ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。 LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。Comparable和Comparator接口是干什么的？列出它们的区别。答：Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明输入对象小于，等于，大于已经存在的对象。Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。什么是Java优先级队列(Priority Queue)？答：PriorityQueue是一个基于优先级堆的无界队列，它的元素是按照自然顺序(natural order)排序的。在创建的时候，我们可以给它提供一个负责给元素排序的比较器。PriorityQueue不允许null值，因为他们没有自然顺序，或者说他们没有任何的相关联的比较器。最后，PriorityQueue不是线程安全的，入队和出队的时间复杂度是O(log(n))。如何权衡是使用无序的数组还是有序的数组？答:有序数组最大的好处在于查找的时间复杂度是O(log n)，而无序数组是O(n)。有序数组的缺点是插入操作的时间复杂度是O(n)，因为值大的元素需要往后移动来给新元素腾位置。相反，无序数组的插入时间复杂度是常量O(1)。Java集合类框架的最佳实践有哪些?答：根据应用的需要正确选择要使用的集合的类型对性能非常重要，比如：假如元素的大小是固定的，而且能事先知道，我们就应该用Array而不是ArrayList。有些集合类允许指定初始容量。因此，如果我们能估计出存储的元素的数目，我们可以设置初始容量来避免重新计算hash值或者是扩容。为了类型安全，可读性和健壮性的原因总是要使用泛型。同时，使用泛型还可以避免运行时的ClassCastException。使用JDK提供的不变类(immutable class)作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。编程的时候接口优于实现。 底层的集合实际上是空的情况下，返回长度是0的集合或者是数组，不要返回null。Enumeration接口和Iterator接口的区别有哪些？答：Enumeration速度是Iterator的2倍，同时占用更少的内存。但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。HashSet和TreeSet有什么区别？答：HashSet是由一个hash表来实现的，因此，它的元素是无序的。add()，remove()，contains()方法的时间复杂度是O(1)。另一方面，TreeSet是由一个树形的结构来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。Java中垃圾回收有什么目的？什么时候进行垃圾回收？答：垃圾回收的目的是识别并且丢弃应用不再使用的对象来释放和重用资源。finalize()方法什么时候被调用？析构函数(finalization)的目的是什么？答：垃圾回收器(garbage collector)决定回收某对象时，就会运行该对象的finalize()方法 但是在Java中很不幸，如果内存总是充足的，那么垃圾回收可能永远不会进行，也就是说filalize()可能永远不被执行，显然指望它做收尾工作是靠不住的。 那么finalize()究竟是做什么的呢？它最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器，所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序（C或C++），finalize()的工作就是回收这部分的内存。如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？答: 不会，在下一个垃圾回收周期中，这个对象将是可被回收的。Java堆的结构是什么样子的？什么是堆中的永久代(Perm Gen space)?答：JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。在Java中，对象什么时候可以被垃圾回收？答：当对象对当前使用这个对象的应用程序变得不可触及的时候，这个对象就可以被回收了。Java中的两种异常类型是什么？他们有什么区别？答：Java中有两种异常：受检查的(checked)异常和不受检查的(unchecked)异常。不受检查的异常不需要在方法或者是构造函数上声明，就算方法或者是构造函数的执行可能会抛出这样的异常，并且不受检查的异常可以传播到方法或者是构造函数的外面。相反，受检查的异常必须要用throws语句在方法或者是构造函数上声明。Java中Exception和Error有什么区别？答：Exception和Error都是Throwable的子类。Exception用于用户程序可以捕获的异常情况。Error定义了不期望被用户程序捕获的异常。具体解释和图说明见：http://blog.csdn.net/zjwcdd/article/details/51508475throw和throws有什么区别？答：throw关键字用来在程序中明确的抛出异常，相反，throws语句用来表明方法不能处理的异常。每一个方法都必须要指定哪些异常不能处理，所以方法的调用者才能够确保处理可能发生的异常，多个异常是用逗号分隔的。异常处理完成以后，Exception对象会发生什么变化？答：Exception对象会在下一个垃圾回收过程中被回收掉。finally代码块和finalize()方法有什么区别？答：无论是否抛出异常，finally代码块都会执行，它主要是用来释放应用占用的资源。finalize()方法是Object类的一个protected方法，它是在对象被垃圾回收之前由Java虚拟机来调用的。

首先介绍一下什么是Map.在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key,其对应的对象叫做value.这就是我们平时说的键值对。　　HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。　　HashMap 非线程安全 TreeMap 非线程安全　　线程安全　　在Java里，线程安全一般体现在两个方面：　　1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized.如ArrayList和Vector,HashMap和Hashtable　　（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element,问题就出现了。　　2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。　　1.AbstractMap抽象类和SortedMap接口　　AbstractMap抽象类：（HashMap继承AbstractMap）覆盖了equals（）和hashCode（）方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。　　SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图（子集），包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。　　2.两种常规Map实现　　HashMap:基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode（）和equals（）[可以重写hashCode（）和equals（）],为了优化HashMap空间的使用，您可以调优初始容量和负载因子。　　（1）HashMap（）： 构建一个空的哈希映像　　（2）HashMap（Map m）： 构建一个哈希映像，并且添加映像m的所有映射　　（3）HashMap（int initialCapacity）： 构建一个拥有特定容量的空的哈希映像　　（4）HashMap（int initialCapacity, float loadFactor）： 构建一个拥有特定容量和加载因子的空的哈希映像　　TreeMap:基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。　　（1）TreeMap（）：构建一个空的映像树　　（2）TreeMap（Map m）： 构建一个映像树，并且添加映像m中所有元素　　（3）TreeMap（Comparator c）： 构建一个映像树，并且使用特定的比较器对关键字进行排序　　（4）TreeMap（SortedMap s）： 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序　　3.两种常规Map性能　　HashMap:适用于在Map中插入、删除和定位元素。　　Treemap:适用于按自然顺序或自定义顺序遍历键（key）。　　4.总结　　HashMap通常比TreeMap快一点（树和哈希表的数据结构使然），建议多使用HashMap,在需要排序的Map时候才用TreeMap.　　import java.util.HashMap;　　import java.util.Hashtable;　　import java.util.Iterator;　　import java.util.Map;　　import java.util.TreeMap;　　public class HashMaps {　　public static void main（String[] args） {　　Map<String, String> map = new HashMap<String, String>（）；　　map.put（"a", "aaa"）；　　map.put（"b", "bbb"）；　　map.put（"c", "ccc"）；　　map.put（"d", "ddd"）；　　Iterator<String> iterator = map.keySet（）。iterator（）；　　while （iterator.hasNext（）） {　　Object key = iterator.next（）；　　System.out.println（"map.get（key） is :" + map.get（key））；　　}　　// 定义HashTable,用来测试　　Hashtable<String, String> tab = new Hashtable<String, String>（）；　　tab.put（"a", "aaa"）；　　tab.put（"b", "bbb"）；　　tab.put（"c", "ccc"）；　　tab.put（"d", "ddd"）；　　Iterator<String> iterator_1 = tab.keySet（）。iterator（）；　　while （iterator_1.hasNext（）） {　　Object key = iterator_1.next（）；　　System.out.println（"tab.get（key） is :" + tab.get（key））；　　}　　TreeMap<String, String> tmp = new TreeMap<String, String>（）；　　tmp.put（"a", "aaa"）；　　tmp.put（"b", "bbb"）；　　tmp.put（"c", "ccc"）；　　tmp.put（"d", "cdc"）；　　Iterator<String> iterator_2 = tmp.keySet（）。iterator（）；　　while （iterator_2.hasNext（）） {　　Object key = iterator_2.next（）；　　System.out.println（"tmp.get（key） is :" + tmp.get（key））；　　}　　}　　}　　运行结果如下：　　map.get（key） is :ddd　　map.get（key） is :bbb　　map.get（key） is :ccc　　map.get（key） is :aaa　　tab.get（key） is :bbb　　tab.get（key） is :aaa　　tab.get（key） is :ddd　　tab.get（key） is :ccc　　tmp.get（key） is :aaa　　tmp.get（key） is :bbb　　tmp.get（key） is :ccc　　tmp.get（key） is :cdc　　HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。　　下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:　　import java.util.*;　　public class Exp1 {　　public static void main（String[] args）{　　HashMap h1=new HashMap（）；　　Random r1=new Random（）；　　for （int i=0;i<1000;i++）{　　Integer t=new Integer（r1.nextInt（20））；　　if （h1.containsKey（t））　　（（Ctime）h1.get（t））。count++;　　else　　h1.put（t, new Ctime（））；　　}　　System.out.println（h1）；　　}　　}　　class Ctime{　　int count=1;　　public String toString（）{　　return Integer.toString（count）；　　}　　}　在HashMap中通过get（）来获取value,通过put（）来插入value,ContainsKey（）则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。　　前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode（）方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode（）方法。下面就举这样一个例子：　　import java.util.*;　　public class Exp2 {　　public static void main（String[] args）{　　HashMap h2=new HashMap（）；　　for （int i=0;i<10;i++）　　h2.put（new Element（i）， new Figureout（））；　　System.out.println（"h2:"）；　　System.out.println（"Get the result for Element:"）；　　Element test=new Element（5）；　　if （h2.containsKey（test））　　System.out.println（（Figureout）h2.get（test））；　　else　　System.out.println（"Not found"）；　　}　　}　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　}　　class Figureout{　　Random r=new Random（）；　　boolean possible=r.nextDouble（）>0.5;　　public String toString（）{　　if （possible）　　return "OK!";　　else　　return "Impossible!";　　}　　}　　在这个例子中，Element用来索引对象Figureout,也即Element为key,Figureout为value.在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!",否则打印"Impossible!".之后查看Element（3）对应的Figureout结果如何。　　结果却发现，无论你运行多少次，得到的结果都是"Not found".也就是说索引Element（3）并不在HashMap中。这怎么可能呢？　　原因得慢慢来说：Element的HashCode方法继承自Object,而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode（）在此时能够返回相同的值。在上面的例子中，我们期望 new Element（i） （i=5）与 Elementtest=newElement（5）是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　public int hashCode（）{　　return number;　　}　　public boolean equals（Object o）{　　return （o instanceof Element） && （number==（（Element）o）。number）；　　}　　}　　在这里Element覆盖了Object中的hashCode（）和equals（）方法。覆盖hashCode（）使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals（）是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals（）的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：　　h2:　　Get the result for Element:　　Impossible!　　请记住：如果你想有效的使用HashMap,你就必须重写在其的HashCode（）。　　还有两条重写HashCode（）的原则：　　[list=1]　　不必对每个不同的对象都产生一个唯一的hashcode,只要你的HashCode方法使get（）能够得到put（）放进去的内容就可以了。即"不为一原则".　　生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则".至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。　　掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone（），equals（）和hashCode（）虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性--覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

【答案】：Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。

在Windows下运行应用程序时出现非法操作的提示此类故障引起原因较多，在如下几钟可能:（1） 系统文件被更改或损坏，倘若由此引发则打开一些系统自带的程序时就会出现非法操作，（例如，打开控制面板）（2） 驱动程序未正确安装，此类故障一般表现在显卡驱动程序之止，倘若由此引发，则打开一些游戏程序时就会产生非法操作，有时打开一此网页也会出现这种程况。（3） 内存质量不好，降低内存速度也可能会解决这个问题。（4） 软件不兼容，如，IE 5。5在Windows 98 SE 上，当打开多个网页也会产生非法操作。

一个中级java工程师应该掌握编码能力和业务能力，可以通过网上课程获取这些知识，中级java工程师需要综合能力，丰富的经验。

如果我面试3年的工程师。至少看他使用的框架是否了解。 你用的是ssh，ssi还是hadoop。只要你用了，就必须对其比较熟悉。另外java的基本内容，容器类，工具类的使用。数据库的使用。没人会指望你会所有的框架，但是你使用的熟不熟悉，代表你是否好学，是否能力足够。

看源码去吧

上面的仁兄讲的挺清楚的，回楼主的追问，hash值是不会一样的

Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(loadfactor)和扩容极限(thresholdresizing)。

你想问什么呢？判断队列是否有值？取队列中的值？这两个问题你能完成的话还有啥需要解决呢？跟你以前的需求不一样么？

swt执行线程SWT中的多线程机制和awt/swing中有些不同,这个大家应该都知道,不过还是要说下,Display对象中负责调用其他线程的方法有以下3种：● asyncExec(Runnable runnable)：异步启动新的线程。所谓异步就是，UI线程不会等待runnable对象执行结束后再继续进行，就是说UI线程可以和runnable对象所在的线程同时运行。● syncExec(Runnable runnable)：同步启动新的线程。所谓同步就是，UI线程会等待runnable对象执行结束后才会继续进行，当runnable对象是耗时大的线程时，尽量不要采用此种方式。另外，对于该种方式创建的线程可通过getSyncThread()方法获得线程对象。● timerExec(int milliseconds,Runnable runnable)：指定一段时间再启动新的线程。用此方法创建的线程，将会在指定的时间后再启动线程。当然用此方法创建的线程启动后，与UI线程是异步的。如果指定的时间为负数，将不会按时启动线程。另外Display对象中，与UI线程相关的方法如下所示：● 获得当前的UI线程对象的方法：getThread()，返回Thread对象。● 使UI线程处于休眠状态：sleep()。● 唤醒UI线程：wake()。上面几点都是书里面的原话,不做阐述了.下面我要说的是一个写法的问题,不能小瞧啊,后果很严重.如果有一个线程他要做的事需要很久比如5分钟,像我这样的初学swt的人一定是new了一个线程然后getDisplay().asyncExec(线程对象); 结果虽然执行成功,但是界面确处于挂起状态(假死),直到执行结束,不过要说的是的确是异步执行的,还是ui却不知道为什么停止用户响应,原理暂时先不去理了,swt源码太复杂了.这里面就要引出一个问题为什么不 像下面这么写呢?Thread thread = new Thread(线程对象); thread.start();因为swt中非UI线程中调用窗口控件如果不像上面三种写法那样写的话,会抛org.eclipse.swt.SWTException: Invalid thread access这个异常在swt中程序启动时只有一个主线程,在这里与awt和swing是不一样的,它不允许其他线程访问UI主线程中的部件,具读过swt源码的人说AsyncExec方法根本就没有新启动一个线程而是由Synchronizer调用其中的 run 方法而已.如果是这样的话,也就难怪UI会挂起.解决这个问题的一个比较好的方法是如果要异步执行的线程所做的工作非常少的话,就无所谓了,如果异步线程需要执行很长时间的话,应该像下面这样启动线程Thread thread = new Thread(线程对象); thread.start();在线程对象里面所有调用到UI部件的地方classFinder.getGui().getDisplay().syncExec(new Runnable() { public void run() { //do run }});历经几个小时问题终于解决了这里做个总结吧.我对swt多线程的评价swt的syncExec ,asyncExec 以及timerExec都是伪线程执行方法,把它看成特别的Synchronizer调用就可以了,syncExec ,asyncExec 以及timerExec执行的线程要做的事只是改变UI部件的属性而已执行时间不能太长.此外的其他操作仍然由传统的线程来做.这里要特别注意，swt执行线程只用于在传统线程中操作ui组建在这里要感谢内部类,否则一个复杂的swt线程不知道要写多少个为swt部件服务的标准类

在SWT中的tree 和table要实现对应的动态编辑功能，SWT中实现了这样的方法，对应的类叫做TableEditor和TreeEditor.可以去看看

　　Java对于服务器 个人电脑和移动设备来说是一项伟大的技术 由于需要java的跨平台的特性 因此java在服务器和移动设备方面的应用是非常成功的 但java在个人电脑应用方面的情况和在服务器及移动设备方面的应用有所不同 但是这很快就会有所改变 至少比你想象得要快 在这篇文章中 我会分析一下java在桌面环境中的应用将怎样得到提升 然后具体说一下java GUI（用户图形接口）的三个主要的工具:AWT Swing 和SWT 在下文中 我将会开发一个完整的java桌面应用程序 　　　　 Java与桌面端 　　现在 流行的桌面平台要数Windows Mac and Linux了 但它们不是十全十美的 Windows主宰著桌面操作系统的市场 其上有巨大的应用和开发群体 但它昂贵且有许多安全漏洞 Linux有着稳固的基础 它是开源的软件 比Windows更可靠 Macs非常容易操作且不是黑客的目标 但与Windows和Linux比起来 Mac的硬件和软件可选的余地非常的有限 公司和个人选择他们的操作系统基于许多因素 花费少且安全性高是首选的因素 这导致一些组织从Windows 系统转而选择Linux 对许多用户来说 可用性及对原有应用程序的支持是非常重要的因素 这意味着Windows 将继续享有巨大的市场 Mac有其自己忠诚的用户 这使得苹果机仍然可以存活 Linux 在桌面的流行及Mac的成功创造了多样性 这种多样性正是Java需要的 这种多样性使得Java在桌面有举足轻重的地位 　　　　 跨平台的支持 　　Java 运行于所有相关的操作系统 包括Windows Mac和Linux 对于任何组织 他想把现有的应用从一个操作系统移植到另一个操作系统而不用做太多的改动 那么Java正是他们首选的桌面开发平台 或许用微软的可视化工具很容易构建 NET应用 但是这将使你被绑定在了Windows平台上了 很多人也许想立刻用Linux 代替Windows 从而避免由微软件操作系统的漏洞带来的问题 用户不能容忍的问题之一是当从Windows移植到Linux带来的巨大的费用 如果你的应用程序用Java构建 你就没有了这些问题 Java的图形用户界面看上去会跟你用的操作系统一样 而并不需要做什么改动 假如有一天又有一种桌面操作系统出现的话 java 是个安全的赌注 因为它现在能够运行在Windows和Linux 上 那么可以推测它也可以运行在将来可能出现的操作系统上 这些操作系统可能或迟或早地由微软 或是开源社区 或是其它的人开发出来 　　　　 丰富的特征 　　最初 Java只有非常有限的一些特征去构建图形用户界面 思想就是用平台无关的Java应用程序接口打包不同的操作系统的本地图形用户界面 称之为抽象的窗口工具 仅有普通的部件如文件域 文本区 选择框 单选按钮 列表框和按钮被AWT支持 图形和图像的特性支持非常有限 也就是说 只足够构建简单的applet程序 认识到需要更高级的图形用户界面组件和图形能力 Sun公司开发了Swing Java D Java D 图像的输入/输出 Java高级图像(JAI)和很多其它的 这些中的一些窗体组件现在已经是Java 标准版(J SE)里的一部分 并且其它的一些扩展必须和你的应用程序打包在一起 例如Swing Java D 图像的输入/输出都是Java的核心API 随着Java开发工具包(JDK)和Java运行环境一起提供 让我们不要忘了J EE平台 如果你开发服务器端的应用程序并且需要丰富的图形用户界面 那么你毫无疑问应该选择Java 这允许你把服务器端的一些代码移到客户端 反之亦然 例如 一个项目可能开始是基于WEB和图形界面 在某些时候 用户可能要求图形元素不能在HTML中实现 如果你选择java做客户端应用 那么你可以重用这些当初用来做服务器端的代码 如果你用远程调用 一些类会真正地实现服务器和客户端的共享 通过页面服务器 Java桌面应用也能够和其它的Java 或非Java应用程序通信 如CORBA TCP/IP 或是 HTTP 　　　　　　 Java图形界面工具 　　Java有三个主要的图形界面工具 AWT Swing和SWT Swing 是构建java图形界面标准的API(应用程序接口) 一些AWT类由Swing基础而来 SWT是一个非常有前途的新的窗体工具 由IBM资助 但是事实上 这三者相互补充 他们满足不同的需求 　　　　 AWT 　　抽象窗口工具集为简单的applet程序设计 它不适宜用来构建丰富的桌面图形界面 但是从开始被介绍 它至少有一个好的思想就是布局管理 它负责为组件找到一个放置的位置 这种机制是必需的 因为GUI组件在不同的操作系统中有不同的尺寸 现在 AWT扩展了组件模型和事件处理机制(由JavaBeans说明定义) 新的图形API(称为Java D) 支持剪贴板和拖拉操作 打印 准入 和新的GUI工具Swing 所有这些都归到Java基础类中(JFC) Swing Swing是曾经开发的最复杂的GUI之一 它有一套完全的组件从按钮到文件域到表格 树型和文件编辑器 这些组件不依赖于操作系统本地的部件 而是用原始的图形像直线 矩形 文字画出 这种画代表感观插件 它能够模仿本地的感观 Swing也有平台无关的外观称为 Metal Swing的结构由MVC模式得到启发 这里在屏幕上的视觉GUI组件和支持数据的模型对象之间有一个明显的分隔 在GUI和数据层之间的通讯基于事件 在最初的Swing版本中有许多错误并且有执行问题 这减慢了接受它的速度 Swing最大的问题是被从事于并且许多人相信它是为开发桌面应用而准备的 今天 有许多基于Swing开发的商业产品 包括大多数的Java集成开发工具 我所喜欢的集成开发工具是Jbuilder 它的速度相当的快 　　　　 SWT 　　SWT是IBM为它的Eclipse集成开发环境而开发的图形用户界面工具 SWT可以在Eclipse环境外使用 而且提供对操作系统本地图形用户界面的直接访问 因此 基于SWT的Java应用程序拥有本地的图形用户界面并且可以和本地别的应用程序和部件集成在一起 假如你的桌面应用程序产生HTML报表 你想把它显示给用户看 你可以使用Swing去浏览简单的HTML文档 但这不是一个理想的的解决方案 最好是在你的应用程序里提供IE或者Mozilla浏览器引擎 SWT社区现在正在设计浏览器API 这些API可以让你产生基于IE或者Mozilla的HTML窗口 SWT现在可以在AIX HPUX Linux QNX Solaris and Windows下面运行 Mac OS X is 也在进行之中 　　　　 误解与Bug 　　对于java/Swing一直有着误解 诸如 Java/Swing太慢了 或者是Java/Swing需要更多的内存 Swing也许在老式的奔腾的cpu而且只有 m内存运行JDK 运行起来却是很慢 但是如果在PIII级别的CPU有着 mb的内存 运行JDK 环境是足够快的 对于一个应用程序来说鼠标在 毫秒和在 毫秒的反映的区别 对于使用者来说看起来是 没什么区别的 Java在企业级的数百人 上千人同时在线的服务器表现的很好 Java在对于有限资源的移动设备上的表现也是很出色的 那为什么Java不能成为很好的桌面应用程序呢？以我的观点看 Swing的bug比其运行速度慢这问题还严重 例如 如果你用的是JDK 你将不能在表格（称为JTable）中输入%& ($#!q 等这些字符 这八个字符和箭头键及Home End Pgup and Pgdn这几个键的键值是相同的 其中一个由JTable由到的类调用了KeyEvent getCharCode()方法代替KeyEvent getKeyCode() 这个bug这JDK 已经得到了纠正 你大概已经放弃过Swing 如果你是从用JDK 的Swing 你可能因为你不能在表格里输入q而恼怒 可能不幸的是你正需要用Jtable开发一个Swing应用 你将花费许多时间从sun的bug数据库中查找解决的办法 但没有发现你需要的（记住在那时Swing还是个新事物） 你将花费更多的时间去看Swing的源代码和发展中的工作区 经过了这个的经历之后 很少有人很在另一个项目里再用Swing了 你的工作区会像下面这样子 　　import java awt *; import java awt event *; import javax swing *; import javax swing table *; 　　　　public class WorkingTable extends JTable { public static final boolean JDK = System getProperty( java version ) startsWith( ); 　　　　public void processKeyEvent(KeyEvent e) { if (JDK ) { char ch = e getKeyChar(); if (e getID() == KeyEvent KEY_TYPED && (( <= ch && ch <= 40) || ch == "q")) { int anchorRow = getSelectionModel().getAnchorSelectionIndex(); int anchorColumn = getColumnModel() .getSelectionModel().getAnchorSelectionIndex(); if (anchorRow != -1 && anchorColumn != -1) { if (!isEditing()) editCellAt(anchorRow, anchorColumn); Component editorComp = getEditorComponent(); if (isEditing() && editorComp instanceof JTextField) { JTextField textField = (JTextField) editorComp; textField.setText(textField.getText() + ch); return; } } } } super.processKeyEvent(e); } 　　　　} 　　　　不幸的是，Swing有许多像上面描述的那样的问题，一些问题很难解决，需要做大量的工作。Tw.WInGwiT.例如，Swing的打开文件和保存文件的对话框是基于称为JfileChooser的组件，它部分的执行了JDK 1.2和JDK 1.3（一些特性总是不能用的，要创建一个新的目录对大多数用户来是一个挑战）。我不知道为什么Sun需要几年的时间直到jdk1.4中才完成JfileChooser。在JDK 1.4之前，你有两种选择：用这种破烂的JfileChooser或是创建你自己的文件选择框，Borland公司在他们的JBuilder 4中做一个很好的文件打开对话框。然而，大多数的开发者用的是标准的JfileChooser，给他们的用户带来许多问题。有一件重要的事情需要注意：可以像上面描述的那个去创建工作环境，因为Swing的源代码是可以得到的。学习java源代码也能够让你成为更好的程序员并且让你理解工作在Java API的内部机制。当你开发你自己习惯的GUI组件，这点是有用 lishixinzhi/Article/program/Java/hx/201311/26851

为什么不能满足？mouseUp就是按下之后被释放，mouseDown是按下去还没有释放。你可以结合Control的bound和location来计算按下和释放时的位置来确定是否进行必要的事件处理。

Caused by: java.lang.IllegalArgumentException: Argument cannot be null关键在这句话，说的是你的参数不能为空，你看下你的程序是不是哪里需要一个参数，而你没写呢！然后提醒你一下，如果你要问问题最好把你的问题说清楚一点，有代码的尽量把代码附上，这样回答者才能更好的帮你解决问题！

你需要从新执行以下哪个读文件列表的函数，这样就可以实现刷新了。

如果要想弹出B的话,你的B类.肯定是已经写的了.那就这样Button c = new Button(shell, SWT.none); c.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent e) { new B(); } });

放在陆经理

打包成jar要打包成runablejar。

窗体顶部菜可以在实例化的时候设置，也可以单独设置：Shell s = new Shell(parent,SWT.BORDER); //建立一个有边框但没有标题栏的窗口 Shell dlgShell = new Shell(parent, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL); setShellStyle(这里可以任意设置样式);能够设置的样式如下：（以下属性可以多选，但是某些属性相冲突时会导致设置的其他属性失效）SWT.BORDER //建立一个有边框但没有标题栏的窗口SWT.CLOSE //建立一个只有关闭按钮的窗口SWT.MIN //建立一个不能最大化的窗口SWT.MAX, //建立一个可以最大化最小化的窗口SWT.NO_TRIM //建立一个没有任何边界和标题栏的窗口SWT.RESIZE //建立一个可以改变大小的窗口SWT.TITLE //建立一个没有标题栏图标，没有关闭按钮的窗口SWT.ON_TOP //建立一个总是在上的窗口，注意：此属性最好与CLOSE、MIN、MAX一起使用。SWT.TOOL //建立一个类似工具栏的窗口SWT.APPLICATION_MODAL //建立一个APPLICATION模态窗口SWT.MODELESS //建立一个非模态窗口SWT.PRIMARY_MODAL //建立一个PRIMARY模态窗口SWT.SYSTEM_MODAL //建立一个SYSTEM模态窗口 还有两个快捷属性来建立窗口SHELL_TRIM //建立一个标准模式的窗口，相当于属性设置为CLOSE | TITLE | MIN | MAX | RESIZEDIALOG_TRIM //建立一个对话框模式的窗口，相当于属性设置为TITLE | CLOSE | BORDER

你是不是给你窗体设了frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)?改为frame.setDefaultCloseOperation(do_nothing_on_close);

方法1，安装一个32位的jdk 然后window->preferences->java->installed JREs 勾选32位的jdk方法2，下载一个64位的SWT，替换即可

额。。我想问，你这写法是什么语言转过来的，看着怪别扭的，大小写之类的全部都没区分。错误的话，应该是，text.setText(null);这个不能设置为null，改成text.setText("");就可以了。

SWT插件用于Java 图形用户界面开发的，可以去其官网下载与Eclipse版本相关的压缩包。本人使用的是Eclipse3.4，下载的SWT包是Designer_v6.7.0_for_Eclipse3.4.zip。（注：SWT必须与Eclipse版本要一致，下载SWT是要看清楚）。将下载的SWT包解压缩，解压后有一个批处理文件和features、plugins文件夹。将这个批处理文件拷贝到eclipse目录，双击运行。然后将该批处理文件删除。将SWT解压包中features、plugins文件夹中的内容全部拷贝到eclipse的相应目录中。（注：有的资料上说：需要将eclipse目录下的configuration目录中，所有org.eclipse.*文件夹都删除。我这样试了，但是这样做Eclipse根本无法启动。所以我的这个方法中不需要这样做，不知到是否与eclipse的版本有关，还需详细考证）。然后启动eclipse，在file-new-other中如果看到designer选项，就证明SWT安装成功了。下来进行插件的注册，我选择的免费注册，不过这样需要填写一个用户的详细资料，然后就会通过email收到一个注册码。步骤：window－Preferences－Designer－Registration and Activation。在select a product to evaluate中选择SWT-Designer。点击next，然后填写你的个人信息。然后就会通过email收到一个Activation key。重新执行上述注册步骤，在Activation Key的文本框中输入通过email收到的key就完成了SWT的免费注册。

import java.awt.Label;你自己引入了awt的label怎么用SWT的label去掉这行，再导入swt的label就行了

jtabpanel可以实现,另个动态table model也可以实现

你能不能把代码发下呢？你丢个异常给大家 大家如何分析啊

filterText.addFocusListener(new FocusAdapter(){ @Override public void focusGained(FocusEvent e) { filterText.selectAll(); } });

由于在不同的操作系统下，提供的控件是不一样的，AWT采用最小公约数的办法，只提供所有操作系统都有的控件。但后来SUN改变了做法，在Swing里除了JFrame,JWinodows,JDialog（记不太清了，好像是这几个）是调用本地操作系统的控件，其它JPanel,JButton之类的都是绘出来的，所以Swing在所有平台看起来都是一样的外观。这样保持了外观一致性，但牺牲了性能。 IBM更喜欢AWT的实现机制，做出了SWT，SWT采用的是最大公倍数的做法。SWT大部分都是用的本地操作系统的控件，一些在ｗｉｎｄｏｗｓ里有的控件可能在ｌｉｎｕｘ下没有，对这种控件才采用自己绘制的方式。SWT采用类似JAVA虚拟机的方式，在不同的平台，有不同的开发包，我们写的ｊａｖａ代码是一样的，但不同平台下看起来外观是不一样的，但性能提升很高，据说和C++做的界面速度差不多：） 也许你会问哪种更好，引一名话：this is equivalent to asking whether a harmmer is better than a screw driver,of course ,a hammer wieldded with sufficient force can probably drive a screw into a wall ,and the butt of a screw can be used in a pinch to knock in a nail. However, a good carpenter keeps both harmer and screw drivers in her tool box and will use the tool that is appropriate for the job at hand. 个人感觉以前ｊａｖａ做界面完全没有优势，从外观到性能（我很喜欢Swing的look and feel,可以改变风格），SWT的出现改变了性能上的缺点，再加上JFace，及Eclipse的RCP，我还是倾向于用SWT。

eclipse 是用Swt开发的，swt是为了开发Eclipse而设计的一个可视化组件，相当的不错，所以说在Eclipse的安装目录下肯定有Swt这个包，同事Swt也是可用用来做应用软件开发的，比起Swing，Awt有很多优势。

原来是Eclipse推出的。。 囧

　　Java语言的声望和它在桌面应用程序（GUI程序）所取得的成就显然极不相符 至今仍然很少能看到非常成功Java桌面程序 虽然有JBuilder Netbean JProbe等大型软件作为代表 但这仍不能证明Java的GUI程序是成功的 它们的外观总是和同一操作系统平台下的其它软件显得格格不入 对机器配置的需求也似乎永无止境 这使得它们只能被一些总是拥有当前最高性能PC的程序员们所容忍 或是那些不在乎金钱和时间的专业用户所接受 对绝大多数计算机使用者来说 AWT或SWING代表着怪异的界面和无法接受的速度 Standard Widget Toolkit（SWT）或许是Java这一噩梦的终结者 广大Java程序员终于可以开发出高效率的GUI程序 它们拥有标准的外观 几乎没有人能看出你的程序是用Java写出来的 更为重要的是 这些程序是跨平台的 　　SWT本身仅仅是Eclipse组织为了开发Eclipse IDE环境所编写的一组底层图形界面 API 或许是无心插柳 或是有意为之 至今为止 SWT无论是在性能和外观上 都超越了SUN公司提供的AWT和SWING 目前Eclipse IDE已经开发到了 版本 SWT已经十分稳定 这里指的稳定应该包含两层意思 　　一是指性能上的稳定 其中的关键是源于SWT的设计理念 SWT最大化了操作系统的图形构件API 就是说只要操作系统提供了相应图形的构件 那么SWT只是简单应用JNI技术调用它们 只有那些操作系统中不提供的构件 SWT才自己去做一个模拟的实现 可以看出SWT的性能上的稳定大多时候取决于相应操作系统图形构件的稳定性 　　另一个稳定是指SWT API包中的类 方法的名称和结构已经少有改变 程序员不用担心由于Eclipse组织开发进度很快（Eclipse IDE每天都会有一个Nightly版本的发布） 而导致自己的程序代码变化过大 从一个版本的SWT更新至另一版本 通常只需要简单将SWT包换掉就可以了 　　 第一个SWT程序 　　下面让我们开始一个SWT程序 （注意 以下的例子和说明主要针对Windows平台 其它的操作系统应该大同小异） 首先要在Eclipse安装文件中找到SWT包 Eclipse组织并不提供单独的SWT包下载 必须下载完整的Eclipse开发环境才能得到SWT包 SWT是作为Eclipse开发环境的一个插件形式存在 可以在$｛你的eclipse安装路径｝plugins路径下的众多子目录下去搜索SWT JAR文件 在找到的JAR文件中包含了SWT全部的Java类文件 因为SWT应用了JNI技术 因此同时也要找到相对应的JNI本地化库文件 由于版本和操作平台的不同 本地化库文件的名称会有些差别 比如SWT WIN DLL是Window平台下Eclipse Build 的动态库 而在Unix平台相应版本的库文件的扩展名应该是 so 等等 注意的是 Eclipse是一个开放源代码的项目 因此你也可以在这些目录中找到SWT的源代码 相信这会对开发很有帮助 下面是一段打开空窗口的代码(只有main方法) import e one example;public class OpenShell{　public static void main(String [] args) {　　Display display = new Display();　　Shell shell = new Shell(display);　　shell open();　　// 开始事件处理循环 直到用户关闭窗口　　while (!shell isDisposed()) {　　　if (!display readAndDispatch())　　　　display sleep();　　}　　display dispose();　}} 　　确信在CLASSPATH中包括了SWT JAR文件 先用Javac编译例子程序 编译无错后可运行java Djava library path=${你的SWT本地库文件所在路径} e one example OpenShell 比如SWT WIN DLL件所在的路径是C:swtlib 运行的命令应该是java Djava library path=c:swtlib e one example OpenShell 成功运行后 系统会打开了一个空的窗口 　　 剖析SWT API 　　下面再让我们进一步分析SWT API的组成 所有的SWT类都用 eclipse swt做为包的前缀 下面为了简化说明 我们用*号代表前缀 eclipse swt 比如* widgets包 代表的是 eclipse swt widgets包 　　我们最常用的图形构件基本都被包括在* widgets包中 比如Button Combo Text Label Sash Table等等 其中两个最重要的构件当数Shell和Composite Shell相当于应用程序的主窗口框架 上面的例子代码中就是应用Shell构件打开一个空窗口 Composite相当于SWING中的Panel对象 充当着构件容器的角色 当我们想在一个窗口中加入一些构件时 最好到使用Composite作为其它构件的容器 然后再去* layout包找出一种合适的布局方式 SWT对构件的布局也采用了SWING或AWT中Layout和Layout Data结合的方式 在* layout包中可以找到四种Layout和与它们相对应的布局结构对象（Layout Data） 在* custom包中 包含了对一些基本图形构件的扩展 比如其中的CLabel 就是对标准Label构件的扩展 上面可以同时加入文字和图片 也可以加边框 StyledText是Text构件的扩展 它提供了丰富的文本功能 比如对某段文字的背景色 前景色或字体的设置 在* custom包中也可找到一个新的StackLayout布局方式 　　SWT对用户操作的响应 比如鼠标或键盘事件 也是采用了AWT和SWING中的Observer模式 在* event包中可以找到事件监听的Listener接口和相应的事件对象 例如常用的鼠标事件监听接口MouseListener MouseMoveListener和MouseTrackListener 及对应的事件对象MouseEvent 　　* graphics包中可以找到针对图片 光标 字体或绘图的API 比如可通过Image类调用系统中不同类型的图片文件 通过GC类实现对图片 构件或显示器的绘图功能 　　对不同平台 Eclipse还开发了一些富有针对性的API 例如 在Windows平台 可以通过* ole win 包很容易的调用ole控件 这使Java程序内嵌IE浏览器或Word Excel等程序成为可能！ 　　 更复杂的程序 　　下面让我们展示一个比上面例子更加复杂一些的程序 这个程序拥有一个文本框和一个按键 当用户点击按键的时候 文本框显示一句欢迎信息 　　为了文本框和按键有比较合理的大小和布局 这里采用了GridLayout布局方式 这种布局是SWT中最常用也是最强大的布局方式 几乎所有的格式都可能通过GridLayout去达到 下面的程序也涉及到了如何应用系统资源(Color) 以及如何释放系统资源 private void initShell(Shell shell) {　//为Shell设置布局对象　GridLayout gShellLay = new GridLayout();　shell setLayout(gShellLay);　//构造一个Composite构件作为文本框和按键的容器　Composite panel = new Composite(shell SWT NONE);　//为Panel指定一个布局结构对象 　　这里让Panel尽可能的占满Shell 也就是全部应用程序窗口的空间 　GridData gPanelData = new GridData(GridData GRAB_HORIZONTAL| GridData GRAB_VERTICAL|GridData FILL_BOTH);　panel setLayoutData(gPanelData);　//为Panel也设置一个布局对象 文本框和按键将按这个布局对象来显示 　GridLayout gPanelLay = new GridLayout();　panel setLayout(gPanelLay);　//为Panel生成一个背景色　final Color bkColor = new Color(Display getCurrent() );　panel setBackground(bkColor);　//生成文本框　final Text text = new Text(panel SWT MULTI|SWT WRAP);　//为文本框指定一个布局结构对象 　　这里让文本框尽可能的占满Panel的空间 　GridData gTextData = new GridData (GridData GRAB_HORIZONTAL| GridData GRAB_VERTICAL|GridData FILL_BOTH);　text setLayoutData(gTextData);　//生成按键　Button butt = new Button(panel SWT PUSH);　butt setText( Push );　//为按键指定鼠标事件　butt addMouseListener(new MouseAdapter(){　　public void mouseDown(MouseEvent e){　　　//当用户点击按键的时候 显示信息　　　text setText( Hello SWT );　　}　};　//当主窗口关闭时 会触发DisposeListener 这里用来释放Panel的背景色 　shell addDisposeListener(new DisposeListener(){　　public void widgetDisposed(DisposeEvent e) {　　　bkColor dispose();　　}　};} 　　把这段代码中的方法initShell()加入到第一个打开空窗口的例子中 得到的是一段能成功运行的完整GUI应用程序 运行方法可参考第一个例子 　　 系统资源的管理 　　在一个图形化的操作系统中开发程序 都要调用系统中的资源 如图片 字体 颜色等 通常这些资源都是有限的 程序员务必非常小心的使用这些资源 当不再使用它们时 就请尽快释放 不然操作系统迟早会油尽灯枯 不得不重新启动 更严重的会导致系统崩溃 　　SWT是用Java开发的 Java语言本身的一大优势就是JVM的 垃圾回收机制 程序员通常不用理会变量的释放 内存的回收等问题 那么对SWT而言 系统资源的操作是不是也是如此？答案是一个坏消息 一个好消息 　　坏消息是SWT并没采用JVM的垃圾回收机制去处理操作系统的资源回收问题 一个关键的因素是因为JVM的垃圾回收机制是不可控的 也就是说程序员不能知道 也不可能做到在某一时刻让JVM回收资源！这对系统资源的处理是致命的 试想你的程序希望在一个循环语句中去查看数万张图片 常规的处理方式是每次调入一张 查看 然后就立即释放该图片资源 而后在循环调入下一张图片 这对操作系统而言 任何时刻程序占用的仅仅是一张图片的资源 但如果这个过程完全交给JVM去处理 也许会是在循环语句结束后 JVM才会去释放图片资源 其结果可能是你的程序还没有运行结束 操作系统已经宕掉 　　但下面的好消息也许会让这个坏消息变得无关紧要 对于SWT 只需了解两条简单的 黄金 法则就可以放心的使用系统资源！之所以称为黄金法则 一是因为少 只有两条 二是因为它们出奇的简单 第一条是 谁占用 谁释放 第二条是 父构件被销毁 子构件也同时被销毁 第一条原则是一个无任何例外的原则 只要程序调用了系统资源类的构造函数 程序就应该关心在某一时刻要释放这个系统资源 比如调用了 Font font = new Font (display Courier SWT NORMAL); 　　那么就应该在不在需要这个Font的时候调用 font dispose(); 　　对于第二个原则 是指如果程序调用某一构件的dispose()方法 那么所有这个构件的子构件也会被自动调用dispose()方法而销毁 通常这里指的子构件与父构件的关系是在调用构件的构造函数时形成的 比如 Shell shell = new Shell();Composite parent = new Composite(shell SWT NULL);Composite child = new Composite(parent SWT NULL); 　　其中parent的父构件是shell 而shell则是程序的主窗口 所以没有相应的父构件 同时parent又包括了child子构件 如果调用shell dispose()方法 应用第二条法则 那么parent和child构件的dispose()方法也会被SWT API自动调用 它们也随之销毁 　 　线程问题 　　在任何操作平台的GUI系统中 对构件或一些图形API的访问操作都要被严格同步并串行化 例如 在一个图形界面中的按键构件可被设成可用状态(enable)或禁用状态(disable) 正常的处理方式是 用户对按键状态设置操作都要被放入到GUI系统的事件处理队列中（这意味着访问操作被串行化） 然后依次处理（这意味着访问操作被同步） 想象当按键可用状态的设置函数还没有执行结束的时候 程序就希望再设置该按键为禁用状态 势必会引起冲突 实际上 这种操作在任何GUI系统都会触发异常 　　Java语言本身就提供了多线程机制 这种机制对GUI编程来说是不利的 它不能保证图形构件操作的同步与串行化 SWT采用了一种简单而直接的方式去适应本地GUI系统对线程的要求 在SWT中 通常存在一个被称为 用户线程 的唯一线程 只有在这个线程中才能调用对构件或某些图形API的访问操作 如果在非用户线程中程序直接调用这些访问操作 那么SWTExcepiton异常会被抛出 但是SWT也在* widget Display类中提供了两个方法可以间接的在非用户线程的进行图形构件的访问操作 这是通过syncExec(Runnable)和asyncExec(Runnable)这两个方法去实现 例如 //此时程序运行在一个非用户线程中 并且希望在构件panel上加入一个按键 Display getCurrent() asyncExec(new Runnable() {　public void run() {　　Button butt = new Button(panel SWT PUSH);　　butt setText( Push );　}}); 　　方法syncExec()和asyncExec()的区别在于前者要在指定的线程执行结束后才返回 而后者则无论指定的线程是否执行都会立即返回到当前线程 　　 SWT的扩展 JFace 　　JFace与SWT的关系好比Microsoft的MFC与SDK的关系 JFace是基于SWT开发 其API比SWT更加易于使用 但功能却没SWT来的直接 比如下面的代码应用JFace中的MessageDialog打开一个警告对话框 MessageDialog openWarning(parent Warning Warning message ); 　　如果只用SWT完成以上功能 语句不会少于 行! 　　JFace原本是为更加方便的使用SWT而编写的一组API 其主要目的是为了开发Eclipse IDE环境 而不是为了应用到其它的独立应用程序 因此在Eclipse 版本之前 很难将JFace API完整的从Eclipse的内核API中剥离出来 总是要多多少少导入一些非JFace以外的Eclipse核心代码类或接口才能得到一个没有任何编译错误的JFace开发包 但目前Eclipse组织似乎已经逐渐意识到了JFace在开发独立应用程序起到的重要作用 在开发的 版本中 JFace也开始变成了和SWT一样的完整独立的开发包 只是这个开发包还在变动中(笔者写本文时 应用的Eclipse M 版本) JFace开发包的包前缀是以 eclipse jface开头 JAR包的源代码也和SWT一样 也在$｛你的eclipse安装路径｝plugins路径下去找 　　对开发人员来说 在开发一个图形构件的时候 比较好的方式是先到JFace包去找一找 看是不是有更简洁的实现方法 如果没有再用SWT包去自己实现 比如JFace为对话框提供了很好的支持 除了各种类型的对话框(比如上面用的MessageDialog 或是带有Title栏的对话框) 如要实现一个自定义的对话框也最好从JFace中的Dialog类继承 而不是从SWT中的* widget Dialog继承 　　应用JFace中的Preference包中的类很容易为自己的软件做出一个很专业的配置对话框 对于Tree Table等图形构件 它们在显示的同时也要和数据关联 例如Table中显示的数据 在JFace 中的View包中为此类构件提供了Model View方式的编程方法 这种方法使显示与数据分开 更加利于开发与维护 JFace中提供最多的功能就是对文本内容的处理 可以在 eclipse jface text * 包中找到数十个与文本处理相关类 　　 与应用程序更近一步 　　Java程序通常是以class文件的方式发布的 运行class需要JRE或JDK的支持 这又是Java GUI程序的另一个致命的弱点 想象对一个面向广大用户的应用程序来说 无论你的程序功能有多简单 或是你的代码十分的精简 你都不得不让用户去下载一个 M的JRE 那是多么令人沮丧的一件事 而且对程序员来说 Class通常意味着源代码的暴露 反编译的工具让那些居心叵测的人轻易得到你的源代码 虽然有很多对Class的加密方法 但那总是以牺牲性能为代价的 好在我们还有其它的方式可用 把Class编译成exe文件! lishixinzhi/Article/program/Java/gj/201311/27737

getDefaultToolkitpublic static Toolkit getDefaultToolkit()获取默认工具包。 如果有一个系统属性名为 "awt.toolkit"，则将它看作 Toolkit 的子类的类名。 如果系统属性不存在，则使用的默认工具包是名为 "sun.awt.motif.MToolkit" 的类，它是 Abstract Window Toolkit 的主题实现。 还可以使用 Sun 引用实现中指定的属性 "assistive_technologies" 将其他类加载到 VM 中，该属性是在 "accessibility.properties" 文件的一个行中指定的。加载形式是 "assistive_technologies=..."，其中 "..." 是以逗号分隔的、要加载的辅助技术类的列表。每个类都以给定的顺序加载，并且要使用 Class.forName(class).newInstance() 创建每个类的单独实例。此操作在创建 AWT 工具包之后进行。所有错误都通过 AWTError 异常来处理。 返回：默认工具包。 抛出： AWTError - 如果不能找到工具包，或者不能访问或实例化工具包。

toolkit此类是所有 Abstract Window Toolkit 实际实现的抽象超类。Toolkit 的子类被用于将各种组件绑定到特定本机工具包实现。这意味着如果设置某一组件的状态，随后立刻查询该状态，则返回的值可能并没有反映所请求的更改。这包括但不局限于以下操作： 滚动到指定位置。例如，如果原始请求没有被处理，那么调用 ScrollPane.setScrollPosition 并随后调用 getScrollPosition 可能返回一个不正确的值。 将焦点从一个组件移动到另一个组件。使顶层容器可见。对 Window、Frame 或 Dialog 调用 setVisible(true) 可能异步发生。 设置顶层容器的大小或位置。对 Window、Frame 或 Dialog 调用 setSize、setBounds 或 setLocation 将被转发到底层窗口管理系统，并可能被忽略或修改。Wall.class 加载Wall类对象，额说实话，还真没有什么好说的哦。。。数据库加载驱动的时候也是这样，当然也只是为了加载对象而已。

Toolkit这是一个工具抽象类,提供一些取资源的方法.比如这个getImage就是取图象资源的.Wall.class.getClassLoader().getResource("images/stone.gif")这句话的意思是把Wall类所在文件夹中的images文件夹下的stone.gif转换成JAVAURL类,这是一种相对地址的获取方式.

包含用于创建用户界面和绘制图形图像的所有类。 getDefaultToolkitpublic static Toolkit getDefaultToolkit()获取默认工具包。 如果有一个系统属性名为 "awt.toolkit"，则将它看作 Toolkit 的子类的类名。 如果系统属性不存在，则使用的默认工具包是名为 "sun.awt.motif.MToolkit" 的类，它是 Abstract Window Toolkit 的主题实现。 还可以使用 Sun 引用实现中指定的属性 "assistive_technologies" 将其他类加载到 VM 中，该属性是在 "accessibility.properties" 文件的一个行中指定的。加载形式是 "assistive_technologies=..."，其中 "..." 是以逗号分隔的、要加载的辅助技术类的列表。每个类都以给定的顺序加载，并且要使用 Class.forName(class).newInstance() 创建每个类的单独实例。此操作在创建 AWT 工具包之后进行。所有错误都通过 AWTError 异常来处理。 返回：默认工具包。 抛出： AWTError - 如果不能找到工具包，或者不能访问或实例化工具包。 Dimension：对单个对象的组件的宽度、高度封装在一个类中。通常，width与height的值是正数（若为负数，则由其他对象定义的一些方法的行为是不明确的）。获取的宽度、高度都是double型的，且向上取整。 setSize(double width, double height)：Note that if width or height are larger than Integer.MAX_VALUE, they will be reset to Integer.MAX_VALUE.toString()方法：输出width、height的值，用于调试用。

围观

JAVA零基础，JavaSE,数据库，WEB前端技术，JavaWEB基础 ，电商竞拍平台，

java学习的学习内容涵盖较多方面，大致可以分为以下几个阶段，从基础的语法，到高阶的框架，必须按部就班，才能够走得更远，提升的空间才会更大。一、预科学习：HTML5：HTML5标签入门、HTML5表格、表单CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习二、JavaSEJava语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld变量运算符条件和循环方法和数组Java面向对象：面向对象入门面向对象应用_管理系统类Java常用类、String相关、算法相关面向对象深入（重载、this、static）继承（重写、super、初始化顺序）多态（抽象类和接口、final、克隆和比较接口设计模式、对象和类的生命周期）API：异常、日志集合集合工具类和泛型IOJDBC基础线程网络编程反射NIOJunitJava面向对象思想：设计模式面向对象原则Java底层理论：集合底层性能监控工具反编JUC三、Javawebweb基础：TOMCAT/WEB程序结构/HTTP协议Servlet基础入门、servlet作用域（cookie、session、）、Cookie和Session、Servlet的交互/JSP原理及运用、JavaBean/EL/JSTL/MVC思想、JSPServletJDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/LogbackJavaScript和jQuery框架技术：JS入门和DOM基础、DOM模型深入、jQ基础、jQ操作DOMMVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）Web开发高级运用：tomcatserver服务器配置、nginx使用、jetty配置网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建四、SSM框架Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、配置文件详解和动态sql的使用、mybatis管理关系映射和延迟加载、查询缓存和逆向工程、Spring入门和集成、myBatisSpringMVC入门、SSM集成、Spring配置详解、SpringAOP、Spring事务配置、SpringMVC高级功能、SpringMVC原理五、前沿技术高可用、高并发、高扩展：SpringBoot、缓存、分布式、全文索引、服务中间件、myCat、云服务、人脸识别、语言识别、JVM底层优化希望能够帮到你！

我可以很负责的跟你说，C# 难度大些的确，c#上手很容易，但 由于开源了很少很少的源码，很多技术是如何实现还是个迷，不像JAVA ，完全开源，搞java的应该有种体会，配置好XML文件（一些插件的配置），开发会变得简单多。

Java工程师要学习得课程很多，主要包括Java基础语法• 面向对象基础• 常用API• 集合框架• 线程（池）• 代理反射• 网络编程、html•Css•javaScript•Jquery• JavaWeb• session（cookie）• filter• 上传和下载组件• JSP• Tomcat服务器• Druid连接池、Spring SpringMVC SpringBoot MyBatis(MyBatis-plus) Maven管理 GitTomcat集成数据库分库分表、Dubbo分布式框架• SpringCloud微服务• RocketMQ消息中间件• Redis缓存中间件• ES查询中间件• Vue前端框架•OSS对象存储中间件、mysql数据库->javase->javaweb->企业级框架->微服务框架等

其实花钱去线上并不一定质量好，现在B站上等很多第三方网站上有免费的，其实质量很不错的我把我自己整理的一些比较好的书列出来，当然好书可能不止这些，我只是举个例子第一阶段：初学java核心技术java语言程序设计第二阶段：熟悉java编程思想effective java中文版深入理解java 7:核心技术与最佳实践java网络编程(以及java web方面的书)第三阶段：加强或精通java并发编程实战java虚拟机规范(java se 7版)深入理解java虚拟机：jvm高级特性与最佳实践设计模式之禅(java版)算法导论 或者 算法（第四版）深入剖析tomcat深入理解计算机系统代码大全编程珠玑学习路线可以参考这个问题

首先,java基础要扎实,只有这样,书写代码时才能代码规范,逻辑清晰.java基础需要学习一下几方面;第一,掌握静态方法和属性.java中大量应用了静态方法和属性，这是一个通常的技巧。但是这种技巧在很多语言中不被频繁地使用。理解静态方法和属性对于理解类与对象的关系是十分有帮助的，在大量的Java规范中，静态方法和属性被频繁使用。因此学习者应该理解静态方法和属性。第二:重视接口.在框架使用上,很多需要用到动态代理,那么就需要注意接口的使用.第三:学好集合框架.Java描述复杂数据结构的主要方式是集合框架。Java没有指针，而是通过强大的集合框架描述数组、对象数组等复杂的数据结构。学好这些数据结构的描述方法对于应用程序编写，特别是涉及到服务器方、3层结构编程至关重要。程序员在这个时候不能再用诸如数据库结果集之类的结构描述数据了。第四:异常处理.程序异常有运行时异常,和非运行时异常,那么我们需要处理好运行异常,代码才能健壮.第五:理解多线程.程序员应该了解的是多线程原理和多线程安全，这对于今后准确地把握程序是至关重要的。例如JSP中编写到不同的位置对于多个用户环境的安全影响完全不同，又如着名的SuperServlet是每一个访问作为一个进程，但是每一个页面是一个线程，和Servlet正好相反，对程序的性能和安全的影响有天壤之别。其次:主流框架知识要掌握.那么就需要熟练掌握Mybatis,Spring,SpringMVC等常用框架.这是作为程序员要掌握的基础框架.当然,如果想找到高薪工作,我们还需要掌握先进的框架,例如SpringBoot,SpringCloud,dubbo,redis,solr,activeMQ,FastDfs等等......受互联网+概念的催化，当今中国在线教育市场，互联网，电商等行业的发展可谓是百花齐放、如火如荼。想进入这类高薪企业需要掌握微服务架构。掌握微服务就应该知道微服务中常遇到问题，例如微服务的雪崩效应。表现在服务与服务之间调用，当其中一个服务无法提供服务可能导致其它服务也死掉，比如：单点登录服务调用用户信息服务查询用户信息，由于用户信息服务无法提供服务导致单点登录服务一直等待，从而导致用户登录、用户退出功能无法使用，像这样由一个服务所引起的一连串的多个服务无法提供服务即是微服务的雪崩效应。

java学习的学习内容涵盖较多方面，大致可以分为以下几个阶段，从基础的语法，到高阶的框架，必须按部就班，才能够走得更远，提升的空间才会更大。一、预科学习：HTML5：HTML5标签入门、HTML5表格、表单CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习二、JavaSEJava语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld 变量运算符 条件和循环 方法和数组Java面向对象：面向对象入门 面向对象应用_管理系统类 Java常用类、String相关、算法相关 面向对象深入（重载、this、static ）继承（重写、super、初始化顺序） 多态（抽象类和接口、final、克隆和比较接口 设计模式、对象和类的生命周期）API：异常、日志 集合 集合工具类和泛型 IO JDBC基础线程 网络编程 反射 NIO JunitJava面向对象思想：设计模式 面向对象原则Java底层理论：集合底层 性能监控工具 反编 JUC三、Java webweb基础：TOMCAT/WEB程序结构/HTTP协议 Servlet基础入门、servlet作用域（cookie、session、ServletContext）、 Cookie和Session 、Servlet的交互/JSP原理及运用、 JavaBean/EL/JSTL/MVC思想 、JSP+Servlet+JDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/Log backJavaScript和jQuery框架技术：JS入门和DOM基础 、DOM模型深入 、jQ基础、 jQ操作DOMMVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）Web开发高级运用：tomcat server服务器配置 、nginx使用、 jetty配置网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建四、SSM框架Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、 配置文件详解和动态sql的使用、 mybatis管理关系映射和延迟加载、 查询缓存和逆向工程 、Spring入门和集成、myBatis SpringMVC入门 、SSM集成、 Spring配置详解 、Spring AOP、 Spring事务配置 、SpringMVC高级功能 、SpringMVC原理五、前沿技术高可用、高并发、高扩展：Spring Boot 、缓存 、分布式 、全文索引、 服务中间件、 myCat、 云服务 、人脸识别 、语言识别 、JVM底层+优化希望能够帮到你！！！

在Java程序员行业中，有不少Java开发人员的理想是成为一名优秀的Java架构师，Java架构师的主要任务不是从事具体的软件程序的编写，而是从事更高层次的开发构架工作。他必须对开发技术非常了解，并且需要有良好的组织管理能力。可以这样说，一个Java架构师工作的好坏决定了整个软件开发项目的成败。那么Java架构师需要掌握哪些知识点呢？1、框架源码分析设计模式：Singleton单例模式，Factory工厂模式，Proxy代理模式，Template模板模式，Prototype原型模式等Spring5：Spring提醒结构，IOC注入原理，AOP设计原理，Spring事务处理机制，SpringMVC，Spring源码分析。Mybatis：Mybatis体系结构，Mybatis核心应用与配置，Mybatis关联查询，与Spring集成，Mybatis源码分析。2、性能优化JVM性能优化：剖析JVM整体结构，详解垃圾回收机制GC,JVM性能调优与工具排查Nginx调优：Nginx项目架构，Nginx核心配置，Nginx负载算法配置Tomcat调优：Tomcat运行机制及框架，Tomcat线程模型，Tomcat性能调优MySQL性能优化：SQL执行计划，AQL优化，索引优化。3、掌握池技术对象池，连接池，线程池，Java反射技术，写框架必备的技术，但是有严重的性能问题，替代方案Java字节码技术。4、掌握nio，值得注意的是“直接内存”的特点，使用场景。5、掌握Java多线程同步异步。6、掌握Java各种集合对象的实现原理，了解这些可以让你在解决问题时选择合适的数据结构，高效的解决问题。7、熟练使用各种数据结构和算法，数组、哈希、链表、排序树就是一句话要么是时间换空间要么是空间换时间。8、熟悉tcp协议，创建连接三次握手和断开连接四次握手的整个过程，不了解的话，无法对高并发网络应用做优化。9、熟悉http协议，尤其是http头，我发现好多工作五年以上的都弄不清session和cookie的生命周期以及它们之间的关联。10、熟悉系统集群、负载均衡、反向代理、动静分离，网站静态化。11、掌握分布式。Java并发编程和网络编程：Java线程状态，线程池，线程通信，线程安全，Netty高性能原理分布式开发框架：分布式系统口调用技术：RPC，Apache分布式系统Zookeeper原理与应用，阿里Dubbo设计思想与应用分布式中间件：分布式服务器治理，分布式消息通信，分布式数据缓存，MongoDB企业集群解决方案12、掌握数据库的设计能力，对它基本的参数优化，慢查询日志分析，主从复制的配置，至少要成为半个mysqldba。

如果你不知道的话，可以看下这个：特别适合初学者，希望能帮助到你

智游大数据的课程大纲如下：第一阶段：Java基础l Java基础介绍及常用开发术语操作，Java跨平台原理，JDK的安装与卸载l Java开发基本语法和编程规范，Eclipse的安装与使用l Java面向对象、封装、继承、抽象类l String、StringBuffer、StringBuilder等开发文档的使用，l NIO的设计思想和常用组件使用方法l IP/端口/URL等网络基础l 多线程的创建与启动l 完成聊天工具（线程+IO+网络编程）l 反射的意义和概念，通过内省机制处理JavaBeanl XML格式与XML解析第二阶段:Java Webl MySQL基本概念及使用l 使用JDBC完成CRUD操作，JDBC重构/封装/解耦合代码思想，JDBC多条件过滤和分页的代码封装l HTML5网页技术，HTML常用标签使用，JavaWeb发展历程和规范，Tomcat安装、配置、插件使用、部署l Servlet基础知识，Cookie和Session原理和技术l JSP原理、JSP九大内置对和四大作用于,EL和JSTL原理和重用操作l Struts2和Spring MVC，过滤器、监听器、国际化，文件上传和文件下载l Hibernate的基础知识及使用，Hibernate查询的方式和结果集的包装，Hibernate的HQL常用语法，Hibernate的事务管理及缓存机制和性能优化l JPA2.0规范和常见JPA标签的使用l Spring原理，Spring IoC容器，bean生命周期、bean作用域，Spring测试l Spring针对不同持久化方式的操作模板以及DAO支持l Spring集成JDBC、Hibernate、MyBatis操作l spring struts hibernate 大型企业级项目实践开发 第三阶段 大数据基础：Hadoopl Linux系统概述及系统安装相关配置l Linux的常用命令，Linux系统进程管理基本原理及相关管理工具l Linux启动流程，用户和组账户管理，磁盘管理，系统文件权限管理，RPM软件包管理l Linux网络基础，Shell编程，yum命令，yum源搭建l Linux上常见软件的安装：安装JDK、安装Tomcat、安装mysql,web项目部署l Hadoop生态环境概览、功能和作用、Hadoop 核心组成介绍及hdfs、mapreduce 体系结构、hadoop集群搭建l Hdfs shell编写、Hdfs java api操作、Hadoop基本命令操作，Hadoop优化l 日志及常见故障处理，名称节点管理l Mapreduce数据去重，数据类型，数据排序，倒排索引，输入输出格式，MR串联，MR模型核心解析l Lucene入门实例及概述，Lucene 中文分词器，Lucene 复杂检索，Lucene 和hadoop的整合l Yarn基础及Yarn框架核心原理解析l Hive入门及集群安装，Hive CRUD操作，hive UDF第四阶段 大数据进阶l Zookeeper概论及集群安装，Zookeeperjava 操作l Hbase总体概述及基本原理及架构，Hbase 分布式安装操作，Hbase java操作l Hbase的复杂操作、二级索引、协处理器、分页实例、存储及检索原理、行键设计原则、预分区及优化l Phoenix的安装及常用操作，Phoenixjava操作，Phoenix spring整合l Flume概述及核心讲解，Flume-ng的安装及测试、核心流程讲解、串联、多路、插件开发、正则表达式l Kafka概述及集群安装，kafka sink，Flume-ng自定义 interceptorl 大型日志分析和用户行为分析项目第五阶段：Spark内存数据处理l Scala的语言开发环境、基本语法、集合之数组、集合之List、集合之MAP、集合之元组、集合操作l Scala的伴生对象及apply、模式匹配、并发编程、并发编程actor、并发编程akka，Scala IO编程l Scala 与java互操作，Spark概论及与其他几个平台的对比，Spark搭建过程l spark yarn模式部署，spark 实例开发，spark的核心进程及资源调度，spark API，spark MapReduce，spark java应用实例l spark SQL实例语法，Sparkstream入门l Spark stream整合kafka，Spark stream整合spark SQL，Spark stream整合flume-ngl spark MLLib算法，Spark MLlib之协同过滤，Spark MLlib之K-Means聚类算法，Spark实现贝叶斯算法l spark大型机房主机实时监控系统项目

1、技术够硬，2、小公司镀金，3、建立名气。进腾讯公司程序员的要求有1、计算机相关专业本科及以上学历，6年以上JAVA开发经验，有三年以上大型公司（或系统）开发经验。2、精通Spring、MyBatis、SpringMVC、SpringBoot等应用框架并熟悉实现原理。3、熟悉分布式缓存、消息中间件、RPC框架、负载均衡、安全防御等技术，掌握各类中间件使用，包括zookeeper、redis、nginx、tomcat等。4、精通SQL，熟练主流数据库Oracle/Mysql，具备优秀的数据建模能力和数据库分库分表设计能力。5、有大型分布式、微服务系统架构经验，对服务治理有深入理解，使用过dubbo或springcloud且有实际项目经验。

第一阶段：HTML5+CSS3开发01、网站页面设计 02、HTML5 03、CSS3第二阶段：Javascript开发与实战01、Javascript开发 02、Jquery实战第三阶段：Java开发基础01、开发工具介绍与环境搭建 02、基本语法 03、基础数据结构 04、逻辑结构体 05、函数与方法 06、数组 07、基础类与对象第四阶段：Java面向对象01、面向对象编程 02、抽象类和接口 03、反射机制 04、集合类和IO类 05、多线程 06、异常处理 07、算法和数据结构第五阶段：数据库01、关系数据库 02、数据库事务与存储过程 03、NOSQL0 4、JDBC连接池 05、XML与JSON第六阶段：Java网络编程基础01、TCP/IP原理与socket编程 02、Http协议 03、Servlet工作原理 04、Apache Tomcat服务器第七阶段：Java框架01、Java经典设计模式 02、Struts2框架 03、Spring4框架 04、SpringMVC 05、Hibernate5 06、MyBatis 07、WebService(wsdl，RestFul) 08、Apache、Nginx服务器 09、Maven项目构建工具 10、log4j日志管理 11、Junit单元测试 12、Jmeter压力测试第八阶段：项目实战

第一阶段：Java语言基础Java语言基础1、面向对象思维JAVASE2、（类加载机制与反射，annotation，泛型，网络编程，多线程，IO，异常处理，常用API，面向对象，JAVA编程基础）3、Java8新特性第二阶段：数据库JAVA战狼班数据库1、Oracle（SQL语句、SQL语句原理、SQL语句优化、表、视图2、序列、索引、Oracle数据字典、Oracle数据库PL/SQL开发3、数据库设计原则、MySQL、JDBC兄弟连JAVA战狼班第三阶段：Web基础Web基础1、HTML5（H5）基本文档结构、链接、列表、表格、表单;2、CSS基础语法、盒子模型、浮动布局、定位;3、JavaScript语言基础、DOM编程、事件模型等），JQuery，AJAX框架，XML，BootStrap组件第四阶段：JavaWeb技术和主流框架JavaWeb技术和主流框架1、JSP&Servlet、struts2，hibernate4，spring4，JPA，maven2、SpringData，SpringMVC，MyBatis，，shiro，Nginx第五阶段：LinuxLinux1、Linux安装、熟悉Linux的基础命令、vi编辑器的使用、awk和sed命令使用、用户和组2、文件及目录权限管理、使用ACL进行高级访问控制、网络配置和软件包安装、启动流程和服务管理3、系统监控和日志管理、进程管理和计划任务、ssh远程登录、shell基础和shell脚本。第六阶段：大数据技术（Hadoop和Spark）大数据技术（Hadoop和Spark）1、Hadoop（Hadoop基础和环境搭建，HDFS体系结构，MapRece；Hadoop的集群模式、HDFS联盟，利用ZooKeeper来实现Hadoop集群的HA（高可用性）功能2、Yarn的任务调度机制，ApacheHive，Pig数据处理，集成Hadoop和Sqoop3、Flume以及ApacheKafka来实现数据的交换,安装部署HBase,Storm）4、Scala语言（Scala环境搭建、Scala基础语法、模式匹配、重载与构造器、Map与rece、元组、继承、，OptionSomeNone，Tuple；集合方法和运算，future对象同步处理和异步处理返回结果）5、Spark（Spark搭建，Spark-shell的使用，Spark-submit提交应用，Spark的内核设计和实现，并对内核中的实现架构、运行原理进行详细的讲解；Spark生态体系中的各个组件，包括：SparkCore，Shark，SparkSQL和SparkStreaming等等）第七阶段：项目项目1、China-UCSP项目SSM(SpringSpringMVCMyBatis)2、用户关系管理系统S2SHMavenNodejsMySQL技术实战开发3、电子商务交易平台S2SHMavenShiroOracle

学习内容繁多，涵盖较多方面，大致可以分为以下几个阶段。一、预科学习：HTML5：HTML5标签入门、HTML5表格、表单CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习二、JavaSEJava语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld 变量运算符 条件和循环 方法和数组Java面向对象：面向对象入门 面向对象应用_管理系统类 Java常用类、String相关、算法相关 面向对象深入（重载、this、static ）继承（重写、super、初始化顺序） 多态（抽象类和接口、final、克隆和比较接口 设计模式、对象和类的生命周期）API：异常、日志 集合 集合工具类和泛型 IO JDBC基础线程 网络编程 反射 NIO JunitJava面向对象思想：设计模式 面向对象原则Java底层理论：集合底层 性能监控工具 反编 JUC三、Java webweb基础：TOMCAT/WEB程序结构/HTTP协议 Servlet基础入门、servlet作用域（cookie、session、ServletContext）、 Cookie和Session 、Servlet的交互/JSP原理及运用、 JavaBean/EL/JSTL/MVC思想 、JSP+Servlet+JDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/Log backJavaScript和jQuery框架技术：JS入门和DOM基础 、DOM模型深入 、jQ基础、 jQ操作DOMMVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）Web开发高级运用：tomcat server服务器配置 、nginx使用、 jetty配置网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建四、SSM框架Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、 配置文件详解和动态sql的使用、 mybatis管理关系映射和延迟加载、 查询缓存和逆向工程 、Spring入门和集成、myBatis SpringMVC入门 、SSM集成、 Spring配置详解 、Spring AOP、 Spring事务配置 、SpringMVC高级功能 、SpringMVC原理五、前沿技术高可用、高并发、高扩展：Spring Boot 、缓存 、分布式 、全文索引、 服务中间件、 myCat、 云服务 、人脸识别 、语言识别 、JVM底层+优化

Java前景是很不错的，像Java这样的专业还是一线城市比较好，师资力量跟得上、就业的薪资也是可观的，Java软件工程师主要学习的内容有8个阶段，0基础学习Java是没有问题的，关键是找到靠谱的Java培训机构，你可以深度了解机构的口碑情况，问问周围知道这家机构的人，除了口碑再了解机构的以下几方面：1. 师资力量雄厚要想有1+1>2的实际效果，很关键的一点是师资队伍，你接下来无论是找个工作还是工作中出任哪些的人物角色，都越来越爱你本身的技术专业java技术性，也许的技术专业java技术性则绝大多数来自你的技术专业java教师，一个好的java培训机构必须具备雄厚的师资力量。2. 就业保障完善实现1+1>2效果的关键在于能够为你提供良好的发展平台，即能够为你提供良好的就业保障，让学员能够学到实在实在的知识，并向java学员提供一对一的就业指导，确保学员找到自己的心理工作。3. 学费性价比高一个好的Java培训机构肯定能给你带来1+1>2的效果，如果你在一个由专业的Java教师领导并由Java培训机构自己提供的平台上工作，你将获得比以往更多的投资。希望你早日学有所成。

强力推荐疯狂java 提高自己java水平

1、用script标签包围，然后像xml语法一样书写@Select({"<script>", "SELECT * FROM tbl_order", "WHERE 1=1", "<when test="title!=null">", "AND mydate = #{mydate}", "</when>", "</script>"})2、用Provider去实现SQL拼接，例如：public class OrderProvider { private final String TBL_ORDER = "tbl_order"; public String queryOrderByParam(OrderPara param) { SQL sql = new SQL().SELECT("*").FROM(TBL_ORDER); String room = param.getRoom(); if (StringUtils.hasText(room)) { sql.WHERE("room LIKE #{room}"); } Date myDate = param.getMyDate(); if (myDate != null) { sql.WHERE("mydate LIKE #{mydate}"); } return sql.toString(); }}public interface OrderDAO { @SelectProvider(type = OrderProvider.class, method = "queryOrderByParam") List<Order> queryOrderByParam(OrderParam param);}注意：方式1有个隐患就是当传入参数为空的时候，可能会造成全表查询。复杂SQL用方式2会比较灵活（当然，并不建议写复杂SQL），而且可以抽象成通用的基类，使每个DAO都可以通过这个基类实现基本的通用查询，原理类似Spring JDBC Template。

Java由C/C++演化而来，汲取了C++的诸多优点,，同时还增加了许多新特性

把“,”改成“+”才可以用。

java学习内容很多，这个直接给你java开发需要学习的全部内容，你可以参考进行学习。一、预科学习：HTML5：HTML5标签入门、HTML5表格、表单CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习二、JavaSEJava语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld 变量运算符 条件和循环 方法和数组Java面向对象：面向对象入门 面向对象应用_管理系统类 Java常用类、String相关、算法相关 面向对象深入（重载、this、static ）继承（重写、super、初始化顺序） 多态（抽象类和接口、final、克隆和比较接口 设计模式、对象和类的生命周期）API：异常、日志 集合 集合工具类和泛型 IO JDBC基础线程 网络编程 反射 NIO JunitJava面向对象思想：设计模式 面向对象原则Java底层理论：集合底层 性能监控工具 反编 JUC三、Java webweb基础：TOMCAT/WEB程序结构/HTTP协议 Servlet基础入门、servlet作用域（cookie、session、ServletContext）、 Cookie和Session 、Servlet的交互/JSP原理及运用、 JavaBean/EL/JSTL/MVC思想 、JSP+Servlet+JDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/Log backJavaScript和jQuery框架技术：JS入门和DOM基础 、DOM模型深入 、jQ基础、 jQ操作DOMMVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）Web开发高级运用：tomcat server服务器配置 、nginx使用、 jetty配置网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建四、SSM框架Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、 配置文件详解和动态sql的使用、 mybatis管理关系映射和延迟加载、 查询缓存和逆向工程 、Spring入门和集成、myBatis SpringMVC入门 、SSM集成、 Spring配置详解 、Spring AOP、 Spring事务配置 、SpringMVC高级功能 、SpringMVC原理五、前沿技术高可用、高并发、高扩展：Spring Boot 、缓存 、分布式 、全文索引、 服务中间件、 myCat、 云服务 、人脸识别 、语言识别 、JVM底层+优化

你放心吧！java做后端开发很强的，你学精通一门语言，其他语言也都顺手拈来

可以 android和web联系不大 和swing很像

1、用script标签包围，然后像xml语法一样书写@Select({"<script>", "SELECT * FROM tbl_order", "WHERE 1=1", "<when test="title!=null">", "AND mydate = #{mydate}", "</when>", "</script>"})2、用Provider去实现SQL拼接，例如：public class OrderProvider { private final String TBL_ORDER = "tbl_order"; public String queryOrderByParam(OrderPara param) { SQL sql = new SQL().SELECT("*").FROM(TBL_ORDER); String room = param.getRoom(); if (StringUtils.hasText(room)) { sql.WHERE("room LIKE #{room}"); } Date myDate = param.getMyDate(); if (myDate != null) { sql.WHERE("mydate LIKE #{mydate}"); } return sql.toString(); }}public interface OrderDAO { @SelectProvider(type = OrderProvider.class, method = "queryOrderByParam") List<Order> queryOrderByParam(OrderParam param);}注意：方式1有个隐患就是当传入参数为空的时候，可能会造成全表查询。复杂SQL用方式2会比较灵活（当然，并不建议写复杂SQL），而且可以抽象成通用的基类，使每个DAO都可以通过这个基类实现基本的通用查询，原理类似Spring JDBC Template。

有，目前java培训班很多，可以根据需求去选择。比如动<力><节>点java系统架构师培训课程内容：1、以T-ELTE-Learning评测系统为驱动(1)Unix开发环境(2)java语言基础(3)java面向对象(4)JDK核心API2、以电信T-DMS数据采集系统驱动(1)SQL语言(2)Oracle数据库开发(3)javaSE核心(4)XML(5)JDBC(6)软件工程基础(7)OOAD及设计模式3、以T-GWAP通用电子商务平台为驱动(1)HTML/CSS(2)javaScript核心(3)Servlet/JSP(4)Ajax(5)javaScript框架高级课程课程比较多，需要好好了解一下。

其实每个培训机构讲的东西都差不多，主要还是看后面实践课程，还有老师风格适合你不。1、刚接触编程语言，不知道该从哪里学起，也不知道该学点啥；2、书本太枯燥，厚厚一本看着都头疼；课上也没法录像，听了一遍没听懂；3、去网上找点教学视频吧，却发现教学视频那么多，不知道该学哪个。万一遇到冒牌讲师，讲成一坨翔了，纯属浪费生命；4、诶，好不容易找到一个靠谱的好视频，却没有配套资料（源码、讲义、笔记什么的）；5、好吧，千辛万苦终于入门了。遇到一个bug改到昏天黑地，自己跟它死磕，不知道该问谁…作为一个过来人，我走了许多弯路才步入正轨。有了我这个前车之鉴，我不希望你们也像我一样，刚从一个坑爬出来，然后马上掉进另一个坑。如果你真的想学习的话，建议参加培训。多看看几个机构。兄弟连合肥分校有试听课程，在深港城，你可以去听听的

自制力不好的话自学Java的话还是又一定难度的，推荐兄弟连Java课程可以参考一下

　　主要培养训练什么？你是不是想问，java培养训练都是要学哪些知识点？　　下面就来看一下动力节点所需要学习哪些知识点：　　第一阶段：JavaSE基础，一定要把基础打好了，当前的知乎才干学的更彻底。JavaSE基础包括：Java开发环境搭建、Java基础语法、Java面向对象。1、Java开发环境搭建：Java顺序的加载与执行；类加载器机制；Java8的下载与装置；path和classpath环境变量；第一个Java顺序的编写；Java中的注释；public class和class的区别；2、Java基础语法：标识符；关键字；字面量；数据类型；字符编码；进制换算；变量；运算符；控制语句 ；办法；办法重载；办法执行的内存剖析；递归算法；3、Java面向对象：面向进程和面向对象的区别、类和对象、this、super、JVM运转内存分析、成员变量 和部分变量、隐藏和封装、深化结构器、类的承继、办法重写、多态、承继与组合、初 始化块、处置对象、类成员、final 修饰符、笼统类、接口及作用、外部类、枚举类、 对象与渣滓回收、修饰符的适用范围、运用Jar文件、外部类　　　　第二阶段：环境搭建、基础语法、面向对象中心、异常、数组、常用类、集合、线程、IO流、反射机制、网络编程。1、异常：异常承继构造图、捕获异常、声明异常、异常与办法重写、自定义异常、手动抛出异常 、Java7多异常捕捉、 拜访异常信息、 运用finally回收资源、 异常处置的嵌套、Java 7自动封闭资源、catch 和 throw 同时运用、Java7加强的throw 语句、异常链追踪 信息。2、数组/算法：数组存储构造、数组优缺陷、一维数组、二维数组、多维数组、冒泡排序、选择排序、 二分法查找、工具类Arrays、二维数组完成酒店管理系统、数组拷贝、main办法的 args参数解析、数组扩容。3、常用类：字符串相关String、StringBuffer、StringBuilder；八种根本数据类型对应的包装类 ；日期处置相关；数字处置相关；枚举类型；4、集合/数据构造：Collection和Map集合承继构造图；Collections工具类；Iterator迭代集合；Array List、LinkedList、Vector集适宜用场景剖析以及Vector运用较少的缘由；数组、单 向链表、双向链表数据构造；各种集合源码级剖析；哈希表散列表数据构造；Hashtab le以及Properties属性类详解；SorteMap、TreeSet、TreeMap集合排序机制；红 黑树；5、IO流：迅雷下载演示流的原理；流的分类；装饰器设计形式；IO流体系承继构造；文件字节/字 符输出输入流；带有缓冲区的字节/字符输出输入流；对象流、序列化和反序列化；规范 输入流、改动规范输入流的输入方向；数据流；文件File类以及递归算法复制目录；zip 紧缩技术；6、线程线程和进程；线程生命周期；线程调度；线程同步7、反射机制获取Class的方式；读取配置文件中的类名来实例化对象；经过反射操作Field、Metho d、Constructor；经过反射机制调用Method；经过反射获取父类型；8、网络编程IP地址以及端口号的作用；TCP/IP协议；UrlDecoder和UrlEncoder；Socket编程基 础；UDP协议以及多点播送；9、注解Annotation注解和配置文件的区别；Java自带注解；自定义注解；经过反射机制读取注解；10、MySQL初级MySQL的装置与配置；常用命令；复杂查询；要求查询；排序；数据处置函数；分组函 数；分组查询；衔接查询；子查询；union；limit；表的创立；增删改表构造；约束； 存储引擎；事务；索引；视图；DBA命令；数据库设计三范式；MySQL存储进程；11、JDBCJDBC实质；JDBC开发前预备职业；编程六步；采用Class.forName方式注册驱动以 及注册原理；SQL注入；避免SQL注入；Statement和PreparedStatment比对； JDBC事务；JDBC行级锁；JDBC完成银行账户转账。　　　　第三阶段：1、HTML/HTML5HTML根本构造、HTML表格、HTML超链接、HTML图片、HTML背景图片和背风光、 HTML字体、HTML列表、HTML根本标签、HTML格式标签、HTML实体符号、HTML 表单、HTML向服务器发送恳求的多种方式、HTML DOM、HTML节点id属性、div和 span规划、HTML框架。2、CSS/CSS3标签选择器、ID选择器、类选择器、CSS高级语法、派生选择器、属性选择器、CSS常 用款式、CSS框模型、CSS定位3、JavaScriptJavaScript中心语法；JavaScript DOM编程；JavaScript BOM编程；JavaScript 承继；JavaScript闭包；手动开发jQuery框架；4、jQueryjQuery九大选择器；增删改节点；款式操作；属性操作；事情操作；5、Bootstrap下拉菜单、按钮组、按钮式下拉菜单,输出框组、面板和Well、正告框、进度条和列表 组件、导航和导航条Bootstrap媒体对象、栅格系统6、XML+XPathXML是什么；开发中主要用XML干什么；XML和HTML的区别与联络；XML/DTD/XS D/XSL关系；XML的SAX解析和DOM解析；Java解析XML；dom4j解析XML；XML +XPath解析XML文件；7、ServletServlet/GenericServlet/HttpServlet；Servlet生命周期；Http协议分析；GET和 POST区别；转发和重定向；Cookie；Session；Servlet标准中常用接口的解说；8、JspJsp实质；Jsp和Servlet区别以及职责；小脚本；声明；表达式；举措；九大内置对象9、EL经过EL表达式从作用域中取数据；EL的隐含对象；从数组、List、Map中取数据；EL常 用运算符；10、JSTL中心标签core的运用；JSTL的完成原理；自定义标签；　　　　第四阶段：1、Filter完成Filter过滤器、Filter中办法分析、Gof设计形式之责任链设计形式、分析Tomcat 服务器源码检查Filter调用进程、字符编码过滤器完成、web站点登录阻拦过滤器完成 、web站点ip地址过滤器完成、AOP编程思想、Filter生命周期、FilterConfig详解2、Listener怎么完成一个Listener监听器、ServletContextListener详解、SessionListener详 解、Session对象销毁时完成购物车耐久化操作、Gof设计形式之监听器形式、服务器 启动时监听器初始化资源、服务器封闭时监听器回收资源3、Servlet3.0@WebServlet、@WebInitParam、@WebFilter、@WebListener、 @MultipartConfig、异步处置支持、可插性加强、ServletContext功能加强、 HttpServletRequest对文件上传的支持4、AJAXajax发送get/post恳求、eval函数、json处置、中文乱码处理方案、ajax中心对象创 建、注册回调函数、回调函数详解、readyState属性详解、status属性详解、 responseText属性详解、ajax完成自动补全功用、下拉列表联动效果、表单验证效果5、MVC系统职能分工、MVC架构形式优点、开发准绳：高内聚、低耦合。组件独立性/复用性、 Model数据：业务数据剖析service、数据库数据剖析dao。View视图：JSP、 Freemarker等。Controller控制器：完成调度，管理Model与View。MVC表现了 Gof设计形式之监听形式6、ThreadLocal系统职能分工、MVC架构形式优点、开发准绳：高内聚、低耦合。组件独立性/复用性、 Model数据：业务数据剖析service、数据库数据剖析dao。View视图：JSP、 Freemarker等。Controller控制器：完成调度，管理Model与View。MVC表现了 Gof设计形式之监听形式7、Gof之代理形式静态代理形式；JDK自带的静态代理；CGLIB代理；静态代理方式控制事务；8、衔接池/C3P0/DBCP/Druid衔接池完成原理；常用衔接池C3P0/DBCP的运用；阿里巴巴的Druid衔接池；9、JNDIJava Naming and Directory Interface，SUN公司提供的一种规范的Java命名系统 接口；JNDI和衔接池结合运用；10、Gof之工厂形式工厂形式的适用场所、复杂工厂形式、工厂办法形式、笼统工厂形式11、MySQL高级事务、隔离级别、隔离级别与分歧性成绩的关系、并发事务与隔离级别示例、MySQL架 构组成，MySQL备份和恢复，MySQL查询和索引优化、MySQL存储引擎优化， MySQL锁机制优化及高可用设计、MySQL集群、视图、DBA命令、导入导出12、OracleOracle的装置、服务的启动和封闭、监听器、网络服务名、VARCHAR2、sequence、 rowid、rownum、通用的分页SQL、Oracle索引完成原理分析、数据库平安管理、表 空间、系统表、PLSQL Developer客户端工具的运用13、PL/SQLPL/ SQL 字符集、 PL/ SQL 块、 PL/ SQL 高级编程、用 PL/ SQL 顺序拜访数据库、 声明和运用子顺序、进程和函数、记载类型、％type和％rowtype属性、游标、集合、 异常处置、 PL/SQL 顺序类型（包括：匿名 PL/SQL 块、存储进程和函数、删除存储过 程和函数 ） 、触发器14、SQL优化什么是执行策划、SQL语句能否清楚的告知查询优化器它想干什么、索引查找和全表扫 描、一致SQL语句写法、不要把SQL语句编写的太复杂、明晰SQL语句执行顺序、运用 暂时表暂存中间后果、一些SQL查询语句添加nolock、运用like停止模糊查询应留意什 么、数据类型的隐式转换对查询效率的影响、尽量防止大事务操作，进步系统并发才能15、MyBatisMyBatis完成原理、MyBatis入门、装置和配置MyBatis、运用映射语句、执行非查询 语句、运用高级查询技术、事务、运用静态SQL、运用高速缓存进步功能、MyBatis数 据拜访对象、DAO运用进阶。　　　　当然，这些知识点一定是不片面的，假如你想理解详细的话你可以去动力节点实地去看一下，最近他们仿佛有一个java实验班可以收费的协助本人测验适不合适学习java而且还可以报销路费以及住宿费，假如你有时刻可以去理解一下。

不需要，JavaScript虽然名字里带Java，但实际上和Java并没有什么关系，它使用来写网络脚本的，完全是另外一门语言，因为原公司被Sun收购了，所以加了个Java在名字里面。

从基础的语法到高阶的框架，底层的jvm，java需要学习的内容很多，大致可以分为以下几个阶段进行学习。一、预科学习：HTML5：HTML5标签入门、HTML5表格、表单CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习二、JavaSEJava语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld 变量运算符 条件和循环 方法和数组Java面向对象：面向对象入门 面向对象应用_管理系统类 Java常用类、String相关、算法相关 面向对象深入（重载、this、static ）继承（重写、super、初始化顺序） 多态（抽象类和接口、final、克隆和比较接口 设计模式、对象和类的生命周期）API：异常、日志 集合 集合工具类和泛型 IO JDBC基础线程 网络编程 反射 NIO JunitJava面向对象思想：设计模式 面向对象原则Java底层理论：集合底层 性能监控工具 反编 JUC三、Java webweb基础：TOMCAT/WEB程序结构/HTTP协议 Servlet基础入门、servlet作用域（cookie、session、ServletContext）、 Cookie和Session 、Servlet的交互/JSP原理及运用、 JavaBean/EL/JSTL/MVC思想 、JSP+Servlet+JDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/Log backJavaScript和jQuery框架技术：JS入门和DOM基础 、DOM模型深入 、jQ基础、 jQ操作DOMMVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）Web开发高级运用：tomcat server服务器配置 、nginx使用、 jetty配置网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建四、SSM框架Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、 配置文件详解和动态sql的使用、 mybatis管理关系映射和延迟加载、 查询缓存和逆向工程 、Spring入门和集成、myBatis SpringMVC入门 、SSM集成、 Spring配置详解 、Spring AOP、 Spring事务配置 、SpringMVC高级功能 、SpringMVC原理五、前沿技术高可用、高并发、高扩展：Spring Boot 、缓存 、分布式 、全文索引、 服务中间件、 myCat、 云服务 、人脸识别 、语言识别 、JVM底层+优化

如果完全没了解过，有兴趣的话可以去上个培训班。可以看下基础书籍和教学视频，如:head first java

什么是循环中嵌套switch输入某年某月?你写的是命令行?判断距离1900年1月1日,直接用Calendar类就可以在网上拷了一份代码,可以参考publicstaticvoidmain(String[]args){Calendarcal=Calendar.getInstance();cal.set(1900,0,1);//Calendarcal2=Calendar.getInstance();//cal2.set(2010,10,18);////longcalm=cal.getTimeInMillis();//longcal2m=cal2.getTimeInMillis();//longre=(cal2m-calm)/1000/60/60/24;//System.out.println(re);cal.add(Calendar.DAY_OF_MONTH,40498);System.out.println(cal.get(Calendar.YEAR));System.out.println(cal.get(Calendar.MONTH));System.out.println(cal.get(Calendar.DAY_OF_MONTH));}

java中，线程安全的解决方法或过程：1.如果对象是immutable，则是线程安全的，例如:String，可以放心使用。2. 如果对象是线程安全的，则放心使用。3.有条件线程安全，对于Vector和Hashtable一般情况下是线程安全的，但是对于某些特殊情况，需要通过额外的synchronized保证线程安全。4.使用synchronized关键字。

学以致用才有用，最好的方法是以实际开发学习为最佳路径

黑马程序员视频库

Java前景是很不错的，像Java这样的专业还是一线城市比较好，师资力量跟得上、就业的薪资也是可观的，0基础学习Java是没有问题的，关键是找到靠谱的Java培训机构，你可以深度了解机构的口碑情况，问问周围知道这家机构的人，除了口碑再了解机构的以下几方面：1. 师资力量雄厚要想有1+1>2的实际效果，很关键的一点是师资队伍，你接下来无论是找个工作还是工作中出任哪些的人物角色，都越来越爱你本身的技术专业java技术性，也许的技术专业java技术性则绝大多数来自你的技术专业java教师，一个好的java培训机构必须具备雄厚的师资力量。2. 就业保障完善实现1+1>2效果的关键在于能够为你提供良好的发展平台，即能够为你提供良好的就业保障，让学员能够学到实在实在的知识，并向java学员提供一对一的就业指导，确保学员找到自己的心理工作。3. 学费性价比高一个好的Java培训机构肯定能给你带来1+1>2的效果，如果你在一个由专业的Java教师领导并由Java培训机构自己提供的平台上工作，你将获得比以往更多的投资。希望你早日学有所成。

首先JavaSE是核心，这是初学Java人员应最先接触学习的部分。Java的运行原理，jdk的配置，与jre的区别，基本数据类型，流程控制(顺序结构、选择结构、循环结构)，数组、集合框架，异常处理等，这些都是比较容易学习的，需要多练习，在联系过程中加强理解。面向对象部分是Java初学者，尤其是没有任何编程语言基础的学起来有些难度，类、对象、继承、封装、多态等技术点需要多参照些现有的设计模型，学习设计的思路。诸如工厂模式、观察者模式、代理模式等重要的设计模式也是需要学习的，否则在将来应用框架时就会只知其然，不知其所以然。IO流、多线程也一定需要学习，尤其是XML、JSON等文件格式一定要掌握，这在数据交互时常用。其次是数据库知识，作为初级Java程序员必须要掌握一种常用的关系型书库的应用，如MySQL或oracle等，数据库对象诸如表、视图等的创建、增删改查语句，尤其是查询，在企业中经常需要从十几张表、或几十张表中查询数据，所以对于如何进行内连接、外连接、以及联合查询等一定要掌握，另外对于索引、事务等也要掌握。第三是Java Web部分，由于Java主要做web开发，一些前端技术HTML3、CSS5，javaScript，jQuery等这些不见得要学得有多深入，但是必须要掌握，tomcat、jsp，以及和数据库的交互这些都是必须要掌握的。第四是框架部分，主流的ORM框架有Mybatis、hibernate，MVC框架有Spring MVC、Struts2等，可以优先掌握主流的SSM框架组合，框架的学习有人认为很简单，就按照规定、规范调用、使用呗，初学者可以先学习如何使用这些框架，然后慢慢的探究内部原理，因为框架是技术封装、简化的产物。这里面有些同类型的技术比如hibernate，如果会使用Mybatis了，那么上手就会很容易，同理如果Spring MVC框架应用熟练了，那么Struts2框架其实就可以现学现卖了。一个web程序包含的模块很多，不一定包括所有模块。系统模块：Windows、Linux系统等。存储模块：这里既包括关系型数据库MySQL、oracle等，也包括内存数据库redis、memcached等。程序模块：还可以细化成持久化模块、业务逻辑模块、表现层模块，MVC框架的实现。搜索模块：应用solr或Elasticsearch等。服务器模块：tomcat、weblogic、Resion等中间件模块：nginx、MQ消息队列技术等。在这里额外说一下技术和技能的区别，初学者学一个技术可能很容易，但是这个技术如何在企业开发环境中应用这就是技能了，所以在学习的同时，要多应用，最好通过一些案例项目来学习，这样既高效，学习的还扎实。补充一点，现在的应用级别越来越大，海量数据、高并发是处理的重点，单应用的程序已经无法满足要求，分布式是趋势，Dubbo、Zookeeper、Docker、SpringBoot、SpringCloud、MyCat等技术，包括上面系统模块里提到的一些技术都要学习的