java集合学习

链表和迭代器，hasnext()指向内存索引横线处，而next()指向对应的元素，remove()删除当前

public class MyLink2 {
    public static void main(String[] args) {
        List list=new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        Iterator<String> iterator=list.iterator();
        ListIterator<String> listIterator=list.listIterator();
        //链表，删除头，
        if(iterator.hasNext()){
            System.out.print("--");
        }
        if(listIterator.hasNext()){
            System.out.print("--");
        }
        iterator=list.iterator();
        int i=0;
        while(iterator.hasNext()){
            System.out.println(iterator.next());            
            if(i==0){
                iterator.remove();
            }
            i++;
        }
        System.out.println(list);
    }
}
打印为：----abc[b, c]

public class MyLink {
    public static void main(String[] args) {
        List list=new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        List<String> list2=new LinkedList<>();
        list2.add("A");
        list2.add("B");
        list2.add("C");
        ListIterator<String> aIterator=list.listIterator();
        Iterator<String> biterator=list2.iterator();
        //要添加的元素
        while(biterator.hasNext()){
            //自身的元素
            if(aIterator.hasNext()){
                aIterator.next();
            }
            //[a, A, b, B, c, C]
            aIterator.add(biterator.next());
        }
        System.out.println(list);
        biterator=list2.iterator();
        //指向头指针和下一位，
        while(biterator.hasNext()){
            /*if(biterator.hasNext()){
                
            }*/
            biterator.next();
            biterator.remove();
        }
        //打印为[]null
        System.out.println(list2);
    }
    
}

散列，以对象产生散列码，散列码%长度得到余数，散列集(hashset)，

SortedSet<Object> set=new TreeSet<Object>(); 树集合，也就是以红黑树排序的；

Set<String> set=new HashSet<>();//HaseSet  都是有序的

优先级队列以堆结构，常用在任务调度，任务优先级最高，值越小，而优先级队列每次移除最小值的元素；

散列集set,映射表map,

       分为树状映射表TreeMap和散列映射表HashMap

 Map<String,String> map1 = new  HashMap<String,String>();//会按照键从小到大排序

 Map<String,String> map = new LinkedHashMap<String,String>();//按照添加顺序，也就是不会排序

https://www.cnblogs.com/hubingxu/archive/2012/02/21/2361281.html

键的值是根据hascode()函数计算出来的

Map<String, String>map2=Collections.synchronizedMap(map);//map2将是加锁的，同步的，安全的，一般下的是不安全的；

        String[] ss={};
        List list=Arrays.asList(ss);//将数组转为集合

降序排序

int index=Collections.binarySearch(list, "");//二分查找，

Arrays.binarySearch(a, key)

元素的索引；比线型查找好多了

链表的二分查找，是线型的查找，二分查找失去优势

Collections.swap(list, 1, 2);//交换顺序
        Collections.reverse(list);//反转

Collections.rotate(list, 2); //也就是2及其后面的，转到前面；0-1转到后面

int i=Collections.frequency(list, "E");//

Collections.disjoint(c1, c2)//比较两个集合是否有重复元素

 System.out.println(listA.containsAll(listB));//判断子集
        System.out.println(Collections.indexOfSubList(listA, listB));

https://www.nowcoder.com/questionTerminal/5f3b7bf611764c8ba7868f3ed40d6b2c

判断一个字符串能否拼出字典内的单词

ss[i].contains(s)