一、集合框架
有关LinkedList的集合的,它是一个链表结构的集合
1、链表结构
1.1 单链表的结构
所谓单链表(Linked)在内存中不连续的一端内存空间, 链表的每一个元素是一个节点,每一个结点由数据元素和下一个结点的存储位置组成,链表结构与数组结构最大区别是链接结构的存储内存是不连续的,而数组结构的内存是连续的,链表结构不能与数组结构一样快速查找,
链表结构操作特点是 添加,删除元素效率高,查询效率低;
数组结构操作特点: 添加,删除效率低,查询效率高
链表结构的示意图
前驱: 该节点的上一个元素的地址
后继: 该节点的下一个元素的地址
链表结构中最后一个元素的”后继“为null
1.2 单链表的实现
链表实现添加元素:
/** * 添加到最后元素 * @param obj */ public void addLast(Object obj){ //将节点添加到最后 //add(obj , this.size); // 创建节点 // Node node = new Node(obj); // // 找到最后一个元素的地址 // Node lastNode = this.header; // for(int i = 0;i<this.size-1 ;i++){ // lastNode = lastNode.next; // } // // lastNode.next=node; // 找最后一个结点 (由于最后一个结点的next是null) Node node = new Node(obj); Node lastNode = this.header; while(lastNode.next!=null){ lastNode = lastNode.next; } lastNode.next = node; this.size++; }
/** * 删除第一个节点 * @param index * @return */ public void removeFirst(){ //删除第一个节点 if(this.size==0){ throw new IllegalArgumentException("没有需要删除的原始"); } // 获取当前连接的“后继” Node node = this.header.next; // 并让后继作为头 this.header = node; this.size--; } /** * 删除最后节点 */ public void removeLast(){ //删除是否存在数据 if(this.size==0){ throw new IllegalArgumentException("没有需要删除的原始"); } // 找最后一个元素的前一个 地址 ,并将该地址的next 改为null Node cur = this.header; Node pre = this.header; while(cur.next!=null){ pre = cur; // 下一个变为当前 cur = cur.next; } // 最后一个元素 就是 当前 pre.next = null; size--; }
2、队列结构
队列结构(Queue): 在基于链表结构的基础上 ,实现的一种“先进先出”的结构, 常用操作 入队(put),出队(pop) ,设置队列的头结点 和 尾结点
package com.j2008.dataStruct; /** * ClassName: MyQueue * Description: * date: 2020/10/26 16:41 * * @author wuyafeng * @version 1.0 softeem.com */ public class MyQueue<T> { // 头结点 private Node front; // 尾结点 private Node tail; // 大小 private int size; public MyQueue(){ // 头,尾为空 this.front= this.tail=null; } class Node{ private T obj; private Node next; public Node(T obj){ this.obj = obj; } public T getObj() { return obj; } public void setObj(T obj) { this.obj = obj; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } } /** * 入队 : 将元素添加到队列的尾部 */ public void put(T obj){ // 创建节点 Node node = new Node(obj); // 如果元素为空 则头就尾,尾就是头 if(isEmpty()){ this.front = this.tail = node; return ; } // 将新元素的地址 作为尾的next this.tail.next=node; //将新元素的结点 作为尾节点 this.tail = node; this.size++; } /** * 出队: 将元素从队列的头部移除 (保持与队列脱离关系) * @return */ public T pop(){ if(isEmpty()){ throw new IllegalArgumentException("没有弹出的原始"); } // 移除头部元素 Node popNode = this.front; // 设置现在的头元素是下一个 this.front = popNode.next; // 将弹出的元素next 设置null,与队列脱离关系 popNode.next=null; this.size--; // 如果没有元素了 则需要 设置头尾都是null if(this.size<0){ this.front=this.tail=null; } return popNode.getObj(); } /** * 判断元素是否为空 * @return */ public boolean isEmpty(){ if(this.front==null && this.tail==null){ return true; } return false; } }
3、栈结构
栈(Stack)结构也是常用数据结构之一,它具有 “后进先出” 的特点
public class MyStack<T> { // 定义一个数组 ,用于存储元素 private Object[] obj; private int size; public MyStack(){ obj = new Object[10]; size=0; } /** * 入栈: 压入栈顶元素 * @param t */ public void push(T t){ expandCapacity(size+1); obj[size]=t; size++; } /** * 返回栈顶元素:peek */ public T peek(){ if(size>0) { return (T) obj[size - 1]; } return null; } /** * 出栈: 返回栈顶的元素,并删除该元素 * @return */ public T pop(){ T t = peek(); if(size>0) { // 将最后一个元素 删除 obj[size - 1] = null; size--; } return t; } /** * 是否为空元素 * @return */ public boolean isEmpty(){ return size==0; } /** * 扩容数组大小 : 扩容1.5倍 */ public void expandCapacity(int size){ if(obj.length< size){ // 需要扩容 int length = size*3/2 + 1; this.obj = Arrays.copyOf(this.obj,length); } } }
一、LinkedList集合
java.util.LinkedList集合是java.util.List的实现类,实现List接口的所有方法(添加,删除,查找,判断是空等) ,它添加,删除元素较快,查询相对慢,但是查询头尾元素较快
LinkedList集合实现双向链表接口,实现从头元素到尾元素的链表和从尾到头元素的链表,目标为了增加元素的检索效率 ,如下图
关于LinkedList实现大量操作头元素和尾元素的方法。 其中必须通过LinkedList的引用创建该对象
public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
public boolean isEmpty() :如果列表不包含元素,则返回true
二、 Set集合
java.util.Set 接口 继承自Collection接口,实现对元素的基本操作 ,与java.util.List区别于 Set集合存储无序,且唯一的元素,List存储有序,且可重复的元素
Set接口的实现类 HashSet 、 LinekedHashSet 、TreeSet
1、HashSet
HashSet集合依据元素的哈希值确定在内存中的存储位置, 所谓Hash值是内存中哈希表的唯一标志,通过哈希值可快速检索到元素所在的位置 , 所以它查询效率高 ,与HashSet类似结构的包括HashMap 等
创建一个HashSet时,就是创建一个HasMap( 关于HashMap结构后面讲)
什么是哈希表?
在Java1.8以前,哈希表的底层实现采用数组+链表结构,但是这样对于“Hash冲突” (两个对象生成的哈希值一样),即多个元素存储在一个“数据桶”中, 这样查找该元素时,依然效率低下, 为了解决由于哈希冲突导致的数据查询效率低下,JDK8以后将哈希表实现采用 数组+链表+红黑树结构
1.2.HashSet存储自定义对象类型
HashSet对于对象是否相同的依据,判断对象的hashCode值和equals是否相等,如果它们相等则判断元素一致,不能重复添加
public class People { private int pid; private String pname; private int age; public People(int pid, String pname, int age) { this.pid = pid; this.pname = pname; this.age = age; } public int getPid() { return pid; } public void setPid(int pid) { this.pid = pid; } public String getPname() { return pname; } public void setPname(String pname) { this.pname = pname; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { return this.pid; } @Override public boolean equals(Object obj) { if(this == obj){ return true; } if(obj instanceof People){ People p = (People) obj; if(p.pid == this.pid && p.getPname().equals(p.getPname())){ return true; } } return false; } }
//存储 对象类型 Set<People> sets = new HashSet<>(); People p = new People(1001,"关羽",100); People p2 = new People(1002,"张飞",100); People p3 = p2; System.out.println("p的hashcode:"+p.hashCode()); sets.add(p); // 检查是否为同一个地址 sets.add(p); sets.add(p2); sets.add(p3); // 插入一个重新new的张飞对象 HashSet以 equals和hashcode的结果作为是否重复对象的依据 People p4 = new People(1002,"张飞",90); sets.add(p4); // 会当做是重复的对象 ,不能添加成功。 System.out.println("sets的长度:"+sets.size()); for(People obj : sets){ System.out.println(obj.getPid()+"---"+obj.getPname()+"---"+obj.getAge()); }
1.3 LinkedHashSet
在HashSet中存储的数据是唯一且无序,如何保证数据的有序型,可通过扩展HashSet的子类完成,
java.util.LinkedHashSet ,它实现有序的Hash结构, 它的底层实现使用链表+哈希结构,
创建LinkedHashSet时,就是创建一个LinkedHashMap结构 ,linkeHashSet中如何保证顺序一致性
accessOrder = false; 按照插入的顺序存储 accessOrder = true: 按照访问的顺序存储。
// 创建LinkedHashSet对象 LinkedHashSet<String> set = new LinkedHashSet(); set.add("aaa"); set.add("bbb"); set.add("ccc"); set.add("ddd"); //遍历元素 for(String s : set){ System.out.println(s); }
1.4 TreeSet
TreeSet实现对Set元素的排序功能, 也包含基础的Set集合功能。 存放在TreeSet中的元素时有序的,默认升序,也可以自定义排序规则。
两种方式实现自定义排序规则
1、对元素(自定义类)实现 java.lang.Comparable 接口,重写 compareTo方法
public class Fruit implements Comparable<Fruit>{ private int id; private String name; public int compareTo(Fruit o) { // return this.id-o.id; 升序 return o.id - this.id; // 正数: 前一个大于后一个 // 负数: 前一个小于后一个 } }
// 实现自定义排序规则的方式一 : 对象实现Comparable接口 (java.lang) // 重写compareTo 方法。 TreeSet<Fruit> fruitSet = new TreeSet<>(); Fruit f1 = new Fruit(100,"苹果"); Fruit f2 = new Fruit(101,"香蕉"); fruitSet.add(f1); fruitSet.add(f2); System.out.println(fruitSet.size()); for(Fruit f : fruitSet){ System.out.println(f.getId()+"---"+f.getName()); }
2、通过匿名内部类的方式 在创建TreeSet时,创建自定义排序规则 ,new Comparator的接口
// 自定义排序规则的方式二: 对treeSet实现匿名内部类 new Comparator(java.util) TreeSet<Integer> scores = new TreeSet (new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; //降序 } }); // 添加元素 scores.add(80); scores.add(87); scores.add(90); scores.add(78); for(Integer score : scores){ System.out.println(score); }
// 按照对象的某一属性降序 TreeSet<People> peopleSet = new TreeSet<>(new Comparator<People>() { @Override public int compare(People o1, People o2) { return o2.getAge()- o1.getAge(); // 根据age降序排列 } }); peopleSet.add(new People(1001,"张飞",100)); peopleSet.add(new People(1002,"刘备",102)); peopleSet.add(new People(1003,"关羽",108)); for(People p : peopleSet){ System.out.println(p.getPid()+"--"+p.getAge()); }
三、Map集合
java.util.Map集合用于存储key-value的数据结构 ,一个键对应一个值,其中键在集合中是唯一的, Value可以重复, 例如 学号与学生的关系,省份编号对应省份信息, 对于Map集合的常用实现类包括 HashMap 、LinkedHashMap、HashTable 、TreeMap 等 。
1、HashMap(重点)
java.util.HashMap 存储无序的,键值对数据,HashMap的实现原理在JDK1.8以前使用 链表+数组结构,1.8以后使用链表+数组+红黑树结构, 使用Hash表的存储方式其检索效果高
特点:
a、HashMap的key唯一,且无序,value不唯一
b、HashMap的key和value 都可以为null
c、对于相同key 元素,它的value会覆盖原始value
HashMap的常用方法
HashMap() 构造一个空的 HashMap ,默认初始容量(16)和默认负载系数(0.75)。 HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子(0.75)。 HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。
a、put(K key,V value) : 存储key-value 到容器中
b、V get(K key): 根据key 获取对应的value
c、Set keySet(): 返回所有的key,Set集合
d、boolean containsKey(K key): 判断key是否存在
e、clear():清空容器的原始
f、boolean containsValue(V value):判断value是否存在
g、Collection values() : 返回所有的value集合
h、isEmpty(): 判断是否为空集合
i、remove(Object key) : 根据key删除这个key-value
j、size():返回元素的大小
k、Set<Map.Entry<Key,Value>> entrySet(): 返回容器的key-value的实体类的集合,方便遍历元素
HashMap的源码分析
// 创建HashMap对象 Map<String , Integer> cards = new HashMap(); //存储 cards.put("红桃",3); cards.put("黑桃",3); cards.put("方片",2); cards.put("梅花",8); cards.put("红桃",2); // 会覆盖原始的value //获取指定key的value元素 System.out.println(cards.get("红桃")); // 获取所有的key Set<String> keys= cards.keySet(); //通过遍历所有的key 访问对应的value for(String k : keys){ System.out.println(k+"-----"+cards.get(k)); } // 判断key 是否存在, 判断value是否存在 System.out.println("是否有红桃:"+cards.containsKey("红桃")); System.out.println("判断是否有value:"+cards.containsValue(2)); // 获取所有的value Collection<Integer> values = cards.values(); Iterator its= values.iterator(); while(its.hasNext()){ System.out.println("values ----"+its.next()); } //获取所有的元素 System.out.println(cards.size()); // 遍历map集合元素 entrySet Set<Map.Entry<String, Integer>> entrys = cards.entrySet(); for(Map.Entry<String, Integer> en : entrys ){ System.out.println("entry遍历方式:"+en.getKey()+"-----"+en.getValue()); } // remove System.out.println("删除元素:"+cards.remove("红桃")); //清空元素 cards.clear(); System.out.println("元素的大小:"+cards.size()); }
2、HashMap的原理以及源码分析
HashMap基于键值对存储,这里讲解的jdk8的源码
HashMap实现步骤:数据结构(数组+链表+红核数)
1、根据key生成对应是hash值(采用Hash函数生成) ,根据hash值找到该元素所在的数组结构中的位置,如果该位置中存在元素,说明产生了哈希冲突,此时JDK8采用元素尾插入法 (JDK7采用头插法) ,将元素放入链表的尾部,这样可能会形成一条长长的链表。
2、当链表长度达到8时,此时会转成 红黑树结构(树形结构的检索效率较高) ,为了提高查询效率。
HashMap中的一些关键属性和方法
/** * 扩容的临界值,通过capacity * load factor可以计算出来。超过这个值HashMap将进行扩容 * @serial */ int threshold; /** * 存储键值对的数组,一般是2的幂 */ transient Node<K,V>[] table; /** * 键值对的实际个数 */ transient int size; /** * 记录HashMap被修改结构的次数。 * 修改包括改变键值对的个数或者修改内部结构,比如rehash * 这个域被用作HashMap的迭代器的fail-fast机制中(参考ConcurrentModificationException) */ transient int modCount; /** * HashMap的节点类型。既是HashMap底层数组的组成元素,又是每个单向链表的组成元素 */ static class Node<K,V> implements Map.Entry<K,V> { //key的哈希值 final int hash; final K key; V value; //指向下个节点的引用 Node<K,V> next; } //增长因子 0.75 this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
几个常用方法分析:
1、get(Object)
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value;
返回目标Node
final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // 整个数组长度不为空, 且第一个Node不为空 说明已找到对一个的hash位置 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 表示当前“桶”的第一个元素 的hash值相同,且 key也相同,说明value 是目标查找对象 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 说明一个“桶”中有多个元素, 继续找 if ((e = first.next) != null) { // 多个元素中 需要先判断是否为 “树”结构,因为超过8个长度就转成了数 if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); // 一定是单链表结构 ,依次从头找到尾,看有没有对应的 key do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }
2、put(K,V)
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; // 获取元素的总长度 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // 判断如果当前集合中没有对应的 “桶”,说明没有出现 “Hash碰撞” if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { Node<K,V> e; K k; //如果碰撞了,且桶中的第一个节点就匹配了 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //如果桶中的第一个节点没有匹配上,且桶内为红黑树结构,则调用红黑树对应的方法插入键值对 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //不是红黑树结构,那么就肯定是链式结构 for (int binCount = 0; ; ++binCount) { //如果到了链表的尾部 ,插入到后面 if ((e = p.next) == null) { // 创建一个新节点 创建最后节点 next中 p.next = newNode(hash, key, value, null); // 如果长度大于 8 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // 将tab 的桶的所有元素 转成 树结构 treeifyBin(tab, hash); break; } // 如果还没有到达尾部 就找到元素了, 直接返回 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } // 如果找到该元素 ,需要替换它的 value if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } // 修改次数增加 ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
put插入的流程
步骤一: 先判断容器是否为空,为空需要扩容,
步骤二: 根据key 生成hash值,根据hash值找到对应的数组的位置,如果数组位置为空,说明没有hash冲突,直接插入,并长度+1 。
步骤三:如果数组位置的内容不为空,说明产生hash冲突 ,继续通过key查找元素,如果第一个元素存在(说明还没有生产链表)直接返回value 并覆盖value的值。
步骤四: 如果key对应的第一个元素不存在,则此时可能出现链表或红黑树, 如果是红黑树采用树结构的插入法(省略分析过程)。 否则一定是链表结构
步骤五: 如果是链表,将该元素插入到末尾,之后验证整个链表的长度是否大于8 ,如果大于8,将链表转成红黑树结构。
步骤六:插入成功之后,判断整个容器的元素个数是否超出 扩容的临界值(threshold = capacity* 增长因子)
关于JDK7.0和JDK8.0的HashMap有什么区别
1、结构不同
JDK7采用数组+链表 JDK8采用数组+链表+红黑树
2、hash值的计算方式不同
JDK7 table在创建hashmap时分配空间
JDK8 通过key的hashcode计算,在put时分配空间
3、发生hash冲突插入方式不同
JDK7采用头插法,JDK8采用尾插法
4、resize操作方式不同
JDK7重写计算index 的值,JDK8通过判断相应的位是0还是1,要么依旧是原index,要么是oldCap + 原index
3、LinkedHashMap
由于HashMap存储的key是无序,如果需要存储有序的key可使用LinkedHashMap 它依然满足HashMap的所有特点 ,并在此基础上有序
4、TreeMap
TreeMap实现一个可排序的Map集合 ,默认对key升序排列,也可以降序排序,
如果添加元素的key为自定义类,需要实现Comparable接口或Comparator接口。 TreeMap的底层实现是二叉树结构 (有关二叉树的特点 ) ,实现有序的key的分布
// TreeMap 用于存储可排序的Key -Value集合 , // 其中key必须实现了排序规则的对象 (包装类,String,自定类) public static void main(String[] args) { // 存储学号和分数 默认对key 进行升序 // TreeMap<Integer ,Integer> maps = new TreeMap<>(); TreeMap<Integer,Integer> maps = new TreeMap<>(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; // 降序 } }); maps.put(1003,88); maps.put(1002,90); maps.put(1004,80); maps.put(1001,85); //输出 Set<Integer> keys = maps.keySet(); for(Integer k : keys){ System.out.println(k+"----"+maps.get(k)); } // 自定义规则 // 注意 ,如果key不是包装类而是自定义,必须要求该类实现Comparable或Comparator接口 TreeMap<Student ,Integer> stuMap = new TreeMap<>(); stuMap.put(new Student(1001,"张飞"),90); stuMap.put(new Student(1003,"刘备"),87); stuMap.put(new Student(1002,"关羽"),96); // 这里降序排列 for(Map.Entry<Student,Integer> en : stuMap.entrySet()){ System.out.println(en.getKey().getSid() + "---"+ en.getValue()); } }
class Student implements Comparable<Student>{ private int sid; private String sname; public Student(int sid, String sname){ this.sid = sid; this.sname = sname; } public int getSid() { return sid; } public void setSid(int sid) { this.sid = sid; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } @Override public int compareTo(Student o) { return o.sid-this.sid; // this表示前一个对象, o表示后一个对象 } }
5、HashTable
HashTable 实现 hash结构的key-value集合, 与HashMap很相似, HashTable 是线程安全(它的很多方法是同步操作),它不需要存储null的 key 和value
扩展自 Dictionary类 和 实现Map接口
常用方法 :
put ()
get()
clear()
containsKey()
containsValue()
它 有一个子类 是 Properties类,用于存储属性文件的 key- value
public static void main(String[] args) { //创建HashTable 无序 Hashtable<String,String> tables = new Hashtable<>(); // 存储 tables.put("王宝强","马蓉"); tables.put("贾乃亮","李小璐"); tables.put("文章","马伊琍"); //获取 使用所有key遍历 返回枚举类型 Enumeration<String> keys = tables.keys(); while(keys.hasMoreElements()){ String s = keys.nextElement(); System.out.println(s + "---"+ tables.get(s)); } // 有一个HashTable的子类 Properties Properties prop = new Properties(); prop.setProperty("username","张三"); prop.setProperty("password","123456"); //获取对应属性名的值 System.out.println("根据属性名获取值:"+prop.getProperty("username")); System.out.println("根据属性名获取值:"+prop.getProperty("password")); }
四、集合常见面试题
1、Collection 和 Collections 的区别? Array 和Arrays的区别?
Collection是集合的顶级接口 ,Collections是一个集合工具类 ,它提供大量的操作集合方法,例如排序, 打乱顺序,添加元素等。
Array 表示一个数组对象 , Arrays是一个数组工具类 ,提供大量的数组操作方法。
2、List 和 Set 的区别? ArrayList 和 LinkedList的区别
相同点:List、Set 都继承Collection接口
不同点: List 存储不唯一,有序集合元素 , Set 存储唯一,无序的集合元素
ArrayList 实现数组结构集合,查询比较快,添加,删除效率低
LinkedList实现双向链表结构集合,添加,删除效率高, 查询效率低
3、HashSet 和 TreeSet的区别?
它们都存储唯一集合,都实现Set接口
HashSet无序,底层实现Hash结构的存储, TreeSet有序,可实现自定义排序,存储树形结构
4、HashMap 和 HashSet的区别?
它们都属于Hash结构的集合,存储效率较高 , HashSet是存储单个元素 ,HashMap存储键值对元素
HashMap实现Map接口,HashSet实现Set接口 ,
5、HashMap 和HashTable的区别
它们都来自Map 的实现类, HashTable 还继承一个父类 Dictionary
-
HashMap 的key和value 可以为空,HashTable 的key value 不能为空;
-
HashTable 的子类包含key value 的方法
-
HashMap线程不安全效率高 ,HashTable线程安全效率低
6、HashMap 和 TreeMap的区别?
它们都实现Map接口 ,TreeMap 有序,HashMap无序, HashMap实现哈希结构 集合,TreeMap实现二叉树集合。
五、JDK8的特性
在JDK8中新增一些特殊功能,一般开发时方便使用, 其中最主要的功能如下
1、接口的默认函数
public interface MyInterface { public default void defaultMethods(){ System.out.println("这是一个接口的默认方法。"); // 静态方法可以在default方法中调用 staticMethods(); } public void service(); public static void staticMethods(){ System.out.println("这是接口的静态方法"); } }
public static void main(String[] args) { // 创建匿名内部类的方式 MyInterface my = new MyInterface() { @Override public void service() { System.out.println("service方法....."); } }; my.defaultMethods(); //通过接口名 调用静态方法 MyInterface.staticMethods(); }
2、Lambda表达式
JDK8中支持一种对方法调用的 简写方式 ,也是一种特殊写法
语法: ([形参名]) ->{ 方法的实现}
这个接口中有且只有一个方法,并对方法实现
原始代码
ArrayList<String> list = new ArrayList<>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); // 降序 Collections.sort(list, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o2.compareTo(o1); //降序 } })
由于JDK能识别sort的参数二是Comparator , 并Comparator是函数式接口(一个接口中有且只有一个方法。),实现的一定是唯一的方法名, 所有这里方法名和返回值也省略, 它的简写方式
// 使用lambda表达式 ([形参])->{方法体} Collections.sort(list ,(String o1,String o2)->{ return o2.compareTo(o1); });
由于形参的数据类与集合的元素类型一致,这里的形参类型也省略 、return也省略
// 最精简的Lambda Collections.sort(list ,(o1,o2)->o2.compareTo(o1));
3、函数式接口
函数式接口主要用于满足前面Lambda表达式的语法的使用。 在一个接口中 有且只有一个方法的接口称为 “函数式接口” ,
如何将一个接口定义为函数式接口呢? 在接口上增加注解 “@FunctionalInterface”
package com.j2008.functionalFun; @FunctionalInterface // 该注解的意义在于 约束接口只能由一个方法 public interface ConverterInterface<T> { public String convertStr(T t); }
//传统写法 ConverterInterface<Integer> con = new ConverterInterface<Integer>() { @Override public String convertStr(Integer o) { return o.toString(); } }; String ss = con.convertStr(100); System.out.println(ss); //使用 lambda表达式写法 ConverterInterface<Date> cons = (o)->o.toLocaleString(); String s = cons.convertStr(new Date()); System.out.println(s);
4、方法和构造器的引用
4.1 方法的引用
在以上接口函数中 这个convert方法的实现 对于java.lang包中是存在相同的方法的,所以 convert的实现可以直接引用已有静态方法 Integer.valueOf 或者 Integer.parseInt
以上代码的实现可以改成这样 :
语法: 类名 :: 静态方法名
@FunctionalInterface public interface Convert<F,T> { //将F转成T public T convertType (F f); }
public static void main(String[] args) { // 原始使用lambda表达式 可以这样写 // 把字符串转成 Integer Convert<String ,Integer> con = (f)->{ return Integer.parseInt(f); }; Integer n = con.convertType("888"); // 在lambda基础上,如果实现的方法 已存在,则可直接调用 类名::方法名 Convert<String ,Integer> con2 = Integer::valueOf; Convert<String ,Integer> con3= Integer::parseInt; //调用方法实现 Integer n2 = con2.convertType("123"); int n3 = con3.convertType("555"); }
4.2 构造器的引用
当方法的实现 是构造器时,可直接引用构造器
语法: 类名::new
@FunctionalInterface public interface StudentFactory<T> { // 参数是创建对象时 的 属性 public T create(int id ,String name); }
public class Student { private int sid; private String sname; public Student(int sid, String sname) { this.sid = sid; this.sname = sname; } }
public static void main(String[] args) { //使用Lambda实现 函数接口的方法 StudentFactory<Student> factory = (id,name)->{ return new Student(id ,name); }; Student stu1 = factory.create(1001,"张三丰"); System.out.println(stu1); // 以上写法可以直接换成 引用构造器方式 StudentFactory<Student> factory1 = Student::new; //创建 Student stu2 = factory1.create(1002,"张无忌"); System.out.println(stu2); }
5、集合的流式处理