java集合

Collection{//泛型用?还不如用Object,否则list的add方法必须指定下标
    List:{
        ArrayList:{},//可重复
        LinkedList:{}//使用如下84,
        Vector:{}
    },
    Set:{//下151
        TreeSet:{},//可以有条件的去重及排序
        HashSet:{
            LinkedHashSet:{}
        }
    },
    Queue:{
        LinkedList:{},
        PriorityQueue:{}
    }
}

Map{//接口
    HashMap:{//实现类
        LinkedHashMap:{}//实现类
    },
    TreeMap:{}//实现类//有条件的去重及排序,
    CaseInsensitiveMap:{},
        使用说明,多个相同key(会不区分大小写)时,遍历key为全小写的一个,value为最后一个key的值
        获取map.get("key不区分大小写")
    LinkedCaseInsensitiveMap:{}
        同上但有序key,根据此key第一次赋值时的位置,且遍历key时为原样
}

线程中用:CopyOnWriteArrayList 同list使用;CopyOnWriteArraySet同 set 使用;ConcurrentMap 同 map//详见JAVA\数组、集合\在循环里删除集合元素

//Linked表有序;Hash唯一
无序含义:所谓无序，并非是输出的结果每次会不一样，而是没有按放进去的顺序
//返回零长度的集合别返回null(推荐)

list的元素,和map的value值(key一般是字符串),赋多次并都是同一对象,值是一样的,以后为准
List接口：不唯一(允许重复),有序的对象
    ArrayList:适用于类数组,安全性差,查询快于LinkedList
        声明
            ArrayList alist=new ArrayList();
        赋值
            alist.add(某);alist[0]=某;
        声明+赋值//不能add,猜不能set与之前是不同类型的数据
            List str = Arrays.asList("a", "A", 7, "f");
        遍历，获取长度alist.size()
                for(int i=0;i                     alist.get(i);
                }
                    //与while区别,for括号里的i不能外部引用,while括号里的可以
            或
                for(Object obj: alist){}
                退出当前循环用break;跳过用continue;return会使后不运行,放第二重循环里,执行其后不执行二重循环停止,开始新的一重循环.在一层循环里return会终止其所在方法
            或
                list对象.forEach(a -> {System.out.println(a);});
                {}里break,continue不让用;return同跳过,后不执行进行下一个循环
                箭头后为单条语句可不用{},例(a -> System.out.println(a));
            for循环提高
                 for(int ii=0,j=0;j         插入
            alist.add(插入后下标数,某);--插入,数据会向后搓一个
        删除
            alist.remove(下标数或某);//(每次删一个)
        获取
            alist.get(数);//超出下标报错
            获取最后一个 alist.get(alist.size-1)    
        获取元素下标
            list.indexOf(某);
    替换list元素
        1.
            set的使用,当指定下标值,可替换,并返回,被替换的值;add表插入
            List l1 = new ArrayList();
            ......
            String b = (String)l1.set(3, "a200");//下标不能超出list的已有长度    
        2.    
            如元素是实体类改属性值如下
            list的第一个元素为实体类,修改它的a属性  list.get(0).setA(值),下回用list值已变,setA()为类的set方法
            如果不知道实体类T位置,可list.get(list.indexOf(T))取得T的引用，然后修改属性    
        注意:当赋值时若是同一个引用空间,值传递问题--请看下Map|List值传递
    list获取方式改变时
        list.add实体类,若想list.get(0).get("key")获取会报错,只能list.get(0).get属性方法;否则可list转为json,再转为list

    LinkedList:同ArrayList,但比其多几个方法而已,但便于插、删//当执行插、删时优于ArrayList;使用get,set时ArrayList优
        addFirst()  addList()  removeLast()  removeFirst()
        getFirst()//返回列表第一个元素  
        getLast()    
    add()注意事项    
        add();里为实体类对象,对象里没赋的为null
        add方法里可以添加任意类型的object，但是不能添加int, long, short, char,double 等基本类型
        如果一定要添加int类型，可先转换为Integer,Double,Boolean,Character,Long,Short,Float,Byte 这些封装类,office笔记本p34(数据类型)
    排序
        Collections.sort(list对象);  
        System.out.println(list对象); 
    
    是否包含
        集合对象.containsAll(另集合对象);集合对象.contains(元素);判断集合对象是否包含此，方法返回true、false、
        集合对象：Collection\List\Set    
--判断---
    List list=new ArrayList();
    没赋值只能用list.size()!=0;判定
    用list!=null;不会报错
    当指定list=null;用.size()报错,所以用list!=null;猜:当从来不指定list=null,list不会为null
    所以综上判定没赋值用
    if(list!=null&&list.size()!=0)

不要在 for 循环里进行元素的 remove/add操作;remove元素请使用 Iterator;//猜即对此元素进行遍历,在遍历时remove/add操作会报错
    如果并发操作,参考文件’学习资料\JAVA\数组、集合\在循环里删除集合元素’
    原因,猜-循环一次后,判断已经循环的次数,与此时集合的个数是否一致,不一致继续循    环,
    若循环里有删除,modCount变量+1;若确定继续循环,会调用iterator的next()方法,
    方法里判断modCount与expectedModCount(默认为0)是否相等,不等报错
    
当需要list=null或返回null给list时可用Collections.emptyList();
    例:List persons = Collections.emptyList();或List persons = Collections.emptyList();
    这样写不占内存(猜null也不占),可用 persons.size==0判断,而不用考虑为null的情况导致异常
    注意:此时persons.add方法报错,因为Collections.emptyList()是不可变的列表;
        
    

Vector和ArrayList类似,Vector较其线程安全,但通常性能较其差

Map:接口
    声明
        Map map=new HashMap(16);    
            //设置初始大小原因
                从结构实现来讲,HashMap是数组+链表+红黑树(JDK1.8增加了红黑树部分,链表长度大于8转为红黑树)
                不知道多少设16,若大约知道会有x个,初始值设为    x/0.75+1(减少其扩容的几率:每次扩容都需要重建hash表，是非常影响性能的)
    遍历
        for(Object obj:map.keySet()或map.values()){
            //例map.keySet()-Set类型
        }
    输出显示    
        System.out.println(map);//输出{ uk=英国,cn=中国 }
        System.out.println(map.keySet());//输出[ uk,cn ]//像这种不是根据插入的顺序来输出,称为无序,但它是根据哈希表输出
    多少数据
        map.size();//可得出共有多少数据
    是否包含
        map.containsKey("key");---猜不包含if(!map.containsKey("key"))
        map.containsValue("value");//返回true、false表是否存在某值
    获取
        //map.get(key);获取key不存在返回null
    赋值
        //map.put(key,value)
        //赋值为null,遍历会有,不会删除
    覆盖
        当key重复时,会顶替重名的
        //key可为int等!?
    删除
        //map.remove(key)
    map里放list
        例map.get("key").add(值);//list下回取是变动的
    是否有序
        key不许重复,不求有序,value允许重复,不求有序
    
迭代器Iterator
    Iterator it=List或Set集合对象.iterator();
    while(it.hasNext()){//返回true或false
        Object obj=it.next();
        System.out.println(obj);
    }
    
    ListIterator 用于List(可能Set也行),可在循环里对此集合新增等操作,猜Iterator会报错

Map|List值传递
     ---等号右侧是list|map|实体类类型变量,即对象变量传给另一个(例lista=listb;也可以是lista[0]=listb,简写为A=B),当A或B任意一方用点的形式赋值,会值传递,当在后续的操作中用等号给变量A|B重新赋值是不会值传递的,且之后变量A|B也不会产生值传递现象;
        注意lista[0]=listb要为lista[0].add(某),才会值传递给listb
     --    put|add同一对象,改其一,其它也改变(因为是地址引用)解决方案:推荐-每次都是new一个源值对象再赋值(如写在循环里);若源值对象写在循环外,在循环里new一个赋值对象,遍历源值对象给赋值对象赋值,最好再引用赋值对象;序列号(不会)
  发现:方法参是集合|类等,是地址引用,会值传递 !!!(猜在方法里重新赋值如参=new ArrayList();就不会再传递了)
     
把此集合全部赋给另集合,是累加不是覆盖
    把list的全部元素赋给set集合//addAll()适合list、set
    Set set = new HashSet();
    set.addAll(list);

    
去重转为set

Set
    //与List类似，唯一(不允许重复),无序的对象;猜准确说是Set set = new HashSet();时是如此.Set是所有set的接口
    //set无法单独获取值即无get方法,可用.addAll 方法或 Iterator 遍历set
    //Set方法有add,remove,clear等
用set不用list，因为set唯一，list不唯一
    
TreeSet    //有条件的去重及排序
        TreeSet sets=new TreeSet(new Comparator(){
            public int compare(Student s1, Student s2) {
                //按年龄进行比较
                int num=s2.getAge()-s1.getAge();
                //按姓名进行比较
                int num2=num==0?s2.getNameString().compareTo(s1.getNameString()):num;
                System.out.println(num2+";s1年龄:"+s1.getAge()+";s1姓名:"+s1.getNameString()+";s2年龄:"+s2.getAge()+";s2姓名:"+s2.getNameString());
                return num2;
                //返回值为0则想s1会被去重当遍历使
                //返回值为正数,s1放在s2下面
                //返回值为负数,s1放在s2上面
                //s2是要插入的,s1是排好序的
            }
        });
        TreeSet使集合每次add时会排序
    
TreeMap    //有条件的去重及排序key
        TreeMap hm=new TreeMap(new Comparator(){
            public int compare(Student s1, Student s2) {//对key的一个排序
                int num=s2.getAge()-s1.getAge();
                int num2=num==0?s2.getNameString().compareTo(s1.getNameString()):num;
                return num2;
            }                    
        });
        key是实体类,提取不一定非要是同一的对象;其属性值一致,也能提取value