Collection系列集合
1. 数组的弊端：①数组的长度不可变 ②数组中没有提供可以查看有效元素个数的办法
2. 集合的特点：
①集合的长度是可变的
②集合可以添加任意类型的对象
③集合中只能存对象
3.集合框架
java.util.Collection 接口: 是集合层次的根接口
|-- java.util.List 接口：有序的，允许重复的。因为 List 系列集合都具有索引值
|--java.util.ArrayList : 采用的数组结构存储元素。查询操作多时。
|--java.util.LinkedList : 采用的链表结构存储元素。增删操作多时选择。
|--java.util.Vector : 是一个古老的实现。线程安全，因此效率低
|-- java.util.Set 接口： 无序的，不允许重复的。
|--java.util.HashSet:是 Set 接口的典型实现类。
判断元素是否存在的依据是，先比较 hashCode 值，若 hashCode 值不存在
则直接存储，若 hashCode 值存在，再通过 equlas 比较两个对象的内容。
注意：重写 hashCode 和 equals 时二者需要保持一致！
|--java.util.LinkedHashSet：是 HashSet 的子类，相较于 HashSet 多了链表维护元素的顺序。
增删效率低于 HashSet ，查询遍历效率高于 HashSet
|--java.util.TreeSet: 拥有指定的排序方式
自然排序（Comparable）：
①需要添加到集合中对象的类实现 Comparable 接口
②实现接口中的 compareTo(Object o1)
定制排序（Comparator）：
①声明一个类实现 Comparator 接口
②实现接口中的 compare(Object o1, Object o2){}
③将该实现类的实例作为参数传递给 TreeSet 的构造器
集合的遍历
1. 增强 for 循环for(被遍历集合中元素的数据类型 变量名 : 被遍历的集合){
}
@Test
public void test1(){
List list = new ArrayList();
list.add("AA");
list.add("BB");
list.add("CC");
list.add("DD");
list.add("EE");
for(Object obj : list){
String str = (String) obj;
System.out.println(str.toLowerCase());
}
}
2. 使用 Iterator 迭代器
@Test
public void test2(){
List list = new ArrayList();
list.add("AA");
list.add("BB");
list.add("CC");
list.add("DD");
list.add("EE");
//①获取当前集合的迭代器
Iterator it = list.iterator();
//②通过 hasNext() 和 next() 方法取出集合中存储的元素
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
3. (了解) ListIterator 列表迭代器 : 是 List 系列集合特有的迭代器
@Test
public void test5(){
List list = new ArrayList();
list.add("AA");
list.add("BB");
list.add("CC");
list.add("DD");
list.add("EE");
//需求:判断若集合中元素为“BB”则在该位置添加一个 “bbb”
/*Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("BB")){
list.add("bbb");
}
}*/
ListIterator li = list.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("BB")){
// li.add("bbbb");
li.set("bbbbbbbbbbb");
}
}
while(li.hasPrevious()){
System.out.println(li.previous());
}
}
Map 系列映射集合
一、java.util.Map : 用于操作成对对象的集合。具有 key（键）-value（值）映射关系的集合。
一个 key 对应着一个 value，key 不允许重复。
|--java.util.HashMap : 是 Map 接口的典型实现类。线程不安全的，因此效率高。
|--java.util.LinkedHashMap:
|--java.util.Hashtable: 是一个古老的实现。是线程安全的，因此效率低。
|--java.util.Properties:用于操作属性文件
|--java.util.TreeMap:根据 key 拥有指定的排序方式
自然排序（Comparable）：
定制排序（Comparator）：
@Test
public void test3() throws FileNotFoundException, IOException{
//①创建 Properties 对象
Properties props = new Properties();
//②使用 load() 方法加载属性文件
props.load(new FileInputStream("hello.properties"));
//②使用 getProperty() 方法根据 key 获取对应的 value
String userName = props.getProperty("userName");
String password = props.getProperty("password");
System.out.println(userName);
System.out.println(password);
}
二、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)
元视图操作的方法：
Set keySet()
Collection values()
Set entrySet()
三、遍历 Map 的三种方式：
@Test
public void test4(){
Map map = new HashMap();
map.put("AA", 11);
map.put("BB", 22);
map.put("CC", 33);
map.put("DD", 44);
map.put("EE", 55);
//遍历 Map 的方式一：获取 Map 中所的 key
Set keySet = map.keySet();
for(Object obj : keySet){
String str = (String) obj;
System.out.println(str.toLowerCase());
Object value = map.get(obj);
System.out.println(value);
}
System.out.println("----------------------------------------------");
//遍历 Map 的方式二：获取 Map 中所的 value
Collection values = map.values();
Iterator it = values.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
System.out.println("----------------------------------------------");
//遍历 Map 的方式：获取 Map 中所的 Entry(是 Map 的内部类，一个 Entry 对应着一个 key 和一个 value)
Set entrySet = map.entrySet();
for (Object obj : entrySet) {
Entry entry = (Entry) obj;
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
Iterator iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry entry = (Entry) iterator.next();
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key + "=" + value);
}
}
Collections 工具类
一、Collections 工具类：用于操作集合的工具类
排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
查找、替换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值
泛型
一、
为什么使用泛型：若集合中不使用泛型，意味着集合中可以添加任意类型的对象
若需要具体到某一个类型时，需要强制类型转换，可能引发 ClassCastException
泛型：是 jdk1.5 后出的特性，泛型在 Java 中以 "<>" 的形式呈现，<> 中写引用数据类型
可以限制集合中存放元素的类型
1. 集合中使用泛型
//集合中使用泛型
@Test
public void test2(){
List<String> list = new ArrayList<>();
list.add("AA");
list.add("BB");
list.add("CC");
for(String str : list){
System.out.println(str.toLowerCase());
}
}
//集合中不使用泛型的弊端
@Test
public void test1(){
List list = new ArrayList();
list.add("AA");
list.add("BB");
list.add("CC");
list.add(11);
for(Object obj : list){
String str = (String) obj;
System.out.println(str.toLowerCase());
}
}
2. 自定义泛型类、接口、方法
class DAO<T>{//T : Type E : Element K : Key V : value R : Return
private List<T> list = new ArrayList<T>();
public void add(T t){
//
}
public T get(){
//
}
//自定义泛型方法
public static <R> R sort(Class<R> clazz){
}
}
DAO.sort("AA");
DAO<User> dao = new DAO<User>();
dao.add(new User());
class UserDAO extends DAO<User>{
}
3.通配符 ? : 虽然 Student 是 Person 的子类，但是 List<Student> 就不是 List<Person> 的子类。
意味着不能使用多态，会大大降低程序的灵活性。
List<?> : 可以接收任意类型泛型的集合
List<? extends Person> : 可以接收 Person 本类类型的泛型集合及 Person 子类类型的泛型集合
List<? super Person> : 可以接收 Person 本类类型的泛型集合及 Person 父类类型的泛型集合
Student stu = new Student();
Perosn p = stu;//多态
List<Student> stuList = new ArrayList<>();
//List<Person> perList = stuList; //错误的语法
/*//需求：展示一堆男人吃饭和走路的功能
public static void show(List<Man> list){
}
//需求：展示一堆女人吃饭和走路的功能
public static void show(List<Woman> list){
}*/
public stsatic void show(List<? extends Person> list){
for(Person person : list){ //多态
person.eat(); //虚拟方法调用
person.walk();
}
}
最后：
集合中的null问题，list中可以存储nall自然不用多说；set中存储的值也可以为null；最最重要的是map中hashmap与linkedhashmap的key与value也都可以为null；注意！！！treemap中的key与value也可以为null，但必须是定制排序的情况下实现Comparator接口中的public int compare(Object o1, Object o2)方法才允许key为null，否则在put数据是会出现——Exception in thread “main” Java.lang.NullPointerException 异常！！！