java容器

Collection容器

所有容器的父接口     

容器可以存储任意类型的数据 内部存储的是地址

容器只能存储引用数据类型的数据(数据需要通过自动装箱实现)

Collection的子接口包括List接口和set接口

格式

       Collection 引用= new 子容器()

方法

       迭代iterator()                          获取迭代器

增   add(Object)                       增加指定元素

       addAll(Collection)             将子容器的内容全部加入

删   remove(Object)                 移除指定元素,只移除存储位置最前的一个

       removeAll(Collection)        将子容器的内容移除

       clear()                                清空容器

       retain(Collection)               获取交集return交集的容器

查   contain(Object)                 查找单个元素

       containAll(Collection)        查找子容器

       size()                                 查找长度

判断isEmpty()                          判断是否为空

       equals(Collection)             比较

转换toArray()                          转换为数组

遍历

       增强for|for…each

              For(元素类型 引用: 容器){操作 }

              迭代器

范型

              在定义容器和迭代器时添加<>类型标签

              Collectin<范型> 引用=new 子容器<范型>()

              Iterator<范型> 引用=容器.iterator()

迭代器

       Iterator迭代器接口

       定义获取

              Iterator 引用=容器.iterator()

       方法

              hasNext()     判断是否有下一个

              next()           获取下一个元素

       能够通过迭代器进行遍历

      

Collection<String> coll=new ArrayList();     coll.add("张三");     coll.add("李四");     coll.add("王五"); Iterator<String> it=coll.iterator();         //定义迭代器,指定范型    while(it.hasNext()){                        //循环遍历        System.out.println(it.next());     }

List接口

       特点       有序可重复   ArraysList LinkedList Vector

       格式

              List 引用=new 子容器();

       方法       根据索引的增删查改

       增   add(int,Object)                 增加元素并指定插入索引,原元素索引后移

              addAll(int,Collection)        增加子容器内容

删   remove(int)                       删去原位置的元素 原元素索引前移

set(int,Object)                   替换元素

查   get(int)                              获取索引出的元素

              indexOf(Object)                查询元素的首次索引,若无返回-1

              lastIndexOf(Object)          查询元素的末次索引

       截取sublist(int fromindex,int lastIndex) 根据索引获取子容器

       迭代listIterator()                      获取list迭代器

              listIterator(int)                  获取list迭代器,并指定起始索引

       遍历

              普通For循环       指定索引进行操作

              增强For循环       指定引用,需要注意范型的设置,否则需要类型强转

              普通迭代遍历      不能同时进行增删改操作,会导致对象并发异常

              List迭代遍历       通过listIterator执行操作  避免并发异常

              注意:

                     在对自定义类比较时需要,对自定义类预先重写equals方法,避免地址比较

                     或者可以指定使用Comparator接口的重写定义compare方法

       List迭代遍历

              定义       ListIterator<范型> 引用 = list容器.listInterator<范型>()

              方法

                     hasNext()            判断是否有下一个

                     next()                  获取下一个元素

                     nextIndex()         获取下一元素的索引

add(Object)         插入增加,在隐式光标之前插入

set(Object)          元素替换前一next或previous的元素

hasPrevious()      判断逆向元素是否存在

previous()           逆向获取逆向元素

previousIndex()   获取逆向元素的索引

       ArrayList

特性      

       底层       采用数组(可变数组)

                     优点       查询,随机获取效率高         缺点       增删效率低

                     动态扩容       采用Arrays.copyof()进行拼接扩容,每次扩容1.5倍

                                          首次扩容为10容量,加载因子为1一般为(0-1)

                     线程       单线程,线程不安全

                     方法       与list基本一致

                     构造器   能够空构造创建,初始容量null

能够根据指定容器创建,

能够根据指定值容量创建

       Vector

              采用同步线程,线程安全,但是效率低 单次扩容2倍

底层与使用与ArrayList基本一致

       LinkedList

              底层特性       双向链表

              优点              增删效率高

              缺点              查询和随机获取效率低

              新增方法 涉及链表头和链表尾的操作

                     AddFrist()      AddLast()       getFirst() getLast()

                     offer(Object)  offerFirst(Object)  offerLast(Object)   首位插入

                     descendingIterator()逆向迭代器

                     element()      peek()     peekFirst()     peekLast()      获取表头和表尾(不移除)

                     poll()      pollFirst()       pollLast()       获取表头和表尾(移除)

                     removeFirst() removeLast()                移除表头和表尾

                     removeFirstOccurrence(Object o)      移除首次出现的元素

                     removeLastOccurrence(Object o)      移除末次出现的元素

              链表特性

                     数据构成节点(Node)  节点存有数据和地址  

                     单向链表       关注链表头   地址指向下一节点      链表尾地址为null

                     双向链表       关注链表头和链表尾   两个地址指向上下节点,若无内null

 

Set接口

无序不可重复,只能有一个null

功能与collecting一致,遍历采用增强for或迭代器

存放无序       存储完成后存储顺序一致

HashSet            底层为HashMap

       结构       HashSet <范型> 引用=new HashSet实现类();

                     HashSet <范型> 引用=new HashSet实现类(外部比较器);

       底层结构       哈希表存储结构(数组+链表+红黑树)

       优点 查询,增加,删除效率高       缺点 无序

       扩容 容量默认初始为16,加载因子0.75 扩容2倍

       存储逻辑

              1对元素数据执行hashCode()计算所存储的数组位置  数组中存有桶

              2将存入的数据与桶内的数据equals()比较是否相同,再以链表形式存入桶中

              3桶中数据超过8个再以红黑树结构存储

      

机制说明: hashCode()不相同的对象肯定不相同,过滤掉一写不相同的对象,不需要进一步比较equals方法效率较高

自定义类对象的存储去重处理

       1重写自定义类的hashCode和equals

       2自定义类设置内部比较器并重写hashCode方法

3容器接入外部比较器(推荐)

原因       针对需要内容判断的存储对象,需要重写equals方法,进一步地,如果不重写hashCode(),可能将相同的存储对象放入不同桶中导致不会执行equals方法而直接存放.

TreeSet

       结构       TreeSet<范型> 引用=new TreeSet实现类();

                     TreeSet <范型> 引用=new TreeSet实现类(外部比较器);

底层结构       红黑树

优点 默认升序排序            缺点 效率低

排序查找过程中

       优先执行外部比较器

       若没有外部比较器

默认类型的类(String等)都预设了比较器,调用了现有的compareTo方法

自定义类需要自行设置内部比较器,否则会报错

比较器

       针对需要进行比较存入的容器

外部比较器(不需要对自定义类的源代码处理)

实现了Comparator接口    外部比较器|自定义比较器|自定义排序

       重写了compare()方法

内部比较器(需要对自定义类的源代码进行接口实现)

实现了Comparable接口    内部比较器|自然排序 

重写compareTo()方法,方法中自定义比较规则

 

外部比较器的实现

       1获取自定义类的源代码    获取类名和需要进行判断的属性

       2根据原代码撰写外部比较器

pubic class比较器名 implements Comparator<范型>{  //范型选择时所需的自定义类         public int compare(自定义类的对象引用1,引用2){                        //具体的比较内容     注意比较结果为int类型               return 比较结果;              结果为+则前者较大,结果为-前者较小 }                                   结果为0两者相同 }

       3套接使用

       目前可以使用在Set实现类的容器中,通过容器的构造使用

       使用时可以采用创建对象的方式和匿名对象的方式实现

以TreeSet为例

       创建对象       TreeSet ts =new TreeSet(new 外部比较器名());

       匿名类          TreeSet ts =new TreeSet(new Comparator () {重写方法内容} );

外部比较器的实现可以采用lanmada表达式直接实现

       TreeSet ts =new TreeSet((自定义类的对象引用1,引用2)->{重写的方法体} )

 

 

内部比较器的实现

       直接对自定义类的源代码修改

       接口实现Comparable        内部加入compareTo()的方法

//实现接口Comparable public class Person implements Comparable<Person>{      private int age; //重写compareTo方法     public int compareTo(Person o){ //重写指定想要比较的返回值   返回int值,+为当前大,-为当前小,0两者相同        return o.age-this.age;                                } }

来源：https://www.cnblogs.com/javaxiaobu/p/11020810.html