集合与泛型 |
一、集合:就像是一种容器。用于存储、获取、操作对象的容器。
1. 数组的弊端
①数组的长度不可变 ②数组没有提供可以查看有效元素个数的方法
2. 集合的特点
①集合的长度是可变的
②集合可以存储任意类型的对象
③集合只能存储对象
3. 集合框架
java.util.Collection : 集合层次的根接口
|--- java.util.List: 有序的,可以重复的。
|--- ArrayList: 采用数组结构存储元素。 查询操作多时选择
|--- LinkedList: 采用链表结构存储元素。 增删操作多时选择
|--- Vector:
|--- java.util.Set: 无序的,不允许重复。
|--- HashSet : 是 Set 接口的典型实现类。
判断元素是否存在的依据是:先比较 hashCode 值,若 hashCode 存在,再通过 equals() 比较内容
若 hashCode 值不存在,则直接存储
注意:重写 hashCode 和 equals 二者需要保持一致!
|--- LinkedHashSet: 相较于 HashSet 多了链表维护元素的顺序。遍历效率高于 HashSet , 增删效率低于 HashSet
|--- TreeSet : 拥有自己排序方式
|-- 自然排序(Comparable):
①需要添加 TreeSet 集合中对象的类实现 Comparable 接口
②实现 compareTo(Object o) 方法
|-- 定制排序(Comparator)
①创建一个类实现 Comparator 接口
②实现 compare(Object o1, Object o2) 方法
③将该实现类的实例作为参数传递给 TreeSet 的构造器
4. 集合的遍历
① 增强 for 循环
for(被遍历集合中元素的数据类型 变量名 : 被遍历的集合){
}
ArrayList al = new ArrayList();
al.add("AA");
al.add("BB");
for(Object obj : al){
System.out.println(obj);
}
② 使用 Iterator 迭代器
//1)获取当前集合的迭代器
Iterator it = al.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
/*错误的做法:通常一个 hasNext() 配合一个 next() 使用
Iterator it = al.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(it.next());
}*/
③ ListIterator : 列表迭代器,是List特有的迭代器(了解)
ListIterator li = al.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("BB")){
li.set("BBBBBBBBBBb");
}
}
二、Map系列集合
java.util.Map : 用于存储成对对象的集合。具有 key(键)-value(值)对映射关系的集合。一个 key 对应着一个 value。 key不允许重复的。
|--- HashMap:是 Map接口的典型实现类。
|--- LinkedHashMap: 相较于 HashMap 多了链表维护元素的顺序
|--- Hashtable: 是线程安全的,因此效率低
|--- Properties : 用于操作属性文件
|--- TreeMap : 根据 key 拥有自己的排序方式
|-- 自然排序(Comparable):
|-- 定制排序(Comparator):
//使用 Properties 操作属性文件
@Test
public void test1() throws FileNotFoundException, IOException{
//1. 创建 Properties 对象
Properties props = new Properties();
//2. 通过 load() 方法加载属性文件
props.load(new FileInputStream("hello.properties"));
//3. 通过 getProperty() 方法根据key获取对应的value
String userName = props.getProperty("username");
String password = props.getProperty("password");
System.out.println(userName);
System.out.println(password);
}
1. Map的常用方法:
添加、删除操作:
Object put(Object key,Object value)
Object remove(Object key)
void putAll(Map t)
void clear()
元素查询的操作:
Object get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
boolean isEmpty()
boolean equals(Object obj)
2. Map 的遍历:
Map map = new HashMap();
map.put("AA", 123);
map.put("BB", 456);
keySet();
//遍历Map的方式一: 获取 Map 中所有的 key
Set set = map.keySet();
values();
//遍历Map的方式二:获取 Map中所有的 value
Collection coll = map.values();
//遍历Map的方式三: 获取Map中所有的 Entry (是Map 的一个内部类,一个Entry对应着Map中的一个key和一个value)
Set entrySet = map.entrySet();
for(Object obj : entrySet){
Entry entry = (Entry)obj;
Object key = entry.getKey();
Object value = entry.getValue();
}
Iterator it = entrySet.iterator();
while(it.hasNext()){
Entry entry = (Entry)it.next();
Object key = entry.getKey();
Object value = entry.getValue();
}
三、
为什么使用泛型:若集合中不使用泛型,意味着集合中可以添加任意类型的对象。若需要具体到某一个类型时,需要强制类型转换
可能引发 ClassCastException
泛型: 在 Java 中以 "<>" 的形式呈现,<> 中写引用数据类型
用于限制集合中存放元素的类型
1. 在集合中应用泛型
2. 自定义泛型类、接口、方法
class DAO<T>{ // T : Type E:Element K:Key V:Value
private List<T> list = new ArrayList<T>();
public void add(T t){
list.add(t);
}
public T get(int id){
return list.get(id);
}
//自定义泛型方法
public <E> E[] srot(E[] e){
}
}
3. 通配符 ?
虽然 Person 是 Student 的父类,但是 List<Person> 就不是 List<Student> 的父类
//需求:
//public void show(List<Student> list){}
//public void show1(List<Man> list){}
public void show(List<? extends Person> list){}
List<?> : 可以接收任意带泛型类型的集合
List<? extends Person> : 可以接收 Person 本类类型及 Person子类类型带泛型类型的集合
List<? super Person> : 可以接收 Person 本类类型及 Person父类类型带泛型类型的集合