Java第十章总结

 10.1集合类概述

java.util 包中提供了一些集合类，这些集合类又被称为容器。提到容器不难想到数组，集合类
与数组的不同之处是，数组的长度是固定的，集合的长度是可变的; 数组用来存放基本类型的数据 
集合用来存放对象的引用。常用的集合有 List 集合、Set集合和 Ma p 集合，其中 List 与 Set 继承了 Collection 接口，各接口还提供了不同的实现类。上述集合类的继承关系如图所示。

10.2 Collection接口

Collection接口是层次结构中的根接口。构成 Collection的单位称为元素。Collection 接口通常不能直接使用，但该接口提供了添加元素、删除元素和管理数据的的方法。由于 List 接口与 Set接口都继承了Collection接口,因此这些方法对List集合与Set集合是通用的.

表10.1 Collection接口的常用方法

方法	功能描述
add(Object e)	将指定的对象添加到该集合中
remove(Object o)	将指定的对象从该集合中移除
isEmpty()	返回boolean值,用于判断当前集合是否为空
iterator()	返回在此Collection的元素上进行迭代器,用于遍历集合中的对象.
size()	返回int型值,获取该集合中元素的个数

10.3 List集合

List集合包括List接口以及List接口的所有实现类.List集合中的元素允许重复,各元素的顺序就是对象插入的顺序.类似于Java数组,用户可通过使用索引(元素在集合中的位置)来访问集合中的元素.

10.3.1 List接口

List接口继承了Collection接口,因此包含了Collection中所有的方法.此外,List接口还定义了以下两个非常重要的方法.

表10.2 List接口的常用方法

方法	功 能 描 述
get(int index)	获得指定索引位置的元素
set(int index,Object obj)	将集合中指定索引位置的对象修改为指定的对象

10.3.2 List接口的实现类

List 接口由于不能直接实例化，因此，在 JDK 中提供了其实现子类，最常用的实现子类有 
ArrayList 类与LinkedList类，分别如下。
(1)ArrayList 类的优点是实现了可变的数组， 允许保存所有元素，包括 null，并可以根据索 
引位置对集合进行快速的随机访问;缺点是向指定的索引位置插入对象或删除对象的速度较慢，因为ArrayList 实质上是使用数组来保存集合中的元素的的，在增加和删除指定位置的元素时，虚拟机会创建新的数组，效率低，所以在对元素做大量的增删操作时不适合使用 ArrayList 集合。

(2)LinkedList类采用链表结构保存对象,这种结构的优点是便于向集合中插入和删除对象,需要向集合中插入,删除对象时,使用LinkedList类实现的List集合的效率较高;但对于随机访问集合中的对象,使用LinkedList类实现List集合的效率较低.

注:实例化List接口对象时,建议优先使用ArrayList,只有在插入和删除操作特别频繁时,才使用LinkedList.

分别通过ArrayList,LinkedList类实例化List集合,代码如下:

List<E> list = new ArrayList<>();

List<E> list2 = new LinkedList<>();

例10.1

import java.util.*;

public class LinkTest {

	public static void main(String[] args) { //主方法
		List<String> list = new ArrayList<>();  //创建集合对象
		list.add("a"); //向集合添加元素
		list.add("b");
		list.add("c");
		int i = (int) (Math.random()*list.size()); //获得0~2之间的随机数
		System.out.println("随机获得数组中的元素:" + list.get(i)); 
		list.remove(2); //将指定索引位置的元素从集合中移除
		System.out.println("将索引是'2'的元素从数组移除后,数组中的元素是:");
		for (int j = 0;j<list.size(); j++) { //循环遍历集合
			System.out.println(list.get(j)); //获得指定索引处的值
	}
		// TODO Auto-generated method stub

	}

}

 与数组相同,集合的索引也是从0开始.

10.3.3 Iterator迭代器

package error;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class InteratorTest{ //创建类IteratorTest
	public static void main (String args[]) { //主方法
		Collection<String> list = new ArrayList<>(); //实例化集合类对象
		list.add("a");
		list.add("b");
		list.add("c");
		Iterator<String> it = list.iterator(); //创建迭代器
		while (it.hasNext()) {//判断是否有下一个元素
			 String str = (String) it.next(); //获取集合中元素
			 System.out.println(str);
		}
	}
}

10.4 Set集合

10.4.1 Set接口

Set接口是一个不包含重复元素的集合,由于继承了Collection接口,因此包含Collection接口的所有方法.

Set的构造有一个约束条件,传入的Collection对象不能有重复值,必须小心操作可编程对象(Mutable Object).如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true,则会出现一些问题

10.4.2 Set接口的实现类

Set接口常用的实现类有HashSet类和TreeSet类;

(1) HashSet是 Set接口的一个实现类，它不允许有重复元素。HashSet主要依据哈希算法直接将元素指定到一个地址上。当向 HashSet 集合中添加一个元素时，会调用 equals 方法来判断读置是否有重复元素。判断是通过比较它们的HashCode 来进行比较的。HashSet集合的常用方法都是重写了Set接口中的方法。此集合允许保存 null。
(2) TreeSet 类不仅实现了 Set 接口，还实现了java.util.SortedSet接口，因此，TreeSet类实用的Set集合在遍历集合时按照自然顺序递增排序，也可以制定排序规则，让集合按照我们想要的方式进行排序。TreeSet类新增的方法如表 10.4所示。此集合不能保存null。(值不可重复)

表10.4 TreeSet类增加的方法

方法	功 能 描 述
first()	返回此Set中当前第一个最低元素
last()	返回此Set中当前最后一个最高元素
comparator()	返回此Set中元素进行排序的比较器.如果此Set使用自然顺序,则返回null
headSet(E toElement)	返回一个新的Set集合,新集合是toElement(不包含) 之前的所有对象
subSet(E fromElement,E toElement)	返回一个新的Set集合,是fromElement(包含)对象与toElement(不包含)对象之间的所有对象
tailSet(E fromElement)	返回一个新的Set集合,新集合包含对象fromElement(包含)之后的所有对象

例10.3 

import java.util.*;
public class HashSetTest {

	public static void main(String[] args) {
		Set set = new HashSet();    //创建Set集合
		set.add("c");  //向集合中添加数据
		set.add("c");
		set.add("a");
		set.add("b");
		Iterator<String> it = set.iterator();   //创建迭代器
		while (it.hasNext()) {   //遍历HashSet集合
			String str = (String) it.next(); //获取集合中的元素
			System.out.println(str);
		}
		// TODO Auto-generated method stub

	}

}

 

10.4.3 TreeSet的两种排序方式 

一、引入排序

	@Test
	public void test1() {
		TreeSet treeSet = new TreeSet();
		treeSet.add(10);
		treeSet.add(11);
		treeSet.add(13);
		treeSet.add(12);
		for (Object object : treeSet) {
			System.out.print(object + " " );
		}	
	}

运行结果：10 11 12 13

结论：默认进行升序排列

思考：但是对于自定义对象呢？

   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /*  
        测试类
    */
     @Test
     public void test2() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
		
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	   }
		
	}

运行结果：

解决方案：1、自然排序 2、定制排序

二、自定义类型排序

如果集合存储的是自定义类型，当存入自定义的引用类型的时候就必须考虑到元素要求具有可排序性，不然会引发ClassCastException异常，所以要对自定义类型进行处理，必须要实现 Comparable或Compared接口。当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树算法决定它的存储位置。

2.1 自然排序

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排序。（比较的前提：两个对象的类型相同）。

操作步骤：

1、Book类实现Comparable接口；

2、重写Comparable接口中的compareTo方法。

  /*
      Book类
      compareTo(T o) ： 比较此对象与指定对象的顺序。
      特别注意在重写Compareto方法时，注意排序 ！！！
  */ 
   public class Book implements Comparable{ // 第一步：实现Comparable接口
   
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;

        
        public int compareTo(Object o) {    // 第二步：重写Comparable接口中的compareTo方法。
                // 若想按照价格从小到大排序，则需要return  = 1 ，即已存在数据大于待存数据
		Book book = (Book)o;
	        int flag = (int)(this.getPrice() - book.getPrice()); 
		return flag;
 	}

    }
   /*
       测试类
   */
    @Test
    public void test3() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
		
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	}
		
	}

运行结果：

2.2 定制排序

TreeSet的自然排序是根据集合元素的大小，TreeSet将他们以升序排列。如果需要实现定制排序，例如降序，则可以使用Comparator接口。该接口里包含一个int compare（T o1， T o2）方法，该方法用于比较o1和o2的大小。如果需要实现定制排序，则需要在创建TreeSet集合对象时，并提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

操作步骤：

让集合构造方法接收Comparator的实现类的compare()方法。

   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /** 
       测试类
   */
   @Test
   public void test4() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(1, "西游记", "曹雪芹",3.0);
	Book book3 = new Book(1, "水浒传", "曹雪芹",12.0);
	/**
           compare有两个参数，o1和o2，如果
	   o1 < o2  返回负数,
	   o1 = o2  返回正数,
           o1 > o2 返回正数。
        */
	TreeSet treeSet = new TreeSet(new Comparator() {   // 匿名内部类操作
	public int compare(Object o1, Object o2) {	
               Book book1 = (Book)o1;
               Book book2 = (Book)o2;			
	       return (int)( book1.getPrice() - book2.getPrice());				
		}
			
	});
		treeSet.add(book1);
		treeSet.add(book2);
		treeSet.add(book3);
		for (Object object : treeSet) {
			Book book = (Book)object;
			System.out.println(book.getBookName() + book.getPrice());
		}
		
	}
   

运行结果：

10.5 Map集合

在现实生活中，每辆车都有唯一的车牌号，通过车牌号可以查询到这辆车的详细信息，这两都是一对一的关系，在应用程序中，如果想存储这种具有对应关系的数据，则需要使用JDK 中提供的 Map 接口。Map 接口没有继承 Collection接口，其提供的是 key到value的映射。Map中不能包含相同的key，每个key只能映射一个value，另外，key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值来确定存储对象在映射中的存储位置。Map 集合包括Map接口以以及Map接口的所有实现类。

10.5.1 Map接口

表10.5 Map接口中的常用方法

方法	功能描述
put(Object key,Object values)	向集合中添加指定的key与value的映射关系
containsKey(Object key)	如果此映射包含指定key的映射关系,则返回true
containsValue(Object value)	如果此映射将一个或多个key映射指定值,则返回true
get(Object key)	如果存在指定的key对象,则返回该对象对应的值,否则返回Null
keySet()	返回集合中的所有key对象形成的Set集合
values()	返回集合中所有值对象形成的Collection集合

10.5.2 Map接口的实现类

10.5.2 Map接口的实现类
Map接口常用的实现类有HashMap和TreeMap两种，分别如下。
(1)HashMap类是基于哈希表的 Map接口的实现，此实现提供所有可选的映射操作，并允许使用null 值和null键，但必须保证键的唯一性。HashMap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
(2)TreeMap类不仅实现了Map接口，还实现了javautilSortedMap接户，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap 类比 HashMap 类性能稍差。1于TreeMap 类实现的 Map 集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null.

例10.4

import java.util.*;

public class HashMapTest {

	public static void main(String[] args) {
		Map<String,String> map = new HashMap<>(); //创建Map实例
		map.put("ISBN-978654", "JAVA从入门到精通");//向集合中添加对象
		map.put("ISBN-978361", "Android从入门到精通");
		map.put("ISBN-978893", "21天学Android");
		map.put("ISBN-978756", "21天学Java");
		Set<String> set = map.keySet();  //构建Map集合中所有key对象的集合
		Iterator<String> it = set.iterator();  //创建集合迭代器
		System.out.println("key值:");
		while (it.hasNext()) {   //遍历集合
			System.out.print(it.next() + "\t");  
		}
		Collection<String> coll = map.values();  //构建Map集合中所有values值集合
		it = coll.iterator();
		System.out.println("\nvalues值:");
		while (it.hasNext()) {
			 System.out.print(it.next() + "\t");
		}
		// TODO Auto-generated method stub

	}

}

说明:集合中允许值对象是null,而且没有个数限制

10.5.2 Map接口的实现类
Map接口常用的实现类有HashMap和TreeMap两种，分别如下。
(1)HashMap类是基于哈希表的 Map接口的实现，此实现提供所有可选的映射操作，并允许使用null 值和null键，但必须保证键的唯一性。HashMap通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
(2)TreeMap类不仅实现了Map接口，还实现了javautilSortedMap接户，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap 类比 HashMap 类性能稍差。1于TreeMap 类实现的 Map 集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许里对象是null.

10.6 集合的使用场合

前面介绍了Java中最常见的3种集合:List 集合、Set 集合和Map集合，那么在实际开发中，具体何时应该选择哪种集合呢?这里我们总结了以下原则。
(1)List 集合关注的是索引，其元素是顺序存放的，例如一个班的学生成绩，成绩可以重复，就可以使用List集合存取。
(2)Set集合关注唯一性，它的值不允许重复，例如每个班的学生的学号，每个学生的学号是不能重复的。
(3)Map集合关注的是唯一的标识符(KEY)，它将唯一的键映射到某个元素，例如每个班学生的学号与姓名的映射，每个学号对应一个学生的姓名，学号是不能重复的，但是学生的姓名有可能重复。