JAVA基础系列（五）集合

作者: Acamy丶 | 来源:发表于2017-06-01 23:11 被阅读37次

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类.

** 集合和数组的区别:**

1. Collection

集合的顶层接口

功能概述

添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素
删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有);
boolean isEmpty()：判断集合是否为空
获取功能
Iterator<E> iterator()(重点)
长度功能
int size():元素的个数
交集功能
boolean retainAll(Collection c);
把集合转换为数组
Object[] toArray()

2. Iterator

对 collection 进行迭代的迭代器,依赖于集合而存在

接口成员方法

public interface Iterator<E> {
    // 如果仍有元素可以迭代，则返回 true。
    boolean hasNext();
    // 获取元素,并移动到下一个位置。
    E next();
    void remove();
}

** Demo: **

public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");
        Iterator it = c.iterator(); 
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

3. List

有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

List集合的特有功能：

** A:添加功能 **
void add(int index,Object element):在指定位置添加元素
** B:获取功能 **
Object get(int index):获取指定位置的元素
** C:列表迭代器 **
ListIterator listIterator()：List集合特有的迭代器
** D:删除功能 **
Object remove(int index)：根据索引删除元素,返回被删除的元素
** E:修改功能 **
Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

4. ListIterator

List集合特有的迭代器

特有功能

A.Object previous():获取上一个元素
B.boolean hasPrevious():判断是否有元素
注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用。

** Demo:**

public class ListIteratorDemo {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // ListIterator listIterator()
        ListIterator lit = list.listIterator(); // 子类对象
        // while (lit.hasNext()) {
        // String s = (String) lit.next();
        // System.out.println(s);
        // }
        // System.out.println("-----------------");

        // System.out.println(lit.previous());
        // System.out.println(lit.previous());
        // System.out.println(lit.previous());
        // NoSuchElementException
        // System.out.println(lit.previous());

        while (lit.hasPrevious()) {
            String s = (String) lit.previous();
            System.out.println(s);
        }
        System.out.println("-----------------");

        // 迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
        System.out.println("-----------------");

    }
}

5. ArrayList

** Demo:**

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建元素对象，并添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        // 遍历
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }

        System.out.println("-----------");

        for (int x = 0; x < array.size(); x++) {
            String s = (String) array.get(x);
            System.out.println(s);
        }
    }
}

6. Vector

特有功能：

//1. 添加功能
 public void addElement(Object obj)     --  add() 
//2. 获取功能
public Object elementAt(int index)      --  get()
public Enumeration elements()           -- Iterator iterator()
boolean hasMoreElements()               hasNext()
Object nextElement()                    next()

** Demo:**

public class VectorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Vector v = new Vector();

        // 添加功能
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");

        // 遍历
        for (int x = 0; x < v.size(); x++) {
            String s = (String) v.elementAt(x);
            System.out.println(s);
        }

        System.out.println("------------------");

        Enumeration en = v.elements(); // 返回的是实现类的对象
        while (en.hasMoreElements()) {
            String s = (String) en.nextElement();
            System.out.println(s);
        }
    }
}

7. LinkedList

特有功能

A:添加功能
    public void addFirst(Object e)
    public void addLast(Object e)
B:获取功能
    public Object getFirst()
    public Obejct getLast()
C:删除功能
    public Object removeFirst()
    public Object removeLast()

Demo:

public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();

        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");

        // public void addFirst(Object e)
        // link.addFirst("javaee");
        // public void addLast(Object e)
        // link.addLast("android");

        // public Object getFirst()
        // System.out.println("getFirst:" + link.getFirst());
        // public Obejct getLast()
        // System.out.println("getLast:" + link.getLast());

        // public Object removeFirst()
        System.out.println("removeFirst:" + link.removeFirst());
        // public Object removeLast()
        System.out.println("removeLast:" + link.removeLast());

        // 输出对象名
        System.out.println("link:" + link);
    }
}

List的子类比较

8. Set

一个不包含重复元素的 collection

** Demo:**

public class SetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Set<String> set = new HashSet<String>();

        // 创建并添加元素
        set.add("hello");
        set.add("java");
        set.add("world");
        set.add("java");
        set.add("world");

        // 增强for
        for (String s : set) {
            System.out.println(s);
        }
    }
}

9. HashSet

不保证 set 的迭代顺序,特别是它不保证该顺序恒久不变。

** Demo:**

/*
 * HashSet:存储字符串并遍历
 * 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
 * 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
 * 步骤：
 *      首先比较哈希值
 *      如果相同，继续走，比较地址值或者走equals()
 *      如果不同,就直接添加到集合中  
 * 按照方法的步骤来说：   
 *      先看hashCode()值是否相同
 *          相同:继续走equals()方法
 *              返回true： 说明元素重复，就不添加
 *              返回false：说明元素不重复，就添加到集合
 *          不同：就直接把元素添加到集合
 * 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
 */
public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet<String> hs = new HashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");

        // 遍历集合
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

LinkedHashSet

底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性, 链表保证元素有素。(存储和取出是一致)

** Demo:**

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashSet<String> hs = new LinkedHashSet<String>();

        // 创建并添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        hs.add("world");
        hs.add("java");

        // 遍历
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

10. TreeSet

能够对元素按照某种规则进行排序。
TreeSet集合的特点：排序和唯一

排序有两种方式
A:自然排序
B:比较器排序
Demo1:

public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
        //A:自然排序(元素具备比较性)
              //让元素所属的类实现自然排序接口 Comparable

        TreeSet<Integer> ts = new TreeSet<Integer>();

        // 创建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        // 遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

Demo2:

import java.util.Comparator;
import java.util.TreeSet;

/*
 * 需求：请按照姓名的长度排序
 * 
 * TreeSet集合保证元素排序和唯一性的原理
 * 唯一性：是根据比较的返回是否是0来决定。
 *      
 */
public class TreeSetDemo {
    //比较器排序(集合具备比较性)
    //让集合的构造方法接收一个比较器接口的子类对象 Comparator
    public static void main(String[] args) {
        // 创建集合对象
        // TreeSet<Student> ts = new TreeSet<Student>(); //自然排序
        // public TreeSet(Comparator comparator) //比较器排序
        // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());

        // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
        // 而匿名内部类就可以实现这个东西
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 姓名长度
                int num = s1.getName().length() - s2.getName().length();
                // 姓名内容
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
                        : num;
                // 年龄
                int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
                return num3;
            }
        });

        // 创建元素
        Student s1 = new Student("linqingxia", 27);
        Student s2 = new Student("zhangguorong", 29);
        Student s3 = new Student("wanglihong", 23);
        Student s4 = new Student("linqingxia", 27);
        Student s5 = new Student("liushishi", 22);
        Student s6 = new Student("wuqilong", 40);
        Student s7 = new Student("fengqingy", 22);
        Student s8 = new Student("linqingxia", 29);

        // 添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        ts.add(s8);

        // 遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        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;
    }
}

11. Map

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

Map集合和Collection集合的区别?

 Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对

 Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。

功能概述

** 添加功能 **
V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
** 删除功能 **
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
** 判断功能 **
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
** 获取功能 **
Set<Map.Entry<K,V>> entrySet():???
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
** 长度功能 **
int size()：返回集合中的键值对的对数

** Demo: **

public class MapDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");

        // 遍历
        // 获取所有的键
        Set<String> set = map.keySet();
        // 遍历键的集合，获取得到每一个键
        for (String key : set) {
            // 根据键去找值
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

HashMap

是基于哈希表的Map接口实现,哈希表的作用是用来保证键的唯一性的。

** Demo:**

public class HashMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        HashMap<String, String> hm = new HashMap<String, String>();

        // 创建元素并添加元素
        // String key1 = "it001";
        // String value1 = "马云";
        // hm.put(key1, value1);

        hm.put("it001", "马云");
        hm.put("it003", "马化腾");
        hm.put("it004", "乔布斯");
        hm.put("it005", "张朝阳");
        hm.put("it002", "裘伯君"); // wps
        hm.put("it001", "比尔盖茨");

        // 遍历
        Set<String> set = hm.keySet();
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

LinkedHashMap

是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。

**　Demo: **

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();

        // 创建并添加元素
        hm.put("2345", "hello");
        hm.put("1234", "world");
        hm.put("3456", "java");
        hm.put("1234", "javaee");
        hm.put("3456", "android");

        // 遍历
        Set<String> set = hm.keySet();
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

13. TreeMap

是基于红黑树的Map接口的实现,可以保证键的排序和唯一性

** Demo: **

public class TreeMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        TreeMap<String, String> tm = new TreeMap<String, String>();

        // 创建元素并添加元素
        tm.put("hello", "你好");
        tm.put("world", "世界");
        tm.put("java", "爪哇");
        tm.put("world", "世界2");
        tm.put("javaee", "爪哇EE");

        // 遍历集合
        Set<String> set = tm.keySet();
        for (String key : set) {
            String value = tm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

14. Hashtable

Hashtable和HashMap的区别?

Hashtable:线程安全，效率低。不允许null键和null值
HashMap:线程不安全，效率高。允许null键和null值

** Demo: **

public class HashtableDemo {
    public static void main(String[] args) {
        // HashMap<String, String> hm = new HashMap<String, String>();
        Hashtable<String, String> hm = new Hashtable<String, String>();

        hm.put("it001", "hello");
        // hm.put(null, "world"); //NullPointerException
        // hm.put("java", null); // NullPointerException

        System.out.println(hm);
    }
}

15. Collections

是针对集合进行操作的工具类，都是静态方法。

Collection和Collections的区别?

Collection:是单列集合的顶层接口，有子接口List和Set。
Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

成员方法

public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换

** Demo:**

public class CollectionsDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List<Integer> list = new ArrayList<Integer>();

        // 添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);

        System.out.println("list:" + list);

        // public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
        // Collections.sort(list);
        // System.out.println("list:" + list);
        // [10, 20, 30, 40, 50]

        // public static <T> int binarySearch(List<?> list,T key):二分查找
        // System.out
        // .println("binarySearch:" + Collections.binarySearch(list, 30));
        // System.out.println("binarySearch:"
        // + Collections.binarySearch(list, 300));

        // public static <T> T max(Collection<?> coll):最大值
        // System.out.println("max:"+Collections.max(list));

        // public static void reverse(List<?> list):反转
        // Collections.reverse(list);
        // System.out.println("list:" + list);

        // public static void shuffle(List<?> list):随机置换
        Collections.shuffle(list);
        System.out.println("list:" + list);
    }
}

JAVA基础系列（五）集合

1. Collection

功能概述

2. Iterator

接口成员方法

3. List

List集合的特有功能：

4. ListIterator

特有功能

5. ArrayList

6. Vector

特有功能：

7. LinkedList

特有功能

List的子类比较

8. Set

9. HashSet

LinkedHashSet

10. TreeSet

11. Map

功能概述

LinkedHashMap

13. TreeMap

14. Hashtable

15. Collections

成员方法

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java学习之路

JAVA基础知识

JAVA基础系列（五） 集合

1. Collection

功能概述

2. Iterator

接口成员方法

3. List

List集合的特有功能：

4. ListIterator

特有功能

5. ArrayList

6. Vector

特有功能：

7. LinkedList

特有功能

List的子类比较

8. Set

9. HashSet

LinkedHashSet

10. TreeSet

11. Map

功能概述

LinkedHashMap

13. TreeMap

14. Hashtable

15. Collections

成员方法

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java学习之路

JAVA基础知识

JAVA基础系列（五）集合