集合常见问题总结下

答案： C

分析：A：LinkedList实现List接口

B：AbstractSet实现Set接口

D：TreeMap继承AbstractMap

答案：A

分析：已经指定了长度, 所以不扩容

答案：C

分析：Map接口继承了java.lang.Object类,但没有实现任何接口.

publicclassSolution {

publicListNode mergeTwoLists(ListNode l1, ListNode l2) {

if(l1 == null|| l2 == null) {

            returnl1 != null? l1 : l2;

        }

        ListNode head = l1.val < l2.val ? l1 : l2;

        ListNode other = l1.val >= l2.val ? l1 : l2;

        ListNode prevHead = head;

        ListNode prevOther = other;

        while(prevHead != null) {

            ListNode next = prevHead.next;

            if(next != null&& next.val > prevOther.val) {

                prevHead.next = prevOther;

                prevOther = next;

            }

            if(prevHead.next==null){

                prevHead.next=prevOther;

                break;

            }

            prevHead=prevHead.next;

        }

        returnhead;

}

}

/**

Definition for singly-linked list.

public class ListNode {

int val;

ListNode next;

ListNode(int x) { val = x; }

* }

*/

publicclassSolution {

publicListNode reverseList(ListNode head) {

if(head==null||head.next ==null)

            returnhead;

        ListNode prev = reverseList(head.next);

        head.next.next = head;

        head.next = null;

        returnprev;

}

}

publicclassSolution {

    publicList<List<Integer>> subsets (int[] nums) {

        List<List<Integer>> res = newArrayList<ArrayList<Integer>>();

        List<Integer> item = newArrayList<Integer>();

        if(nums.length == 0|| nums == null)

            returnres;

        Arrays.sort(nums); //排序

        dfs(nums, 0, item, res);  //递归调用

        res.add(newArrayList<Integer>());  //最后加上一个空集

        returnres;

    }

    publicstaticvoiddfs(int[] nums, intstart, List<Integer> item, List<List<Integer>> res){

        for(inti = start; i < nums.length; i ++){

            item.add(nums[i]);

            //item是以整数为元素的动态数组，而res是以数组为元素的数组，在这一步，当item增加完元素后，item所有元素构成一个完整的子串，再由res纳入

            res.add(newArrayList<Integer>(item));

            dfs(nums, i + 1, item, res);

            item.remove(item.size() - 1);

        }

    }

}

答案：B

分析：

A，C，D都线程不安全，B线程安全，具有同步功能

答案：B

分析：

数组插入、删除效率差，排除A

tor不是java里面的数据结构，是一种网络路由技术；因此排除C

Collection 是集合的接口，不是某种数据结构；因此排除D

LinkedList

分析：

Stack是先进后出的线性结构；所以链表比较合适；不需要散列表的数据结构

packagecom.bjsxt;

importjava.util.LinkedList;

publicclassStack {

LinkedList list = newLinkedList();

publicsynchronizedvoidpush(Object x) {

synchronized(list) {

list.addLast(x);

notify();

}

}

publicsynchronizedObject pop() throwsException{

synchronized(list){

if(list.size()<=0){

wait();

}

returnlist.removeLast( );

}

}

}