黑马程序员——集合

最新推荐文章于 2015-10-15 15:33:32 发布

luo_yawa

最新推荐文章于 2015-10-15 15:33:32 发布

阅读量230

点赞数

本文链接：https://blog.csdn.net/luo_yawa/article/details/25830223

版权

------- android培训、java培训、期待与您交流！ ----------

集合框架图

Collection

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

Collection API

List接口

　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

ArrayList类

    ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦

　　ArrayList是一个可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
　　每个ArrayList实例都有一个容量，即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

方法示例：

public class Test1 {

	public static void main(String[] args) {
		ArrayList<Person> al = new ArrayList<Person>();
		// 向集合中添加元素
		al.add(new Person("lzy", 18));
		al.add(new Person("zhangsan", 33));
		al.add(new Person("lzy", 18));
		al.add(1,new Person("zhangsan", 19));//将指定的元素插入此列表中的指定位置。

		al.clear(); //移除此列表中的所有元素。
		al.get(1);  //返回此列表中指定位置上的元素。
		al.contains(new Person("lzy", 18)); // 如果此列表中包含指定的元素，则返回 true。
		al.indexOf(new Person("lzy", 18));  //返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
		al.lastIndexOf(new Person("lzy", 18)); // 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
		al.isEmpty();  // 如果此列表中没有元素，则返回 true
		al.remove(1);  // 移除此列表中指定位置上的元素。
		al.remove(new Person("lzy", 18)); // 移除此列表中首次出现的指定元素
		al.set(1, new Person("aaa", 11)); //用指定的元素替代此列表中指定位置上的元素。
		int i = al.size(); //返回此列表中的元素数。
		Object[] p = al.toArray();  //按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
		// 遍历集合
		for (Person person : al) {
			System.err.println(person.getName());
		}
	}
}

ArrayList中判读元素是否相同

1、ArrayList中判读元素是否相同用的是元素equals方法；所以要存入不相同的元素就要重写元素equals方法；定义判读元素相同的方法。

2、可以利用集合工具类 Collections的sort方法对元素进行排序

public class Test22 {
	public static void main(String[] args) {

		sortDome();
	}

	private static void sortDome() {
		List<Person> list = new ArrayList<Person>();
		list.add(new Person("sdfs", 15));
		list.add(new Person("sds", 15));
		list.add(new Person("fs", 15));
		list.add(new Person("AAAAAA", 15));
		Collections.sort(list); //对元素进行排序
		for (Person person : list) {
			System.out.println(person.getName());
		}
	}

}

public class Person implements Comparable<Person> {
	private String name;
	private int age;

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	@Override
	public int compareTo(Person o) {
		// 自定义的排序方法
		int result = o.getAge() > age ? 1 : (o.getAge() == age ? 0 : -1);
		if (result == 0) {
			result = o.getName().indexOf(0) > o.getName().indexOf(0) ? 1 : -1;
		}
		return result;

	}
}

LinkedList类

LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引  但是缺点就是查找非常麻烦 要丛第一个索引开始

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

Set接口

在Java中使用Set,可以方便地将需要的类型以集合类型保存在一个变量中.主要应用在显示列表.Set是一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

public class Test12 {
	public static void main(String[] args) {
		Set set = new HashSet();
		set.add("abc");
		set.add("cde");
		set.add("efg");
		set.add("fgh");
		set.add("abc"); // 重复的abc,set会自动将其去掉
		set.size();  //该集合的元素数
		List list = new ArrayList();
		list.add("abc");
		list.add("aaa");
		list.add("fff");
		set.addAll(list); // 将list中的值加入set,并去掉重复的abc
		//遍历打印
		System.out.println("size=" + set.size());
		for (Iterator it = set.iterator(); it.hasNext();) {
			System.out.println("value=" + it.next().toString());
		}
	}
}

set的常用子类有HashSet和TreeSet（和ArrayList和TreeList一样）

Map接口

在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。在下文中会有例子具体说明。

　　Map没有继承Collection接口， Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将 List 看作是具有数值键的 Map。而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。

Map 接口和方法

Map重写了equals方法和hashCo的方法

equals(Object o)	比较指定对象与此 Map 的等价性
hashCode()	返回此 Map 的哈希码

clear()	从 Map 中删除所有映射
remove(Object key)	从 Map 中删除键和关联的值
put(Object key, Object value)	将指定值与指定键相关联
clear()	从 Map 中删除所有映射
putAll(Map t)	将指定 Map 中的所有映射复制到此 map

entrySet()	返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素
keySet()	返回 Map 中所包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应的映射（键和值）
values()	返回 map 中所包含值的 Collection 视图。删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）

get(Object key)	返回与指定键关联的值
containsKey(Object key)	如果 Map 包含指定键的映射，则返回 true
containsValue(Object value)	如果此 Map 将一个或多个键映射到指定值，则返回 true
isEmpty()	如果 Map 不包含键-值映射，则返回 true
size()	返回 Map 中的键-值映射的数目

HashMap

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

TreeMap

TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

class  HashMaps    
{    
       public static void main(String[] args)     
      {    
            Map map=new HashMap();                
            map.put("a", "aaa");    
            map.put("b", "bbb");    
            map.put("c", "ccc");    
            map.put("d", "ddd");    
               
            Iterator iterator = map.keySet().iterator();                
            while (iterator.hasNext()) {    
             Object key = iterator.next();    
             System.out.println("map.get(key) is :"+map.get(key));    
            }            
            Hashtable tab=new Hashtable();                
            tab.put("a", "aaa");    
            tab.put("b", "bbb");    
            tab.put("c", "ccc");    
            tab.put("d", "ddd");    
            Iterator iterator_1 = tab.keySet().iterator();    
            while (iterator_1.hasNext()) {    
             Object key = iterator_1.next();    
             System.out.println("tab.get(key) is :"+tab.get(key));    
            }             
                
            TreeMap tmp=new TreeMap();                
            tmp.put("a", "aaa");    
            tmp.put("b", "bbb");    
            tmp.put("c", "ccc");    
            tmp.put("d", "ddd");    
            Iterator iterator_2 = tmp.keySet().iterator();    
            while (iterator_2.hasNext()) {    
             Object key = iterator_2.next();    
             System.out.println("tmp.get(key) is :"+tmp.get(key));    
            }             
   
       }      
}

执行完后，hashmap是没有顺序的，而treemap则是按顺序排列的。

HashMap 非线程安全 TreeMap 非线程安全

……

Collections

Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

常用方法

1、sort(Collection)方法的使用(含义：对集合进行排序)。

2、shuffle(Collection)方法的使用(含义：对集合进行随机排序)。

3、binarySearch(Collection,Object)方法的使用(含义：查找指定集合中的元素，返回所查找元素的索引)。

4、max(Collection),max(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。

5、min(Collection),min(Collection,Comparator)方法的使用(前者采用Collection内含自然比较法，后者采用Comparator进行比较)。
6、indexOfSubList(List list,List subList)方法的使用(含义：查找subList在list中首次出现位置的索引)。
8、replaceAll(List list,Object old,Object new)方法的使用(含义：替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false)。

7、lastIndexOfSubList(List source,List target)方法的使用与上例方法的使用相同，在此就不做介绍了。

9、reverse()方法的使用(含义：反转集合中元素的顺序)。

10、rotate(List list,int m)方法的使用(含义：集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来)。

11、copy(List m,List n)方法的使用(含义：将集合n中的元素全部复制到m中,并且覆盖相应索引的元素)。

12、swap(List list,int i,int j)方法的使用(含义：交换集合中指定元素索引的位置)。

13、fill(List list,Object o)方法的使用(含义：用对象o替换集合list中的所有元素)。

14、nCopies(int n,Object o)方法的使用(含义：返回大小为n的List，List不可改变,其中的所有引用都指向o)。

15、enumeration(Collection)方法的使用(含义：为参数生成一个旧式的Enumeration)。

16、list(Enumeration e)方法的使用(含义：返回使用Enumeration生成的ArrayList,用来转换遗留的老代码)。

示例：运用Collections工具类的sort方法对集合进行排序


public class TestCollections {
	
	public static void main(String args[]) {
		//注意List是实现Collection接口的
		List list = new ArrayList();
		double array[] = { 112, 111, 23, 456, 231 };
		for (int i = 0; i < array.length; i++) {
			list.add(new Double(array[i]));
		}
		Collections.sort(list);
		for (int i = 0; i < array.length; i++) {
			System.out.println(list.get(i));
		}
		// 结果：23.0 111.0 112.0 231.0 456.0
	}
}

------- android培训、java培训、期待与您交流！ ----------