回忆集合笔记
集合和数组的区别
元素类型
集合：引用类型（存储基本类型时会自动装箱）
数组：基本类型、引用类型
元素个数
集合：不固定，可以任意扩容
数组：固定
集合优点
不受容器大小限制，可以随时添加、删除元素、提供了大量操作元素方法
List集合
特点：可重复，有序（存取顺序相同）
应用：List list = new ArrayList();
List listDemo = new ArrayList();
Student s1 = new Student("谢广坤",44);
Student s2 = new Student("谢永强",20);
Student s3 = new Student("谢广坤",44);
Student s4 = new Student("谢大脚",43);
listDemo.add(s1);
listDemo.add(s2);
listDemo.add(s3);
System.out.println(listDemo.get(2));
System.out.println(listDemo.size());
for (int i = 0; i < listDemo.size(); i++) {
System.out.println(listDemo.get(i));
}
迭代器
对过程的重复叫迭代
迭代器是遍历collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。
迭代器的常用方法
next（）：返回迭代的一个元素对象
hasNext（）：如果有元素可以迭代返回true
注意：列表迭代器是List体系独有的遍历方法，可以在对集合遍历的同时进行添加和删除等操作。
但是必须通过 调用列表迭代器的方法来实现。
//创建集合对象
List list = new ArrayList();
//创建元素对象
//将元素添加到
list.add("a");
list.add("b");
list.add("c");
//遍历集合
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
// 没有添加泛型，需要类型转换
String string = (String) iterator.next();
System.out.println(string);
}
//列表迭代器
//根据集合对象获取列表迭代器对象
ListIterator listIterator = list.listIterator();
//判断迭代器中是否有元素
while(listIterator.hasNext()) {
String string = (String)listIterator.next();
if ("b".equals(string)) {
listIterator.add("java");
}
}
System.out.println(list);
泛型（1.5开始）
泛指任意类型，幼教参数化类型，对具体类型的使用起到辅助作用，类似方法参数
好处：类型安全，避免类型转换
泛型一般只和集合类 相结合使用
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
for (String string : list) {
System.out.println(string);
} Collections工具类
max(Clloection
sort(List
reverse(List
shuffle(List
//打印集合
System.out.println(Collections.max(list));
// Collections.sort(list);
// System.out.println(list);
Collections.sort(list);
Collections.reverse(list);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Set集合
特点：不可重复，无序
//创建集合对象
Set set = new HashSet();
// 创建元素对象
Student s1 = new Student("谢广坤",41);
Student s2 = new Student("刘能",44);
Student s3 = new Student("赵四",39);
Student s4 = new Student("王老七",45);
Student s5 = new Student("宋富贵",43);
Student s6 = new Student("谢广坤",41);
// 将集合对象添加到元素对象中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
// 遍历集合，必须在Student中重写equal()和hashCode()
System.out.println(set);
// 通过迭代器遍历Set集合
Iterator iterator = set.iterator();
// 判断迭代器中是否有元素
while(iterator.hasNext()) {
// 如果有，就获取元素
Student student = iterator.next();
System.out.println(student);
}
System.out.println("=============");
// 通过增强for
for (Student student : set) {
System.out.println(student);
}
Student：
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
Map集合
特点：键不可以重复，值可以重复
成员方法
V put(K key,V value);添加元素（键值对），元素的第一次添加，返回null，重复添加会用新值覆盖旧值，
并返回旧值
V get（Object key）;根据键值获取对应的值
Set
遍历步骤：
1、获取所有键的集合 keySet()
2、遍历所有的键，获取到每一个键 迭代器，增强for
3、根据键，获取指定的值 get（）；
// 创建集合对象
Map map = new HashMap();
// 创建元素的对象
Student s1 = new Student("广坤",23);
Student s2 = new Student("刘能",23);
Student s3 = new Student("赵四",23);
Student s4 = new Student("赵四",23);
// 将元素对象添加到集合中
Student stu1 = map.put(1, s1);
System.out.println(stu1);
Student stu2 = map.put(1,s2);
System.out.println(stu2);
map.put(2,s2);
map.put(3,s3);
System.out.println(map.get(3));
// 遍历集合
// 获取所有键的集合
Set keys = map.keySet();
//获取迭代器对象
Iterator iterator = keys.iterator();
while(iterator.hasNext()) {
// 如果迭代器中有数据，就获取
Integer key = iterator.next();
// 根据键获取值
Student value = map.get(key);
System.out.println(key+" "+value);
}
System.out.println("======================");
//通过增强for
for (Integer key : keys) {
System.out.println(key+" "+ map.get(key));
}