一、集合是什么？
Java集合类存放于 java.util 包中，是一个用来存放对象的容器。
注意：①、集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。
②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。
③、集合可以存放不同类型，不限数量的数据类型。
Collection是最基本的集合接口，一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。
2、Iterable 和 Iterator 的区别
1. 两者都是接口，Iterable位于java.lang包下，Iterator位于java.util包下，两者之间的关系是Iterable接口提供了一个获取Iterator接口实例的方法。
2. Iterator是迭代器，如果一个对象拥有迭代器，那么就可以将对象中的所有元素和内容遍历出来，所以所有实现了Iterable接口的所有类都拥有迭代器Iterator。
3. Collection 接口 继承 Iterable接口（Java集合的顶层接口）（不包括 map 系列的集合，Map接口 是 map 系列集合的顶层接口）
迭代器Iterator 的方法：
Object next()：返回迭代的下一个元素。，返回值是 Object，需要强制转换成自己需要的类型
boolean hasNext()：判断容器内是否还有可供访问的元素
void remove()：删除迭代器刚越过的元素
ListIterator相对Iterator增加了如下3个方法：
boolean hasPrevious()：返回该迭代器关联的集合是否还有上一个元素。
Object previous()：返回该迭代器的上一个元素。
void add()：在指定位置插入一个元素。
public class Test { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); //迭代器遍历 //遍历原理：得到迭代器-->是否有下一个元素-->如果有就返回下一个元素. Iterator it = list.iterator(); while(it.hasNext()){ //hasNext()判断是否存在下一个元素 Object next = it.next(); //返回迭代的下一个元素。 System.out.print(next); //abcd } // 单项迭代器就是单项迭代器 Iterator it2 = list.iterator(); while(it2.hasNext()){ // 在迭代器中使用 list 直接添加或删除元素， 报 运行时修改异常 ConcurrentModificationException //list.add(3); //list.remove("a"); // 但是set方法却不报错，因为指针没有移动 //list.set(3, "我set方法却不报错，哈哈"); System.out.print(it2.next()); //abcd
如果：这里加入：it2.remove（）； 遍历一个删一个，最后list集合里面的全没了。
} it2.remove(); // 从迭代器指向的 collection集合 中移除迭代器返回的最后一个元素 //双向迭代遍历 interface ListIterator<E> extends Iterator<E> // 双向迭代器可以从前向后迭代，同时也可以从后向前迭代， // 在API中是用ListIterator来实现的，该接口继承Iterator接口 ListIterator listIt=list.listIterator();//获得列表迭代器，扩展了Iterator接口 while(listIt.hasNext()){//向后遍历 System.out.print(listIt.next()); //abc listIt.add(" 我可以用耶 "); } System.out.println("=======下面开始反向迭代======="); while(listIt.hasPrevious())//返回该迭代器关联的集合是否还有上一个元素。 {//返回该迭代器的上一个元素。 System.out.print(listIt.previous());// 我可以用耶 c 我可以用耶 b 我可以用耶 a } } }
3.面试题：ArrayList和LinkedList的关系和区别？
1.原理不一样 ArrayList基于数组，改查快, 添删慢 ；LinkedList基于链表实现，添加删除快 查询修改慢
2.两者都是集合框架中的容器，可以存储重复的数据，都是List接口的实现类
3.LinkedList可以用来模拟队列以及堆栈的数据结构
4.LinkedList相对于ArrayList多了很多的方法，其实操作链表的头部和尾部的一些方法
4. Queue [kju:] 和 Deque ['dek]
结构：Queue和Deque都是接口，Deque接口继承Queue接口，LinkedList是Deque的实现类。
- Queue表示一种队列，也是一种数据结构，它的特点是先进先出，因此在队列这个接口里面提供了一些操作队列的方法，同时LinkedList也具有这些方法；
- Deque(Double ended queues双端队列)，支持在两端插入或者移除元素; 那也应该具有操作双端队列的一些方法;
- LinkedList是他们的子类，说明都具有他们两者的方法；LinkedList也可以充当队列，双端队列，堆栈多个角色;
5 .ArrayList类的常用方法
每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。默认初始容量为10。随着ArrayList中元素的增加，它的容量也会不断的自动增长。在每次添加新的元素时，ArrayList都会检查是否需要进行扩容操作，扩容操作带来数据向新数组的重新拷贝，所以如果我们知道具体业务数据量，在构造ArrayList时可以给ArrayList指定一个初始容量，这样就会减少扩容时数据的拷贝问题。当然在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。
注意，ArrayList实现不是同步的。ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。
List list = Collections.synchronizedList(new ArrayList(...));
——ArrayList 线程不安全，查询速度快
——Vector 线程安全，但速度慢，已被ArrayList替代
——LinkedList 链表结果，增删速度快
package ArrayList类的常用方法; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class Test { public static void main(String[] args) { /*构造方法： 1. ArrayList() 构造一个初始容量为10的空列表，这是最常用的构造方法 2. ArrayList(Collection<? extends E> c) 构造一个包含指定 collection 的元素的列表，这些元素是按照该collection的迭代器返回它们的顺序排列的 3. ArrayList(int initialCapacity) 构造一个具有指定初始容量的空列表。 */ /*//1. 增： 4个方法： // 1.1 add(E e)：将指定的元素添加到此列表的尾部。 // 1.2 add(int index, E element)：将指定的元素插入此列表中的指定位置。 // 1.3 addAll(Collection<? extends E> c)：按照指定 collection的迭代器所返回的元素顺序， // 将该 collection中的所有元素添加到此列表的尾部。 // 1.4 addAll(int index, Collection<? extends E> c)：从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 */ //案例： ArrayList list = new ArrayList(); list.add(5); list.add(2); list.add(2, '你');//将置顶元素添加到指定位置（插入算法） System.out.println(list); //[5, 2, 你] ArrayList list2 = new ArrayList(); list2.add("13"); list2.add("14"); list2.add("呀"); list.addAll(list2); System.out.println(list); //[5, 2, 你, 13, 14, 呀] list.addAll(2, list2); System.out.println(list); //[5, 2, 13, 14, 呀, 你, 13, 14, 呀] list.set(5, "你好呀"); System.out.println(list); //[5, 2, 13, 14, 呀, 你好呀, 13, 14, 呀] /* 2. 删： 4个方法： // 2.1 clear() 移除此列表中的所有元素。 // 2.2 remove(int index)：移除此列表中指定位置上的元素。 // 2.3 remove(Object o)：移除此列表中首次出现的指定元素（如果存在）。 // 2.4 removeAll()：移除此 collection 中那些也包含在指定 collection 中的所有元素 */ // 案例： list.remove(2); list.remove("14"); System.out.println(list); // [5, 2, 呀, 你好呀, 13, 14, 呀] list.removeAll(list2); System.out.println(list); //[5, 2, 你好呀] list.clear(); System.out.println(list); //[] /*3. 改： 3.1 set(int index, E element)：用指定的元素替代此列表中指定位置上的元素。 3.2 ensureCapacity(int minCapacity) 增加此 ArrayList 实例的容量，手动扩容 3.3 trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小 . 比如最开始容器大小为100，后来发现容器只添加了5个，就可以使用该方法，调整为只有5个元素的容器 */ //案例： ArrayList list3 = new ArrayList(50); list3.add("你好"); list3.add("我好"); list3.add("大家好"); list3.set(2, "enen"); System.out.println(list3); //[你好, 我好, enen] list3.ensureCapacity(40); System.out.println(list3.size()); //3 list3.trimToSize(); /*4. 查： 4.1 size() 返回此列表中的元素数。 4.2 get(int index) 返回此列表中指定位置上的元素 4.3 indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1 4.4 lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 */ System.out.println(list3.get(1)); //我好 System.out.println(list3.indexOf("我好")); //1 /*5. 其他方法 */ System.out.println(list.isEmpty()); //true System.out.println(list3.contains("我好")); //true // Object[] toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组 System.out.println(Arrays.toString(list3.toArray())); //[你好, 我好, enen] } }
6.LinkedList类的常用方法
首先我们先看LinkedList的定义：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
从这段代码中我们可以清晰地看出LinkedList继承AbstractSequentialList，实现List、Deque、Cloneable、Serializable。其中AbstractSequentialList提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作,从而以减少实现List接口的复杂度。Deque一个线性 collection，支持在两端插入和移除元素，定义了双端队列的操作。
package LinkedList类的常用方法; import java.util.AbstractSequentialList; import java.util.Deque; import java.util.List; public class Test { public static void main(String[] args) { // LinkedList<E> extends AbstractSequentialList<E> // implements List<E>, Deque<E>, Cloneable, java.io.Serializable //1. 构造方法： /* 1.1 LinkedList()空参构造，仅仅只是将header节点的前一个元素、后一个元素都指向自身。 public LinkedList() { header.next = header.previous = header; } 1.2 LinkedList(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。 public LinkedList(Collection<? extends E> c) { this(); addAll(c); } */ //2. 两个字段 ： size表示的LinkedList的大小，header表示链表的表头 //Entry为节点对象。 /* private transient Entry<E> header = new Entry<E>(null, null, null); private transient int size = 0; */ //3. 常用方法 LinkedList的方法和ArrayList差不多，因为他们都实现了List接口，在List接口中已经定义了大部分的共有方法， //由于LinkedList使用的数据结构是链表方式，所以在有些方法上有些差别，差别在于可以在容器的头部和尾部对元素做操作：
下面介绍LinkedList实现Deque接口的方法
public class Test { public static void main(String[] args) { Deque<Integer> deq = new LinkedList(); deq.add(1); deq.add(2); deq.add(3); deq.add(4); deq.add(5); System.out.println(deq); // [1, 2, 3, 4, 5] //1. peek()和element()方法 都是获取（不移除此双端队列）队列的头部 // 区别：peek()，如果链表为空，则返回null。element()，如果链表为空，则抛异常。 System.out.println(deq.peek()); // 1 System.out.println(deq.element()); // 1 //2. peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 // peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 System.out.println(deq.peekFirst()); //1 System.out.println(deq.peekLast()); //5 //3. poll() pop() 获取并移除此列表的头（第一个元素） pop()出栈 push压栈 // poll（）和 pop（）区别: 如果此列表为空,pop()抛出NoSuchElementException，poll()则返回 null System.out.println(deq.poll()); //1 System.out.println(deq); //[2, 3, 4, 5] System.out.println(deq.pop()); //2 System.out.println(deq); //[3, 4, 5] //4. pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 // pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 System.out.println(deq.pollFirst()); //3 System.out.println(deq.pollLast()); //5 //5 push(E e) 将元素推入此列表所表示的堆栈 , // 如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。 deq.push(520131); System.out.println(deq); //[520131, 4] } }
7.HashSet类的常用方法
HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。
它内部元素的顺序是由哈希码来决定的，所以它不保证set 的迭代顺序；特别是它不保证该顺序恒久不变。
package HashSet类的常用方法; import java.util.AbstractSet; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Test3 { public static void main(String[] args) { //继承关系： class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable /*1. 字段 //基于HashMap实现，底层使用HashMap保存所有元素 private transient HashMap<E,Object> map; //定义一个Object对象作为HashMap的value private static final Object PRESENT = new Object(); */ /*2. 构造方法 2.1//初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。 public HashSet() { map = new HashMap<>(); } 2.2// 构造一个包含指定 collection 中的元素的新 set。 public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16)); addAll(c); } 2.3//构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子 public HashSet(int initialCapacity, float loadFactor) { map = new HashMap<>(initialCapacity, loadFactor); } 2.4//构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 public HashSet(int initialCapacity) { map = new HashMap<>(initialCapacity); } 2.5 在API中我没有看到这个构造函数，今天看源码才发现（原来访问权限为包权限，不对外公开的） * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 * dummy 为标识 该构造函数主要作用是对LinkedHashSet起到一个支持作用 HashSet(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadFactor); } */ /*3.普通方法 * 前言：HashSet的方法和ArrayList的方法大同小异，差别在于： HashSet是无序的，所以涉及到index索引的方法在HashSet里面都没有. */ HashSet set1 = new HashSet(); HashSet set2 = new HashSet(); for (int i = 0; i < 4; i++) { set1.add(i); //[0, 1, 2, 3] } for (int i = 2; i < 6; i++) { set2.add(i); //[2, 3, 4, 5] } set1.add(set2); System.out.println(set1); //[0, 1, 2, 3, [2, 3, 4, 5]] set1.addAll(set2); System.out.println(set1); //[0, 1, 2, 3, 4, 5, [2, 3, 4, 5]] //迭代器遍历 Iterator iterator = set1.iterator(); while(iterator.hasNext()){ Object next = iterator.next(); System.out.print(next); //012345[2, 3, 4, 5] } System.out.println(set1.contains(3)); //true set1.remove(set2); System.out.println(set1); //[0, 1, 2, 3, 4, 5] set1.clear(); System.out.println(set1); //[] } }
8.TreeSet类的常用方法
在TreeSet中默认要求里面的元素进行自然排序，强制要求里面的所有元素必须按照Comparable中的compareTo方法进行比较，如果容器里面的对象不具备compareTo方法此时就会抛出异常报错。
所以必须要让容器中的元素实现Comparable接口，这样它才具备compareTo方法。
1．TreeSet实例在调用add方法时会调用容器对象的compareTo方法对元素进行比较
2．TreeSet实例中对象必须是实现了Comparable接口
package TreeSet类的常用方法; public class Test4 { public static void main(String[] args) { //1.继承关系 /* public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable */ //2.变量 /* private transient NavigableMap<E,Object> m; //PRESENT会被当做Map的value与key构建成键值对 private static final Object PRESENT = new Object(); */ //3.构造方法 /* //3.1默认构造方法，根据其元素的自然顺序进行排序 public TreeSet() { this(new TreeMap<E,Object>()); } //3.2构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。 public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); } //3.3构造一个新的空 TreeSet，它根据指定比较器进行排序。 public TreeSet(Collection<? extends E> c) { this(); addAll(c); } //3.4构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。 public TreeSet(SortedSet<E> s) { this(s.comparator()); addAll(s); } //3.5 TreeSet(NavigableMap<E,Object> m) { this.m = m; } */ //4.主要方法 /* 1、add：将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。 public boolean add(E e) { return m.put(e, PRESENT)==null; } 2、addAll：将指定 collection 中的所有元素添加到此 set 中。 public boolean addAll(Collection<? extends E> c) { // Use linear-time version if applicable if (m.size()==0 && c.size() > 0 && c instanceof SortedSet && m instanceof TreeMap) { SortedSet<? extends E> set = (SortedSet<? extends E>) c; TreeMap<E,Object> map = (TreeMap<E, Object>) m; Comparator<? super E> cc = (Comparator<? super E>) set.comparator(); Comparator<? super E> mc = map.comparator(); if (cc==mc || (cc != null && cc.equals(mc))) { map.addAllForTreeSet(set, PRESENT); return true; } } return super.addAll(c); } 3、ceiling：返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。 public E ceiling(E e) { return m.ceilingKey(e); } 4、clear：移除此 set 中的所有元素。 public void clear() { m.clear(); } 5、clone：返回 TreeSet 实例的浅表副本。属于浅拷贝。 public Object clone() { TreeSet<E> clone = null; try { clone = (TreeSet<E>) super.clone(); } catch (CloneNotSupportedException e) { throw new InternalError(); } clone.m = new TreeMap<>(m); return clone; } 6、comparator：返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。 public Comparator<? super E> comparator() { return m.comparator(); } 7、contains：如果此 set 包含指定的元素，则返回 true。 public boolean contains(Object o) { return m.containsKey(o); } 8、descendingIterator：返回在此 set 元素上按降序进行迭代的迭代器。 public Iterator<E> descendingIterator() { return m.descendingKeySet().iterator(); } 9、descendingSet：返回此 set 中所包含元素的逆序视图。 public NavigableSet<E> descendingSet() { return new TreeSet<>(m.descendingMap()); } 10、first：返回此 set 中当前第一个（最低）元素。 public E first() { return m.firstKey(); } 11、floor：返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。 public E floor(E e) { return m.floorKey(e); } 12、headSet：返回此 set 的部分视图，其元素严格小于 toElement。 public SortedSet<E> headSet(E toElement) { return headSet(toElement, false); } 13、higher：返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。 public E higher(E e) { return m.higherKey(e); } 14、isEmpty：如果此 set 不包含任何元素，则返回 true。 public boolean isEmpty() { return m.isEmpty(); } 15、iterator：返回在此 set 中的元素上按升序进行迭代的迭代器。 public Iterator<E> iterator() { return m.navigableKeySet().iterator(); } 16、last：返回此 set 中当前最后一个（最高）元素。 public E last() { return m.lastKey(); } 17、lower：返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。 public E lower(E e) { return m.lowerKey(e); } 18、pollFirst：获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 public E pollFirst() { Map.Entry<E,?> e = m.pollFirstEntry(); return (e == null) ? null : e.getKey(); } 19、pollLast：获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 public E pollLast() { Map.Entry<E,?> e = m.pollLastEntry(); return (e == null) ? null : e.getKey(); } 20、remove：将指定的元素从 set 中移除（如果该元素存在于此 set 中）。 public boolean remove(Object o) { return m.remove(o)==PRESENT; } 21、size：返回 set 中的元素数（set 的容量）。 public int size() { return m.size(); } 22、subSet：返回此 set 的部分视图 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。 public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { return new TreeSet<>(m.subMap(fromElement, fromInclusive, toElement, toInclusive)); } //返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。 public SortedSet<E> subSet(E fromElement, E toElement) { return subSet(fromElement, true, toElement, false); } 23、tailSet：返回此 set 的部分视图 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。 public NavigableSet<E> tailSet(E fromElement, boolean inclusive) { return new TreeSet<>(m.tailMap(fromElement, inclusive)); } //返回此 set 的部分视图，其元素大于等于 fromElement。 public SortedSet<E> tailSet(E fromElement) { return tailSet(fromElement, true); } */ } }
部分内容参考别人的作品： https://www.cnblogs.com/chenssy/