Java------集合/容器

容器----数组

       数组的特点：

           一组数组类型相同的元素集合

           创建数组时，必须给定长度，而且一旦创建长度不能变。

           一旦数组元素装满，需要创建新的数组，将元素复制过去

       不方便：copyof  ----- 需要自己判断数组是否装满，如果装满，数组复制过去

       

      Java中为了解决数据存储单一的情况。

      Java中提供了许多不同结构的集合类，让我们可以根据不同的场景进行数据存储的选择

      

      

单列集合

                   一次放进去一个值（对象）

                   conllection接口，定义了单列集合共有的方法

                            List  可以重复数据对象（有序的） 

                            Set  不可以重复数据对象

List接口

         ArrayList  数组列表

                  底层有一个数组，可以动态扩展数组长度，并提供一系列方法操作

                  查询快

                  中间删除，增加速度慢 

                  可以添加Object类型的数据，但是一般还是习惯一个集合对象中只保存同一种类型                                                                 （因为保存多个类型，后期处理时，涉及到类型转换问题）

                  泛型：我们在声明类型时，自定义参数类型。     <  s >-----泛型 

            ArrayList<String> arr = new ArrayList();  这个中就只可以存储String类型的数据

                  arr.add（E e）   默认在数组的末尾添加数据   

                  数组扩容，扩容到原来的1.5倍       

                 int newCapacity = oldCapacity + (oldCapacity >> 1);

                 向右移一位，就等于/2.

                  arr.add( 5 ,e)   向指定的位置添加元素   只能在size的范围内添加

                  arr.remove("e")  指定删除元素

                  arr.remove(1)     指定删除位置上的元素     

                  这二个删除同样可以返回一个Boolean值 

                  arr.get（）  获取指定位置上的元素

                  arr.set（ 1，“e”） 将原来位置上的元素给覆盖了  并返回原来位置上的元素 

                  arr.size()    返回数组中元素的个数

         LinkedList 链表列表

                   底层是一个链表结构

                   查询慢

                   增加，删除速度快 

                   arr.add()  //像链表末尾添加元素

                   arr.add(5,"a") //向链表指定位置添加元素 

                   arr.remove()  //删除数组中第一个元素，并返回一个元素

                   add(int index,Object element)

                   addFirist(Object element)

                   addLast(Object element)

                   get(int index)

                   removeFirst() 

                   removeLast()

                   remove(int index)

                   getFirst()

                   getLast()

                   等等，与上面好多方法都是一样的  只是这二种的存储方式不同

     vector数组列表

               线程安全，方法上面时带锁的  其他的都和上面的一样

     List接口实现类

 for循环的遍历 

             这中遍历允许我们对元素进行操作  （如果操作，注意索引的变化，避免元素缺漏）

        for (int i = 0; i < fff.size(); i++) {
            System.out.println(fff.get(i));
        }

 增强for循环   

            在遍历的同时不可以删除元素，添加元素（对元素不能操作）

        for (String s:fff) {
            System.out.println(s);
        }

 迭代器

 Iterator迭代器      

      迭代器中可以对数组进行操作，可以删除元素和添加元素

      迭代器是一个接口，接口所有都是抽象的，所以方法也就定义在子类（ArrysList）中

             //迭代器首先要被创建对象
       Iterator<String> it = fff.iterator();
            //迭代器中确定数组是否遍历完全的方法
             it.hasNext()  //这个中有一个计数器一直和数组长度进行比较
            //基层代码
                public boolean hasNext() {
            return cursor != size;//这里随时都会返回一个布尔值
        }

ListIterator迭代器

        只能对List接口下的实现类遍历

        ListIterator（intde x） 可以从指定位置上开始遍历，可以向前遍历也可以向后遍历

       这个迭代器继承了上一个的方法，但是它可以从指定位置开始遍历

对单列集合的简单理解

        

双列集合

Hashset

HashSet的特点包括：

1. 元素无序：元素在HashSet中的存储顺序与插入顺序无关。
2. 元素唯一：HashSet中不允许重复元素，如果插入重复元素，后续的插入操作会被忽略。
3. 允许null元素：HashSet中可以存储null元素。
4. 非线程安全：HashSet不是线程安全的，如果多个线程同时访问一个HashSet实例，且至少有一个线程修改了HashSet的结构，那么必须通过外部同步来保证线程安全

在使用HashSet时，通常需要注意：

1. 确保元素的hashCode()和equals()方法正确实现，以保证HashSet能正确判断元素是否重复。

Treeset

            特点：  无重复元素 ----  可以排序  通过Comparable接口，重写compareTo（）判断大小                                                                        以及是否有重复

                         可以根据值进行排序（有序）   底层使用了树形结构，树结构本身就是有序的

                         向树形结构中添加元素时，如何判断元素大小以及元素是否重复

                                 向TreeSet中添加的元素类型必须实现Comparable接口，重写compareTo（）

                                 每次添加元素时，调用compareTo（）进行元素大小的判断（小于0放左边，                                   等于0表示重复，大于0放在右边节点）

Map接口

            数据存储是 键：值 形式的存储

            键不可以重复，值可以重复

            一个键只能映射到一个值

 HashMap     

            键是无序的   

                 通过HashCode和equals 方法判断元素是否重复

              map.put(K key,V value)    一个键  映射一个值   键不重复  内容可以相同

              map.remove(Object key)   删除键值，返回键中的内容

              map.isEmpty()            判断map中键值对的个数是否为空  

              map.containsKey(Object key)   判断是否有这个键

              map.containsValue(Object value)   判断每个键中是否有个内容

              map.get（）   这里拿去的是键  通过键  来映射内容

              map.values()    拿去所有元素，放到一个单列集合中

遍历

方式1：先拿到所有的键   遍历键   根据键找值

强制for循环

        Set<String> keySet = map.keySet();
        for (String key:keySet ){
            System.out.println(key+":"+map.get(key));
        }

方式2：推荐的遍历方式

          里面有个以mapEnty类型就相当于给数据还有一个备份。直接拿去，不用一一查找

          个人理解：EntrySet就是将map中所有的元素拿出来放在一个集合中，我们可以直接查去

            

    Set<Map.Entry<String, String>> entries = map.entrySet();
    for(Map.Entry entry : entries){
        System.out.println(entry.getKey()+":"+entry.getValue());
    }

HashMap底层存储数据结构：

                哈希表（数组）

                链表

                红黑树

TreeMap

    底层是一个树形结构

    键可以排序   

    键元素类型必须实现Comparable接口，重写comparable

    适用于按自然顺序或自定义顺序遍历键(key) 

    拥有的方法和其他的都一样

    和HashMap的区别就是键可以排序 

Hashtable

Hashtable与HashMap的区别

  Hashtable的方法都添加了synchronized锁  

  Hashtable中不可以存储为null的键和null的值

  HashMap中可以存储一个为null的键（哈希值为0）也可以存储为null的值

Collections类

addAl l(Col lection c, T... elements);   将一段数组，添加到集合中

        Collections.addAll(arr,2,3,4,5,6);

binarySearch(List> l ist, T key)  二分查找

sort(List l ist)   排序  升序

sort(List l ist, Comparator c)  排序   后面的是可以指定一个排序规则

例如：降序

        Collections.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.intValue()-o1.intValue();
            }
        });

swap(List l ist, int i, int j)    交换指定位置的元素

copy(List dest, List src) ;     集合复制，将原集合复制到目标集合   注意 dest size需大于等于src.siz 

fi l l(List l ist, T obj)  用指定的值，替换到集合中所有的元素

shuffle(List l ist) 随机排序

reverse(List l ist)   逆序