集合框架总图：
一、ArrayList
为什么要使用？
存放多个对象也可以使用数组，但是定义数组有局限性，例如先声明个长度为20的数组，如果存10个就浪费了空间，存25个又不够。所以引入容器，ArrayList就是一种常见的容器，容器的容量会随着存放的对象自动增多。
常用方法
例子：
public class ArrayListTest { public static void main(String[] args) { //泛型，list只能存string类型 //下面这样写可以存各种类型 //ArrayList list1 = new ArrayList(); ArrayList<String> list = new ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); System.out.println(list); System.out.println("之前的长度："+list.size()); list.add("ddd"); System.out.println("新添加一个元素后的长度："+list.size()); System.out.println(list); //contains判断容器中是否有某元素 System.out.println("是否存在aaa:"+list.contains("aaa")); //get获得指定位置的元素 System.out.println("第2个元素是："+list.get(1)); //set替换某位置的元素 System.out.println("拿AAA替换第一个元素："+list.set(0, "AAA")); System.out.println(list); //转化为数组,如果要转换为一个string数组， //那么需要传递一个string数组类型的对象给toArray()， //这样toArray方法才知道，你希望转换为哪种类型的数组，否则只能转换为Object数组 String []arr = new String[list.size()]; arr=(String[]) list.toArray(new String[] {}); for(String str:arr) { System.out.println("转化成数组："+str); } //清空list list.clear(); System.out.println(list); } }
泛型
不指定泛型的容器，可以存放任何类型的元素
指定了泛型的容器，只能存放指定类型的元素以及其子类，如上面代码的 ArrayList<String> list，只能存放String类型
三种遍历集合的方法
使用for循环
方便操作集合中相关元素
使用迭代器iterator
增强型for循环
使用增强型for循环可以非常方便的遍历ArrayList中的元素，这是很多开发人员的首选
不过增强型for循环也有不足：
无法用来进行ArrayList的初始化
无法得知当前是第几个元素了，当需要只打印单数元素的时候，就做不到了。 必须再自定下标变量。
代码：
public class Test { public static void main(String[] args) { ArrayList<Integer> al = new ArrayList<>(); for(int i=0;i<10;i++) { al.add(i); } System.out.println("----------for循环遍历------------"); for(int i=0;i<al.size();i++) { /*for循环遍历的好处，可以操作相关元素 * if((i+1)%8==0) { al.remove(i); continue; }*/ System.out.print(al.get(i)+","); } System.out.println(); System.out.println("----------迭代器遍历------------"); Iterator<Integer> it = al.iterator(); while(it.hasNext()) { System.out.print(it.next()+","); } System.out.println(); System.out.println("----------foreach循环遍历------------"); for(Integer i:al) { System.out.print(i+","); } }
}
二、LinkedList
LinkedList也实现了List接口，像add（），get（）这些List的方法也可以使用。
Deque
特别的是 它实现了双向链表Deque，可以很方便的在头和尾进行操作；
常用方法：
addFirst()在最前面插入元素，addLast()在最后面插入元素，
getFirst(),getLast查看头部和尾部元素，
removeFirst(),removeLast()移除头部尾部元素
Queue
还实现了Queue（队列）接口，队列的特点是先进先出（FIFO）
常用方法：
offer() 在最后面添加元素
peek()查看第一个元素
pool()取出第一个元素
代码
public class LinkedListTest { public static void main(String[] args) { LinkedList<Integer> ll = new LinkedList<Integer>(); //双向链表deque Deque<Integer> d = new LinkedList<Integer>(); //队列queue Queue<Integer> q = new LinkedList<Integer>(); //初始化 for(int i=1;i<10;i++) { ll.add(i); d.add(i); q.add(i); } /* * Deque的相关方法 * * addLast * getFirst * removeFirst * */ System.out.println("deque初始值"+d); //尾部添加10 d.addLast(10); System.out.println("尾部添加："+d); //头部添加0 d.addFirst(0); System.out.println("头部添加："+d); //查看第一个 System.out.println("查看头部："+d.getFirst()); //取出最后一个 d.removeLast(); System.out.println("取出最后一个："+d); /* * Queue队列的相关方法 * offer放置队尾 * poll取出队列第一个元素 * peek查看队列第一个元素 */ System.out.println("queue初始值："+q); q.offer(10); System.out.println("队尾添加后："+q); q.poll(); System.out.println("使用poll去掉队首："+q); System.out.println("使用peek查看队首："+q.peek());
结果：
stack
stack栈是先进后出（FILO），利用Deque实现自定义Stack
先定义接口Stack
public interface Stack { //把元素推入到最后位置 public void push(Integer i); //把最后一个元素取出来 public Integer pull(); //查看最后一个元素 public Integer peek(); }
自定义MyStack实现接口
public class Mystack implements Stack { Deque<Integer> dq = new LinkedList<Integer>(); public void push(Integer i) { // 入栈，到最底部 dq.addLast(i); }
public Integer pull() { // 取出最后一个元素 return dq.removeLast(); } public Integer peek() { // 查看最后一个元素 return dq.getFirst(); } }
三、二叉树
建立二叉树：基本思想 小的在左边，大的在右边
public class Node { //左子节点 public Node leftNode; //右子节点 public Node rightNode; //值 public Object value; public void add(Object o) { //如果当前节点值为空 if(value==null) { value=o; } else {//值小于等于根的值放入左节点 if((int)o<=(int)value) { if(leftNode==null) { leftNode = new Node();} leftNode.add(o); }else {//值大于根的值 if(rightNode==null) {rightNode = new Node();} rightNode.add(o); } } } }
二叉树的遍历：前序遍历：根左右
中序遍历：左根右
后序遍历：左右根
接下来是中序遍历，顺便还能排序，这就是二叉树排序
public List<Object> values() { //中序遍历二叉树 List<Object> al = new ArrayList<>(); //左节点 if(leftNode!=null) al.addAll(leftNode.values()); //当前节点 al.add(value); //右节点 if(rightNode!=null) al.addAll(rightNode.values()); return al; }
四、HashMap
HashMap的存储方式是键值对的方式，键不能重复，值可以重复
public class HashMapTest { public static void main(String[] args) { HashMap<String, String> hm = new HashMap<>(); hm.put("name", "tom"); hm.put("age", "18"); hm.put("sex", "man"); System.out.println(hm.get("name")); } }
3种遍历方式，分别使用foreach和迭代器遍历
package com.yyt.pojo; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.atomic.AtomicStampedReference; import javax.activation.MailcapCommandMap; public class YeYangTao { public static void main(String[] args) { HashMap<String, String> map = new HashMap<>(); map.put("001", "yyt1"); map.put("002", "yyt2"); map.put("003", "yyt3"); //ketSet遍历 foreach for(Object o:map.keySet()) { System.out.println(o); } //ketSet遍历 迭代器 Iterator it1 = map.keySet().iterator(); while(it1.hasNext()) { System.out.println(it1.next()); } //values foreach for(Object o:map.values()) { System.out.println(o); } //values 迭代器 Iterator it2 = map.values().iterator(); while (it2.hasNext()) { System.out.println(it2.next()); } //entry foreach Set<Entry<String, String>> entry = map.entrySet(); for(Entry<String, String> e:entry) { System.out.println(e.getKey()+","+e.getValue()); } //entry 迭代器 Iterator<Entry<String, String>> it = map.entrySet().iterator(); while(it.hasNext()) { Map.Entry<String, String> entry1 = it.next(); System.out.println(entry1.getKey()+","+entry1.getValue()); } } }
五、HashSet
无序，不可重复。其实它就是HashMap中的key。
它没有顺序，不能通过get（）来获取元素
所以遍历用增强型for循环和Iterator迭代器
接下来用HashSet来解决一个问题：
问题：
创建一个长度是100的字符串数组
使用长度是2的随机字符填充该字符串数组
统计这个字符串数组里重复的字符串有多少种并输出重复值
思路：定义两个HashSet，利用第一个插入随机字符串数组，但是HashSet不允许重复，所以第二次遇到重复的则会插入失败，用第二个HashSet保存插入失败的元素，最后只需要统计第二个HashSet的长度和其中元素便找到了有多少种重复和重复值是什么。
代码：
public class HashSetTest { public static void main(String[] args) { //获取100个长度为2的随机字符串 String s[] = new String[100]; for(int i=0;i<s.length;i++) { s[i] = randomStr(2); } System.out.println("初始化字符串数组为："); for(int i=0;i<s.length;i++) { System.out.print(s[i] +" "); if(i%10==9) System.out.println(); } HashSet<String> repeat =new HashSet<String>(); HashSet<String> sets =new HashSet<String>(); for(String str:s) { if(!sets.add(str)) {//当之前有重复值的时候，第二次会插入失败 repeat.add(str);//将插入失败的值保存，也就是重复值 } } System.out.println("重复的有"+repeat.size()+"个"); for(String str:repeat) { System.out.println(str); } } //获取随机字符串 public static String randomStr(int length) { Random r = new Random(); int i; String s = "qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM1234567890"; char sa[]=new char[length]; for(int j=0;j<length;j++) { //26个大写字母，26个小写字母，10位数字 i = r.nextInt(26+26+10-1); sa[j]=s.charAt(i); } return new String(sa); } }
六、关系和区别
1、collection与collections
collection是一个接口，是Set，List，Queue的接口
collections是一个类，容器的工具类
常用方法
2、ArrayList与HashSet
ArrayList有序，HashSet无序
List中可以重复，Set中不能重复
3、ArrayList与LinkedList
都可以重复
ArrayList插入数据慢，删除数据慢，但它是顺序结构，定位快
LinkedList插入、删除数据快，但它是链表结构，定位慢
4、线程安全的与线程不安全的
Vector与ArrayList区别
HashTable与HashMap区别
都是前者是线程安全的类。