黑马程序员——基础学习（十一）集合框架

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

集合

Collection集合

迭代器

A:针对集合进行遍历的一种方式。

B:迭代器是依赖于集合而存在的。

我的代码：

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

 class CollectionsDemo {
	 public static void main(String[] args){
		 List <Integer> list = new ArrayList<Integer>();
		 list.add(35);
		 list.add(5);
		 list.add(56);
		 list.add(31);
		 list.add(78);
		//public static <T> void sort(List<T> list):对集合进行排序
		Collections.sort(list);
		System.out.println(list);
		//public static <T> int binarySearch(List<?> list,T key):对集合进行二分查找
		int index = Collections.binarySearch(list,5);
		System.out.println(index);
		//public static <T> T max(Collection<?> coll):获取集合中的最大值
		System.out.println(Collections.max(list));
		//public static void reverse(List<?> list):对集合进行反转
		Collections.reverse(list);
		System.out.println(list);
		//public static void shuffle(List<?> list):随机置换
		Collections.shuffle(list);
		System.out.println(list);1
	 }
 }

集合的使用步骤

A:创建集合对象

B:创建元素对象

C:把元素添加到集合中

D:遍历集合

a:通过集合对象获取迭代器对象

b:通过迭代器对象判断是否有元素

c:通过迭代器对象获取元素

Collection集合的练习

A:Collection存储字符串并遍历 迭代器

B:Collection存储自定义对象并遍历 迭代器

我的代码：

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
class CollectionDemo1 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("kevin");
		c.add("david");
		c.add("humphrey");
		Iterator it = c.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
	}
}

Collection集合的子类

List:元素有序(取出顺序和存储顺序一致),可重复

Set:元素无序,唯一

 List集合

List特有功能

A:添加功能

add(int index,Object obj)

B:删除功能

remove(int index)

C:修改功能

set(int index,Object obj)

D:获取功能

get(int index)

E:列表迭代器(了解)

ListIterator listIterator()

List集合的练习

A:List存储字符串并遍历 迭代器,普通for

B:List存储自定义对象并遍历 迭代器,普通for

List集合的子类

数据结构概述

栈,队列,数组,链表

List子类的特点：

ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

    Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

   LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

Vector的特有功能及练习

A:特有功能

addElement(Object obj) -- add

elementAt(int index) -- get

elements() -- iterator()

B:Vector集合的练习

Vector存储字符串并遍历 迭代器,普通for

Vector存储自定义对象并遍历 迭代器,普通for

LinkedList的特有功能及练习

A:特有功能

addFirst(),addLast()

removeFirst(),removeLast()

getFirst(),getLast()

B:LinkedList集合的练习

LinkedList存储字符串并遍历 迭代器,普通for

LinkedList存储自定义对象并遍历 迭代器,普通for

Set  元素无序,唯一

HashSet

底层数据结构是哈希表。

哈希表是一个元素为单链表的数组。

HashSet如何保证元素的唯一性?

添加元素的时候，底层其实依赖两个方法：hashCode()和equals()

首先，判断hashCode()值是否相同

如果相同：继续执行equals(),看其返回值

返回true：说明元素重复

返回false：就直接添加到集合

如果不同：就直接添加到集合

LinkedHashSet

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

我的代码

import java.util.LinkedHashSet;
class LinkedHashSetDemo{
	public static void main(String[] args){
		LinkedHashSet<String> link = new LinkedHashSet<String>();
		link.add("董小姐");
		link.add("Go Big or Go Home");
		link.add("Hey Jode");
		for(String s : link){
			System.out.println(s);
		}
	}
}

TreeSet

底层数据结构是二叉树。(红黑树 自平衡二叉树)

TreeSet如何保证元素排序和唯一性?

排序：两种方式

自然排序(元素具备比较性) 

被添加到集合的元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

在构造方法传递一个Comparator的子类对象

唯一：根据比较的返回值是否是0来判断是否添加到集合中

我的代码：

import java.util.TreeSet;
class TreeSetDemo{
	public static void main(String[] args){
		TreeSet<Integer> ts = new TreeSet<Integer>();
		ts.add(434234);
		ts.add(492373);
		ts.add(979793);
		ts.add(324723);
		for(Integer i : ts){
			System.out.println(i);
		}
	}
}

Map集合

Map集合是键值对形式的集合。键是唯一的，一个键只能有一个值。

Map接口的功能概述：

A:添加功能

put(K key,V value)

B:删除功能

V remove(K key)

C:判断功能

containsKey(K key)

containsValue(V value)

D:获取功能

V get(K key)

Set<K> keySet()

Collection<V> values()

Set <Map.Entry<K,V>> entrySet()

E:长度功能

size()

Map集合的遍历

Map<String,String> map = new HashMap<String,String>();

map.put("xxx","yyy");

A:根据键找值

Set<String> set = map.keySet();

for(String key : set) {

String value = map.get(key);

System.out.println(key+"---"+value);

}

B:根据键值对对象找键和值

Set<Map.Entry<String,String>> set = map.entrySet();

for(Map.Entry<String,String> me : set) {

String key = me.getkey();

String value = me.getValue();

System.out.println(key+"---"+value);

}

我的代码

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
class MapDemo{
	public static void main(String[] args){
		HashMap<String,Integer> hm = new HashMap<String, Integer>();
		hm.put("kevin",23);
		hm.put("david",21);
		hm.put("humphrey",22);
		Set<String> set= hm.keySet();
		for(String key :set){
			Integer velue = hm.get(key);
			System.out.println(key+"----"+velue);
		}
	}
}
import java.util.Set;
import java.util.Collection;
import java.util.Map;
import java.util.LinkedHashMap;
class LinkedHashMapDemo{
	public static void main(String[] args){
		LinkedHashMap<String,String> map = new LinkedHashMap<String,String>();
		map.put("22","david");
		map.put("21","kevin");
		map.put("23","humphrey");
		Set<String> set= map.keySet();
		for(String key : set){
			String velue = map.get(key);
			System.out.println(key+"---"+velue);
		}
	}
}

HashMap集合的练习

HashMap<String,String>

HashMap<String,Integer)

HashMap<String,Student>

HashMap<Student,String>

TreeMap集合的练习

TreeMap<String,String>

TreeMap<Student,String>

我的代码：

我的代码：
import java.util.Map;
import java.util.TreeMap;
import java.util.Set;
class TreeMapDemo{
	public static void main(String[] args){
		TreeMap<String,String> tree = new TreeMap<String,String>();
		tree.put("22","david");
		tree.put("21","kevin");
		tree.put("23","humphrey");
		Set<String> set= tree.keySet();
		for(String key :set){
			String velue = tree.get(key);
			System.out.println(key+"----"+velue);
		}
	}
}

综合案例：

A:统计字符串中每个字符出现的次数

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
	public static void main(String[] args) {
		// 定义一个字符串。(该成键盘录入字符串)
		// String s = "aababcabcdabcde";
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串:");
		String s = sc.nextLine();

		// 把字符串转换成字符数组。
		char[] chs = s.toCharArray();

		// 定义一个TreeMap集合。
		TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();

		// 遍历字符数组,得到每一个字符。
		for (char ch : chs) {
			// 那这个字符作为键到map集合中去找对应的值，看其返回值是否为null
			Integer i = tm.get(ch);

			// 是：就把该字符作为键，值是1存储起来。
			if (i == null) {
				tm.put(ch, 1);
			} else {
				// 否：就把该字符对应的值+1，然后重新存储。
				i++;
				tm.put(ch, i);
			}
		}

		// 遍历map集合，把数据按照需求拼接起来。
		StringBuilder sb = new StringBuilder();

		Set<Character> set = tm.keySet();
		for (Character key : set) {
			Integer value = tm.get(key);
			sb.append(key).append("(").append(value).append(")");
		}

		String result = sb.toString();

		// 输出结果。
		System.out.println(result);
	}
}

B:集合的嵌套遍历

a:HashMap嵌套HashMap

b:HashMap嵌套ArrayList

c:ArrayList嵌套HashMap

d:ArrayList嵌套ArrayList

面试题：

A:List,Set,Map是否继承子Collection接口

List,Set是继承Collection接口。Map不是继承Collection接口的

B:HashMap和Hashtable的区别

HashMap是允许null键null值的，线程不安全的，效率较高的。

Hashtable是不允许null键null值的，线程安全的，效率较低的

另外，Hashtable还是java中不太符合类名命名规范的（一般要求驼峰命名，见名知意）

Collections:

是针对集合进行操作的工具类。提供了排序，二分查找等功能。

 Collection和Collections的区别

 A:Collection 是单列集合的顶层接口，定义了共性功能

 B:Collections 是针对集合进行操作的工具类

 Collections里面要掌握的方法：

 public static <T> void sort(List<T> list):对集合进行排序

 public static <T> int binarySearch(List<?> list,T key):对集合进行二分查找

 public static <T> T max(Collection<?> coll):获取集合中的最大值

 public static void reverse(List<?> list):对集合进行反转

 public static void shuffle(List<?> list):随机置换