黑马程序员——Java基础---集合

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、集合框架

先看下面的图：

这就是集合框架的构成。由于数据结构的不同，有不同的集合，也叫容器。下面是集合类的简单介绍。

(一)为什么出现集合类？

        面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

(二)数组和集合类同是容器，有何不同？

        数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

(三)集合类的特点

        集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

二、Collection

        Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

       所属关系：

            Collection

                     |--List//元素是有序的，元素可以重复。因为该集合体系有索引。

                     |--Set//元素是无序的，元素不可以重复。

(一)Collection接口中的常见操作

1、添加元素

        add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。

2、删除元素

        remove(Objectobj);

        removeAll(另一集合);//调用者只保留另一集合中没有的元素。

        clear();//清空集合

3、判断元素

        contains(Objectobj);//判断是否存在obj这个元素

        isEmpty();//是否为空

4、获取个数，集合长度

        size();

5、取交集

        retainAll(另一集合);//调用者只保留两集合的共性元素。

注：集合中存储的都是对象的引用（地址）。

(二)迭代

1、概述

        迭代是取出集合中元素的一种方式。

        对于集合的元素取出这个动作：

        当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。

        而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。

         那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。

         因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

2、迭代的常见操作

        hasNext();//有下一个元素，返回真

        next();//取出下一个元素

        remove();//移除

注：在迭代时循环中next调用一次，就要hasNext判断一次。

使用：

         ArrayList a=newArrayList();//创建一个集合

        Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。

        第一种打印方式：

                for(Iterator iter = a.iterator();iter.hasNext();  )

                {

                           System.out.println(iter.next());

                }

       第二种打印方式：

                 Iteratoriter = a.iterator();

                while(iter.hasNext())

               {

                           System.out.println(iter.next());

               }

3、迭代注意事项

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。

三、List

(一)List

组成

        List：元素是有序的，元素可以重复。因为该集合体系有索引。

ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

(二)List的特有方法

        凡是可以操作角标的方法都是该体系特有的方法。

1、增

        booleanadd(index,element);//指定位置添加元素

        BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

2、删

        Booleanremove(index);//删除指定位置的元素

3、改

        set(index,element);//修改指定位置的元素。

4、查

        get(index);//通过角标获取元素

        subList(from,to);//获取部分对象元素

5、其他

        listIterator();//List特有的迭代器

        indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1

注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

(三)ListIterator

1、概述 

        ListIterator是List集合特有的迭代器，是Iterator的子接口。

       在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。

2、ListIterator特有的方法

        add(obj);//增加

        set(obj);//修改为obj

        hasPrevious();//判断前面有没有元素

        previous();//取前一个元素

(四)枚举Enumeration

枚举：

        就是Vector特有的取出方式。Vector有三种取出方式。

        其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

         addElement(obj);//添加元素，相当于add(obj);

         Enumerationelements();//Vector特有取出方式(枚举)

         hasMoreElements();//相当于Iterator的hasNext()方法

         nextElements();//相当于Iterator的next()方法

(五)LinkedList

        LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

特有方法：

1、增

        addFirst();

        addLast();

2、获取

        //获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

        getFirst();

        getLast();

3、删

        //获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

        removeFirst();

        removeLast();

在JDK1.6以后，出现了替代方法。

1、增

        offFirst();

        offLast();

2、获取

        //获取元素，但是不删除。如果集合中没有元素，会返回null。

        peekFirst();

        peekLast();

3、删

        //获取元素，并删除元素。如果集合中没有元素，会返回null。

        pollFirst();

        pollLast();

示例：

package collection;

/* 

 使用LinkedList模拟一个堆栈或者队列数据结构。 

 堆栈：先进后出  如同一个杯子。 

 队列：先进先出 First in First out  FIFO 如同一个水管。 

 */

import java.util.*;

class LinkedListTest {

public static void main(String[] args) {

LinkedList l = new LinkedList();

l.addFirst("java01");

l.addFirst("java02");

l.addFirst("java03");

l.addFirst("java04");

l.addFirst("java05");

// 堆栈输出

// stack(l);

// 队列输出

queue(l);

}

// 堆栈

public static void stack(LinkedList l) {

while (!l.isEmpty()) {

sop(l.removeFirst());

}

}

// 队列

public static void queue(LinkedList l) {

while (!l.isEmpty()) {

sop(l.removeLast());

}

}

// 输出

public static void sop(Object obj) {

System.out.println(obj);

}

}

四、Set

(一)概述

Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。     

HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。

Set集合的功能和Collection是一致的。

(二)HasSet

HashSet：线程不安全，存取速度快。

可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

示例：

package collection;

/* 

 往hashSet集合中存入自定对象 

 姓名和年龄相同为同一个人，重复元素。去除重复元素 

 思路：1、对人描述，将人的一些属性等封装进对象 

 2、定义一个HashSet容器，存储人对象 

 3、取出 

 */

import java.util.*;

//人描述  

class Person {

private String name;

private int age;

Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public int getAge() {

return age;

}

public boolean equals(Object obj) {

if (!(obj instanceof Person))

return false;

Person p = (Person) obj;

return this.name.equals(p.name) && this.age == p.age;

}

public int hashCode() {

return this.name.hashCode() + this.age;

}

}

class HashSetTest {

public static void main(String[] args) {

HashSet<Person> h = new HashSet<Person>();

h.add(new Person("shenm", 10));

h.add(new Person("shenm2", 6));

h.add(new Person("shenm1", 30));

h.add(new Person("shenm0", 10));

h.add(new Person("shenm0", 10));

getOut(h);

}

// 取出元素

public static void getOut(HashSet<Person> h) {

for (Iterator<Person> it = h.iterator(); it.hasNext();) {

Person p =it.next();

sop(p.getName() + "..." + p.getAge());

}

}

// 打印

public static void sop(Object obj) {

System.out.println(obj);

}

}

(三)TreeSet

1、特点

        a、底层的数据结构为二叉树结构（红黑树结构）

        b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

        java中的很多类都具备比较性，其实就是实现了Comparable接口。

注意：排序时，当主要条件相同时，按次要条件排序。

二叉树示意图

        c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

2、Tree排序的两种方式

1）第一种排序方式：自然排序

        让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

示例：

package collection;

import java.util.*;

//学生类  

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());

}

}

}

2）第二种方式：比较器

        当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

        在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

        比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。

        当两种排序都存在时，以比较器为主。

示例：

package collection;

/* 

 需求： 

 往TreeSet集合中存储自定义对象学生。 

 想按照学生的年龄进行排序。 

 */

import java.util.*;

//学生类  

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 TreeSetTest1 {

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;

}

}

五、Map集合

(一)概述

1、简述：

        Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

2、特点：

        1）该集合存储键值对，一对一对往里存

        2）要保证键的唯一性。

(二)Map集合的子类

        Map

Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

Map和Set很像。其实Set底层就是使用了Map集合。

(三)Map集合的常用方法

1、添加

        Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

        voidputAll(Map <? extends K,? extends V> m);//添加一个集合

2、删除

        clear();//清空

        Vremove(Object key);//删除指定键值对

3、判断

        containsKey(Objectkey);//判断键是否存在

        containsValue(Objectvalue)//判断值是否存在

        isEmpty();//判断是否为空

4、获取

        Vget(Object key);//通过键获取对应的值

        size();//获取集合的长度

        Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，接下来会逐个讲解：

        Set<Map.Entry<K,V>>entrySet();

        Set<K>  keySet();

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

(四)Map集合的两种取出方式

        Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。

示例：

package collection;

/* 

 每一个学生都有对应的归属地。 

 学生Student，地址String。 

 学生属性：姓名，年龄。 

 注意：姓名和年龄相同的视为同一个学生。 

 保证学生的唯一性。 

 思路：1、描述学生类 

 2、定义一个Map集合，存储学生对象和地址值 

 3、获取Map中的元素 

 */

import java.util.*;

//描述学生类  

class Student implements Comparable<Student> {

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

public int hashCode() {

return name.hashCode() + age * 33;

}

// 复写equals，比较对象内容

public boolean equals(Object obj) {

if (!(obj instanceof Student))

throw new ClassCastException("类型不匹配");

Student s = (Student) obj;

return this.name.equals(s.name) && this.age == s.age;

}

// 复写compareTo,以年龄为主

public int compareTo(Student c) {

int num = new Integer(this.age).compareTo(new Integer(c.age));

if (num == 0) {

return this.name.compareTo(c.name);

}

return num;

}

// 复写toString，自定义输出内容

public String toString() {

return name + "..." + age;

}

}

class HashMapTest {

public static void main(String[] args) {

HashMap<Student, String> hm = new HashMap<Student, String>();

hm.put(new Student("zhangsan", 12), "beijing");

hm.put(new Student("zhangsan", 32), "sahnghai");

hm.put(new Student("zhangsan", 22), "changsha");

hm.put(new Student("zhangsan", 62), "USA");

hm.put(new Student("zhangsan", 12), "tianjing");

keyset(hm);

}

// keySet取出方式

public static void keyset(HashMap<Student, String> hm) {

Iterator<Student> it = hm.keySet().iterator();

while (it.hasNext()) {

Student s = it.next();

String addr = hm.get(s);

System.out.println(s + ":" + addr);

}

}

}

2、Set<Map.Entry<K,V>>   entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

       其实，Entry也是一个接口，它是Map接口中的一个内部接口。

package collection;

interface Mapdemo {

public static interface Entry {

public abstract Object getKey();

public abstract Object getValue();

}

}

示例：

       同上面示例的学生类

package collection;

import java.util.*;

class HashMapTest {

public static void main(String[] args) {

HashMap<Student, String> hm = new HashMap<Student, String>();

hm.put(new Student("zhangsan", 12), "beijing");

hm.put(new Student("zhangsan", 32), "sahnghai");

hm.put(new Student("zhangsan", 22), "changsha");

hm.put(new Student("zhangsan", 62), "USA");

hm.put(new Student("zhangsan", 12), "tianjing");

entryset(hm);

}

// entrySet取出方式

public static void entryset(HashMap<Student, String> hm) {

Iterator<Map.Entry<Student, String>> it = hm.entrySet().iterator();

while (it.hasNext()) {

Map.Entry<Student, String> me = it.next();

Student s = me.getKey();

String addr = me.getValue();

System.out.println(s + ":::" + addr);

}

}

}

关于Map.Entry：

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

原因：

a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

(五)Map集合的应用及扩展

1、何时使用Map集合：当量数据之间存在着映射关系的时候，就应该想到使用Map集合。

2、示例：

        获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....

        通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。代码如下：

package collection;

/* 

 思路：1、将字符串转换为字符数组 

 2、定义一个TreeMap集合，用于存储字母和字母出现的次数 

 3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入 

 4、将TreeMap集合中的元素转换为字符串 

 */

import java.util.*;

class CharCount {

public static void main(String[] args) {

String s = "sdfgzxcvasdfxcvdf";

System.out.println("s中各字母出现的次数：" + charCount(s));

}

// 定义一个方法获取字符串中字母出现的次数

public static String charCount(String str) {

char[] cha = str.toCharArray();// 转换为字符数组

// 定义一个TreeMap集合，因为TreeMap集合会给键自动排序

TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();

int count = 0;// 定义计数变量

for (int x = 0; x < cha.length; x++) {

if (!(cha[x] >= 'a' && cha[x] <= 'z' || cha[x] >= 'A'

&& cha[x] <= 'Z'))

continue;// 如果字符串中非字母，则不计数

Integer value = tm.get(cha[x]);// 获取集合中的值

if (value != null)// 如果集合中没有该字母，则存入

count = value;

count++;

tm.put(cha[x], count);// 存入键值对

count = 0;// 复位计数变量

}

StringBuilder sb = new StringBuilder();// 定义一个容器

// 遍历集合，取出并以题目格式存入容器中

for (Iterator<Character> it = tm.keySet().iterator(); it.hasNext();) {

Character ch = it.next();

Integer value = tm.get(ch);

sb.append(ch + "(" + value + ")");

}

return sb.toString();// 返回字符串

}

}

(六)Map扩展知识

        在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。

如： 

package collection;

/* 

 map扩展知识。 

 map集合被使用是因为具备映射关系。 

 以下是班级对应学生，而学生中学号对应着姓名的映射关系： 

 "yureban"   Student("01" "zhangsan"); 

 "yureban" Student("02" "lisi"); 

 "jiuyeban" "01" "wangwu"; 

 "jiuyeban" "02" "zhaoliu"; 

 就如同一个学校有多个教室。每一个教室都有名称。 

 */

import java.util.*;

class MapExpandKnow {

public static void main(String[] args) {

// 预热班集合

HashMap<String, String> yureban = new HashMap<String, String>();

// 就业班集合

HashMap<String, String> jiuyeban = new HashMap<String, String>();

// 学校集合

HashMap<String, HashMap<String, String>> czbk = new HashMap<String, HashMap<String, String>>();

// 学校中班级集合和名称的映射

czbk.put("yureban", yureban);

czbk.put("jiuyueban", jiuyeban);

// 预热班级中学号与姓名的映射

yureban.put("01", "zhangsan");

yureban.put("02", "lisi");

// 就业班级中学号与姓名的映射

jiuyeban.put("01", "wangwu");

jiuyeban.put("02", "zhouqi");

// 直接显示全部学生信息

getAllStudentInfo(czbk);

}

// 定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少

public static void getAllStudentInfo(

HashMap<String, HashMap<String, String>> hm) {

for (Iterator<String> it = hm.keySet().iterator(); it.hasNext();)// 用keySet取出方式

{

String s = it.next();// 班级名称

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

HashMap<String, String> stu = hm.get(s);// 班级集合

getStudentInfo(stu);

}

}

// 获取班级中学生的信息，包括姓名和学号

public static void getStudentInfo(HashMap<String, String> hm) {

for (Iterator<String> it = hm.keySet().iterator(); it.hasNext();) {

String key = it.next();// 学号

String value = hm.get(key);// 姓名

System.out.println(key + "..." + value);

}

}

}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------