集合

一,集合

  1. 集合的概述

    1),什么是集合,有什么用

    数组其实就是一个集合,集合实际上就是一个容器。可以用来容纳其它数据类型的数据。集合为什么说在开发中用的最多?

    集合是一个容器是一个载体,可以一次容纳多个对象。在实际开发中,假设连接数据库,数据库当中有十条记录,那么假设把这十条记录查询出来,在JAVA程序中会将十条数据封装成10个JAVA对象,然后将10个java对象放到某一集合当中,将集合传到前端,然后遍历集合,将一个数据一个数据展示出来。

    2),集合不能直接存储基本数据类型,另外集合也不能直接存储java对象,集合当中存储的都是java对象的内存地址。 注:集合在java中本身就是一个容器,是一个对象

     3),在java中每一个不同的集合,底层会对应不同的数据结构,往不同的集合中存储元素,等于将数据放到不同的数据结构当中。什么是数据结构? 数据存储的结构就是数据结构,不同的数据结构,数据的存储方式不同.

       例如:数组     二叉树    链表    哈希表

    4),集合在java  JDK  中哪个包下?  java.util 包下

      5),在JAVA 中集合分为两大类

      一类是单个方式存储元素:这一类集合中超级父接口:JAVA.util.Collection

      一类是以键值对的方式存储元素:超级父接口:JAVA.util.Map   

  2. 集合体系图 

     

 

       

        

     总结一(所有实现类):

        1. ArrayList: 底层是数组

        2.LinkedList:  底层是双向链表

        3. Vector: 底层是数组,线程是安全的,效率就低,使用较少

        4. HashSet: 底层是HashMap,放到HashSet中的元素等同于放到了HashMap集合Key部分

        5. TreeSet : 底层是TreeMap ,放到TreeSet中的元素等同于放到了TreeMap集合key部分

        6. HashMap :底层是哈希表

        7.Hashtable: 底层是哈希表,只不过线程安全,效率低  使用少

        8.Properties: 线程安全,并且key和value只能存储字符串String 

        9. TreeMap: 底层是二叉树,TreeMap集合中key可以自动按照大小顺序排序

 

    总结二 (List     , Set     ,  SortedSet)

        1. list 集合存储元素的特点:

          1》 有序 可重复

          2》 有序: 存进去的顺序和取出来的顺序相同,每一个元素都有下标

          3》可重复: 存进去1,可以再存储一个1

        2.Set 集合存储元素的特点

          1》 无序 不可重复

          2》无序:存进去的顺序和取出来的顺序不一定相同,另外Set集合中元素没有下标

          3》不可重复:存进去1,不能再存储1

        3.SortedSet集合存储元素特点

          首先是无序不可重复的,但是SortedSet集合中元素是可排序的

          可排序:可以按照大小顺序排序

        4. Map集合中key,就是一个Set集合

          在set集合中放数据,实际上放到了Map集合中的key部分

 

二,Collection接口

  1,Collection中能存放什么元素?

    没有使用泛型之前,Collection中可以存储Object所有子类行,使用泛型之后,Collection中只能存储某个具体的类型。Collection中什么都能存,只要是Object的子类型就行

    (集合中不能存储基本数据类型,也不能存java对象,只是存储java对象的内存地址)

  2,Collection中常用的方法

    1)  boolean  add(Object o)        向集合中添加元素       举例:c.add("hello");   "hello"对象内存地址放到集合中

    2)int    size()                           获取集合中元素的个数

    3) void  clear ()                      清空集合

    4)boolean  contains(Object o )  判断当前元素是否包含a,包含返回true   不包含返回false

    5)  boolean   remove(Object  o)  删除集合中某个元素

    6)boolean  isEmply();        判断元素个数是否为0

    7)Object[]    toArray()      调用这个方法可以把集合转换成数组

    

public class Collection01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("abc");
        c.add("def");
        c.add(123);
        System.out.println(c.size());            //3
        System.out.println(c.isEmpty());         //false
        System.out.println(c.remove(123));    //true
        System.out.println(c.contains("def"));   //true
        Object[] obj = c.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);       //abc   def
        }
        c.clear();
    }
}

   3,关于集合遍历/迭代专题

     是所有Collection 通用的一种方式,在Map集合中不能用,所有Collection及其子类使用

     1)创建集合对象

     2)添加元素

     对集合Collection 进行遍历/迭代

      第一步:获取集合对象的迭代器对象 Iterator   it  =  c.iterator();

      第二部:通过以上获取的迭代器对象开始迭代遍历集合

        boolean   hasNext()  如果仍有元素可以迭代,则返回true

        object    next()          返回迭代的下一个元素

      

public class Collection02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(123);   //Integer i = new Integer(123);
        c.add("hello");
        c.add("456");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            System.out.println(next);
        }
    }
}

 

 

 

 

 

三, List  接口(有序可重复)

  1,接口中 常用的方法

     1》void add(int  index, Object  element)          通过下标插入添加元素

     2》Object   get(int   index)                               查找元素

          因为有下标 ,所以List集合 有自己特殊的遍历方式 【list集合有,Set没有】

                for (int i = 0; i <list.size(); i++) {

             Object o = list.get(i);
System.out.println(o);}
     3》int indexOf( Object o) ; 获取指定对象第一次出现的索引
     4》 int lastIndexOf (Object o ) : 获取最后一次出现的索引
   增删改查的几个单词:
    增: delete ,save
    删: delete, drop, remove
    改: update, set, modify
    查: find , get , query , select

         2. ArrayList

      ArrayList集合初始化容量是10,底层是Object 类型的数组 Object[]  

     ArrayList 集合的扩容:    原容量的1.5倍,  Arraylist集合底层是数组,怎么优化

     尽可能的少扩容,因为数组扩容效率比较低,建议在使用ArrayList集合的时候预估计元素的个数,给定一个初始化容量

    

public class List01 {
    public static void main(String[] args) {
        
        List  list = new ArrayList();    //默认初始化为10
        List  list1 = new ArrayList(100);  //指定初始化为100
        Collection c = new HashSet();   //创建一个HashSet集合
        c.add(100);
        c.add(200);
        c.add(50);
        ArrayList arrayList = new ArrayList(c); //通过这个构造器方法就可以将HashSet集合转换成List集合
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
    }
}

   3,链表和数组的优缺点

      1)链表

          优点:由于链表上的元素在空间存储上内存地址不连续,所以随机增删元素的时候不会有大量元素位移,因此随机增删效率较高。在以后的开发中,如果遇到随机增删集合中元素的业务较多时,建议使用Linkedlist.

          缺点:不能通过数学表达式计算被查找内存的元素地址,每一次查找都是从头节点开始遍历,直到找到为止。所以Linkedlist集合检索/查找的效率较低。

      ArrayList:把检索发挥到极致

      LinkedList:  把随机增删发挥到极致

      加元素都是往末尾添加,所以ArrayList用的比Linkedlist比较多  

      2)数组

       优点:检索效率比较高(每个元素占用空间大小相同,内存地址是连续的,知道首元素内存地址,然后知道下标,通过数学表达式计算出元素的内存地址,所以检索效率高 

       缺点: 随机增删元素效率较低,另外数组无法存储大数据量,向数组末尾添加元素,效率很高,不受影响

 四,Map集合(无序不可重复)

      Map集合以Key和Value的方式存储元素:键值对

        key和 value 都是引用数据类型

        key和value 都是存储对象的内存地址

        key起主导的地位, value是key的一个附属品

  1,java.util.Map接口中常用的方法

    1)put(key , vaule)   向Map集合中添加键值对

    2)get(Object   key)    通过key获取value

    3)  void   clear()            清空Map集合

    4)boolean    containskey( Object   key)               判断Map中是否包含了某个key

    5)boolean   containsValue(Object  value)            判断Map中是否包含了某个Value

    6) boolean  isEmpty()                                              判断Map集合中元素是否为0

    7)Set<key>  keySet()                                       获取Map集合中所有的key(所有的键是一个Set集合)

    8)remove(Object key)                                      通过Key删除键值对

    9)int  Size()                                                    获取Map集合中键值对的个数

    10)Collection<V>Values()                                获取Map集合中所有的value ,返回一个Collection

    11)Set<Map.Entry>entrySet()                           将Map转换成一个Set集合     

   2,遍历Map

      

public class Map01 {
    public static void main(String[] args) {
        //遍历Map ,获取所有的Key,通过遍历key 遍历value
        Map<Integer,String> map = new HashMap();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        Set<Integer> keySet = map.keySet(); //获取所有的key是一个Set集合
        Iterator<Integer> it = keySet.iterator();
//        while (it.hasNext()) {  //遍历key 通过key获取value
//            Integer key = it.next();
//            String value = map.get(key);
//            System.out.println(key  + "\t" + value);
//        }
        for (Integer key: keySet){
            System.out.println(key + map.get(key));
        }
    }
}
public class Map02 {
    public static void main(String[] args) {
        //Set<Map , Entry<k,v>> entrySet();
//        这种方法是把Map集合直接全部转换成Set集合,Set集合元素类型Map.Entry
        Map map = new HashMap();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> node = iterator.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key + value);
        }
    }
}

  3,哈希表数据结构

    1)HashMap集合底层是哈希表/ 散装表的数据结构

    2)哈希表是怎样的一种数据结构呢?

      哈希表是一个数组和单向链表的结合体

      数组:在查询方法效率较高,随机增删方面效率比较低

      单向链表:在随机增删方面效率较高,在查询方面效率较低

      哈希表将以上两种数据结构融合在一起,充分发挥了他们各自的优点

    3)放在HashMap集合key部分的元素,以及放在HashSet集合中的元素,需要同时重写hashCode和equals方法

    4)HashMap集合的默认初始值是16,默认加载因子是0.75,这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候,数组开始扩容

      注:HashMap集合初始化容量必须是2的倍数,这是官方推荐的,这是因为达到散列均匀,为了提高HashMap集合的存取效率,所以必须的

  4,注意要点

     1)HashMap集合Key部分允许null吗?

    允许,HashMap集合Key   null值只有一个,key重复的话,Value 会覆盖

    2)Hashtable的key可以为null吗?

     Hashtable的key和value 都是不能为null的

     HashMap集合的key和value都可以为null

    3)Hashtable方法都带有synchronized:   线程安全的

      线程安全有其它方案,这个Hashtable对线程的处理,导致效率低下,使用少

      Hashtable的初始化容量是11,默认加载因子是0.75个

      Hashtable的扩容是 :  原容量 *2 +1。     

    4)Properties 是一个Map集合,继承Hashtable,   properties的key和value 都是String 类型,被称为属性类对象,是线程安全的

        setProperties     存

        getProperties    取

    5)TreeSet集合底层实际上是一个TreeMap,      底层是一个二叉树, 放到TreeSet中的元素等同于放到TreeMap集合中的key部分。

      TreeSet集合中的元素:元素不可重复,但是可以按照元素的大小顺序自动排序,称为:可排序集合。

      

 

 

 

 

 

 

 

 

 

 

 

 

posted @ 2022-12-12 20:37  阿文程序猿  阅读(190)  评论(0)    收藏  举报