集合框架

集合框架总图：

一、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区别

都是前者是线程安全的类。