都在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("\n由后向前输出：") ;
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("\n返回对象数组：") ;
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("\n由后向前输出：") ;
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("*ngtuan","www.*ngtuan.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("*ngtuan","www.*ngtuan.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("*ngtuan","www.*ngtuan.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("*ngtuan","www.*ngtuan.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("\n全部的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、*ngtuan","www.*ngtuan.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、*ngtuan --> www.*ngtuan.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("*ngtuan"),new String("www.*ngtuan.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("*ngtuan","www.*ngtuan.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()) ;
}
}
};
结果:
*ngtuan --> www.*ngtuan.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("*ngtuan","www.*ngtuan.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、*ngtuan","www.*ngtuan.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("\t|- " + me.getKey() + " --> " + me.getValue()) ;
}
System.out.println("返回大于指定范围的集合：") ;
for(Map.Entry<String,String> me:map.tailMap("B、mldnjava").entrySet()){
System.out.println("\t|- " + me.getKey() + " --> " + me.getValue()) ;
}
System.out.println("部分集合：") ;
for(Map.Entry<String,String> me:map.subMap("A、mldn","C、*ngtuan").entrySet()){
System.out.println("\t|- " + 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、*ngtuan --> www.*ngtuan.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("\t|- " + 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("\t|- " + s) ;
}
// 通过学生找到学生参加的课程
System.out.println(s6) ;
Iterator<Course> iter2 = s6.getAllCourses().iterator() ;
while(iter2.hasNext()){
Course c = iter2.next() ;
System.out.println("\t|- " + c) ;
}
}
};