javase集合框架

  1. 1.集合中储存的对象的引用,不是对象本身
  2. 结合算法类:Collections:提供用来处理集合的大量静态方法(可以直接用Collections.静态方法()来使用),例如排序,乱序,反转,二分法查找等
    Collections.shuffle乱序
    Collections.sort 排序
    Collections.swap指定两点调换
    Collections.resever反转
    慢慢补充。。。
  3. Arrays类:对数组进行操作的算法类
    Arrays.sort()
    慢慢补充
  4. Comparable:这是一个按照自然顺序排序的接口,实现此接口的类就可以比较,使用Colletions.sort()和Arrays.sort()时元素的类型需要实现此接口,唯一的方法是:
int compareTo(T t);

    public class Student implements Comparable<Student>{
        //比较分数,分数相等时再比较姓名;
        @Override
        public int compareTo(Student o) {
            if(this.score==o.score) {
                return this.name.compareTo(o.getName());
            }
            return this.score-o.score;
        }
    }
  1. Comparator比较器:可以定义一个比较方法使比较更灵活
    Collection.sort(List,Comparator);
  2. Comparable 和Comparator的区别:Comparable按照自然顺序比较,Comparator按照自定义顺序比较;每个类只能使用一个Comparable使用方式,而能使用多个Comparator方式;Comparator的优先级较高
  3. List接口代表有序的可重复的集合,集合中每个元素都有其对应的顺序索引,可以通过索引来访问指定位置的元素集合,默认按照元素添加的顺序排序
    add(String);
    clear();
    remove(int)移除相应位置的元素
    removeAll()移除所有元素
    remove(String)移除第一次出现的该元素
    getItem(int);
  4. 泛型(数据类型参数化)
    安全检查;直接完成类型转化
    9.ArraysList类型动态数组,实现List接口,可以随时扩容,
    线程不安全Vector线程安全但是不经常使用
    boolean add(E)添加指定元素到此列表的尾部
    add(int,E)将指定元素添加到列表的指定位置
    addAll(Collection)按照Collection迭代器制定的
    indexof(String)返回首次出现词元素的索引,若不存在返回-1
    toArray()
    size()
    1. ArrayList源代码

重要属性:
elementData:用来存储数据的Object[]数组
size:元素的个数
构造方法
三个构造方法;
():空的数组
(int):固定长度
(Collection):与集合中元素个数相同的数组
重要方法
add():增加一个元素或多个元素,根据新增加的元素判断空间是否够用,如够不,不扩容,不够则采有两种算法扩容,
size+size>>1:即1.5倍
size+新增加元素的长度(如果增加的是多个元素时(Collection))

  1. 链表
    链表是数据结构中线性结构中的一种;
    链表中由多个存储在不同位置的节点(元素)组成,每个节点由三部分级成;
    数据
    前驱节点:上一个节点是谁 (引用)
    后继节点:下一个节点是谁(引用)
    源代码

源代码
内部类
private static class Node {
E item; //元素
Node next; //后一个节点
Node prev; //前一个节点

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}
重要属性:
    size:元素个数;
    first:指向头节点
    last:指向尾节点
构造方法;
    ():空链表
    (Collection):将集合中的数据取出存在链表中
方法:
    add():

创建一个新节点(前驱,后继,元素)
将上一个节点的next指向它;last指向它
get();
size/2后,判断从前向后找,还是从后向前找;


  1. 栈(Stack):
    特点:先进后出;FILO(first in last out)
    三个方法:
    push(数据):入栈
    pop():出栈(获取栈顶元素,并删除)
    peek():获得栈顶元素的引用,但不删除;

例题.比如说,入栈的顺序是 a b c ,以下哪个选择不可能是出栈的顺序
A a,b,c B c,b,a C b,a,c D
c,a,b

  1. 队列接口Queue
    队列;先进先出的集合,FIFO:first in first out;
    操作;
    offer():向队列尾部插入一个元素
    poll();从队列头部获得一个元素,并从队列中删除此元素
    peek():获得队列头部的元素;
  2. Deque双端队列
    实现类:
    ArrayDeque
    LinkedList
  3. set接口
    Set是Collection的子接口
    Set集合不允许添加相同的元素,否则添加不成功,判断两个对象相同使用equals
  4. HashSet是使用Set的常用接口,使用Hash算法储存元素便于查找和插入。
    **特点:不能保证元素顺序
    不是线程安全
    集合元素可以使用NULL
    **
    当向HashSet中存数据时,HashSet会调用HashCode()方法来得到对象的HashCode值然后根据HashCode值来决定对象在HashSet中的储存位置,如果两个元素的equals()返回为TRUE但是HashCode()不等,会把他们储存在不同位置,但是可以添加成功
    什么算是重复:Object类判断相等是根据equals(),相等对象必须有相等的哈希码
    HashSet中先判断hashCode,不相等则不判断equals()

List list=new ArrayList(set);可以转换为LIst
HashMap Node类型的数组,每个元素都是一个链表,长度是16,哈西冲突通过链表解决但是
equals不相等hashcode可能相等
5. Iterator:迭代器
作用:从集合(Collection)中遍历数据
操作步骤;
获得集合的迭代器 Iterator ite=set.iterator();
从迭代器取出每条数据
while(ite.hasNext()){
String s=ite.next();
}
6.TreeSet:实现了SortedSet接口,是一个排序的集合,内部通过红黑树实现,实现Comparable接口,或者传递一个Comparator类,根据这两项判断数据是否相同。
first()
pollfirst();
subSet();
headSet();

  1. Map集合框架的另一个顶层接口,Map中元素成对出现,形式是
Set<Entry<K,V>> set=map.entrySet();
for(Entry<K,E>e:sets){
    System.out.println(e.getKey()+":"+e.getValue());
}

keySet()键的集合

Set<String> keys=map.keySet();
System.out.println(keys);
Itreator<String> ite=set.Iterator();
while(ite,.itenext()){
    System.out.prinltn(ite.next());
}
for(String s:keys){
    System.out.println(s+":"+map.get(s));
}

values()键值的集合

Collection<E> e=map.values();
for(E s:e){
System.out.println(s);
}

putAll()将指定映射放到该映射中
remove()
get()得到指定键所对应的映射
put(K,V)
1. hashMap:Map最常用的实现类
源码分析:
Node类,此类实现Map.Entry接口,此类是对key,和value的封装;同时它也是一个单向链表;
它的属性有;
hash;哈希值
key :键
value:值
next: 下一个节点的引用;
属性:
size:元素个数
loadfactor:加载因子,默认为0.75;当(元素的个数/数组长度超)过这个值是,将会扩容;
table:内部用来存储键值(Node)对的数组;
构造方法:
():初始长度16,加载因子是0.75
(int):指定初始长度; 建议2的次方
(int,double);指定初始长度和加载因子
(map):有初始值;
方法;
put(key,value):
重新计算hash值
判断容量是否扩容,并完成扩容
计算存储位置; (table.legth-1)&hash == hash%table.legth;
存储新元素
如果此位置没有元素,直接存到此位置
如果此位置的key与新key相等,替换
如果不相等,则遍历单向链表;

  1. HashTable(哈希表)
    早期版本遗留的Map实现,属于Dictinary类
    线程安全,而HashMap线程不安全
    对于null来说,HashMap支持null(key,value),而Hashtable不支持null
  2. TreeMap:是SortedMap的实现类,具备了排序功能,它TreeMap中的元素(Key)按照Comparable或Comparator进行排序;
    TreeMap内部是一个红黑树(平衡二叉树)
  3. TreeMap源码
    内部类
    Entry
    K 键
    V value
    parent :父元素
    left: 左子元素
    right:右子元素
    属性;
    comparator:比较器
    size:元素的个数
    root:根元素
    put方法
    找到root元素,判断是否为null,如果为null,将些元素赋给root;
    如果root不为空,获得comparator,如果comparator不会 null,使用比较器进行,否则用comparable进行比较
    与entry进行比较,如果<0,找left进行比较,如果>0,与rigth进行比较,如果=0,给entry 的value重新赋值
    重复步骤3,直到entry为null,将此元素放到此节点中;
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页