Java入门笔记 09-集合

一、Collection接口方法：Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。

1、添加

•  add(Object obj)
•  addAll(Collection coll):将coll中的元素添加到当前集合中

2、获取有效元素的个数

•  int size()

3、清空集合

•  void clear()

4、是否是空集合

•  boolean isEmpty()

5、是否包含某个元素

•  boolean contains(Object obj):判断是否包含obj,是通过元素的equals方法来判断是否是同一个对象
•  boolean containsAll(Collection c):也是调用元素的equals方法来比

较的。拿两个集合的元素挨个比较。
6、删除

•  boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
•  boolean removeAll(Collection coll):取当前集合的差集

7、取两个集合的交集

•  boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响c

8、集合是否相等

•  boolean equals(Object obj)

9、转成对象数组

•  Object[] toArray()

10、获取集合对象的哈希值

•  hashCode()

11、遍历

•  iterator():返回迭代器对象,用于集合遍历

 

二、Iterator迭代器接口：

• Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。迭代器模式,就是为容器而生；
• Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象；
• Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力，如果需要创建Iterator 对象,则必须有一个被迭代的集合；
• 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。

@Test //迭代器中的remove()
public void test2(){
    Collection collection1 = new ArrayList();
    collection1.add("A");
    collection1.add("B");
    collection1.add("Jerry");

    //移除操作
    Iterator iterator = collection1.iterator();
    while(iterator.hasNext()){
        Object next = iterator.next();
        if("B".equals(next))
            iterator.remove();

    }

    //从头开始遍历
    iterator = collection1.iterator();//必须重新生成，不然接上面的集合最后
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

　　注意:

• Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
• 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException。

 

三、Collection子接口——List：List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。

　　1. List接口常用方法：

• 增：add(Object o)
• 删：remove(int index)/remove(Object o)
• 改：set(int index, Object o)
• 查：get(int index)
• 插：add(int index, Object o)
• 长度：size()
• 遍历：

    |--- Iterator迭代器
    |--- for
    |--- foreach

public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("A");
        list.add(456);
        System.out.println("原始：" + list);

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(0,"B");
        System.out.println("add(0,B):" + list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1,2,3);
        list.addAll(2,list1);
        System.out.print("list1" + list1 + "*** ");
        System.out.println("addAll(2,list1):" + list);

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));
    }

    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(456);
        list.add(123);
        list.add("A");
        list.add(456);
        System.out.println("原始：" + list);

        //int indexOf(Object obj):返回obj在集合中首次出现的位置,没有返回-1
        System.out.println(list.indexOf("A"));//2

        //int lastIndexOf(Object obj):返回obj在当前集合中最后一次出现的位置
        System.out.println(list.lastIndexOf(456));//3

        //Object remove(int index):移除指定index位置的元素,并返回此元素
        System.out.println(list.remove(0));
        System.out.println("remove 0 后：" + list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele,并返回index处的元素
        System.out.println(list.set(0,567));
        System.out.println("set(0,567)后：" + list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合,左闭右开
        System.out.println("subList(0,2): " + list.subList(0,2));
        System.out.println("list: " + list);
    }

    //遍历
    @Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(456);
        list.add(123);
        list.add("A");
        list.add(456);

        //Iterator迭代器
        Iterator iterator = list.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());
        System.out.println();

        //foreach
        for(Object o: list){
            System.out.println(o);
        }
        System.out.println();

        //for
        for(int i=0;i<list.size();i++)
            System.out.println(list.get(i));
    }
}

　　2. List的实现类ArrayList：ArrayList 是 List 接口的典型实现类、主要实现类，非线程安全，效率高，底层使用Object数组存储。

　　3. List的实现类LinkedList：对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高，底层是双向链表，新增如下方法：

• void addFirst(Object obj)
• void addLast(Object obj)
• Object getFirst()
• Object getLast()
• Object removeFirst()
• Object removeLast()

　　4. List的实现类Vector：Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。

　　面试题：请问ArrayList/LinkedList/Vector的异同?谈谈你的理解?ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?

　　ArrayList和LinkedList的异同：

• 二者都线程不安全,相对线程安全的Vector,执行效率高。
• 此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。

　　ArrayList和Vector的区别：

• Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。
• Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。

 

四、Collection子接口——Set：Set接口是Collection的子接口,set接口没有提供额外的方法，Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。

　　1. Set的实现类HashSet：HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。

　　HashSet 具有以下特点:

• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以是 null

　　HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。因此对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Objectobj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。

　　添加元素的过程，以HashSet为例：首先利用hash值确定index，若此index上有元素：

• hash值不同，添加成功
• hash值相同，调用该对象所在类的equals方法
  •     true：添加失败
  •     false：添加成功

　　2. Set的实现类LinkedHashSet：是 HashSet 的子类，根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全部元素时有很好的性能。

@Test
public void test2(){
    Set set = new LinkedHashSet();
    set.add(123);
    set.add(456);
    set.add("A");
    set.add(new Integer(789));

    Iterator iterator = set.iterator();
    while(iterator.hasNext())
        System.out.println(iterator.next());
}

　　3. Set的实现类TreeSet：是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态，使用红黑树结构存储数据。新增如下方法：

• Comparator comparator()
• Object first()
• Object last()
• Object lower(Object e)
• Object higher(Object e)
• SortedSet subSet(fromElement, toElement)
• SortedSet headSet(toElement)
• SortedSet tailSet(fromElement)

　　3.1 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列。因此如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现 Comparable接口。向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。因为只有相同类的两个实例才会比较大小,所以向 TreeSet 中添加的应该是同一个类的对象。对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值，不再是equals方法。

public class TreeSetTest {
    @Test
    public void test2(){
        TreeSet set = new TreeSet();
        set.add(new User("Amy",12));
        set.add(new User("Bob",13));
        set.add(new User("Emily", 14));
        set.add(new User("Dean", 15));
        set.add(new User("Dean", 16));

        Iterator iterator = set.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());
    }
}

class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

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

    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;
    }

    @Override
    //按照姓名从大到小排列，年龄从小到大
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
            int compare = -this.name.compareTo(user.name);
            if(compare == 0){
                return Integer.compare(this.age, user.age);
            }else
                return compare;

        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }

    /*
    @Override
    //按照姓名从小到大排列
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
            return this.name.compareTo(user.name);
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }
    */

    @Override
    public String toString() {
        return "name: " + name + ", age: " + age;
    }
}

　　3.2 定制排序：在定制排序中，比较两个对象是否相同的标准为：compare方法的返回值，不再是equals方法。

@Test
public void test3(){
    Comparator com = new Comparator() {
        //按照年龄从小到大，年龄一样的数据只要一个
        @Override
        public int compare(Object o, Object t1) {
            if(o instanceof User && t1 instanceof User){
                User u1 = (User)o;
                User u2 = (User)t1;
                return Integer.compare(u1.getAge(), u2.getAge());
            }else{
                throw new RuntimeException("输入的数据类型不匹配");
            }
        }
    };

    TreeSet set = new TreeSet(com);
    set.add(new User("Amy",12));
    set.add(new User("Bob",12));
    set.add(new User("Emily", 14));
    set.add(new User("Dean", 15));
    set.add(new User("Dean", 16));

    Iterator iterator = set.iterator();
    while(iterator.hasNext())
        System.out.println(iterator.next());
}

 

五、Map接口：用于保存具有映射关系的数据:key-value，类似与高中讲的函数的概念。

　　0. Map结构的理解：

• key：无序、不可重复，使用Set存储所有的key；--->要求key所在的类重写equals和hashcode方法（以HashMap为例的）
• value：无序、可重复，使用Collection存储所有的value。--->要求value所在的类重写equals方法
• 一个key-value对构成了一个Entry对象。entry是无序、不可重复的。

1. Map接口常用方法：

public class MapTest {
    @Test
    //增删改
    public void test1(){
        //put
        HashMap hashMap = new HashMap();
        hashMap.put("AA",123);
        hashMap.put("BB",456);
        hashMap.put("CC",789);
        hashMap.put("AA",101);

        System.out.println(hashMap);//{AA=101, BB=456, CC=789}相当于原有的123被改为101

        //putAll
        HashMap hashMap1 = new HashMap();
        hashMap1.put("DD",102);
        hashMap1.putAll(hashMap);
        System.out.println(hashMap1);

        //remove(key),返回对应key的value并删除该entry
        System.out.println(hashMap.remove("AA"));
        System.out.println(hashMap);

        //clear
        hashMap1.clear();
        System.out.println(hashMap1);
    }

    @Test
    //查询
    public void test2(){
        HashMap hashMap = new HashMap();
        hashMap.put("AA",123);
        hashMap.put("BB",456);
        hashMap.put("CC",789);

        //get
        System.out.println(hashMap.get("AA"));

        //containsKey
        System.out.println(hashMap.containsKey("DD"));

        //containsValue
        System.out.println(hashMap.containsValue(789));

        //size
        System.out.println(hashMap.size());

        //isEmpty
        System.out.println(hashMap.isEmpty());
    }

    @Test
    //遍历
    public void test3(){
        HashMap hashMap = new HashMap();
        hashMap.put("AA",123);
        hashMap.put("BB",456);
        hashMap.put("CC",789);

        //keySet,返回一个Set
        Set set = hashMap.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext())
            System.out.println(iterator.next());

        //values,返回一个Collection
        Collection values = hashMap.values();
        Iterator iterator2 = values.iterator();
        while(iterator2.hasNext())
            System.out.println(iterator2.next());

        //entrySet,返回一个Set
        Set set1 = hashMap.entrySet();
        Iterator iterator1 = set1.iterator();
        while(iterator1.hasNext()){
            Object object = iterator1.next();
            Map.Entry entry = (Map.Entry) object;
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }
}

2. HashMap：作为Map的主要实现类，线程不安全，效率高，可以存储null，底层是数组+链表（jdk8及以后+红黑树）

3. LInkedHashMap：作为HashMap的子类，保证了遍历map元素时按照添加时的顺序遍历。对于频繁遍历的操作，此类执行的效率高于HashMap

4. TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然/定制排序，底层使用红黑树。要求都是同一个类

public class TreeMapTest {

    @Test
    //自然排序
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jack",12);
        User u3 = new User("Bob",21);

        map.put(u1, 90);
        map.put(u2, 81);
        map.put(u3, 62);

        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while(iterator1.hasNext()){
            Object object = iterator1.next();
            Map.Entry entry = (Map.Entry) object;
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }

    @Test
    //定制排序:定制按照年龄排序
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(), u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jack",12);
        User u3 = new User("Bob",21);

        map.put(u1, 90);
        map.put(u2, 81);
        map.put(u3, 62);

        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while(iterator1.hasNext()){
            Object object = iterator1.next();
            Map.Entry entry = (Map.Entry) object;
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }
}

5. Hashtable：作为古老的实现类，线程安全的，效率低，不能存储null

　　|--- Properties：常用来处理配置文件，key和value都是String类型。

public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();

        FileInputStream fis = new FileInputStream("jdbc.properties");
        properties.load(fis);

        String name = properties.getProperty("name");
        String password = properties.getProperty("password");

        System.out.println(name + " " + password);
    }
}

 

六、Collections工具类：Collections 是一个操作 Set、List 和 Map 等集合的工具类

　　1. 排序操作:(均为static方法)

• reverse(List):反转 List 中元素的顺序
• shuffle(List):对 List 集合元素进行随机排序
• sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
• sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
• swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换

　　2. 查找、替换：

• 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 对象的所有旧值

public class CollectionsTest {
    @Test
    public void test(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        List list1 = Arrays.asList(new Object[list.size()]);
        Collections.copy(list1, list);
        System.out.println(list1);
    }
}