13.2 具体的集合

Posted 2020-09-01 motivated_Dou

 

 

• Set（集）：集合中的元素不按特定方式排序，并且没有重复对象。他的有些实现类能对集合中的对象按特定方式排序。
• List（列表）：集合中的元素按索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象。
• Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。他的有些实现类能对集合中的键对象进行排序。

 

1、collection接口

　　Collection是整个类集中单值保存的最大父接口。

 

1	Public boolean add(E e)	普通	向集合中添加
2	Public boolean addAll(Collection<? extends E> c)		追加一个集合
3	Public void clear()
4	Public boolean contains(Object o)
5	Public boolean isEmpty
6	Public boolean remove(Object o)
7	Pulic int size()
8	Public Object[] toArray()		将集合变为字符数组
9	Public Iterator<E> iterator()

 

只有add和Iterator会常常使用，但是要记住contains和remove方法需要Object的支持。

现在基本不使用collection接口，而是使用list和set这两个接口。

13.2.1 链表

　　从数组的中间位置删除一个元素要付出很大的代价，因为数组中处于被删除元素之后的元素都要向数组的前端移动，在数组中间的位置插入一个元素也是如此。

　　从链表中删除一个元素是一个非常轻松操作，急需要对被删除元素附近的节点更新一下即可。

List<String> staff = new LinkList<>();
staff.add("Amy");
staff.add("Bob");
staff.add("Carl");
Iterator iter = staff.iterator();
String first = iter.next();
String second = iter.next();
iter.remove();

　　链表是一个有序集合，每个对象的位置十分重要。LinkList.add方法将对象添加到链表的尾部，但是，常常需要将元素添加到链表的中间。由于迭代器是描述集合中位置的，所以这种依赖于位置的add方法将由迭代器负责。只有对自然有序的集合使用迭代器添加元素才有实际意义。例如，下一节中讨论的集（set）类型，其中的元素完全无序。因此，在Iterator接口中就没有add方法，相反的，集合类库提供了子接口ListIterator，其中包含add方法。

　　Collection接口中声明了很多对链表操作的有用方法，其中大部分方法都是在LinkList类的超类AbstractCollection中实现的。例如，toString方法调用了所有元素的toString，并产生了一个很长的格式为[A,B,C]的字符串。这为调试工作提供了便利。可以使用contaions方法检测某个元素是否出现在链表中。例如，如果链表中包含一个等于“Harry”的字符串，调用staff.contains("Harry")后将会返回true。

　　链表不支持快速地随机访问。

　　如果要查看链表的第n个元素，就必须从头开始，超过n-1个元素，没有捷径可走，所以在采用整数索引访问元素的时候，一般不选用链表。

　　尽管如此，LinkList中提供了一个用来访问某个特定元素的get方法：

LinkList<String> list = ... ;
String obj = list.get(n);

　　get方法的效率不高，而且非常不建议使用get方法对链表进行遍历。

　　列表迭代器接口中有一种方法，可以告知当前位置的索引。实际上，Java迭代器指向两个元素之间的位置，所以可以 同时产生两个索引：nextIndex方法返回下一次调用next时返回元素的整数索引；previousIndex方法返回下一次调用previous方法时返回元素的整数索引。当然，这个索引只比nextIndex返回的索引值小1.这两个方法的效率非常高，因为迭代器保持着当前位置的计数值，

　　如果一个整数索引是n，则list。listIterator(n)将返回一个迭代器，这个迭代器指向索引为n的元素前面的位置，也就是说，调用next与调用list.get(n)会产生同一个元素，只是get方法效率比较低。

　　如果链表中只有很少的几个元素，就完全不必担心get方法和set方法的开销带来的烦恼。

　　为什么优先使用链表？唯一的理由是尽可能减少在列表中间插入或删除元素所付出的代价。如果列表中只有少数几个元素，就完全可以使用ArrayList。

　　如果需要对集合进行随机访问，就使用数组或者ArrayList，而不是使用链表。

　　　　

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

public class list_13_1 {
	public static void main(String args[])
	{
		List<String> a = new LinkedList<>();
		a.add("Amy");
		a.add("Carl");
		a.add("Erica");
		
		List<String> b = new LinkedList<>();
		b.add("Bob");
		b.add("Doug");
		b.add("Frances");
		b.add("Gloria");
		
		ListIterator<String> aIter = a.listIterator();
		Iterator<String> bIter = b.listIterator();
		
		//b非空
		while(bIter.hasNext())
		{
			//跳过一个
			if(aIter.hasNext()) aIter.next();
			//每隔一个，将b中的元素加入到a中
			aIter.add(bIter.next());
		}
		
		System.out.println(a);
		
		bIter = b.iterator();
		while(bIter.hasNext())
		{
			bIter.next();
			if(bIter.hasNext())
			{
				//每隔一个，删除一个b中的元素
				bIter.next();
				bIter.remove();
			}
		}
		
		System.out.println(b);
		
		a.removeAll(b);
		
		System.out.println(a);
	}

}

　　　创建两个链表，将他们合并在一起，然后从第二个链表中每隔一个元素删除一个元素，最后测试removeAll方法。　

　　

13.2.3 散列表

　　　链表和数组可以按照人们的意愿排列元素的次序。但如果要查询某个元素，却又忘记了位置，就必须访问所有的元素，直到找到为止。如果集合中的元素较多，就会消耗较长的时间。如果不在意元素的顺序，可以有几种快速查找元素的数据结构，缺点就是无法控制元素的位置。他们将按照有利于操作目的的原则组织数据。

　　散列表（hash table）可以快速查找所需要的对象，散列表为每一个对象计算一个整数，称为散列码（hash code）。散列码是由对象的实例域产生的一个整数，更准确的说，具有不同数据域的对象产生不同的散列码。

　　如果自己定义类，就需要负责实现这个类的hashCode方法，自己实现的hashCode方法应该与equals方法兼容，即如果a.equals(b)为true，则a与b必须具有相同的散列码。

　　在Java中，散列表用链表数组实现，每个列表称为桶（bucket）。要想查找表中对象的位置，就需要计算它的散列码，然后与桶中的总数取余，所得到的结果就是保存这个元素的桶的索引。例如，若对象的散列码是76268，并且有128个桶，对象应该保存在第108号桶中（76268除以128余108）。如果这个桶中没有其他元素，可以直接将这个元素插入到桶中，有时候可能遇到桶被占满的情况，这种现象称为散列冲突（hash collision）。如果散列码是合理且随机分布的，桶的数目也足够大，需要比较的次数就会很少。

　　如果大致知道需要插入多少个元素到散列表中，就可以设置桶的数量，通常将桶的数量设置为预计元素个数的75%~150%。

　　如果散列表太满，就需要再散列（rehashed）。如果要对散列表再散列，就需要创建一个桶更多的表，并将所有的元素都插入到这个表中，然后丢弃原来的表。这个装填因子决定了在什么时候对散列表进行再散列。

　　散列表可以实现几个重要的数据结构，其中最简单的是set类型。set是没有重复元素的元素集合。set的add方法首先在集合中查找要添加的对象，如果不存在，就将这个对象添加进去。

　　java集合类库提供了一个HashSet库，它实现了基于散列表的集。可以用add方法添加元素。contains方法被重新定义了，用来快速地查看是否某个元素已经出现在集中。它只是在某个桶中查找元素，而不必查看集合中的所有元素。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class set_13_2 {
	public static void main(String args[])
	{
		Set<String> words = new HashSet();
		long totalTime = 0;
		
		Scanner in = new Scanner(System.in);
		while(in.hasNext())
		{
			String word = in.next();
			long callTime = System.currentTimeMillis();
			words.add(word);
			callTime = System.currentTimeMillis() - callTime;
			totalTime += callTime;
			
		}
		
		Iterator<String> iter = words.iterator();
		for(int i = 0; i <= 20 && iter.hasNext(); i++)
		{
			System.out.println(iter.next());
		}
		System.out.println("...");
		System.out.println(words.size() + " distinct words" + totalTime + "milliseconds");
		
	}

　　这个程序将读入输入的所有单词，并且将它们添加到散列集中，然后遍历散列集中的不同单词，最后打印出单词的数量，单词以随机的顺序出现。

13.2.4 树集

　　TreeSet类与散列表十分类似，不过，它比散列表有所改进。树集是一个有序集合（sorted collection）。可以以任意顺序将元素插入到集合中。在对集合进行遍历的时候，每个值将自动地按照排序后的顺序呈现。

SortedSet<String> sorter = new TreeSet<>();
sorter.add("Bob");
sorter.add("Amy");
sorter.add("Carl");
for(String s:sorter)
{
      System.out.println(s);  
}

　　这时候，每个值都会按照顺序打印出来：Amy、Bob、Carl。排序是按照树结构来实现的（在这里使用的是红黑树red-black tree），每次讲一个数据添加到树中，都被放置在正确的排序位置上，因此，迭代器总是以排好序的顺序访问每个元素。

 

13.2.5 对象的比较

　　TreeSet如何知道希望元素怎样排列呢？在默认情况下，树集假定插入的元素实现了Comparable接口。

public interface Comparable<T>
{
    int compareTo(T other);
}

　　如果a和b相等，调用a.compareTo(b)一定返回0；

　　如果排序后a位于b之前，则返回负值；

　　如果排序后a位于b之后，则返回正值。

　　有些标准的java平台类实现了Comparable接口，例如，String类。这个类的compareTo方法依据字典序对字符串进行比较。

　　如果要插入自定义的对象，就必须通过实现Comparable接口自定义排列顺序，在Object类中，没有提供任何compareTo接口的默认实现。

　　如下代码展示了如何使用部件编号对Item对象进行排序：

class Item implements Comparable<Item>
{
    public int compareTo(Item other)
    {
        return partNumber - other.partNumber;    
    }  
}

　　如果对两个正整数进行比较，可以直接返回它们的差。

　　如果第一项位于第二项之前，就返回负值；

　　如果第一项位于第二项之后，就返回正值。

 

　　只有两个正整数进行比较的时候，才能使用上述的方法进行，直接返回它们的差值，如果x是一个较大的正整数，而y是一个绝对值较大的负整数，x - y可能会溢出。

　　然而，使用Comparable接口定义排列顺序显然有局限性，对于一个给定的类，只能实现这个接口一次。如果在一个集合中需要按照部件编号进行排序，在另一个集合中却要按照描述信息进行排序，该怎么办？

　　在这种情况下，可以通过将Comparator对象传递给TreeSet构造器来告诉树集使用不同的比较方法。Comparator接口声明了一个带有两个显式参数的compare方法。

 

 

 

 

13.2.8 映射表

　　集是一个集合，它可以快速查找现在的元素，但是，要查看一个元素，需要有要查找元素的精确地副本，这不是一种非常通用的查找方式。通常，我们知道某些键的信息，并想要查找与之对应的元素。映射表（map）数据结构就是为此设计的。映射表用来存放键/值对。如果提供键。就能够查到值。例如，键为员工ID，值为Employee对象。

　　Java类库为映射表提供了两个通用的实现：HashMap和TreeMap，这两个类都实现了Map接口。

　　散列映射表对键进行散列，树映射表用键的整体顺序对元素进行排序，并将其组织成搜索树。散列或比较函数只能作用于键。与键关联的值不能进行散列或比较。

　　与集一样，散列稍微快一些，如果不需要按照排列顺序访问键，就最好选用散列。

　　每当往映射表中添加对象的时候，必须同时提供一个键。在这里，键是一个字符串，对应的值是Employee对象。

　　要搜索一个对象，必须提供一个键。

String s = "987-98-9996";
e = staff.get(s);

　　如果在映射表中没有与给定键对应的信息，get将返回null。

　　键必须是唯一的。

　　如果对同一个键两次调用put方法，第二个值就会取代第一个值。实际上，put将返回这个键参数存储的上一个值。

　　remove方法用于从映射表中删除给定键对应的元素；size方法用于返回映射表中的元素数。

　　

　　键集　　　　Set<K> keySet()

　　值集合　　   Collection<K> values()

　　键/值对集　  Set<Map.Entry<K,V>> entrySet()

 

　　keySet既不是HashSet，也不是TreeSet，而是实现了Set接口的某个其他类的对象。Set接口扩展了Collection接口。因此，可以与任何集合一样使用了keySet。

Set<String> keys = map.keySet();
for(String key:keys)
{
     ...  
}

　　如果要同时查看键和值，就可以通过枚举各个条目（entries）查看，以避免对值进行查找。

for(Map.Entry<String, Employee> entry:staff.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    ...  
}

　　如果调用迭代器的remove方法，实际上是从映射表中删除了键以及对应的值。但是，不能将元素添加到键集的视图中。如果只添加键而不添加值是毫无意义的。如果视图调用add方法，将会抛出UnsupportedOperationException异常。

package map_13_6;

import java.util.HashMap;
import java.util.Map;

public class MapTest {
	public static void main(String args[])
	{
		//String n, double s, int year, int month, int day
		Map<String, Employee> staff = new HashMap<>();
		staff.put("1", new Employee("Amy Lee", 20000, 1993, 12, 1));
		staff.put("2", new Employee("Allen Iverson", 30000, 1983, 12, 1));
		
		System.out.println(staff);
		staff.remove(1);
		
		//替换掉“1”
		staff.put("1", new Employee("Lebron James", 30000, 1983, 2, 23));
		
		System.out.println(staff);
		
		System.out.println(staff.get("2"));
		
		for(Map.Entry<String, Employee> entry:staff.entrySet())
		{
			String key = entry.getKey();
			Employee value = entry.getValue();
			
			System.out.println("key = " + key + ",value = " + value);
		}
	}
}

　　首先将键值对添加到映射表中，然后从映射表中删除掉一个键值对，接下来修改某一个键对应的值，并调用get方法查看这个值。最后，对条目进行迭代输出。

{1=map_13_6.Employee@42a57993, 2=map_13_6.Employee@75b84c92}
{1=map_13_6.Employee@6bc7c054, 2=map_13_6.Employee@75b84c92}
map_13_6.Employee@75b84c92
key = 1,value = map_13_6.Employee@6bc7c054
key = 2,value = map_13_6.Employee@75b84c92