集合与泛型

集合与泛型

一、集合：就像是一种容器。用于存储、获取、操作对象的容器。

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父类类型带泛型类型的集合