集合框架和泛型

一.集合框架
Collection  Collection 接口存储一组不唯一，无序的对象。  不唯一，无序
  List       List 接口存储一组 不唯一，有序（插入顺序）的对象 不唯一 有序
Array List 常用方法
 boolean add（object o） 在列表的末尾顺序添加元素，起始索引值从0开始
 void add(int index,Objece obj) 将元素obj插入到集合的index索引位置
 Object get(int index) 返回集合中索引为index的元素
 int indexof(object obj) 返回元素在集合中出现的索引
 Object set(int index,object obj)将index 索引位置的元素替换为obj元素
 Object remove(int index)删除并返回index索引位置的元素
 boolean is Empty() 判断集合是否为空
 boolean contains(object obj) 判断集合中是否包含obj  
 clear() 清空集合
 isEmpty()  是否为空
 toArray()转换数组
import java.util.ArrayList;


public class TestArrayList {
public static void main(String[] args) {
//定义集合
ArrayList list1 = new ArrayList();
//List list2 = new ArrayList();

//添加
list1.add(1);
list1.add("sfd");
list1.add(new String("aaa"));

//在某个位置添加(如果下标超过集合的长度，存在下标越界)
list1.add(1, "test");

//返回指定元素的下标值，如果存在返回下标值，如果不存在返回-1
int index = list1.indexOf("sfhsdfjs");
//System.out.println(index);

//替换指定下标位置的值(如果下标超过集合的长度，存在下标越界)
list1.set(1, "zhonguo");

//删除指定下标位置的元素，返回值为该元素
Object obj = list1.remove(1);
System.out.println("======="+obj);

//判断集合中元素是否为空 ，如果为空返回true,如果不为空返回false
boolean isEmpty = list1.isEmpty();
System.out.println(isEmpty);

//判断集合中某个元素是否存在，如果存在返回true,不存在返回false
boolean isCz = list1.contains("aaa");
System.out.println("是否存在"+isCz);

//集合的遍历(长度为：集合对象名.size())
for (int i = 0; i < list1.size(); i++) {
//获取指定下标位置的元素
System.out.println(list1.get(i));
}
}
}
LinkedList常用方法
 void addFirst(Object o)  将给定元素插入当前集合头部
 void addLast(Object o)   将给定元素插入当前集合尾部
 Object getFirst( )       获得当前集合的第一个元素
 Object getLast( )        获得当前集合的最后一个元素
 Object removeFirst( )    移除并返回当前集合的第一个元素
 Object removeLast( )     移除并返回当前集合的最后一个元素


public class TestLinkedList {
public static void main(String[] args) {
Employee emp1 = new Employee(1,"张三",25,"2016-3-14");

LinkedList linked = new LinkedList();

linked.addFirst("aa");
linked.addLast(456);
linked.add(emp1);
linked.addLast(46);

//删除第一个
linked.removeFirst();
//获取下标为2的值
linked.get(2);

for (Object object : linked) {
System.out.println(object);
}
}
}


ArrayList和LinkedList分别在何时使用？
ArrayList
遍历元素和随机访问元素的效率比较高
插入、删除等操作频繁时性能低下
 
LinkedList
插入、删除元素时效率较高
查找效率较低
  




 Map       键----值对 key-value(k-v)
Iterator 


Collections:类
1.  List
   Size()
  get(index)
  add(Object)
2.  LinkedList 
  addFirst()
  addLast()
3.Set


   Set     Set接口 存储一组唯一，无序的对象   唯一  无序
   Set 里面存放的是对象的引用
   Set使用对象的equals（）方法比较是否为同一对象
4.迭代集合
 增强型for
 迭代器 Iterator
        iterator
hasNext();
(Type)**Next();
获得Map键和值的方式
（1）KeySet()--Set    Set keySet=hm.keySet();
 (2)迭代这个 Set(Iterator)  Iterator iterator=keySet.iterator();
（3）get(key)        while(iterator.hasNext()){
Object o=(Object)iterator.next();
System.out.println(hm.get(o));
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class TestEmployee {
public static void main(String[] args) {
//创建员工对象
Employee emp1 = new Employee(1,"张三",25,"2016-3-14");
Employee emp2 = new Employee(2,"李四",25,"2016-2-14");
Employee emp3 = new Employee(3,"王五",25,"2016-1-14");

//定义集合
List list = new ArrayList();
list.add(emp1);
list.add(emp2);
list.add(emp3);

System.out.println("共有员工:"+list.size()+"名。");

//循环输出信息
// for (int i = 0; i < list.size(); i++) {
// //获取指定下标的元素(返回值为Object,需要强制类型转换)
// //Object obj = list.get(i);
// Employee em = (Employee)list.get(i);
// System.out.println("编号:"+em.getEmpNo()+",姓名:"+em.getEmpName()+",年龄:"+em.getAge()+",入职时间:"+em.getJoinDate());
// }

//用Iterator遍历集合对象
Iterator it = list.iterator();

//hasNext()判断是否有下一条数据
while(it.hasNext()){
//next()获取元素
Employee employee = (Employee)it.next();

System.out.println("编号:"+employee.getEmpNo()+",姓名:"+employee.getEmpName()+",年龄:"+employee.getAge()+",入职时间:"+employee.getJoinDate());
}

//改写是错误的...
// while(it.next()!=null){
// //next()获取元素
// Employee employee = (Employee)it.next();
//
// System.out.println("编号:"+employee.getEmpNo()+",姓名:"+employee.getEmpName()+",年龄:"+employee.getAge()+",入职时间:"+employee.getJoinDate());
// }
}
}
集合框架（二）
5.Map接口
  键值对
 put(k,v)；
 get(k)；
 remove(k);
 size();
keySet() --set类型
values（） collection类型
遍历集合 ****************************************************8
 增强for 
key不允许重复
value允许重复
添加的对象将转换为Object类型
Object put(key, value)  将相互关联的一个关键字(key)与一个值(value)放入该集合。
Object remove(Object key) 从当前集合中移除与指定键相关的映射，并返回该键关联的旧值。如果key没有任何关联，则返回null
Object get(Object key)  获得与关键字key相关的值。如果该键不关联任何非null值，则返回null
 boolean containsKey(key) 判断集合中是否存在关键字key
boolean containsValue(value)  判断集合中是否存在值value
boolean isEmpty()  判断集合中是否有存在元素
void clear()   清除集合中所有元素
int size()   返回集合中元素的数量
Set  keySet()  获取所有键key的集合
Collection values()  获取所有值value的集合
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;


public class TestHashMap {
public static void main(String[] args) {
//创建HashMap集合
HashMap hashMap = new HashMap();

//1.添加元素
// hashMap.put(new Employee(1,"张三",25,"2016-3-14"),"aa");
// hashMap.put(new Employee(2,"李四",25,"2016-3-14"),"bb");


hashMap.put("b","aa");
hashMap.put("a","bb");
hashMap.put("c","cc");
hashMap.put("z","dd");
hashMap.put("f","ee");
hashMap.put("e","ff");

//2.删除元素(根据key的值来删除)
//Object obj = hashMap.remove("a");
//System.out.println(hashMap.size());
//System.out.println(obj);

//3.获取元素的value值(根据key的值来获取value,如果key不存在，则返回null值)
Object object = hashMap.get("b");
//System.out.println(object);

//4.获取所有的key值
Set keySet = hashMap.keySet();

//用迭代器来遍历key的值
Iterator it = keySet.iterator();
while(it.hasNext()){
Object obj1 = it.next();
//System.out.print("key的值为:"+obj1);
}

//5.获取所有的value的值
Collection coll = hashMap.values();

//用增强for循环来遍历
for(Object obj:coll){
//System.out.println(obj);
}

//6.集合中是否存在key的值(如果存在返回true。否则返回false)
boolean isKey = hashMap.containsKey("aa");
System.out.println(isKey);

//7.集合中是否存在value的值(如果存在返回true。否则返回false)
boolean isValue = hashMap.containsValue("aa");
System.out.println(isValue);

//8.是否为空(如果为空返回true。否则返回false)
boolean isEmpty = hashMap.isEmpty();
System.out.println(isEmpty);

//9.清空
hashMap.clear();

//10.集合的大小
System.out.println(hashMap.size());
}
}


import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;


public class TestPoem {
public static void main(String[] args) {
Poem p1 = new Poem("静夜思","李白","窗前...");
Poem p2 = new Poem("草","白居易","野火烧不尽，春风吹又生!");
Poem p3 = new Poem("声声慢","李清照","凄凄惨惨...");

//集合
HashMap hm = new HashMap();

//添加
hm.put(p1.getName(),p1.getContent());
hm.put(p2.getName(),p2.getContent());
hm.put(p3.getName(),p3.getContent());

//获取所有的key值
Set keySet = hm.keySet();

//迭代key的值
Iterator iterator = keySet.iterator();
while(iterator.hasNext()){
Object key = iterator.next();
System.out.println(key+"---"+hm.get(key));
}
}
}








二  泛型


泛型 将对象的类型作为参数，指定到其他类或者方法上,从而保证类型转换的安全性和稳定性
 本质是参数化类型
import java.util.ArrayList;
import java.util.HashMap;


public class Demo01 {
public static void main(String[] args) {
ArrayList<String> listStr = new ArrayList<String>();

listStr.add("aa");

ArrayList<Person> listPer = new ArrayList<Person>();
listPer.add(new Person("李蕾",20,"男"));
listPer.add(new Person("李雷",20,"男"));

for (Person person : listPer) {
System.out.println(person.getName());
}

//
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1, "aa");
hm.put(2,"bb");
}
}