十一、集合
一、集合的分类：
单列集合：
Collection:
List:一致，可重复 --àarraylist linkedlist
Set:唯一，不可重复-àhashset
双列集合：map:
HashMap
*红色的为实现类，蓝色的为接口
二、常用方法
//JDK7的新特性，看懂就可以
//Collection<String> c = new ArrayList<>(); //多态的方式
Collection<String> c = new ArrayList<String>(); //多态的方式
boolean add(Ee):添加元素
booleanremove(Object o):从集合中移除元素
void clear():清空集合中的元素
booleancontains(Object o):判断集合中是否存在指定的元素
booleanisEmpty():判断集合是否为空
int size():集合的长度，也就是集合中元素的个数
三、集合的遍历
Collection<String>s = new ArrayList<>();
s.add("Hello");
s.add("guojia");
Iterator<String>iterator = s.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next()+ ",");
}
四、list集合
1、有序、可重复
void add(intindex,E element):在指定位置添加元素
E remove(intindex):删除指定位置的元素
E get(intindex):获取指定位置的元素
E set(intindex,E element):修改指定位置的元素
2、list普通for循环遍历
List<String> s = new ArrayList<>();
s.add("Hello");
s.add(",");
s.add("guojia");
s.add("!");
for (int i = 0; i <s.size(); i++) {
System.out.print(s.get(i));
}
3、列表迭代器
ListIterator:
ListIterator<E> listIterator():返回此列表元素的列表迭代器
public interface ListIterator<E>extendsIterator<E>
特有功能：
Eprevious():返回列表中的前一个元素。
booleanhasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
注意：ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆 //创建集合对象
List<String> list = newArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
ListIterator<String> lit =list.listIterator();
// while(lit.hasNext()){
// String s = lit.next();
// System.out.println(s);
// }
System.out.println("--------------------------");
while(lit.hasPrevious()) {
String s = lit.previous();
System.out.println(s);
}
向遍历。
4、增强for循环
增强for：是for循环的一种
格式：
for(元素的数据类型 变量名 : 数组名或者Collection集合对象名) {
使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
}
好处：简化了数组和Collection集合的遍历
弊端：目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。
List<String>s = new ArrayList<>();
s.add("Hello");
s.add(",");
s.add("guojia");
s.add("!");
for(String list:s){
System.out.println(list);
}
5、并发修改异常
List<String>s = new ArrayList<>();
s.add("Hello");
s.add(",");
s.add("guojia");
s.add("!");
Iterator<String> iterator =s.iterator();
while (iterator.hasNext()) {
if(iterator.next().equals(",")) {
s.add(" , ");
}
}
System.out.println(s);
}
java.util.ConcurrentModificationException
ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
产生的原因：
迭代器依赖于集合而存在，在判断成功后，集合中添加了新的元素，而迭代器并不知道，所有就报错了。
其实这个问题说的是：迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素。
如何解决呢?
A:迭代器遍历的时候，我可以通过迭代器修改集合中的元素
元素是跟在刚才迭代的元素后面的
B:集合遍历的时候，我可以通过集合对象修改集合中的元素
元素是在最后添加的
//迭代器遍历的时候，我可以通过迭代器修改集合中的元素
ListIterator<String> lit =list.listIterator();
while(lit.hasNext()) {
String s = lit.next();
if(s.equals("world")) {
lit.add("javaee");
}
}
//集合遍历的时候，我可以通过集合对象修改集合中的元素
// for(int x=0; x<list.size(); x++) {
// String s = list.get(x);
// if(s.equals("world")) {
// list.add("javaee");
// }
// }
五、常见的数据结构
1、栈
压栈：A，B,C
弹栈：C,B,A
2、队列（先进先出）
入 ：A，B,C ：
出：A，B,C
3、数组
查询快增删慢
4、链表
有数组和地址组成，查询慢，增删快
六、list的两个实现类
1、Arraylist:底层是数组查询快，增删慢
三种遍历方式：迭代器，for循环，增强for循环
2、linkedlist:底层是链表，增删快,查找慢
七、set集合
1、set是一个包含重复元素的集合，具体实现类hashset(不能保证迭代顺序，不能保证该顺序永久不变)
Hashset保证元素唯一性的原理：
八、Map集合
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。键名不可以相同，值可以 ,只保证键的唯一性，当有相同的key时，后面的value会覆盖掉前面的
1、hashmap
Map<String, String> m = newHashMap<>();
m.put("001", "张三");
m.put("002", "李四");
System.out.println(m);//{001=张三, 002=李四}
2、Map的成员方法
V put(K key,V value):添加元素
V remove(Object key):根据键删除键值对元素
void clear():移除所有的键值对元素
boolean containsKey(Objectkey)：判断集合是否包含指定的键
booleancontainsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
int size()：返回集合中的键值对的对数
V get(Object key):根据键获取值
Set<K> keySet():获取所有键的集合
Collection<V> values():获取所有值的集合
3、Map集合的遍历
方式一：Map<String,String> m=new HashMap<>();
m.put("001", "一");
m.put("002", "二");
m.put("003", "三");
m.put("004", "四");
m.put("005", "一");
m.put("006", "一");
Set<String> keySet = m.keySet();
for(String key:keySet){
String value = m.get(key);
System.out.println(key+":"+value);
}
方式二：
Set<Entry<String, String>> set =m.entrySet();
for(Entry<String, String> s:set){
String key = s.getKey();
String value = s.getValue();
System.out.println(key+":"+value);
}
例子：
Map<Student,String > m= new HashMap<>();
Student s1 = newStudent("大雄", 12);
Student s2 = newStudent("静香", 12);
Student s3 = newStudent("胖虎", 12);
Student s4 = newStudent("小夫", 12);
Student s5 = newStudent("小夫", 12);
m.put(s1, "广州");
m.put(s1, "上海");
m.put(s2, "北京");
m.put(s3, "上海");
m.put(s4, "深圳");
m.put(s5, "深圳");//重写hashcode和equels方法保证键的唯一性
// Student [name=胖虎, age=12]----上海
// Student [name=静香, age=12]----北京
// Student [name=小夫, age=12]----深圳
// Student [name=大雄, age=12]----上海
Set<Student> keySet =m.keySet();
for(Student s:keySet){
String adress =m.get(s);
System.out.println(s+"----"+adress);
}
}
4、arrayList嵌套HashMap
ArrayList<HashMap<String,String>> list=new ArrayList<>();
HashMap<String, String> h1=newHashMap<>();
h1.put("孙策", "大乔");
h1.put("周瑜", "小乔");
HashMap<String, String> h2=newHashMap<>();
h2.put("郭靖", "黄蓉");
h2.put("杨过", "小龙女");
HashMap<String, String> h3=newHashMap<>();
h3.put("令狐冲", "任盈盈");
h3.put("林平之", "岳灵珊");
list.add(h1);
list.add(h2);
list.add(h3);
for(HashMap<String, String> h:list){
Set<String> keySet = h.keySet();
for(String key:keySet){
String value = h.get(key);
System.out.println(key+"------"+value);
}
}
三、HashMap嵌套ArrayList
HashMap<String,ArrayList<String>> h = new HashMap<>();
ArrayList<String>list1 = new ArrayList<>();
list1.add("诸葛亮");
list1.add("赵云");
ArrayList<String>list2 = new ArrayList<>();
list2.add("唐僧");
list2.add("孙悟空");
ArrayList<String>list3 = new ArrayList<>();
list3.add("武松");
list3.add("鲁智深");
h.put("三国演义", list1);
h.put("西游记", list2);
h.put("水浒传", list3);
Set<Entry<String,ArrayList<String>>> entrySet = h.entrySet();
for(Entry<String,ArrayList<String>> set:entrySet){
String key= set.getKey();
ArrayList<String>values = set.getValue();
for(Strings:values){
System.out.println(key+"-----"+s);
}
}
}