java类集: collection, list , set, map

都在java.util包里.容器:装各种对象. 

Collections类 : 集合工具类, 提供了一些静态方法, 方法里的参数是List等.

Colection接口,子接口主要有:  

Set: 内容不可重复,  子类: HashSet,  TreeSet

       HashSet: 散列存放, 本身没有顺序

       TreeSet: 有序存放, 也是SortedSet的子类

List: 内容可以重复, 子类: LinkedList, ArrayList, Vector

　　 ArrayList, Vector二者区别:

　　　　　　　　1.推出时间:  ArrayList JDK1.2后推出的, Vector属于旧操作类

                   2.性能: ArrayList采用异步处理方式, 性能更高, Vector采用同步处理方式, 性能低

                   3. 线程安全: ArrayList非线程安全, Vector线程安全

                   4. 输出: ArrayList只能使用Iterator, foreach输出, Vector可以使用Iterator, foreach, Enumeration输出

     LinkedList实现了Queue的接口, 大量扩充了List和Queue接口的操作. 在使用时最好直接使用LinkedList类完成操作

Queue: 队列接口

SortedSet:对集合中的数据排序 

Map接口:

　　HashMap, 无序存放, 新的操作类, key不允许重复

　　HashTable,无序存放, 旧的操作类, key不允许重复

　　TreeMap, 可排序的map集合, 按key排序, key不允许重复

　　WeakHashMap, 弱引用的map集合,

       IdentityHashMap: key可以重复的map集合

      HashMap和HashTable的区别:

　　　　1. HashMap是JDK1.2后推出的,HashTable属于旧的操作类

 　　　  2. HashMap采用异步处理方式, 性能更高, HashTable采用同步处理方式, 性能低

          3. HashMap属于非线程安全的操作类, HashTable属于线程安全的操作类

　　SortedMap: 是TreeMap的实现接口, 可以进行排序.

在集合的操作中, 支持一下几种输出: 

Iterator:  最标准的输出, 经常用!!!

ListIterator

foreach

Enumeration

List举例:

一个集合整体插入一个集合:

import java.util.ArrayList ;
import java.util.List ;
import java.util.Collection ;
public class ArrayListDemo01{
	public static void main(String args[]){
		List<String> allList = new ArrayList<String>() ;	// 指定操作的泛型为String
		Collection<String> allCollection = new ArrayList<String>() ;	// 指定一个集合	
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		System.out.println(allList) ;
		allCollection.add("LXH") ;	// 向Collection中加入内容
		allCollection.add("www.mldn.cn") ;
		allList.addAll(allCollection) ;
		allList.addAll(0,allCollection) ;
		System.out.println(allList) ;
	}
};

删除方法: remove:

import java.util.ArrayList ;
import java.util.List ;
public class ArrayListDemo02{
	public static void main(String args[]){
		List<String> allList = null ;
		allList = new ArrayList<String>() ;	// 指定操作的泛型为String
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		allList.add("MLDN") ;	// 向Collection中加入内容
		allList.add("www.mldn.cn") ;
		allList.remove(0) ; // 删除第一个元素，指定删除的位置
		allList.remove("Hello") ;	// 此方法由Collection接口继承而来
		System.out.println(allList) ;
	}
};

输出, 用size()方法: 此输出方法是list接口独有 的, 尤其是Collection中是没有根据索引取出内容的操作

import java.util.ArrayList ;
import java.util.List ;
public class ArrayListDemo03{
	public static void main(String args[]){
		List<String> allList = null ;
		allList = new ArrayList<String>() ;	// 指定操作的泛型为String
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		allList.add("MLDN") ;	// 向Collection中加入内容
		allList.add("www.mldn.cn") ;
		System.out.print("由前向后输出：") ;
		for(int i=0;i<allList.size();i++){
			System.out.print(allList.get(i) + "、") ;
		}
		System.out.print("
由后向前输出：") ;
		for(int i=allList.size()-1;i>=0;i--){
			System.out.print(allList.get(i) + "、") ;
		}
	}
};

可以把集合转换成数组:用toArray方法: 有两种

import java.util.ArrayList ;
import java.util.List ;
public class ArrayListDemo04{
	public static void main(String args[]){
		List<String> allList = null ;
		allList = new ArrayList<String>() ;	// 指定操作的泛型为String
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		allList.add("MLDN") ;	// 向Collection中加入内容
		allList.add("www.mldn.cn") ;
		String str[] = allList.toArray(new String[]{}) ;	// 指定好类型
		System.out.print("指定数组类型：") ;
		for(int i=0;i<str.length;i++){
			System.out.print(str[i] + "、") ;
		}
		System.out.print("
返回对象数组：") ;
		Object obj [] = allList.toArray() ;	// 返回Object类型
		for(int i=0;i<obj.length;i++){
			String temp = (String)obj[i] ;	// 进行向下转型
			System.out.print(temp + "、") ;
		}
	}
};

其他功能:

boolean isEmpty(): 判断集合是否为空 , 

List<E> subList(fromIndex,toIndex):截取

int indexOf(): 查找指定的对象是否存在

boolean contains(), 查找是否存在

import java.util.ArrayList ;
import java.util.List ;
public class ArrayListDemo05{
	public static void main(String args[]){
		List<String> allList = null ;
		allList = new ArrayList<String>() ;	// 指定操作的泛型为String
		System.out.println("集合操作前是否为空？" + allList.isEmpty()) ;
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		allList.add("MLDN") ;	// 向Collection中加入内容
		allList.add("www.mldn.cn") ;
		System.out.println(allList.contains("Hello")?""Hello"字符串存在！" : ""Hello"字符串不存在！") ;
		List<String> allSub = allList.subList(2,3) ;	// 字符串截取
		System.out.println("集合截取：") ;
		for(int i=0;i<allSub.size();i++){
			System.out.print(allSub.get(i) + "、") ;
		}
		System.out.println("MLDN字符串的位置：" + allList.indexOf("MLDN")) ;
		System.out.println("集合操作后是否为空？" + allList.isEmpty()) ;
	}
};

　　

List另一个子类:Vector: 有addElement方法和add方法差不多:

import java.util.Vector ;
import java.util.List ;
public class VectorDemo01{
	public static void main(String args[]){
		List<String> allList = null ;
		allList = new Vector<String>() ;	// 指定操作的泛型为String
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add("Hello") ;	// 此方法由Collection接口而来
		allList.add(0,"World") ;	// 在第一个位置上添加新的内容
		allList.add("MLDN") ;	// 向Collection中加入内容
		allList.add("www.mldn.cn") ;
		for(int i=0;i<allList.size();i++){
			System.out.print(allList.get(i) + "、") ;
		}
	}
};

　　

LinkedList实现了Queue,所以有队列的方法:

所以, add方法, 有addFirst, addLast, 还有poll()方法查表头会去掉表头:

import java.util.LinkedList ;
public class LinkedListDemo02{
	public static void main(String args[]){
		LinkedList<String> link = new LinkedList<String>() ;
		link.add("B") ;	// 增加元素
		link.addFirst("A") ;	// 增加元素
		link.addLast("C") ;	// 增加元素
		System.out.println("1-1、element()方法找到表头：" + link.element()) ;
		System.out.println("1-2、找完之后的链表的内容：" + link) ;
		System.out.println("2-1、peek()方法找到表头：" + link.peek()) ;
		System.out.println("2-2、找完之后的链表的内容：" + link) ;
		System.out.println("3-1、poll()方法找到表头：" + link.poll()) ;
		System.out.println("3-2、找完之后的链表的内容：" + link) ;
		
	}
};

可以利用poll方法输出:

import java.util.LinkedList ;
public class LinkedListDemo03{
	public static void main(String args[]){
		LinkedList<String> link = new LinkedList<String>() ;
		link.add("A") ;	// 增加元素
		link.add("B") ;	// 增加元素
		link.add("C") ;	// 增加元素
		System.out.print("以FIFO的方式输出：") ;
		for(int i=0;i<=link.size()+1;i++){
			System.out.print(link.poll() + "、") ;
		}
	}
};

　　

Hashset无序存放:

import java.util.HashSet ;
import java.util.Set ;
public class HashSetDemo01{
	public static void main(String args[]){
		Set<String> allSet = new HashSet<String>() ;
		allSet.add("A") ;	// 增加内容
		allSet.add("B") ;	// 增加内容
		allSet.add("C") ;	// 增加内容
		allSet.add("C") ;	// 重复内容
		allSet.add("C") ;	// 重复内容
		allSet.add("D") ;	// 增加内容
		allSet.add("E") ;	// 增加内容
		System.out.println(allSet) ;
	}
};

输出内容: 　[D, E, A, B, C]

TreeSet有序存放:

import java.util.TreeSet ;
import java.util.Set ;
public class TreeSetDemo01{
	public static void main(String args[]){
		Set<String> allSet = new TreeSet<String>() ;
		allSet.add("C") ;	// 增加内容
		allSet.add("C") ;	// 重复内容
		allSet.add("C") ;	// 重复内容
		allSet.add("D") ;	// 增加内容
		allSet.add("B") ;	// 增加内容
		allSet.add("A") ;	// 增加内容
		allSet.add("E") ;	// 增加内容
		System.out.println(allSet) ;
	}
};

结果: 　[A, B, C, D, E]　

TreeSet排序原理,　要实现Comparable接口: 如果一个对象数组要排序, 必须实现Comparable接口后重写compareTo方法:

set接口一看hashCode和equals完成重复元素的判断.

import java.util.Set ;
import java.util.TreeSet ;
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 toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
	public int compareTo(Person per){
		if(this.age>per.age){
			return 1 ;
		}else if(this.age<per.age){
			return -1 ;
		}else{
			return this.name.compareTo(per.name) ;	// 调用String中的compareTo()方法
		}
	}
};
public class TreeSetDemo02{
	public static void main(String args[]){
		Set<Person> allSet = new TreeSet<Person>() ;
		allSet.add(new Person("张三",30)) ;
		allSet.add(new Person("李四",31)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("赵六",33)) ;
		allSet.add(new Person("孙七",33)) ;
		System.out.println(allSet) ;
	}
};

结果:

[姓名：张三；年龄：30, 姓名：李四；年龄：31, 姓名：王五；年龄：32, 姓名：孙七；年龄：33, 姓名：赵六；年龄：33]

去掉重复元素需要重写equals和hashCode方法:

import java.util.Set ;
import java.util.HashSet ;
class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public boolean equals(Object obj){	// 覆写equals，完成对象比较
		if(this==obj){
			return true ;
		}
		if(!(obj instanceof Person)){
			return false ;
		}
		Person p = (Person)obj ;	// 向下转型
		if(this.name.equals(p.name)&&this.age==p.age){
			return true ;
		}else{
			return false ;
		}
	}
	public int hashCode(){
		return this.name.hashCode() * this.age	; // 定义一个公式
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class RepeatDemo01{
	public static void main(String args[]){
		Set<Person> allSet = new HashSet<Person>() ;
		allSet.add(new Person("张三",30)) ;
		allSet.add(new Person("李四",31)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("王五",32)) ;
		allSet.add(new Person("赵六",33)) ;
		allSet.add(new Person("孙七",33)) ;
		System.out.println(allSet) ;
	}
};

　　

SortedSet:

import java.util.SortedSet ;
import java.util.TreeSet ;
public class TreeSetDemo05{
	public static void main(String args[]){
		SortedSet<String> allSet = new TreeSet<String>() ;	// 
		allSet.add("A") ;	// 增加内容
		allSet.add("B") ;	// 增加内容
		allSet.add("C") ;	// 增加内容
		allSet.add("C") ;	// 增加内容
		allSet.add("C") ;	// 增加内容
		allSet.add("D") ;	// 增加内容
		allSet.add("E") ;	// 增加内容
		System.out.println("第一个元素：" + allSet.first()) ;
		System.out.println("最后一个元素：" + allSet.last()) ;
		System.out.println("headSet元素：" + allSet.headSet("C")) ;
		System.out.println("tailSet元素：" + allSet.tailSet("C")) ;
		System.out.println("subSet元素：" + allSet.subSet("B","D")) ;
	}
};

只要看见Sorted开头的接口就是排序接口.

最重要的Iterator接口:

import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo01{
	public static void main(String args[]){
		List<String> all=  new ArrayList<String>() ;	// 
		all.add("hello") ;
		all.add("_") ;
		all.add("world") ;
		Iterator<String> iter = all.iterator() ;	// 为Iterator接口实例化
		while(iter.hasNext()){	// 判断是否有内容
			System.out.println(iter.next()) ;	// 输出内容
		}
	}
};

remove方法,  all.remove(str) ; iter.remove() ; 尽量不要用删除方法

import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo03{
	public static void main(String args[]){
		List<String> all=  new ArrayList<String>() ;	// 
		all.add("hello") ;
		all.add("_") ;
		all.add("world") ;
		Iterator<String> iter = all.iterator() ;	// 为Iterator接口实例化
		while(iter.hasNext()){	// 判断是否有内容
			String str = iter.next() ;
			if("_".equals(str)){
				all.remove(str) ;	// 删除元素		
			}else{
				System.out.println(str) ;	// 输出内容
			}
		}
		System.out.println("删除之后的集合：" + all) ;
	}
};

结果: 所以尽量不用删除, 如果删除的话, 不要使用集合类的remove方法, 要使用Iterator的remove方法.

hello
删除之后的集合：[hello, world]

　　

ListIterator双向输出接口:

import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo01{
	public static void main(String argsp[]){
		List<String> all = new ArrayList<String>() ;
		all.add("hello") ;
		all.add("_") ;
		all.add("world") ;
		ListIterator<String> iter = all.listIterator() ;
		System.out.print("由前向后输出：") ;
		while(iter.hasNext()){
			String str = iter.next() ;
			System.out.print(str + "、") ;
		}
		System.out.print("
由后向前输出：") ;
		while(iter.hasPrevious()){
			String str = iter.previous() ;
			System.out.print(str + "、") ;
		}
	}
};

foreach:

import java.util.ArrayList; 
import java.util.List; 
public class ForeachDemo01{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;
		all.add("hello") ;
		all.add("_") ;
		all.add("world") ;
		for(String str:all){
			System.out.print(str + "、") ;
		}
	}
};

Enumration: 一般是操作Vector的.

import java.util.Vector; 
import java.util.Enumeration; 
public class EnumerationDemo01{
	public static void main(String args[]){
		Vector<String> all = new Vector<String>() ;
		all.add("hello") ;
		all.add("_") ;
		all.add("world") ;
		Enumeration<String> enu = all.elements() ;
		while(enu.hasMoreElements()){	//判断是否有内容，hasNext()
			System.out.print(enu.nextElement() + "、") ;	// 输出元素：next()
		}
	}
};

Map接口: HashMap, HashTable,TreeMap, WeakHashMap　　

一对key,value对于map来说是一个Map.Entry.

Map: put方法和get方法

import java.util.HashMap ;
import java.util.Map ;
public class HashMapDemo01{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashMap<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		String val = map.get("mldn") ;	// 根据key取出值
		System.out.println("取出的内容是：" + val) ;
	}
};

得到全部key的方法map.keySet()

import java.util.HashMap ;
import java.util.Map ;
import java.util.Iterator ;
import java.util.Set ;
public class HashMapDemo03{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashMap<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		Set<String> keys = map.keySet() ;	// 得到全部的key
		Iterator<String> iter = keys.iterator() ;
		while(iter.hasNext()){
			String str = iter.next() ;
			System.out.print(str + "、") ;
		}
	}
};

输出全部value:

import java.util.HashMap ;
import java.util.Map ;
import java.util.Iterator ;
import java.util.Collection ;
public class HashMapDemo04{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashMap<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		Collection<String> values = map.values() ;	// 得到全部的value
		Iterator<String> iter = values.iterator() ;
		while(iter.hasNext()){
			String str = iter.next() ;
			System.out.print(str + "、") ;
		}
	}
};

HashMap和HashTable下面可以互换:

import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.Iterator ;
import java.util.Collection ;
public class HashtableDemo01{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashTable<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		System.out.print("全部的key：") ;
		Set<String> keys = map.keySet() ;	// 得到全部的key
		Iterator<String> iter = keys.iterator() ;
		while(iter.hasNext()){
			String str = iter.next() ;
			System.out.print(str + "、") ;
		}
		System.out.print("
全部的value：") ;
		Collection<String> values = map.values() ;	// 得到全部的value
		Iterator<String> iter2 = values.iterator() ;
		while(iter2.hasNext()){
			String str = iter2.next() ;
			System.out.print(str + "、") ;
		}
	}
};

TreeMap:

import java.util.TreeMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.Iterator ;
import java.util.Collection ;
public class TreeMapDemo01{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new TreeMap<String,String>() ;
		map.put("A、mldn","www.mldn.cn") ;	// 增加内容
		map.put("C、zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("B、mldnjava","www.mldnjava.cn") ;	// 增加内容
		Set<String> keys = map.keySet() ;	// 得到全部的key
		Iterator<String> iter = keys.iterator() ;
		while(iter.hasNext()){
			String str = iter.next() ;
			System.out.println(str + " --> " + map.get(str)) ; // 取出内容
		}
	}
};

结果: 有序:但是, 自定义的类要想作为Key的话, 子需要实现Comparable接口指定比较的规则.

A、mldn --> www.mldn.cn
B、mldnjava --> www.mldnjava.cn
C、zhinangtuan --> www.zhinangtuan.net.cn

WeakHashMap, 当一个　　map中的某些内容长时间不使用的话, 按照之前的做法不会删除, 如果想自动删除掉的话,可以使用弱引用:

import java.util.WeakHashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.Iterator ;
import java.util.Collection ;
public class WeakHashMapDemo01{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new WeakHashMap<String,String>() ;
		map.put(new String("mldn"),new String("www.mldn.cn")) ;
		map.put(new String("zhinangtuan"),new String("www.zhinangtuan.net.cn")) ;
		map.put(new String("mldnjava"),new String("www.mldnjava.cn")) ;
		System.gc() ;	// 强制性进行垃圾的收集操作
		map.put(new String("lxh"),new String("lixinghua")) ;
		System.out.println(map) ;
	}
};

结果:{lxh=lixinghua}

通过entrySet获取key和value的方法:

import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.Iterator ;
public class IteratorDemo04{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashMap<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		Set<Map.Entry<String,String>> allSet = null ;
		allSet = map.entrySet() ;
		Iterator<Map.Entry<String,String>> iter = null ;
		iter = allSet.iterator() ;
		while(iter.hasNext()){
			Map.Entry<String,String> me = iter.next() ;
			System.out.println(me.getKey() + " --> " + me.getValue()) ;
		}
	}
};

结果:

zhinangtuan --> www.zhinangtuan.net.cn
mldn --> www.mldn.cn
mldnjava --> www.mldnjava.cn

foreach输出:

import java.util.HashMap ;
import java.util.Map ;
import java.util.Set ;
import java.util.Iterator ;
public class ForeachDemo02{
	public static void main(String args[]){
		Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
		map = new HashMap<String,String>() ;
		map.put("mldn","www.mldn.cn") ;	// 增加内容
		map.put("zhinangtuan","www.zhinangtuan.net.cn") ;	// 增加内容
		map.put("mldnjava","www.mldnjava.cn") ;	// 增加内容
		for(Map.Entry<String,String> me:map.entrySet()){
			System.out.println(me.getKey() + " --> " + me.getValue()) ;
		}
	}
};

用自定义类作为key和value:

1. 以string作为key, person作为value　

import java.util.Map ;
import java.util.HashMap ;
class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class HashMapDemo05{
	public static void main(String args[]){
		Map<String,Person> map = null ;
		map = new HashMap<String,Person>() ;
		map.put("zhangsan",new Person("张三",30));	// 增加内容
		System.out.println(map.get("zhangsan")) ;
	}
};

但是反过来就会出错:

import java.util.Map ;
import java.util.HashMap ;
class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class HashMapDemo06{
	public static void main(String args[]){
		Map<Person,String> map = null ;
		map = new HashMap<Person,String>() ;
		map.put(new Person("张三",30),"zhangsan");	// 增加内容
		System.out.println(map.get(new Person("张三",30))) ;
	}
};

实例化对象就可以, 　

import java.util.Map ;
import java.util.HashMap ;
class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
};
public class HashMapDemo06{
	public static void main(String args[]){
		Map<Person,String> map = null ;
		map = new HashMap<Person,String>() ;
		map.put(new Person("张三",30),"zhangsan");	// 增加内容
		System.out.println(map.get(new Person("张三",30))) ;
	}
};

可是这样并不是解决问题的方法, 因为不可能把per对象到处带着走, 应该像string可以使用匿名对象的形式找到内容

此时, 与set接口中判断重复元素的方式一样,进行equals和hashCode方法:

import java.util.Map ;
import java.util.HashMap ;
class Person{
	private String name ;
	private int age ;
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String toString(){
		return "姓名：" + this.name + "；年龄：" + this.age ;
	}
	public boolean equals(Object obj){
		if(this==obj){
			return true ;
		}
		if(!(obj instanceof Person)){
			return false ;
		}
		Person p = (Person)obj ;
		if(this.name.equals(p.name)&&this.age==p.age){
			return true ;
		}else{
			return false ;
		}
	}
	public int hashCode(){
		return this.name.hashCode() * this.age ;
	}
};
public class HashMapDemo08{
	public static void main(String args[]){
		Map<Person,String> map = null ;
		map = new HashMap<Person,String>() ;
		map.put(new Person("张三",30),"zhangsan");	// 增加内容
		System.out.println(map.get(new Person("张三",30))) ;
	}
};

所以, 作为key, 或者更准确的说作为对象的时候, 实际上依靠hashCode和equals方法来判断两个匿名对象是否相等.

　　

SortedMap:

import java.util.Map ;
import java.util.SortedMap ;
import java.util.TreeMap ;
public class SortedMapDemo{
	public static void main(String args[]){
		SortedMap<String,String> map = null ;
		map = new TreeMap<String,String>() ;	// 通过子类实例化接口对象
		map.put("D、jiangker","http://www.jiangker.com/") ;
		map.put("A、mldn","www.mldn.cn") ;
		map.put("C、zhinangtuan","www.zhinangtuan.net.cn") ;
		map.put("B、mldnjava","www.mldnjava.cn") ;
		System.out.print("第一个元素的内容的key：" + map.firstKey()) ;
		System.out.println("：对应的值：" + map.get(map.firstKey())) ;
		System.out.print("最后一个元素的内容的key：" + map.lastKey()) ;
		System.out.println("：对应的值：" + map.get(map.lastKey())) ;
		System.out.println("返回小于指定范围的集合：") ;
		for(Map.Entry<String,String> me:map.headMap("B、mldnjava").entrySet()){
			System.out.println("	|- " + me.getKey() + " --> " + me.getValue()) ;
		}
		System.out.println("返回大于指定范围的集合：") ;
		for(Map.Entry<String,String> me:map.tailMap("B、mldnjava").entrySet()){
			System.out.println("	|- " + me.getKey() + " --> " + me.getValue()) ;
		}
		System.out.println("部分集合：") ;
		for(Map.Entry<String,String> me:map.subMap("A、mldn","C、zhinangtuan").entrySet()){
			System.out.println("	|- " + me.getKey() + " --> " + me.getValue()) ;
		}
	}
};

结果:

第一个元素的内容的key：A、mldn：对应的值：www.mldn.cn
最后一个元素的内容的key：D、jiangker：对应的值：http://www.jiangker.com/
返回小于指定范围的集合：
    |- A、mldn --> www.mldn.cn
返回大于指定范围的集合：
    |- B、mldnjava --> www.mldnjava.cn
    |- C、zhinangtuan --> www.zhinangtuan.net.cn
    |- D、jiangker --> http://www.jiangker.com/
部分集合：
    |- A、mldn --> www.mldn.cn
    |- B、mldnjava --> www.mldnjava.cn

　　

Collections集合工具类:

emptyList(), emptySet(), 这个无法实现再增加数据.

import java.util.Collections ;
import java.util.List ;
import java.util.Set ;
public class CollectionsDemo01{
	public static void main(String args[]){
		List<String> allList = Collections.emptyList() ;	// 返回空的 List集合
		Set<String> allSet = Collections.emptySet() ;	// 返回空的 List集合
		allList.add("Hello") ;	// 加入数据 , 没有实现.
	}
};

　

Collections增加操作: 使用可变数组

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo02{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"MLDN","LXH","mldnjava") ;
		Iterator<String> iter = all.iterator() ;
		while(iter.hasNext()){
			System.out.print(iter.next() + "、") ;
		}
	}
};

内容反转:

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo03{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"MLDN","LXH","mldnjava") ;
		Collections.reverse(all) ;	// 内容反转
		Iterator<String> iter = all.iterator() ;
		while(iter.hasNext()){
			System.out.print(iter.next() + "、") ;
		}
	}
};

还有个二分检索功能:

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo04{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"MLDN","LXH","mldnjava") ;
		int point = Collections.binarySearch(all,"LXH") ;	// 检索数据
		System.out.println("检索结果：" + point) ;
		
	}
};

内容替换:

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo05{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"MLDN","LXH","mldnjava") ;
		if(Collections.replaceAll(all,"LXH","李兴华")){// 替换内容
			System.out.println("内容替换成功！") ;
		}
		System.out.print("替换之后的结果：") ;
		System.out.print(all) ;
		
	}
};

排序操作:

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo06{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"1、MLDN","2、LXH","3、mldnjava") ;
		Collections.addAll(all,"B、www.mldn.cn") ;
		Collections.addAll(all,"A、www.mldnjava.cn") ;
		System.out.println("排序之前的集合：" + all) ;
		Collections.sort(all) ;
		System.out.println("排序之后的集合：" + all) ;
		
	}
};

交换内容:

import java.util.Collections ;
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class CollectionsDemo07{
	public static void main(String args[]){
		List<String> all = new ArrayList<String>() ;	// 返回空的 List集合
		Collections.addAll(all,"1、MLDN","2、LXH","3、mldnjava") ;
		System.out.println("交换之前的集合：" + all) ;
		Collections.swap(all,0,2) ;
		System.out.println("交换之后的集合：" + all) ;
		
	}
};

　　

Properties属性:

import java.util.Properties;
public class PropertiesDemo01{
	public static void main(String args[]){
		Properties pro = new Properties() ;	// 创建Properties对象
		pro.setProperty("BJ","BeiJing") ;	// 设置属性
		pro.setProperty("TJ","TianJin") ;
		pro.setProperty("NJ","NanJing") ;	
		System.out.println("1、BJ属性存在：" + pro.getProperty("BJ")) ;
		System.out.println("2、SC属性不存在：" + pro.getProperty("SC")) ;
		System.out.println("3、SC属性不存在，同时设置显示的默认值：" + pro.getProperty("SC","没有发现")) ;
	}
};

往属性文件里写内容:

import java.util.Properties;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class PropertiesDemo02{
	public static void main(String args[]){
		Properties pro = new Properties() ;	// 创建Properties对象
		pro.setProperty("BJ","BeiJing") ;	// 设置属性
		pro.setProperty("TJ","TianJin") ;
		pro.setProperty("NJ","NanJing") ;	
		File file = new File("D:" + File.separator + "area.properties") ;	// 指定要操作的文件
		try{
			pro.store(new FileOutputStream(file),"Area Info") ;	// 保存属性到普通文件
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}catch(IOException e){
			e.printStackTrace() ;
		}
	}
};

读取:

import java.util.Properties;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class PropertiesDemo03{
	public static void main(String args[]){
		Properties pro = new Properties() ;	// 创建Properties对象
		File file = new File("D:" + File.separator + "area.properteis") ;	// 指定要操作的文件
		try{
			pro.load(new FileInputStream(file)) ;	// 读取属性文件
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}catch(IOException e){
			e.printStackTrace() ;
		}
		System.out.println("1、BJ属性存在：" + pro.getProperty("BJ")) ;
		System.out.println("2、SH属性存在：" + pro.getProperty("SH")) ;
	}
};

　　

　

往xml里写内容:

import java.util.Properties;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class PropertiesDemo04{
	public static void main(String args[]){
		Properties pro = new Properties() ;	// 创建Properties对象
		pro.setProperty("BJ","BeiJing") ;	// 设置属性
		pro.setProperty("TJ","TianJin") ;
		pro.setProperty("NJ","NanJing") ;	
		File file = new File("D:" + File.separator + "area.xml") ;	// 指定要操作的文件
		try{
			pro.storeToXML(new FileOutputStream(file),"Area Info") ;	// 保存属性到普通文件
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}catch(IOException e){
			e.printStackTrace() ;
		}
	}
};

从xml读取:

import java.util.Properties;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class PropertiesDemo05{
	public static void main(String args[]){
		Properties pro = new Properties() ;	// 创建Properties对象
		File file = new File("D:" + File.separator + "area.xml") ;	// 指定要操作的文件
		try{
			pro.loadFromXML(new FileInputStream(file)) ;	// 读取属性文件
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}catch(IOException e){
			e.printStackTrace() ;
		}
		System.out.println("1、BJ属性存在：" + pro.getProperty("BJ")) ;
	}
};

　　

集合的使用: 一对多:

一个学校有很多学生 , 不知道多大, 所以需要设定集合:

student.java:

public class Student{
	private String name ;
	private int age ;
	private School school; // 一个学生属于一个学校
	public Student(String name,int age){
		this.setName(name) ;
		this.setAge(age) ;
	}
	public void setSchool(School school){
		this.school = school ;
	}
	public School getSchool(){
		return this.school ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name; 
	}
	public int getAge(){
		return this.age ;
	}
	public String toString(){
		return "学生姓名：" + this.name + "；年龄：" + this.age ;
	}
};

school.java:

import java.util.List ;
import java.util.ArrayList ;
public class School{
	private String name ;
	private List<Student> allStudents ;
	public School(){
		this.allStudents = new ArrayList<Student>() ;
	}
	public School(String name){
		this() ;
		this.setName(name) ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return this.name; 
	}
	public List<Student> getAllStudents(){
		return this.allStudents ;
	}
	public String toString(){
		return "学校名称：" + this.name ;
	}
};

Test.java:

import java.util.Iterator ;
public class TestDemo{
	public static void main(String args[]){
		School sch = new School("清华大学") ;	// 定义学校
		Student s1 = new Student("张三",21) ;
		Student s2 = new Student("李四",22) ;
		Student s3 = new Student("王五",23) ;
		sch.getAllStudents().add(s1) ;
		sch.getAllStudents().add(s2) ;
		sch.getAllStudents().add(s3) ;
		s1.setSchool(sch) ;
		s2.setSchool(sch) ;
		s3.setSchool(sch) ;
		System.out.println(sch) ;
		Iterator<Student> iter = sch.getAllStudents().iterator() ;
		while(iter.hasNext()){
			System.out.println("	|- " + iter.next()) ;
		}
	}
};

　　

实例二: 学生和课程之间的关系:

student.java;

import java.util.List ;
import java.util.ArrayList ;
public class Student{
	private String name ;
	private int age ;
	private List<Course> allCourses ;
	public Student(){
		this.allCourses = new ArrayList<Course>() ;
	}
	public Student(String name,int age){
		this() ;
		this.name = name ;
		this.age = age ;
	}
	public List<Course> getAllCourses(){
		return this.allCourses ;
	}
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public String toString(){
		return "学生姓名：" + this.name + "；年龄：" + this.age ;
	}
};

course.java;

import java.util.List ;
import java.util.ArrayList ;
public class Course{
	private String name ;
	private int credit ;
	private List<Student> allStudents ;
	public Course(){
		this.allStudents = new ArrayList<Student>() ;
	}
	public Course(String name,int credit){
		this() ;
		this.name = name ;
		this.credit = credit ;
	}
	public List<Student> getAllStudents(){
		return this.allStudents ;
	}
	public void setName(String name){
		this.name = name  ;
	}
	public void setCredit(int credit){
		this.credit = credit ;
	}
	public String getName(){
		return this.name ;
	}
	public int getCredit(){
		return this.credit ;
	}
	public String toString(){
		return "课程名称：" + this.name + "；课程学分：" + this.credit ;
	}
};

test.java:

import java.util.Iterator ;
public class TestMore{
	public static void main(String args[]){
		Course c1 = new Course("英语",3	) ;	// 第一门课程
		Course c2 = new Course("计算机",5) ;	// 第二门课程
		Student s1 = new Student("张三",20) ;
		Student s2 = new Student("李四",21) ;
		Student s3 = new Student("王五",22) ;
		Student s4 = new Student("赵六",23) ;
		Student s5 = new Student("孙七",24) ;
		Student s6 = new Student("钱八",24) ;
		// 第一门课程有三个学生参加
		c1.getAllStudents().add(s1) ;
		c1.getAllStudents().add(s2) ;
		c1.getAllStudents().add(s6) ;
		s1.getAllCourses().add(c1) ;
		s2.getAllCourses().add(c1) ;
		s6.getAllCourses().add(c1) ;
		// 第二门课程有六个学生参加
		c2.getAllStudents().add(s1) ;
		c2.getAllStudents().add(s2) ;
		c2.getAllStudents().add(s3) ;
		c2.getAllStudents().add(s4) ;
		c2.getAllStudents().add(s5) ;
		c2.getAllStudents().add(s6) ;
		s1.getAllCourses().add(c2) ;
		s2.getAllCourses().add(c2) ;
		s3.getAllCourses().add(c2) ;
		s4.getAllCourses().add(c2) ;
		s5.getAllCourses().add(c2) ;
		s6.getAllCourses().add(c2) ;
		// 输出一门课程的信息，观察一门课程有多少个学生参加
		System.out.println(c1) ;
		Iterator<Student> iter1 = c1.getAllStudents().iterator() ;
		while(iter1.hasNext()){
			Student s = iter1.next() ;
			System.out.println("	|- " + s) ;
		}
		// 通过学生找到学生参加的课程
		System.out.println(s6) ;
		Iterator<Course> iter2 = s6.getAllCourses().iterator() ;
		while(iter2.hasNext()){
			Course c = iter2.next() ;
			System.out.println("	|- " + c) ;
		}
	}
};