《Java从入门到精通》第十章学习笔记

第10章　　Java集合类

一、概述

Java中的java.util包中提供了一些集合类，也被称为容器，不同于数组，集合的长度是可变的，存放的是对象的引用。常用的集合有List集合、Set集合、Map集合，其中List和Set实现了Collection接口。

二、集合类接口的常用方法

1、List接口的常用方法：因为继承了Collection接口，所以List接口也继承了Collection中的所有方法。List集合以线性有序的方式存储对象。List集合中可以包含重复的对象，的主要方法如下：

（1）add(int index,Object obj):返回值为void。用于向集合中指定索引位置添加对象。

（2）addAll(int index,Collection coll):返回值为boolean型。用于向集合中指定索引位置添加指定的集合对象。

（3）remove(int index):返回值为Object。用于移除集合中的指定索引位置的对象。

（4）get(int index)：返回值为Object。用于获取指定索引位置的对象。
（5）indexOf(Object obj):返回值int。返回集合中对象第一次出现的索引位置，如果不存在则返回-1。

（6）lastIndexOf(Object obj):返回值int。返回集合中对象最后一次出现的索引位置，如果不存在则返回-1。

（7）subList(int formIndex,int toIndex):返回值List。获取两索引之间元素对象组成的List集合。

（8）set(int index,E element):返回值Object。用指定元素替换列表中指定索引位置的元素。

（9）listIterator():返回值ListIterator.用于获得一个包含所有对象的ListIterator列表迭代器。

import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
public class GenericTest{
    public static void main(String[] args){
        String a="A",b="B",c="C",d="D",e="E";//定义插入集合的字符串对象
        List<String> list=new LinkedList<String>();
        //创建一个LinkedList集合
        list.add(a);
        list.add(e);
        list.add(d);
        Iterator<String> fristIterator=list.iterator();
        //创建List的迭代器
        System.out.println("修改前集合中元素是：");
        while(fristIterator.hasNext()){
            System.out.print(fristIterator.next()+" ");
        }
        list.set(1,b);
        list.set(2,c);
        Iterator<String> it=list.iterator();
        System.out.println("");
        System.out.println("修改后集合中元素是：");
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
    }
}

//创建List集合对象，通过add()方法添加元素，并将特殊对象元素在索引中出现的第一次、最后一次索引输出
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
public class CollectionDemo {

    public static void main(String[] args) {
        String a="a",b="b",c="c",d="d",e="e",x="apple";
        List<String> list=new LinkedList<String>();
        list.add(a);
        list.add(x);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(a);
        list.add(d);
        list.add(x);
        Iterator<String> it=list.iterator();
        System.out.println("列表List为：");
        int index=0;
        while(it.hasNext()){
            System.out.print("序号"+index+":"+it.next()+";");
            index++;
        }
        System.out.println("其长度为："+list.size());
        if((list.indexOf(a)!=-1)){
            System.out.println("a第一次出现在列表中的索引位置为:"+list.indexOf(a));
            System.out.println("a最后一次出现在列表中的索引位置为:"+list.lastIndexOf(a));
        }else{
            System.out.println("a没有出现在列表中");
        }
        if((list.indexOf(x)!=-1)){
            System.out.println("apple第一次出现在列表中的索引位置为:"+list.indexOf(x));
            System.out.println("apple最后一次出现在列表中的索引位置为:"+list.lastIndexOf(x));
        }else{
            System.out.println("apple没有出现在列表中");
        }
        if((list.indexOf("ts")!=-1)){
            System.out.println("ts第一次出现在列表中的索引位置为:"+list.indexOf("ts"));
            System.out.println("ts最后一次出现在列表中的索引位置为:"+list.lastIndexOf("ts"));
        }else{
            System.out.println("ts没有出现在列表中");
        }
    }
}

 2、Set接口的常用方法：一样也继承了Collection接口的所有方法，并且Set集合中不允许有重复值。

（1）add(Object obj):如果Set集合中不存在obj则添加。

（2）addAll(Collection coll):将coll添加到Set集合尾部。

（3）remove(Object obj):移除指定的元素。

（4）retainAll(Collection coll):只保存Set集合中包含在coll集合中的元素。

（5）removeAll(Collection coll):移除Set集合中所有包含在coll集合中的元素。

（6)clear():清空Set集合。

（7）iterator()：返回Set集合中元素进行迭代的迭代器。

//创建一个List集合向其中添加元素
//再创建一个Set集合
//利用addAll()将List集合对象存入Set集合，打印Set集合中元素
import java.util.List;
import java.util.Set;
import java.util.LinkedList;
import java.util.HashSet;
public class CollectionDemo {

    public static void main(String[] args) {
        int[] a0={1,3,5,6,8,9,12,15};
        int[] a1={2,4,5,6,8,11,13,15,21};
        List<Integer> list=new LinkedList<Integer>();
        Set<Integer> set=new HashSet<Integer>();
        for(int x:a0){
            list.add(x);
        }
        for(int x:a1){
            set.add(x);
        }
        System.out.println("list集合初始化为："+list);
        System.out.println("set集合初始化为："+set);
        set.addAll(list);
        System.out.println("新的set集合为："+set+"长度为："+set.size());
        set.clear();
        System.out.println("清空后set长度为："+set.size());
    }
}

3、Map接口的常用方法
Map接口提供了将键值映射到值的对象，一个映射中不能包括重复的键，而且每个键最多只能映射到一个值。

（1）put(key k,value v):向集合中添加指定的键和值。

（2）containskey(Object key):如果此映射包含指定的键的映射关系，则返回true.

（3）containsValue(Object value):如果此映射将一个或多个键指向指定值，则返回true.

（4）get(Object key):如果存在指定的键对象，则返回该对象对应的值，否则返回null。

（5）keySet():返回该集合中的所有键对象组成的Set集合。

（6）values():返回该集合中所有值对象形成的Collection集合。

//向一个Map集合中插入元素并根据Key的值打印集合中的元素

import java.util.Map;
import java.util.HashMap;
public class MapDemo {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("1","apple");
        map.put("2","pear");
        map.put("3","orange");
        for(int i=1;i<=3;i++){
            System.out.println("第"+i+"个元素是："+map.get(""+i+""));
        }
    }
}

 三、集合类接口的实现类

1、List接口的常用实现类有ArrayList和LinkedList。

（1）ArrayList类：通过List接口具备的方法实现了可变数组，可通过索引快速访问，但插入和删除操作速度较慢。

（2）LinkedList类：采用了链表结构，便于快速插入和删除对象，但随机访问速度较慢。

List<String> list1=new ArrayList<String>();
List<String> list2=new LinkedList<String>();

对象的声明采用接口类型可便于程序的拓展和修改，并通过泛型<String>约束对象的类型。

import java.util.List;
import java.util.ArrayList;
public class Gather {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list=new ArrayList();
        System.out.println("数组列表长度为："+list.size());
        int ri=(int)(Math.random()*100);
        System.out.println("随机数取得为："+ri);
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println("创建后数组列表长度为："+list.size());
        int i=ri%list.size();
        System.out.println("随机获取数组中的元素："+list.get(i));
        list.remove(2);
        System.out.println("将索引是'2'的元素移除后，数组中的元素是：");
        for(int j=0;j<list.size();j++){
            System.out.print(list.get(j)+" ");
        }
    }
}

2、Set接口的实现类常用的主要有HashSet类和TreeSet类，一般用Set接口类型声明创建的Set对象。

//People类定义
public class People {
    private String name;
    private long id_card;
    public People(String name,long id_card){
        this.name=name;
        this.id_card=id_card;
    }
    public long getId_card(){
        return this.id_card;
    }
    public void setId_card(long id){
        this.id_card=id;
    }
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
}

import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class CollectionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<People> hashSet=new HashSet<People>();
        hashSet.add(new People("KellyWong",98102106));
        hashSet.add(new People("TinsonG",98102118));
        hashSet.add(new People("MingLeu",98102135));
        hashSet.add(new People("YiJon",98102142));
        hashSet.add(new People("YooSan",98102151));
        Iterator<People> it=hashSet.iterator();
        System.out.println("hashSet集合中的元素是：");
        while(it.hasNext()){
            People p=it.next();
            System.out.println(p.getName()+" "+p.getId_card());
        }
    }
}

 3、Map接口的实现类主要有HashMap类和TreeMap类，通常用HashMap类实现的Map集合对于添加和删除映射关系的效率更高。HashMap是基于哈希表的Map接口的实现，HashMap中允许使用null键和null值，但必须保证键的唯一性。TreeMap中映射关系存在一定的顺序，在考虑需要实现顺序存储时可以考虑使用TreeMap类，因为TreeMap类中映射的顺序是按照键对象的规则，所以不允许键对象为null。

public class Emp {
        public String e_id;
        public String e_name;
        public Emp(String id,String name){
            this.e_id=id;
            this.e_name=name;
        }
}
//测试主类，分别创建一个由HashMap和TreeMap实现的Map集合，并遍历之
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.Set;
import java.util.Iterator;

public class MapTest {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map map=new HashMap();
        Emp emp1=new Emp("98102101","GTS");
        Emp emp2=new Emp("98102102","WJ");
        Emp emp3=new Emp("98102103","SYS");
        Emp emp4=new Emp("98102104","YYZ");
        Emp emp5=new Emp("98102105","LM");
        map.put(emp1.e_id, emp1.e_name);
        map.put(emp2.e_id, emp2.e_name);
        map.put(emp3.e_id, emp3.e_name);
        map.put(emp4.e_id, emp4.e_name);
        map.put(emp5.e_id, emp5.e_name);
        Set set=map.keySet();
        Iterator it=set.iterator();
        System.out.println("HashMap类实现的Map集合（无序）：");
        while(it.hasNext()){
            String str=(String)it.next();
            String name=(String)map.get(str);
            System.out.println(str+" "+name);
        }
        TreeMap treemap=new TreeMap();
        treemap.putAll(map);
        Iterator iter=treemap.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合（按键对象升序）：");
        while(iter.hasNext()){
            String str=(String)iter.next();
            String name=(String)map.get(str);
            System.out.println(str+" "+name);
        }
    }
}

//创建一个ArrayList类对象
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

public class ForArrayList {
  public static void main(String[] args){
    List<Integer> list=new ArrayList<Integer>();
    for(int i=0;i<10;i++){
        int x=(int)(Math.random()*100);
        list.add(x);
    }
    Iterator<Integer> it=list.iterator();
    System.out.println("ArrayList实例为：");
    while(it.hasNext()){
        System.out.print(it.next()+" ");
    }
    System.out.println();
    System.out.println("ArrayList实例中奇数为：");
    for(int i=0;i<list.size();i++){
        if(i%2==1){
            System.out.print(list.get(i)+" ");
        }
    }
  }

}

四、迭代器
1、利用Iterator接口创建迭代器，Iterator接口位于java.util包里。

（1）hasNext():如果当前仍有元素可以迭代，则返回true;

（2）next():返回迭代的下一个元素。

（3）remove():从迭代器指向的collection中移除迭代器返回的最后一个元素。

五、实战练习

/*
 * 将1~100之间的所有整数存放在一个List集合中
 * 并将集合中索引位置为10的对象从中删除
 */
import java.util.List;
import java.util.LinkedList;
public class ListDelDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Integer> list=new LinkedList<Integer>();
        for(int i=1;i<=100;i++){
            list.add(i);
        }
        System.out.println("创建的整数列表为：");
        System.out.println(list);
        list.remove(10);
        System.out.println("删除索引位置为10的元素后整数列表为：");
        System.out.println(list);
    }
}

/*
 * 分别向Set集合和List集合中添加"A","a","c","C","a"
 * 观察重复值"a"能否在两集合中成功添加
 */
import java.util.List;
import java.util.LinkedList;
import java.util.Set;
import java.util.HashSet;
public class AddDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String> list=new LinkedList<String>();
        Set<String> set=new HashSet<String>();
        String[] arrx={"A","a","c","C","a"};
        for(int i=0;i<5;i++){
            System.out.println("第"+i+"次添加元素：");
            list.add(arrx[i]);
            System.out.println("List集合为："+list);
            if(set.add(arrx[i])){
                System.out.println("Set集合为："+set);
            }else{
                System.out.println("Set集合无法添加元素："+arrx[i]);
            }
        }
        System.out.println("List和Set初始化完成！");
        System.out.println("List集合为："+list);
        System.out.println("Set集合为："+set);

    }

}

/*
 * 创建Map集合，创建Emp对象，并将创建的Emp对象添加到集合中
 * Emp对象的id作为Map的键
 * 并将id为005的对象从集合中删除
 */
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
public class MapDemo {   
    public class Emp{        //创建Emp类
        private String id;  //private修饰保护对象属性
        private int value;
        public Emp(){        
        }
        public Emp(String id,int value){
            this.id=id;
            this.value=value;
        }
        public String getId(){
            return this.id;
        }
        public int getValue(){
            return this.value;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] arrStr={"001","002","003","004","005","006","007"};
        MapDemo mapDemo=new MapDemo();  //main为static，需要先创建MapDemo对象以访问Emp
        Map<String,Emp> map=new HashMap<String,Emp>();
        //创建map集合，键对象：String类型；值对象：Emp类型
        for(int i=0;i<7;i++){
            Emp temp=mapDemo.new Emp(arrStr[i],i+100);
            map.put(temp.getId(),temp);
        }//初始化
        System.out.println("map初始化完成！");
        Iterator it=map.keySet().iterator();
        while(it.hasNext()){
            String str=(String)it.next();
            String str1=map.get(str).getId();
            int val1=map.get(str).getValue();
            System.out.println(str+":"+str1+"---"+val1);
        }
        map.remove("005");
        System.out.println("删除键为'005'的映射后map为：");
        Iterator it1=map.keySet().iterator();   //需重新设置Iterator
        while(it1.hasNext()){
            String str=(String)it1.next();
            String str1=map.get(str).getId();
            int val1=map.get(str).getValue();
            System.out.println(str+":"+str1+"---"+val1);
        }

    }

}