美文网首页
2019-03-15集合

2019-03-15集合

作者: 果冻_4c9b | 来源:发表于2019-04-20 14:55 被阅读0次

    集合

    能保存一组任意类型数据的元素(只能保存引用数据类型,基本数据类型会经过包装类自动包装成对象),并且可以自动扩容,比数组更具优势
    Java中集合由两大接口代表Collection和Map
    数组:他能保存一组一组元素,数据类型必须一致,定长

    总结

    Collection
    *List 有序可重复
    * ArrayList---基于数组实现的,访问速度快,插入删除速度慢
    * LinkedList---基于列表实现的,访问速度慢,插入删除速度快(改变指向,内存不移动)
    * Set无序不可重复
    * HashSet
    * TreeSet
    * 常用方法:add(),size(),
    Map:以键(key)值(value)对形式保存元素
    * HashMap
    * 常用方法:put(),size(),containskey()


    image.png
    image.png

    Collection接口:

    list子接口 ----有序(元素存入的顺序和元素在集合当中真实的顺序一致)有重复

    • ArrayList-

    基于数组实现的,内部其实是创建了个长度为10的Object类型数组
    当元素个数超过10,ArrayList自动扩容到原来的1.5倍
    数组是一种静态线性表,逻辑是连续的,物理也是连续的 ,
    优缺点:所以他的随机查询的速度比较快,插入删除速度慢

    • Vetor

    他是基于数组实现的,他与ArrayList的区别就在于Vector是数据同步(线程安全)

    List list= new ArrayList();
    // ArrayList list= new ArrayList();
    // add添加元素
    list.add("hello");
    list.add(123);
    list.add(false);
    list.add(new Demo1());
    System.out.println(list);
    // get 获取元素
    // System.out.println(list.get(1));
    // size 元素个数,长度
    // System.out.println(list.size());
    // boolean isEmpty 判断集合是否为空,集合为空返回true(size=0),反之
    // System.out.println(list.isEmpty());
    // 没有list对象且集合元素为零
    if(list !=null && !list.isEmpty()) {
    }
    // remove删除元素
    // list.remove(0);    int 就是根据索引删除
    list.remove("hello");  //删除元素hello
    System.out.println(list);
    // 遍历一
    // for(int i = 0 ; i<list.size();i++) {
    // System.out.println(list.get(i));
    //
    // }
    // 遍历2
    // for(Object ob:list) {
    // System.out.println("---"+ob);
    // }
    }
    }
    // add(int,Object)插入
    // set(int,Object)替换
    // boolean contains(Object)返回集合中是否包含此元素
    
    • LinkedList:

    他是基于链表实现的,链表是动态线性表,逻辑是连续的,物理是不连续的,
    优缺点: 所以他的查询速度比较慢,插入删除速度快

    LinkedList list = new LinkedList<>();
    list.add("hello");
    list.add(123);
    list.add(false);
    // 拓展
    list.addFirst("a");
    list.addLast(212);
    list.removeFirst();
    list.removeLast();
    System.out.println(list);
    list.get(2);
    

    Set子接口 ----无序(元素存入的顺序和元素在集合当中真实的顺序不一致)无重复

    • HashSet
    public class Demo4 {
    public static void main(String[] args) {
    Set set  = new HashSet<>();
            set.add(125);
            set.add("sdas");
            set.add("hello");
            set.add(false);
            set.add("hello");//无序无重复
            System.out.println(set);
            System.out.println(set.size());
            //删除具体元素
            set.remove(false);
            System.out.println(set);
            //遍历
            for(Object ob :set) {
            System.out.println(ob);
            }
    }
    }
    
    • (TreeSet):内部有排序,局限性强

    Map:以键值对的形式保存元素

    • HashMap
    • TreeMap 内部有排序,局限性强
    public class MapDemo1 {
    public static void main(String[] args) {
    // Map:以键值对的形式保存元素
    //     键值不可以重复,否则值被覆盖,value可以重复
        /*    ==HashMap  数据不同步(线程不安全)      null可以作为key或者value
        *  -- ==HashTable  数据同步(线程安全)      null不可以作为key或者value
        *  -- ==TreeMap 内部有排序,局限性强
        *   
        *   
        *    常用方法  :put、containskey
        */
    Map map = new  HashMap<>();
    //put(key【类型随意,相当于下标】,元素)
            map.put(1, "你好1");
            map.put(2, "你好2");
            map.put(3, "你好3");
            map.put(4, "你好4");
            System.out.println(map.get(1));
            System.out.println(map.size());
            //containsKey()  集合中是否包含相应的key值
            System.out.println(map.containsKey(1));
            System.out.println(map.containsValue("你好1"));
    }
    }
    

    泛型

    public class Demo6 {
    public static void main(String[] args) {
    // 泛型  :类型参数化<>遍历更方便了:强行规定集合只存某种类型的数据
    List<String> list = new ArrayList<>();
    list.add("sds");
    List<Integer> list2 = new ArrayList<>();
    list2.add(122);
    List<Stedent> list3 = new ArrayList<>();
    list3.add(new Stedent(1,"545"));
    Set<Integer> set = new HashSet<>();
    set.add(253);
    Map<String, String> map = new HashMap<>();
    map.put("dd", "aaa");
    Map<String, Stedent> map1 = new HashMap<>();
    map1.put("Java1", new Stedent(1,"545"));
    Map<String, List<Stedent>> map2 = new HashMap<>();
    }
    }
    

    遍历List

    public class Demo7 {
    public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("e");
    //1不推荐
    // for(int i =0;i< list.size();i++) {
    // System.out.println(list.get(i));
    // }
    //2.迭代器遍历----专门遍历
    Iterator iter = list.iterator();
    while(iter.hasNext()) {//hasNext()若游标右侧有元素,则返回true
    String str =(String)iter.next();//iter.next()取出游标右侧的元素,并且向右边移动
    System.out.print(str+" ");
    }
    //3.推荐
    for(String a: list) {
    System.out.println(a);
    }
    }
    }
    HashSet遍历
    public class Demo8 {
    public static void main(String[] args){
    Set<String> set =new HashSet<>();
    set.add("A");
    set.add("B");
    set.add("C");
    set.add("D");
    // 1.foreach
    for(String str: set){
    System.out.println(str);
    }
    // 2.迭代器接口 -- 专门用来遍历的
    Iterator iter =set.iterator();
    while(iter.hasNext()) {// iter.hasNext() 若游标右侧有元素,则返回true
    String str = (String)iter.next();//iter.next()取出游标右侧的元素,并将游标向右移动一位
    System.out.println(str);
      }
        }
    }
    

    HashMap遍历

    public class Demo9 {
    public static void main(String[] args) {
    Map<String, String>map = new HashMap<>();
    map.put("java1","好" );
    map.put("java2","很好" );
    map.put("java3","非常好" );
    map.put("java4","最好好" );
    //1.迭代器
    //keySet()返回map中Key值的Set集合
    // Set<String>set = map.keySet();
    //遍历key
    // Iterator<String>  iter = set.iterator();
    // while (iter.hasNext()) {
    // String key  = iter.next();
    // System.out.println(key+" "+map.get(key));
    //
    // }
    //2.加强遍历
    // for(String key :map.keySet()) {
    // System.out.println(key +" "+map.get(key));
    // }
    // Entry 遍历
    //   EntryshiMap接口中的内部接口
    // map.entrySet()把map集合中每一组建值对都封装成一个Entry类型的对象存入了一个集合
    for(Entry<String, String> entry: map.entrySet()) {
    System.out.println(entry.getKey()+","+entry.getValue());
    }
    }
    }
    

    相关文章

      网友评论

          本文标题:2019-03-15集合

          本文链接:https://www.haomeiwen.com/subject/avzkgqtx.html