黑马程序员——集合

最新推荐文章于 2015-10-15 15:33:32 发布

jmw__

最新推荐文章于 2015-10-15 15:33:32 发布

阅读量347

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/jmw__/article/details/47816219

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

——- android培训、java培训、期待与您交流！ ———-

黑马程序员集合

黑马程序员——集合

集合类

为什么出现集合类？
- 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同？
- 数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点
1. 用于存储对象的容器。
2. 集合的长度是可变的。
3. 集合中不可以存储基本数据类型值。

集合框架的构成及分类

集合类的关系图

集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。

框架的顶层Collection接口：

Collection的常见方法：

添加。
- boolean add(Object obj)
- boolean addAll(Collection coll)
删除。
- boolean remove(object obj)
- boolean removeAll(Collection coll)
- void clear()
判断：
- boolean contains(object obj)
- boolean containsAll(Colllection coll)
- boolean isEmpty() 判断集合中是否有元素。
获取：
- int size()
- Iterator iterator() 取出元素的方式：迭代器。
  - 该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
  - 所以该迭代器对象是在容器中进行内部实现的。
  - 对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
  - 也就是iterator方法。
其他：
- boolean retainAll(Collection coll) 取交集。
- Object[] toArray() 将集合转成数组。

Collection接口有两个子接口：
List（列表），Set（集）

List：可存放重复元素，元素存取是有序的。
Set：不可以存放重复元素，元素存取是无序的。

List接口中常用类

Vector：线程安全，但速度慢，已被ArrayList替代。
ArrayList：线程不安全，查询速度快。
LinkedList：链表结构，增删速度快。
取出LIst集合中元素的方式：
- get(int index)：通过脚标获取元素。
- iterator()：通过迭代方法获取迭代器对象。

List:特有的常见方法：有一个共性特点就是都可以操作角标。

添加
- void add(index,element)
- void add(index,collection)
删除；
- Object remove(index)
修改：
- Object set(index,element)
获取：
- Object get(index)
- int indexOf(object)
- int lastIndexOf(object)
- List subList(from,to)

迭代

迭代是取出集合中元素的一种方式。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

用法：

for (Iterator iter = l.iterator(); iter.hasNext();) {
    System.out.println(iter.next());
}

Iterator iter = l.iterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}

迭代注意事项
- 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
- 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
- 迭代器的next方法返回值类型是Object，所以要记得类型转换。

Set接口中常用的类

Set接口中的方法和Collection一致。

HashSet: 内部数据结构是哈希表，是不同步的。
- 如何保证该集合的元素唯一性呢？
  - 是通过对象的hashCode和equals方法来完成对象唯一性的。
  - 如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
  - 如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
  - 如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
  - 记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。建立对象判断是否相同的依据。

TreeSet: 可以对Set集合中的元素进行排序。是不同步的。

判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

TreeSet对元素进行排序的方式一：

让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

//学生类  
class Student implements Comparable {
    private String name;
    private int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 复写hashCode以便HashSet集合调用
    public int hashCode() {
        return name.hashCode() + age;
    }

    // 复写equals以便HashSet集合和集合中一些比较方法调用
    public boolean equals(Object obj) {
        if (!(obj instanceof Student))
            throw new RuntimeException();
        Student s = (Student) obj;
        return this.name.equals(s.name) && this.age == s.age;
    }

    // 复写compareTo以便TreeSet集合调用
    public int compareTo(Object obj) {
        Student s = (Student) obj;
        if (this.age == s.age)
            return this.name.compareTo(s.name);
        return this.age - s.age;
        // return new Integer(this.age).compareTo(new Integer(s.age));
    }
}

class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> t = new TreeSet<Student>();
        t.add(new Student("wo1", 12));
        t.add(new Student("wosj", 2));
        t.add(new Student("wo1sdj", 12));
        t.add(new Student("wo6sd", 12));
        t.add(new Student("wo", 22));

        for (Iterator<Student> it = t.iterator(); it.hasNext();) {
            Student s = it.next();
            System.out.println(s.getName() + "....." + s.getAge());
        }
    }
}

可以使用TreeSet集合第二种排序方式二：

让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。

将该类对象作为参数传递给TreeSet集合的构造函数。

//学生类  
class Student implements Comparable {
    private String name;
    private int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 复写hashCode以便HashSet集合调用
    public int hashCode() {
        return name.hashCode() + age;
    }

    // 复写equals以便HashSet集合和集合中一些比较方法调用
    public boolean equals(Object obj) {
        if (!(obj instanceof Student))
            throw new RuntimeException();
        Student s = (Student) obj;
        return this.name.equals(s.name) && this.age == s.age;
    }

    // 复写compareTo以便TreeSet集合调用
    public int compareTo(Object obj) {
        Student s = (Student) obj;
        if (this.age == s.age)
            return this.name.compareTo(s.name);
        return this.age - s.age;
        // return new Integer(this.age).compareTo(new Integer(s.age));
    }

}

class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> t = new TreeSet<Student>(new LenCompare());
        t.add(new Student("wo1", 12));
        t.add(new Student("wosj", 2));
        t.add(new Student("wo1sdj", 12));
        t.add(new Student("wo6sd", 12));
        t.add(new Student("wo", 22));

        for (Iterator<Student> it = t.iterator(); it.hasNext();) {
            Student s = it.next();
            System.out.println(s.getName() + "....." + s.getAge());
        }
    }

}

// 定义一个比较器，以姓名长度为主要比较
class LenCompare implements Comparator<Student> {
    public int compare(Student s1, Student s2) {
        int num = new Integer(s1.getName().length()).compareTo(new Integer(s2
                .getName().length()));
        if (num == 0) {
            return new Integer(s1.getAge()).compareTo(s2.getAge());
        }
        return num;
    }
}

泛型

jdk1.5出现的安全机制。
好处：
1. 将运行时期的问题ClassCastException转到了编译时期。
2. 避免了强制转换的麻烦。
<>:什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
其实<>就是一个用于接收具体引用数据类型的参数范围。

在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型。
泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。
运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。
为什么擦除呢？因为为了兼容运行的类加载器。
泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。

泛型的通配符：? 未知类型。
泛型的限定：
- ? extends E: 接收E类型或者E的子类型对象。上限
  - 一般存储对象的时候用。比如添加元素 addAll.
- ? super E: 接收E类型或者E的父类型对象。下限。
  - 一般取出对象的时候用。比如比较器。

选择集合技巧

需要唯一吗？

需要：Set
- 需要制定顺序：
  - 需要： TreeSet
  - 不需要：HashSet
  - 但是想要一个和存储一致的顺序(有序):LinkedHashSet
不需要：List
- 需要频繁增删吗？
  - 需要：LinkedList
  - 不需要：ArrayList

看到array：就要想到数组，就要想到查询快，有角标.
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。

Map集合

一次添加一对元素。Collection 一次添加一个元素。
Map也称为双列集合，Collection集合称为单列集合。
其实map集合中存储的就是键值对。
map集合中必须保证键的唯一性。

常用方法：

添加。
- value put(key,value) 返回前一个和key关联的值，如果没有返回null.
删除。
- void clear() 清空map集合。
- value remove(key) 根据指定的key翻出这个键值对。
判断。
- boolean containsKey(key)
- boolean containsValue(value)
- boolean isEmpty()
获取。
- value get(key) 通过键获取值，如果没有该键返回null。
- int size() 获取键值对的个数。

Map常用的子类：

Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
- Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。

集合框架中的工具类

Collections
- 对集合进行查找
- 取出集合中的最大值，最小值
- 对List集合进行排序
- 将非同步集合转成同步集合
Arrays
- 将数组转成List集合
- 对数组进行排序
- 对数组进行二分查找

代码简单实现给非同步的集合加锁。

class MyCollections {

    public static List synList(List list) {

        return new MyList(list);
    }

    private class MyList implements List {
        private List list;

        private static final Object lock = new Object();

        MyList(List list) {
            this.list = list;
        }

        public boolean add(Object obj) {
            synchronized (lock) {
                return list.add(obj);
            }
        }

        public boolean remove(Object obj) {
            synchronized (lock) {
                return list.remove(obj);
            }
        }

    }
}