第17章(上)--集合

 

 本章内容介绍

l  集合的理解和好处

l  集合框架体系图

l  Collection接口 特点 方法

l  Collection接口的子接口：List 实现类：ArrayList、LinkedList、Vector

l  Collection接口的子接口：Set 实现类：HashSet、TreeSet、LinkedHashSet

l  Map接口 特点方法 遍历方式

l  Map接口的实现类 ：HashMap、TreeMap、Hashtable等

l  Collections工具类的使用

 

 

1.集合基本介绍

 Java的集合类很多，主要分为两大类，如图：

 

说明

1) 单列集合，可以理解成就是直接放入一个个数据，比如前面的ArrayList

2) 单列集合的根接口是 Collection

3) Collection接口没有直接的实现子类， 而是有两个子接口List , Set

4) List 子接口的常用的实现类有 ArrayList ,LinkedList, Vector

5) Set子接口常用的实现类有 HashSet 和 TreeSet

6) 层级图

1) Map是存放双列集合的，比如 key-value

2) Map有直接的实现类，常见的有 HashMap, TreeMap, Hashtable, Propeties.

 

 2.Collection集合的常用方法

 

• Collection接口常用方法

 

1)      add:添加单个元素

2)      remove:删除指定元素

3)      contains:查找元素是否存在

4)      size:获取元素个数

5)      isEmpty:判断是否为空

6)      clear:清空

7)      addAll:添加多个元素

8)      containsAll:查找多个元素是否都存在

9)      removeAll：删除多个元素

以ArrayList实现类来演示. 

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 
 4 public class CollectionDemo {
 5 
 6     @SuppressWarnings({ "rawtypes", "unchecked", "unused" })
 7     public static void main(String[] args) {
 8         // TODO Auto-generated method stub
 9         //说明
10         //1. 创建了一个 ArrayList对象实例
11         //2. 创建了一个 ArrayList对象实例 ，赋给了Collection 应用.
12         Collection col = new ArrayList();
13         //演示Collection 添加
14         col.add("张三丰");
15         col.add(100); //100=>Integer(100)
16         col.add(true);//Boolean
17         col.add("张三丰");
18         col.add(new Integer(10));
19         
20         System.out.println(col);
21         
22         
23         //删除元素
24         col.remove("张三丰");
25         System.out.println(col);
26         //判断集合中是否有某个元素
27         
28         boolean contains = col.contains(10);
29         System.out.println("contains=" + contains);//true
30         //获取集合中有多少个元素,类似数组的length
31         
32         System.out.println(col.size()); //4
33         //判断集合是否为空
34         System.out.println(col.isEmpty());//false
35         
36         //清空整个集合
37         col.clear();
38         System.out.println("清空后");
39         System.out.println(col);
40         
41         //可以将一个Collection 集合加入到另个一个Collection
42         Collection c = new ArrayList();
43         c.add("AA");
44         c.add("CC");
45         c.add("BB");
46         col.addAll(c);
47         System.out.println(col);//["AA","BB","CC"]
48 
49         //判断Collection 集合 中是否有另外一个集合的所有元素
50         Collection c2 = new ArrayList();
51 
52         c2.add("CC");
53         c2.add("AA");
54         boolean containsAll = col.containsAll(c2);//false
55         System.out.println("containsAll=" + containsAll);
56         
57         //将一个Collection 集合 的元素一次性全部删除(删除的元素在 c2),如果没有也不报错
58         col.removeAll(c2);
59         System.out.println("col=" + col);//[BB]
60 
61     }
62 }

3. Collection接口遍历元素方式1-使用Iterator(迭代器)

• 基本介绍

 

1)      Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。

2)      所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象, 即可以返回一个迭代器。

3)      Iterator 的结构.[图:]

4)      Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

 

 

 

 4.迭代器使用陷阱

5.Collection接口遍历对象方式2-for循环增强.

说明：jdk5.0出现了增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合或数组。

• 基本语法

for(元素类型 元素名 :  集合名或数组名) {

       访问元素

}

 

 6.List

 

1.1.1       List接口的常用方法

List 集合里添加了一些根据索引来操作集合元素的方法

1)      void add(int index, Object ele):在index位置插入ele元素

2)      boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来

3)      Object get(int index):获取指定index位置的元素

4)      int indexOf(Object obj):返回obj在集合中首次出现的位置

5)      int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置

6)      Object remove(int index):移除指定index位置的元素，并返回此元素

7)      Object set(int index, Object ele):设置指定index位置的元素为ele

8)      List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

import java.util.List;
import java.util.ArrayList;

public class ListCommonMethod {

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List list = new ArrayList();
        list.add(100); //自动装箱
        list.add(3); //自动装箱
        
        //说明:
        //(1)void add(int index, E element);
        //(2)int index : 表示将数据加入到list集合哪个位置(插入)
        //(3)element: 添加元素
        list.add(1, 4); //
        
        for (Object object : list) {
            System.out.println(object);
        }
        
        
        //List的remove
        //(1) E remove(int index); 
        //(2) 指定删除list第几个元素
        list.remove(1);
        //说明: 可以指定内容删除
        list.remove(new Integer(100)); 

        System.out.println("删除后");
        for (Object object : list) {
            System.out.println(object);
        }
        
        //修改
        //说明
        //(1) Object java.util.List.set(int index, Object element)
        //(2) int index: 指定修改哪个索引对应值
        //(3) Object element : 修改成什么
        list.set(0, "张无忌");

        System.out.println("修改后");
        for (Object object : list) {
            System.out.println(object);
        }
        
        
//        //查询
        //说明 int java.util.List.indexOf(Object o)
        //(1) Object o 传入的是list集合中的对象
        //(2) 如果找到了则返回对应的索引，如果没有返回-1
        //(3) 方法原型
//        public int indexOf(Object o) {
//            if (o == null) {
//                for (int i = 0; i < size; i++)
//                    if (elementData[i]==null)
//                        return i;
//            } else {
//                for (int i = 0; i < size; i++)
//                    if (o.equals(elementData[i]))
//                        return i;
//            }
//            return -1;
//        }
        int index = list.indexOf("张无忌");
        System.out.println(index);
        
        
        //测试indexOf
        Dog dog = new Dog("小黄");
        Dog dog2 = new Dog("小黄");
        
        list.add(dog);
        System.out.println("测试indexOf");
        for (Object object : list) {
            System.out.println(object);
        }
        
        int index2 = list.indexOf(dog2);//equals
        System.out.println("index2=" + index2);//1
        

    }

}

class Dog {
    private String name;

    public Dog(String name) {
        super();
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + "]";
    }
    
    
    @Override
    public boolean equals(Object obj) {
        if(obj == this) {
            return true;
        }
        if(!(obj instanceof Dog)){
            return false;
        }
        Dog dog = (Dog)obj;
        return name.equals(dog.name);
    }
    
    
}

 

 7.List接口三种遍历方式

• 说明：使用LinkedList完成

import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListForDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //使用LinkedList演示List实现子类的三种遍历方式
        //1. 有序，可以有重复数据，可以有null
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("smith");
        list.add("mary");
        list.add("jack");
        list.add(null);
        //遍历方式1 -迭代器 [推荐使用]
        Iterator iterator = list.iterator();
        while(iterator.hasNext()) {
            Object object = iterator.next();
            System.out.println(object);
        }
        
        System.out.println("遍历方式2- 增强for");
        //遍历方式2- 增强for [推荐使用]
        for (Object object : list) {
            System.out.println(object);
            
        }
        
        System.out.println("遍历方式3-传统的遍历方式【使用索引】");
        //遍历方式3-传统的遍历方式【使用索引】
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
            System.out.println(object);
        }
    }

}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListSortExercise {

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 使用List的实现类添加三本图书，并遍历，打印如下效果
        //
        // 名称：xx 价格：xx 作者：xx
        // 名称：xx 价格：xx 作者：xx
        // 要求
        // 按价格排序,从低到高(使用冒泡法)
        // 要求使用ArrayList、LinkedList 和 Vector 三种集合实现
        // 结论：主要说明，只要实现了List接口，那么List的实现类都可以使用List接口中的方法 5min

        //List list = new ArrayList(); // shift+ctrl+o
        //List list =  new LinkedList();
        List list = new Vector();
        list.add(new Book2("西游记", 123.4, "吴承恩"));
        list.add(new Book2("三国演义", 12.4, "罗贯中"));
        list.add(new Book2("水浒传", 112.4, "施耐庵"));
        list.add(new Book2("红楼梦", 42.44, "曹雪芹"));
        list.add(new Book2("java从入门到跑路", 2.44, "韩老师"));

        for (Object object : list) {
            System.out.println(object);
        }

        // 使用冒泡法
        for (int i = 0; i < list.size() - 1; i++) {// 外层大循环
            for (int j = 0; j < list.size() - 1 - i; j++) {// 内存循环
                //取出相邻的两个元素[Book2类型]
                Book2 book1 = (Book2)list.get(j);
                Book2 book2 = (Book2)list.get(j+1);
                if(book1.getPrice() > book2.getPrice()) {//成立
                    //定时临时变量
                    list.set(j, book2);
                    list.set(j+1, book1);
                }
            }
        }
        //遍历
        System.out.println("排序后");
        for (Object object : list) {
            System.out.println(object);
        }

    }

}

class Book2 {
    private String name;
    private double price;
    private String author;

    public Book2(String name, double price, String author) {
        super();
        this.name = name;
        this.price = price;
        this.author = author;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Book2 [name=" + name + ", price=" + price + ", author=" + author + "]";
    }

}