集合简述

集合概述

• 集合:就是一个存储数据的容器
• 集合和数组的区别：
  • 数组长度固定，集合长度不固定
  • 数组可以存储基本数据类型和引用类型，集合只能存储引用类型
• 集合框架
  

Collection接口

• Collection层次结构中的根接口。Collection表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些是无序的。
• List：可以重复，有序
• Set：不能重复，无序

常用方法

---

方法名	描述
add（E e）	确保此collection包含指定的元素
addAll（Collection<? extends E> c）	将指定的collection中的所有元素都添加到此collection中
clear（）	移除此collection中的所有元素
contains（Object o）	如果此collection包含指定元素，则返回true
containsAll（Collection<?> c）	如果此collection包含指定collection中的所有元素，则返回true
equals（Object o）	比较此collection与指定对象是否相等
isEmpty（）	如果此collection不包含元素，则返回true
iterator（）	返回此collection的元素上进行迭代的迭代器
remove（Object o）	从此collection中移除指定元素的单个实例，如果存在的话
removeAlll（Collection<?> c）	移除此collection中那些也包含在指定从collection中的所有元素
retainAll（Collection<?> c）	仅保留此collection中那些也包含在指定collection的元素
size（）	返回此collection中的元素数
toArray（）	返回包含此collection中的所有元素的数组

• 代码实例

package waking.test.jh;

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

/**
 * Collection的常用方法
 * @author waking
 *
 */
public class Demo01 {
	@SuppressWarnings("unlikely-arg-type")
	public static void main(String[] args) {
		Collection<String> c = new ArrayList();
		Collection c1 = new ArrayList();
		
		c.add("waking");
		c1.add("to");
		
		c.addAll(c1);
		
		System.out.println(c.toString());//[waking, to]
		
//		c.clear();
//		System.out.println(c.toString());//[]
		
		boolean is = c.contains("waking");
		System.out.println(is);//true
		
		boolean all = c.containsAll(c1);
		System.out.println(all);//true
		
		boolean isequ = c.equals("waking");
		System.out.println(isequ);//false
		
		boolean empty = c.isEmpty();
		System.out.println(empty);//false
		
		Iterator<String> iterator = c.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());//waking to
		}
		
//		c.remove("to");
//		System.out.println(c.toString());//[waking]

		c.retainAll(c1);
		System.out.println(c.toString());//[to]
		
		int size = c.size();
		System.out.println(size);//1
		
		System.out.println(c.toArray());//[Ljava.lang.Object;@6d06d69c
		

	}
}

泛型

• 泛型就是可以表示一个广泛数据类型的类型参数（泛型只能表示引用类型），把数据类型当做参数来传递。
• 形式参数：声明方法时，在方法的参数列表中声明，而且在方法体中会使用到，是一个未知的数据
• 实际参数：调用方法时，实际传递的参数。
• 类型参数：在一个类中声明一个未知的数据类型，在类中可以使用这个类型，但是具体类型取决于实际传入的类型

List接口

• 常用方法和Collection的方法大致一致可以参考

List接口的存储特点

• 相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合
• List接口中可以使用独用的ListIterator，具有反向遍历的功能

List的实现类

• ArrayList

ArrayList类是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。
存储特点：
		相对有序存储，可以存储相同的元素（不排重），可以通过下标访问集合元素，通过数组实现集合
存储结构：数组

package waking.test.jh;

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

/**
 * List实现类ArrayList
 * @author waking
 *
 */
public class Demo02 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("waking");
		list.add("to");
		list.add("love");
		
		//iterator遍历
//		Iterator<String> iterator = list.iterator();
//		while(iterator.hasNext()) {
//			System.out.println(iterator.next());
//		}
		
		//listIterator遍历
		ListIterator<String> listIterator = list.listIterator();
		
		while(listIterator.hasNext()) {
			System.out.println(listIterator.next());
		}
		
		while(listIterator.hasPrevious()) {
			System.out.println(listIterator.previous());
		}
	}
}

LinkedList类

• LinkedList类是List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）
• 存储结构：双向链表
• 存储特点：相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过链表实现的集合

package waking.test.jh;

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

/**
 * LinkedList实现类
 * @author waking
 *
 */
public class Demo03 {
	public static void main(String[] args) {
		List<String> list = new LinkedList<String>();
		list.add("waking");
		list.add("lilke");
		list.add("love");
		
		//通过下标访问
		System.out.println(list.get(1));
		
		Iterator<String> iterator = list.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
		
	}
}

ArrayList和LinkedList的总结

• ArrayList存储结构是数组，LinkedList存储结构是双向列表
• ArrayList集合适用于对元素查询、遍历操作
• LinkedList集合适用于在对元素插入和删除操作

Set接口

• set接口特点：无序的不可重复的（排重），不能通过下标来访问

package waking.test.jh;

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

/**
 * set接口
 * @author waking
 *
 */
public class Demo04 {
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		set.add("waking");
		set.add("to");
		set.add("love");
		
		Iterator<String> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());//love waking to

		}
	}
}

实现类

• hashSet

此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序，特别它不保证该顺序恒久不变。此类允许使用null元素。
Hash：哈希--实际含义散列，就是一种算法，把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值
哈希表：数组加链表，既有数组的优点也有链表的优点
存储特点：相对无序存储，不可以存储相同元素（排重），通过哈希表实现的集合
重写hashCode（）方法
重写equals（）方法

• LinkedHashSet

LinkedHashSet类是具有可预知迭代顺序（相对有序）的set接口的哈希表和链接列表实现。是HashSet的子类。
存储特点：有序存储，不可以存储相同元素（排重），通过链表实现的集合有序。
注意：LinkedHashSet集合的元素排重与HashSet集合排重方法一致

• TreeSet

TreeSet集合是可以给元素进行重新排序的一个Set接口的实现。使用元素的自然顺序对元素进行排序，或者根据创建set时提供的Comparator进行排序，具体取决于使用的构造方法
存储特点：
无序存储，排重，通过二叉树实现的集合，可以给元素进行重新排序

• SortedSet接口

原始的接口

Map接口

• 是双列集合
• 以键值对的形式存储
• 键是唯一的，值可以重复

package waking.test.jh;

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

/**
 * Map接口
 * @author waking
 *
 */
public class Demo05 {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("waking", 22);
		map.put("love", 25);
		
		Integer integer = map.get("waking");
		System.out.println(integer);
	}
}

• 常用方法和以上类似
• HashMap

基于哈希表Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序
存储特点：
相对无序存储，元素以键值对形式存在，键不可以重复，值可以重复，元素整体排重，可以快速的通过键查找到所对应的值，通过哈希表实现的集合

遍历

package waking.test.jh;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Map遍历
 * @author waking
 *
 */
public class Demo06 {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("waking", 22);
		map.put("love", 25);
		
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry.getKey()+"=="+entry.getValue());
		}
		
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			System.out.println(key+"==="+map.get(key));
		}
	}
}

Collections工具类

• 此类完全由在Collection上进行操作或返回Collection的静态方法组成。对集合进行操作时，可以使用这个静态方法

感谢您的观看