容器（Collection接口/List接口/Set接口/Map接口）

Collection接口

1.<>泛型（规定存储数据的类型）
增强可读性和稳定性
使用泛型保留了容器中的元素的类型

Collection<String> names = new ArrayList<String>();
    names.add("abc");
    names.add("www");

2.Iterator接口
方便对容器中的元素进行遍历操作

 //2.迭代器(三步)
    //获取迭代器对象
    Iterator it = col.iterator();
    //判断是否有下一个元素
    while(it.hasNext()) {
    //获取下一个
        System.out.println(it.next());
    }

List接口(有序 可重复)

1.List接口与遍历

public class ListDemo {
public static void main(String[] args) {

	List<Integer> ls = new ArrayList();
	//add
	ls.add(3);
	ls.add(2);
	ls.add(1);
	ls.add(11);
	ls.add(12);
	System.out.println(ls);
	//get(int index)
	System.out.println(ls.get(1));
	//int indexOf
	System.out.println(ls.indexOf(2));
	//remove
	ls.remove(1);
	System.out.println(ls);
	//set
	System.out.println(ls.set(1, 0));
	System.out.println(ls);
	
	//遍历
	System.out.println("------普通for------");
	for(int i = 0;i<ls.size();i++) {
		System.out.println(ls.get(i));
	}
	System.out.println("------for..each------");
for(int i : ls) {
	System.out.println(ls);
}
System.out.println("------iterator-----");
Iterator<Integer> it  = ls.iterator();
while(it.hasNext()) {
	System.out.println(it.next());
}
}
}

2.ArrayList
底层：可变数组（数组在内存中分配连续的内存空间）

特点：
优点：根据索引遍历，获取效率高
缺点：做增删效率低
适用于大量查询少量增删的情况
扩容： 通过copyof进行动态扩容 每次1.5
Vector:
** 与ArrayList类似 使用底层数组**
区别：
V线程安全L线程不安全
V每次扩容原容量2倍，L每次扩1.5倍

LinkedList
底层： 使用双向链表实现
优点：插入删除效率高
缺点：查询效率低
适用于大量增删少量查询的情况
3.LinkedList
使用单向链表简单实现
数据都是以节点为单位
单向链表：节点：数据值 下一个节点的地址
双向链表 节点：上一个节点的地址 数据值 下一个节点的地址

public class LinkedList03 {
public static void main(String[] args) {
	MyLinkedList my = new MyLinkedList();
         


}
}
//自定义容器类
class MyLinkedList{
	//记录链表头节点
	private Node head;
	
	//记录容器中数据的个数（节点的个数）
	 private int size;
	 
	public MyLinkedList() {
		
	}
	
}
//单向链表：节点 ： 数据值 下一个节点的地址
class Node{
	private Object data;//数据值
	private Node next; //下一个节点
	public Node(Object data, Node next) {
		super();
		this.data = data;
		this.next = next;
	}
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data = data;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	public void next(Object data, Node next) {
		
		this.data = data;
		this.next = next;
	}

}

Set接口（无序 不可重复）

set集合的基本用法
1.创建集合对象
2.存储添加数据
3.获取元素，但是不能通过普通for循环

常用方法：添加、删除、改、查

public class SetDemo09 {
public static void main(String[] args) {
	Set<Integer> set = new HashSet<Integer>();
	
	set.add(6);
	set.add(3);
	set.add(11);
	System.out.println(set.size());
	
	for(Integer i : set) {
System.out.println(i);
 }
	
	set.remove(3);
	System.out.println(set);
	
	set.contains(5);
	System.out.println(set);
	
}
}

Map接口

存储键值对
key–value 映射
存储数据的特点–>无序
key–>无序，不可重复，唯一的–>Set集合
value–>无序的，可重复，可以存储任意数据类型 -->Collection集合

注意：
一个key只能对应一个value
如果想要存储多个value值 可以存储在集合中（ArrayList）

去重：根据key去重，如果存放相同的key的映射，值value会被覆盖

Map的遍历
keySet() 获取所有的Key，根据key可以获取value
values() 获取所有的value，没有办法获取到key
Set<Map,Entry<k,v>> entrySet() 把Map集合中的每一个映射封装成Map.Entry类型的数据，放入一个Set集合中返回

public class MapDemo05 {
public static void main(String[] args) {
	Map<String,Integer> map = new HashMap();
	map.put("zhangsan", 180);
	map.put("lisi", 170);
	map.put("wangwu", 160);
	System.out.println(map);
	System.out.println(map.size());
	
	//去重
	map.put("lisi", 187);
	System.out.println(map);
	
	//获取
	System.out.println(map.get("lisi"));
	
	//删除
	System.out.println(map.remove("lisi"));
	System.out.println(map);
	
	/*
	 * boolean containsKey(Object key)
	 *     如果此映射包含指定键的映射关系，则返回true
	 * boolean containsValue(Object Value)

	 * 
	 * */
	
	System.out.println(map.containsKey("wangwu"));
	System.out.println(map.containsValue(185));
	
	//遍历(与collection遍历方式相同只能根据增强for和迭代器)
	
	System.out.println("----keySet------");
	Set<String> keys = map.keySet();
	for(String str : keys) {
		System.out.println(str+"-->"+map.get(str));
	}
	
	
	System.out.println("------values()---------");
	Collection<Integer> col = map.values();
    System.out.println(col);
    
    
    System.out.println("-----Set<Map,Entry<k,v>> entrySet()--------");
    Set<Map.Entry<String, Integer>> set = map.entrySet();
    for(Map.Entry<String, Integer> m :set) {
    	System.out.println(m.getKey()+"-->"+m.getValue());
    }



}
}