Iterable (迭代器)
Collection (集合)
- List
底层使用连续的数组存储
优点:遍历元素和随机访问元素的效率比较高,List添加的顺序和访问的顺序是一致的,List能添加重复元素
缺点:添加和删除需要大量移动元素效率底,按照内容查找效率底
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "姓名:" + name + ",年龄:" + age ;
}
List list = new ArrayList();
list.add(new Student("张三", 5));
list.add(new Student("李四", 7));
print(list);
- LinkedList
底层使用链表存储,不是连续的
优点:插入、删除元素时效率比较高,排序但是需要重写equals方法。
缺点:遍历和随机访问元素效率低下
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "姓名:" + name + ", 年龄:" + age ;
}
@Override
public boolean equals(Object obj) {
if(obj==null)return false;
if(obj instanceof Student){
Student s=(Student) obj;
//return s.age==age&&s.name==name;
//重写了toString方法才可以这样用
return s.toString().equals(toString());
}
return false;
}
List list=new LinkedList();
list.add(new Student("张三", 10));
list.add(new Student("李四", 20));
list.add(new Student("王五", 30));
print(list);
用增强for循环遍历
private static void print(List list) {
for(Object o:list){
System.out.println(o);
}
}
结果
姓名:张三, 年龄:10
姓名:李四, 年龄:20
姓名:王五, 年龄:30
Set
- HashSet
底层使用数组(hash算法)+链表实现
相等对象必须具有相等的哈希码
优点:添加速度快,查询速度快,删除速度快,无序
重写equals方法,必须重写Hashcode方法,有去重的功能
Set set = new HashSet();
set.add("abc");
set.add("asd");
set.add("qwe");
print(set);
增强for
private static void print(Set set) {
for(Object o:set){
System.out.println(o);
}
- TreeSet
底层采用二叉树(红黑树)的存储结构
优点:有序(排序后的升序)查询速度比List快(按照内容查询)
缺点:查询速度没有HashSet快
需要实现Comparable或者new Set(Compartor)才可以排序
private String name;
private int age;
private boolean sex;
public Student(String name, int age, boolean sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
@Override
public String toString() {
return "名字:" + name + ", 年龄:" + age + ",性别:" + sex ;
}
//用compartor 去重 必须实现
Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.toString().compareTo(o2.toString());
// int c = o1.getAge() - o2.getAge();
// if (c != 0) {
// return c;
// }
// c = o1.getName().compareTo(o2.getName());
// if (c != 0) {
// return c;
// }
// return new Boolean(o1.isSex()).compareTo(o2.isSex());
}
});
set.add(new Student("asda", 10, true));
set.add(new Student("张三", 10, true));
set.add(new Student("李四", 20, false));
set.add(new Student("张三", 20, false));
set.add(new Student("张三", 10, true));
set.add(new Student("李四", 20, false));
print(set);
}
private static void print(Set set) {
for (Object o : set) {
System.out.println(o);
}
}
排序可以用
return o1.toString().compareTo(o2.toString());
也可以用
int c = o1.getAge() - o2.getAge();
if (c != 0) {
return c;
}
c = o1.getName().compareTo(o2.getName());
if (c != 0) {
return c;
}
return new Boolean(o1.isSex()).compareTo(o2.isSex());
}
});
同样用增强for
Map
- HashMap
允许使用null键null值
Map map=new HashMap();
map.put("a", "asd");
map.put("c", "asdasf");
map.put("d", "asfssdf");
map.put("b", "agsdfsd");
print(map);
增强for遍历
- Hashtable
不允许使用null键null值
Map map=new Hashtable();
map.put(null, null);
空指针异常
- TreeMap
key必须实现Comparable,根据key排序。
Map map=new TreeMap<>();
map.put("b", "asdasd");
map.put("a", "fsdf");
map.put("d", "fdsfs");
map.put("c", "adada");
print(map);
System.out.println("----------->");
map.put("a", "fsdfsad");
map.remove("b");
print(map);
}
private static void print(Map map) {
Set keyset=map.keySet();
for(Object o:keyset){
System.out.println(o+"--------->"+map.get(o));
}
}
泛型
解决数据类型操作不统一产生的异常
给类定义泛型,类名后面
给静态方法定义泛型
两个泛型参数(也可以写一个,前面的后面的都可以)