JAVA中的集合

集合：储存多个同类型的元素

一.Collection接口

常用的方法：

                   boolean add(E e);         //新增

                   boolean isEmpty();         //是否集合是否为空

                   boolean contains(E e);    //是否包含某个元素

                   boolean remove(E e);     //删除某个元素

                         void clear();        //清除

                          int size()；        //获取元素个数

       Collection<String> c = new ArrayList<>();
       //增加元素是否成功
       boolean b= c.add("张三");
       System.out.println(b); //true
       //删除元素
       boolean o =c.remove("张三");
       System.out.println(o);  //true
       //判断集合有没有元素,有元素false，没有元素true
       boolean v = c.isEmpty();
       System.out.println(v);  //true
       //是否包含某个元素
       v = c.contains("张三");
       System.out.println(v);  //false
       //获取集合中的元素个数
       int n = c.size();
       System.out.println(n); //0
       //清除集合中元素
         c.clear();
       System.out.println(c); //[]

Iterator迭代器

注意事项：

      通过迭代器遍历集合的失败，不能通过集合对象增删元素

      如果删除可以通过迭代器删除方法删除

方法：

     1.获取迭代器对象

          Iterator<E> 变量名= 集合对象.iterator( );

    2.判断是否有元素

            boolean   hasNext( );   //有为true,没有为false

   3.获取下一个元素

             E   next( );

    4.获取谁删除谁

        void  remove( );

     Collection<String> c = new ArrayList<>();
      c.add("张三");
      c.add("李四");
      c.add("王麻子");
      c.add("王柳");
      c.add("小明");
      
      //获取迭代器对象
      Iterator<String> b = c.iterator();
      //获取下一个元素
      String name = b.next();
      System.out.println(name); //张三
      //判断是否有元素,有为true,没有为false
      boolean v = b.hasNext();
      System.out.println(v); //true
      //删除元素
      b.remove();
      System.out.println(c); //[李四, 王麻子, 王柳, 小明]

** 使用迭代器遍历集合操作：**

      Collection<String> c = new ArrayList<>();
      c.add("张三");
      c.add("李四");
      c.add("王麻子");
      c.add("王柳");
      c.add("小明");
      
      //获取迭代器对象
      Iterator<String> b = c.iterator();
      while(b.hasNext()) {
          String name = b.next();
          System.out.println(name);  //张三 李四 王麻子 王柳 小明
      }

增强for循环：

                     ** 遍历集合的时候，底层就是迭代器**

格式：

      for  (数据类型 变量名 ：集合名){

               //数据类型：集合的泛型

              }

      Collection<String> c = new ArrayList<>();
      c.add("张三");
      c.add("李四");
      c.add("王麻子");
      c.add("王柳");
      c.add("小明");  
      
      //增强for循环遍历集合
      for (String name : c) {
        System.out.println(name);  // 张三 李四 王麻子 王柳 小明
    }

二. List集合：

** 特点：**有索引值，可以重复，有序的

常用方法：

        void add( int index, E e)

; //给指定索引值位置添加元素

        E get(int index)

; //获取index位置的元素。

        E remove(int index);

  //移除index位置的元素, 返回的是否被删除的元素。

        E set(int index, E e);

 //index位置元素替换

          List<E>  subList (int beginIndex , int enIndex);  //左闭右开取值

          int  indexOf (object o);   //返回第一次出现索引值位置，参数传入要找的元素

          int   lastIndexOf (object o);   //最后一次出现的索引值位置，如果该元素不存在则返回 -1

    //创建list集合对象
    List<String> list =new  ArrayList<>();
    //添加元素
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    
    
    //根据索引值，添加新元素
    list.add(0, "eeee");
    System.out.println(list); //[eeee, aaa, bbb, ccc, ddd]
    //删除元素，根据索引值
    String remove=list.remove(0);
    System.out.println("被删除元素是"+remove);  //eeee
    System.out.println(list); //[aaa, bbb, ccc, ddd]
    
    
    //根据索引值，获取集合中对应的元素
    String b = list.get(0);
    System.out.println(b); // aaa
    //把索引值对应元素替换
    String n =list.set(0, "hhhh");
    System.out.println("被替换的元素是："+n); //aaa
    System.out.println(list);  //[hhhh, bbb, ccc, ddd]
    //根据索引值从开始到结束的值（左闭右开）
    List<String> list2 =list.subList(1,3);
    System.out.println(list2);  //[bbb, ccc]

三. ArrayList集合

**概况： **底层是数组

特点： 查询快，增删慢

所属包： java.util

构造方法： public ArrayList();

**成员方法： **

** **boolean add(E e); //返回新增是否成功

             E    get(  int  index);         //

             E   remove( int  index);   //根据索引值删除元素，返回被删除元素

             boolean remove( object  obj);   //参数中传入要被删除的元素，删除是否成功

             int   size (  );        //获取元素个数

             int  indexOf( object  obj);  //返回第一次出现索引值位置，参数传入要找的元素

             int lastIndexOf( object obj);  //最后一次出现的索引值位置，如果该元素不存在则返回 -1

             boolean contains(object obj);  //是否包含某个元素 

             E set (int index , E e);  //把参数index位置元素替换为参数e,则返回被替换元素

    //创建ArrayList集合对象
    ArrayList<String> array = new ArrayList<>();
    //添加元素
    array.add("小王");
    array.add("小明");
    array.add("小红");
    array.add("小花");
    array.add("小花");
    array.add("小明");
    
    
    //根据索引值获取元素
    String name = array.get(0);
    System.out.println(name);//小王
    //根据索引值删除元素
    name =array.remove(1);
    System.out.println(name); //小明
    
    
    //参数中传入要删除元素，是否删除成功
    boolean c = array.remove("小王");
    System.out.println(c);//true
    //获取集合中元素个数
    int a = array.size();
    System.out.println(a); //2
    
    
    //判断是否包含牧歌元素
    c = array.contains("小明");
    System.out.println(c); //false
    //把参数位置元素替换成别
    String s = array.set(0, "张三");
    System.out.println("被替换的元素是："+s); //被替换的元素是：小红
    //返回第一次出现索引值位置
    a=array.indexOf("小花");
    System.out.println(a); //小花第一次出现的索引值位置
    //返回最后一次出现索引值位置
    a=array.lastIndexOf("小花");
    System.out.println(a); //小花最后一次出现的索引值位置

四. LinkedList

概括： 底层是双向链表

** 特点：** 查询慢，增删快

常用方法：

             void addFirst(E e) ;       //将指定元素插入此列表的开头。 

             void addLast(E e) ;      //将指定元素添加到此列表的结尾。 

             E  getFirst(  ) ;              //返回此列表的第一个元素。 

             E  getLast(  ) ;              //返回此列表的最后一个元素。 

             E  removeFirst( ) ;        //移除并返回此列表的第一个元素。  

             E removeLast( ) ;         //移除并返回此列表的最后一个元素。 

     //创建LinkedList集合对象
    LinkedList<String> linked = new LinkedList<>();
    linked.add("aaa");
    linked.add("bbb");
    linked.add("ccc");
    linked.add("ddd");
    
    //将指定元素插入此列表的开头
    linked.addFirst("张三");
    System.out.println(linked);//[张三, aaa, bbb, ccc, ddd]
    //将指定元素添加到此列表的结尾。
    linked.addLast("李四");
    System.out.println(linked);//[张三, aaa, bbb, ccc, ddd, 李四]
    
    
    //返回此列表的第一个元素。
    String me =linked.getFirst();
    System.out.println(me); //张三
    //返回此列表的最后一个元素
    me=linked.getLast();
    System.out.println(me);//李四
    
    
    //移除并返回此列表的第一个元素
    String name = linked.removeFirst();
    System.out.println(name);//张三
    //移除并返回此列表的最后一个元素
    name=linked.removeLast();
    System.out.println(name);//李四

五：Vector集合

       **            Vector集合:  **  效率低，线程安全

                **  ArrayList集合:**     线程不安全，效率高

六.Set集合

       **  特点：**    没有索引值，不能重复

Set新增过程：

   1.计算新增元素的哈希值(十进制的地址值)，调用H安世凑得();

   2.通过哈希值%数组长度，去确定元素新增的索引值

       如果该位置有元素：判断这两元素是否相同

               如果不相同：挂到最后一个元素下面

                如果相同：不新增

  判断是否相同的标准：

           比较哈希值相同 && （地址值相同 || equals相同）

总结： 如果自定义类型对象，我们希望添加到HashSet集合中

             我们认为成员变量的值相同，就同一个元素

             则需要覆盖重写hashcode和equals方法

常用实现类：

**1.HashSet：   **所存储的元素是不可重复的，并且元素都是无序的(即存取顺序 不一致)

** 2.LinkedHashset: **有序，结构：链表+哈希表

**3.TreeSet:           **红黑树（可排序 ）

             **构造方法：**

                                   public  TreeSet ( );

                                    public TreeSet (c omparator < >  c)

七.Collections类

    集合工具类方法：

                       static <T> boolean addAll (Collections <T> c, T......array);

                        //用于所有指定元素添加到指定的集合

                        static  viod  shuffle(List <T>  list);   //将List中的内容随机打乱顺序

                        static  <T> extends Comparaable<T>  void sort(List <T>  list);   

                        // 对象进行排序,覆盖重写Comparator接口的compare方法

                        static  <T> void sort (List<T> list,comparator <T>   c);

                         //对象进行排序，那么该类需要实现Comparable接口覆盖重写compartor()方法

​
        List<String> list = new ArrayList<>();
        //用于所有指定元素添加到指定的集合
        Collections.addAll(list, "aaa","bbb","ccc","ddd");
        System.out.println(list); //[aaa, bbb, ccc, ddd]
        //将List中的内容随机打乱顺序
        Collections.shuffle(list);
        System.out.println(list);//[ddd, ccc, aaa, bbb]

​

八.Map集合

** 特点：**

             1.  一个元素key和value两部分

              2.key和value可以是任意类型

              3.key不能重复(底层是Set集合),一个key对应一个唯一的value

常用实现类：

HashMap: 底层是哈希表，无序

LinkeddHashMap: 底层是链表+哈希表，有序

TreeMap: 底层是红黑树，可排序

** 常用的方法：**

       v put(k k,v v);  //添加元素

       v remove(Object key):   //按照指定的Key删除整个元素

       void clear:    //清空

       v  get(Object key):     //获取指定key的value值。若无此key，则返回null。 

       boolean containsKey(object  key);

        boolean containsValue(object  value);

        int size(); //获取元素个数

        boolean  isEmpty( );  //判断集合是否为空

     //创建Map集合对象
     Map<String,Integer>  map = new HashMap<>();
     //添加元素
     map.put("张三", 25);
     map.put("李四", 30);
     map.put("小明", 50);
     map.put("小花", 19);
     System.out.println(map);//{李四=30, 张三=25, 小明=50, 小花=19}
     
     
     //获取元素个数
     int size = map.size();
     System.out.println(size);//4
     //删除某个元素,根据key删除整个元素,返回是Value值
     Integer v = map.remove("张三");
     System.out.println(map); //{李四=30, 小明=50, 小花=19}
     //根据key值,获取value的值
     v = map.get("李四");
     System.out.println(v); //30
    
    
     //判断key值是否此存在
     boolean c = map.containsKey("李四");
     System.out.println(c);//true
     //判断value值是否存在
     c = map.containsValue(50);
     System.out.println(c); //true
     
     
     //判断集合是否为空
     c = map.isEmpty();
     System.out.println(c);//false
     //清空元素
     map.clear();
     System.out.println(map);//{}

Set <K> keyset( ); //获取所有k值

Collection<V> values ( ); //获取所有value值

    //创建Map集合对象
    Map<String,Integer>  map = new HashMap<>();
     //添加元素
     map.put("张三", 25);
     map.put("李四", 30);
     map.put("小明", 50);
     map.put("小花", 19);
     
     //获取所有K值
    Set<String> a=map.keySet();
    System.out.println(a);//[李四, 张三, 小明, 小花]
    //获取所V的值
    Collection c =map.values();
    System.out.println(c);//[25，30，50，19]