Java--------集合Map,List,Set-原创手记-慕课网

集合是java中提供的一种类型 ,用于存储管理对象
为什么不用数组？数组难于扩充，不好进行插入和删除
java三大集合框架：List Set Map

List(序列)：有顺序可重复,动态扩充
Set(集合)：无序不可重复，动态扩充
Map(键值对)：键值对 key value，键不可重复

List：
boolean add(E e);
boolean isEmpty(); //判断序列是否为空
boolean remove(Object o); //移除序列中的元素
void clear(); //清除序列
int size(); //计算序列的长度
Iterator iterator();
E get(int index);
int indexOf(Object o);

ArrayList:序列，可重复，有顺序。可以动态扩充.基于数组实现--连续的。数组实现
LinkedList:序列，可重复，有顺序，可以动态扩充。基于链表实现---离散的。链表实现

foreach(变量:集合) foreach无法知道当前循环次数

*Vector:用法和内部实现和ArrayList一样，区别他是线程安全的，同步的

ArrayList:线程是不安全的

ArrayList:数组实现，线程不安全，不同步
Vector:数组实现，线程安全，同步的，用法和ArrayList完全相同

Collections.sort(list);//使用Collections.sort对集合排序

Set:
HashSet：无序的，不可重复，动态扩充
HashSet：无序的，不可重复，通过Hash表和链表实现

HashSet是如何保障不添加重复的对象呢？
HashSet是通过hshCode和equals方法来实现的。先判断hashCode是否相同，再判断是否equals；
入伙以上两个条件都成立，那么HashSet就认为是重复的对象。

TreeSet:排序的，不可重复，通过排序二叉树实现，有排序功能

排序二叉树：左子树元素值小于右子树元素值
SortedSet接口的实现类
可以排序
必须：元素实现Comparable接口；或调用TreeSet(Comparator<? super E> comparator) 构造函数，传递一个Coparator对象
TreeSet去重复的规则是使用Comparable接口定义的compareTo方法，或者Comparator接口中定义的compare方法
对于TreeSet，如果compareTo()返回0，就认为是相同的元素，即使两个通过equals()比较为false的元素，
也不能同时放入TreeSet，因为equals()方法根本不会被调用；
避开这个陷阱的唯一方式：依次比较成员变量，只有全部需要考虑的成员变量相同，才返回0，或者
只有equals比较为true时，才返回0.

TreeSet:要实现排序功能，就要实现 Comparable 接口或者 Comparator 接口
HashSet 如何保证不添加重复元素？
需要重写hashCode和equals. 1.判断对象的hashCode;2.判断两个对象是否equals

Iterator：迭代器，它和for循环遍历的区别：Iterator:遍历前不知道集合元素的个数，并且元素没有下标

Map：键值对，键不能重复，值能重复，动态扩充
HashMap:键 =值,是无序的，键不能重复，键和值可以为空null，如果添加的键重复，会产生替换效果，基于Hash表
TreeMap:有排序功能，键不能重复，也不能为null* 基于--排序二叉树
HashMap的key也是通过Hash算法过滤重复
Map的key一般都应用String
如果想用自己写的类作为key值，那么就必须重写hashCode()方法和equals()方法，而且要保证对象不可变，
也就是和String一样，一旦创建了这个对象，就不可修改。

TreeMap的key是通过Comparable接口过滤重复排序，也可以通过Comparator接口的实现类的对象来过滤重复排序
Map的key一般都应用String多
HsahMap:遍历的两种方式:
1.获得键的集合，遍历键的集合，取出值。
2.获得关系的集合，取出每个关系(k=v)

HashMap：线程不安全，不同步,允许null作为键/值，父类为 Map
Hashtable:用法和HashMap完全一样。线程安全，null作为键/值时会抛出异常,父类为： Dictionary.
Hashtable:键和值都不能为 null

Collections.shuffle(list);//shuffle打乱次序输出
List subList=list.subList(3, 7);//subList()获得子集合

三大集合的遍历方式：
List:1)for循环 2)Interator(迭代器)
例如：
ArrayList list=new ArrayList(); //创建一个数组集合序列
list.add(100); //添加元素
list.add(true);
list.add("成龙");
list.add("abc");
list.add('A');
list.add(0.123);
list.add(3.1415);
list.add(null);
//迭代器遍历
Iterator it=list.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
System.out.println("---------------");
//for循环遍历
for(int i=0;i<list.size();i++)
{
System.out.println(list.get(i));
} LinkedList list=new LinkedList();
list.add("北京");
list.add("上海");
list.add("广州");
list.add("深圳");
//遍历
for(int i=0;i<list.size();i++)
{
System.out.println(list.get(i));
} Set:Interator(迭代器)
例如：
HashSet set=new HashSet();
set.add("北京");
set.add(100);
set.add(3.14);
set.add('A');
set.add(null);
//遍历,只能使用迭代器
//迭代器：比如将瓜子从盘里，一个一个的取出
Iterator it=set.iterator(); //返回一个迭代器对象
//使用while是不知道循环次数
while(it.hasNext())
{
System.out.println(it.next());
} TreeSet set=new TreeSet();
set.add("beijing");
set.add("tianjing");
set.add("shanghai");
set.add("nanjing");
//使用迭代器排序
Iterator it=set.iterator();
while(it.hasNext())
{
System.out.println(it.next());
} Map:1)获得键的集合，迭代键的集合进行遍历
2)获得关系的集合，迭代关系集合分别获得每个关系的键和值
例如：
HashMap map=new HashMap();
map.put("010", "北京");
map.put("021", "上海");
map.put("071",null);
map.put(null, "深圳");
//先获得键的集合
Set keys=map.keySet();
//遍历键的集合
Iterator it=keys.iterator();
/方法一
while(it.hasNext())
{
Integer index=(Integer)it.next();
System.out.println(index+"=>"+map.get(index));
}/
while(it.hasNext())
{
String index=(String)it.next();
System.out.println(index+"=>"+map.get(index));
}
System.out.println("-------------------");
//方法二
Set<Map.Entry<String, String>> entys=map.entrySet();
it=entys.iterator();
while(it.hasNext())
{
Entry entry=(Entry)it.next();
System.out.println(entry.getKey()+"=>"+entry.getValue());
} TreeMap map=new TreeMap();
map.put("010", "北京");
map.put("021", "上海");
map.put("032", "天津");
Set keys=map.keySet();
Iterator it=keys.iterator();
while(it.hasNext())
{
String s=(String)it.next();
System.out.println(s+"=>"+map.get(s));
} 队列(Queue)：FIFO 先进先出，队头出队，队尾入队
例如：
Queue queue=new LinkedList();
//add()方法就是入队操作
queue.add("张三");
queue.add("李四");
queue.add("龙五");
queue.add("小六");
queue.add("田七");
//isEmpty()方法用于判断队列是否为空
//poll()方法是出栈
while(!queue.isEmpty())
{
System.out.println(queue.poll());
}

栈(Stack)：LIFO 先进后出,只能在栈顶操作，出栈，入栈
例如：
Stack stack=new Stack();
//push()方法是入栈
stack.push("北京");
stack.push("上海");
stack.push("天津");
stack.push("南京");
stack.push("杭州");
while(!stack.isEmpty())
{
//先进后出
System.out.println(stack.pop());
}