黑马程序员_JavaAPI-集合框架

最新推荐文章于 2015-12-17 21:18:03 发布

Sunny_365

最新推荐文章于 2015-12-17 21:18:03 发布

阅读量766

点赞数

本文链接：https://blog.csdn.net/Sunny_365/article/details/8741242

版权

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

每个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。

Collection

List：ArrayList LinkedList Vector

Set：HashSet TreeSet

ArrayList

1、add方法的参数类型是object，以便于接收任意类型对象

2、集合中存储的都是对象的引用（地址）

什么是迭代器？

其实就是集合的取出元素的方式。

import java.util.*;
class CollectionDemo
{
       publicstatic void main(String[] args)
       {
              //创建一个集合容器，使用Collection接口的子类。ArrayList
              ArrayList a1=new ArrayList();
              ArrayList a2=new ArrayList();
              a2.add("java01");
              //1、添加元素
              a1.add("java01");//add(objedtobj);
              a1.add("java02");
              a1.add("java03");
              a1.add("java04");
              a1.retainAll(a2);//取交集，a1中只会保留和a2中相同的元素；a1.removeAll(a2)去掉交集
              //获取个数，集合长度
              sop("size:"+a1.size());
              //删除元素
              a1.remove("java02");
              a1.clear();//清空集合
              sop(a1.contains("java03"));//判断是否存在
              sop(a1.isEmpty());//集合是否为空
              /*Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素
              while(it.hasNext())//
              sop(it.next());//返回迭代下一个元素
              */
              for(Iteratorit=a1.iterator();it.hasNext();)
              {
                     sop(it.next());
              }
       }
       publicstatic void sop(Object obj)
       {
              System.out.println(obj);
       }
}

就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部元素。那么取出方式就被定义成立内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都由共性内容判断和取出，那么可以将共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法iterator（）。

Collection

(1)List:元素是有序的，元素可以重复，因为该集合体系有索引。

ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删速度慢。线程不同步。默认长度10，超过就new一个新的15%延长，复制。

LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询速度慢。

Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

(2)Set：元素是无序的，元素不可以重复。

List特有方法：凡是可以操作角标的方法都是该体系特有的方法。

增

add(index,element);

addAll(index,Collection)

删

remove(index);

改

set(index,element);

查

get(index);

subList(from,to);

listIterator();

List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以，在迭代器时，只能用迭代器的方法元素，可是Iterator方法时有限的。只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

可以进行遍历过程中的增删改查

ListIterator li=al.listIterator();
while(li.hasNext())
{
       Objectobj=li.next();
       if(obj.equals("java02"))
              li.add("java009");
}
while(li.hasPrevious())
{
       sop(li.previous());//逆向遍历
}

import java.util.*
class ListDemo
{
       publicstatic void sop(Object obj)
       {
              System.out.println(obj);
       }
       publicstatic void main(String[] args)
       {
              ArrayList al=new ArrayList();
              //增加元素
              al.add("java01");
              al.add("java02");
              al.add("java03");
              sop("元集合是："+al);
              //在指定位置添加元素。
              al.add(1,"java09");
              //删除指定位置的元素
              al.remove(3);
              //修改元素
              al.set(2,"java007");
              //通过角标获取元素
              sop(al.get(1));
              sop(al);
              //获取所有元素
              for(int x-0;x<al.size();x++)
              {
                     System.out.println(al.get(x));
              }
              Iteratro it=al.iterator();
              while(it.hasNext())
              {
                     sop(it.next());
              }
              //通过indexOf获取对象的位置
              sop("index="+al.indexOf("java02"));
              List sub=al.subList(1,3);
              sop("sub="+sub);
       }
}

//演示Vector：

枚举就是Vector特有的取出方式，枚举和迭代器很像，其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

import java.util.*
class VectorDemo
{
       publicstatic void main(String[] args)
       {
              Vector v=new Vector();
              v.add("java01");
              v.add("java02");
              v.add("java03");
              v.add("java04");
              Enumeration en=v.elements();
              while(en.hasMoreElements())
              {
                     System.out.println(en.nextElement());
              }
       }
}

LinkedList:特有方法

addFirst()

addLast()

getFirst()

getLast()

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst()

removeLast()

获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6中出现了替代方法

offerFirst()

offerLast()

peekFirst()

peekLast()

获取元素，但不删除元素。如果集合中没有元素，会返回null

pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null

import java.util.*
class LinkedListDemo
{
       publicstatic void main(String[] args)
       {
              LinkedList link=new LinkedList();
              link.addFirst("java01");
              link.addFirst("java02");
              link.addFirst("java03");
              link.addLast("java04");
              sop(link.getfirst());
              sop(link.getLast());
              sop(link.removeFirst());
              sop(link.size());
             
       }
       publicstatic void sop(Object obj)
       {
              System.out.println(obj);
       }
}

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出如同一个杯子。

队列：先进先出 Firstin First out FIFO 如同一个水管。

import java.util.*;
class DuiLie
{
       privateLinkedList link;
       DuiLie()
       {
              link=new LinkedList();
       }
       publicvoid myAdd(Object obj)
       {
              link.addFirst(obj);
       }
       publicObject myGet()
       {
              link.removeLast();
       }
       publicboolean isNull()
       {
              return link.isEmpty();
       }
}
class LinkedListDemo
{
       publicstatic void main(String[] arg)
       {
              Duilie dl=new DuiLie();
              dl.myAdd("java01");
              dl.myAdd("java02");
              dl.myAdd("java03");
              dl.myAdd("java04");
              while(!dl.isNull())
              System.out.println(dl.myGet());
       }
}

去除ArrayList重复元素

在迭代时循环中next调用一次，就要hasNext判断一次

class ArrayListTest
{
       publicstatic void main(String[] args)
       {
              ArrayList al=new ArrayList();
              al.add("java01");
              al.add("java02");
              al.add("java01");
              al.add("java02");
              al.add("java01");
              al.add("java03");
              al=singleElement(al);
              sop(al);
             
       }
       publicstatic ArrayList singleElement(ArrayList al)
       {
              //定义一个临时容器
              ArrayList newAl=new ArrayList();
              Iterator it=al.iterator();
              while(it.hasNext())
              {
                     Objectobj=it.next();
                     if(!newAl.contains(obj))
                            newAl.add(obj);
              }
              return newAl;
       }
}

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。

思路：

1、对人描述，将数据封装进人对象；

2、定义容器，将人存入；

3、取出。

List集合判断元素是否相同，依据的是元素equals方法。

import java.util.*;
class Person
{
       privateString name;
       privateint age;
       Person(Stringname,int age)
       {
              this.name=name;
              this.age=age;
       }
       publicboolean equals(Object obj)
       {
              if(!(obj instanceof Person))
                     returnfalse;
              Person p=(Person)obj;
              return this.name.equals(p.name)&&this.age==p.age;
}
       publicString getName()
       {
              return name;
       }
       publicint getAge()
       {
              return age;
       }
}
class ArrayListTest2
{
       publicstatic void sop(Object obj)
       {
              System.out.println(obj);
       }
       publicstatic void main(String[] args)
       {
              ArrayList al=new ArrayList();
              al.add(newPerson("lisi01",30));//al.add(Object obj);//Object obj=newPerson("lisi01",30);
              al.add(newPerson("lisi02",32));
              al.add(newPerson("lisi03",33));
              al.add(newPerson("lisi04",35));
              al.add(new Person("lisi03",33));
              al.add(newPerson("lisi04",35));
              sop(“remove 03:”+a1.remove(new Person(“lisi03,33”)));//删除一项，底层也调用equals
              al=singleElement(al);
              Iterator it=al.iterator();
              while(it.hasNext())
              {
                     Personp=(Person)it.next();
                     sop(p.getName()+"::"+p.getAge());
              }
       }
       publicstatic ArrayList singleElement(ArrayList al)
       {
              //定义一个临时容器
              ArrayList newAl=new ArrayList();
              Iterator it=al.iterator();
              while(it.hasNext())
              {
                     Objectobj=it.next();
                     if(!newAl.contains(obj))
                            newAl.add(obj);
              }
              return newAl;
       }
}

如果涉及到元素很多并且频繁的增删操作用LinkedList；如果涉及到增删同事涉及到查询用ArrayList。其实频繁的增删操作不多见，所以ArryList是最常见的容器。

//Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复

//Set集合的功能和Conllection是一致的

//常见的子类：

HashSet（底层数据结构式哈希表）

HashSet是如何保证元素唯一性的呢？

是通过元素的两个方法，hashCode和equals来完成

如果元素的HashCode值相同，才会判断equals是否为true。

如果元素的hashcode值不同，不会调用equals

HashSet判断和删除的依据

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法

TreeSet

class Demo
{
}
class HashSetDemo
{
	publicstatic void sop(Object obj)
	{
       		System.out.println(obj);
	}
	public staticvoid main(String[] args)
       	{
              Demo d1=new Demo();
              Demo d2=new Demo();
              sop(d1);
              sop(d2);
	}
}

输出结果：

Test.Demo@c17164

Test.Demo@1fb8ee3

c17164——第一个对象的地址

1fb8ee3——第二个对象的地址

两个地址都存放在集合中，比较两个哈希值是否相同再往里添加。

class HashSetDemo
{
       publicstatic void sop(Object obj)
       {
       		System.out.println(obj);
	}
	public staticvoid main(String[] args)
	{
       		HashSet hs=new HashSet();
       		sop(hs.add(“java01”));//true
		sop(hs.add(“java01”));//false，不能重复
      	 	hs.add(“java02”);
		hs.add(“java03”);
		hs.add(“java04”);
		//set 集合取值只有一种方法，迭代器
		Iterator it=hs.iterator();
		while(it.hasNext())
		{
       			sop(it.next());
		}
	}
}

HashSet自定义对象

import java.util.*;
//往HashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素
//覆盖Person的哈希构造方法，建立Person对象自己的哈希值
class HashSetTest
{
       publicstatic void sop(Object obj)
       {
       		System.out.println(obj);
	} 
	public staticvoid main(String[] args)
       {
              HashSet hs=new HashSet();
              hs.add(new Person(“a1”,11));
              hs.add(new Person(“a2”,12));
              hs.add(new Person(“a3”,13));
              hs.add(new Person(“a4”,14));
              sop(hs.contains(new Person(“a1”,11)));//判断是否存在a1,，11
              hs.remove(new Person(“a3”,13));//删除。同样是先判断哈希值，再equals
              Iterator it=hs.iterator();
              while(it.hasNext())
              {
                     Personp=(Person)it.next();
                     sop(p.getName()+”::”+p.getAge());
		}
	}
}
class Person
{
       privateString name;
       privateint age;
       Person(Stringname,int age)
       {
              this.name=name;
              this.age=age;
       }
       publicint hashCode()//复写hashCode
       {
              return name.hashCode()+age*39;//尽量保证哈希值唯一，所以乘以39
	}
       publicboolean equals(Object obj)//复写equals
       {
              if(!(obj instanceof Person))
                     returnfalse;
              Person p=(Person)obj;
              System.out.println(this.name+”…”+p.name);
              returnthis.name.equals(p.name)&&this.age==p.age;
	}
       publicString getName()
       {
              return name;
       }
       publicint getAge()
       {
              return age;
       }
}

Set：无序，不可以重复元素

HashSet：数据结构式哈希表，线程是非同步的。

保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同还会判断元素的equals方法，是否为true。

TreeSet：可以对Set集合中的元素进行排序。

底层数据结构式二叉树。

保证元素唯一性的依据：compareTo方法return 0。

TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现compareTo方法。这种方式也称为元素的自然顺序，或者叫做默认顺序。

TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合初始化时就有了比较方式。

class TreeSetDemo
{
       publicstatic void main(String[] args)
       {
              TreeSet ts=new TreeSet();
              ts.add(“cba”);
              ts.add(“abcd”);
              ts.add(“aaa”);
              ts.add(“bca”);
              Iterator it=ts.iterator();//什么意思？！！
              while（it.hasNext()）
              {
                     System.out.println(it.next());//打印结果：aaa,abcd,bca,cba
		}
	}
}

TreeSet存储自定义对象

需求：往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。

记住：排序时，当主要条件相同时，一定要判断一下次要条件。

import java.util.*;
class TreeSetDemo
{
       publicstatic void main(String[] args)
       {
              TreeSet ts=new TreeSet();
              ts.add(newStudent("lisi02",22));
              ts.add(newStudent("lisi007",20));
              ts.add(newStudent("lisi09",19));
              ts.add(newStudent("lisi01",40));
              Iterator it=ts.iterator();
              while(it.hasNext())
              {
                     Studentstu=(Student)it.next();
		     System.out.println(stu.getName()+"..."+stu.getAge());
	      }
	}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
       privateString name;
       privateint age;
       Student(Stringname,int age)
       {
              this.name=name;
              this.age=age;
	}
	public int compareTo(Object obj)
	{
       		//怎么存怎么取就写一句：return 1；
		if(!(objinstanceof Student))
             		 throw new RuntimeException("不是学生对象");
       		Students=(Student)obj;
       		System.out.println(this.name+"...equls..."+s.name);
       		if(this.age>s.age)//此对象大于指定对象
              		return 1;
       		if(this.age==s.age)//当年龄相同时再判断一下姓名
       		{
       			return this.name.compareTo(s.name);
		}
      		 return-1;
	}
	public String getName()
	{
      		 returnname;
	}
	public int getAge()
	{
       		returnage;
	}
}

二叉树

当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法。

class Student implements Comparable//该接口强制让学生具备比较性
{
       privateString name;
       privateint age;
       Student(Stringname,int age)
       {
              this.name=name;
              this.age=age;
	}
	public int compareTo(Object obj)
	{
		if(!(objinstanceof Student))
              		throw new RuntimeException("不是学生对象");
       		Students=(Student)obj;
       		//System.out.println(this.name+"...equls..."+s.name);
       		if(this.age>s.age)//此对象大于指定对象
              		return 1;
       		if(this.age==s.age)//当年龄相同时再判断一下姓名
       		{
      			return this.name.compareTo(s.name);
		}
      		return-1;
	}
	public String getName()
	{
       		returnname;
	}
	public int getAge()
	{
       		returnage;
	}
}
class TreeSetDemo
{
       publicstatic void main(String[] args)
       {
              TreeSet ts=new TreeSet(new MyCompare());
              ts.add(new Student("lisi02",22));
              ts.add(newStudent("lisi007",20));
              ts.add(newStudent("lisi09",19));
              ts.add(newStudent("lisi01",40));
              Iterator it=ts.iterator();
              while(it.hasNext())
              {
                     Studentstu=(Student)it.next();//不懂
		     System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
class MyCompare implements Comparator
{
       publicint compare(Object o1,Object o2)
       {
              	Student s1=(Student)o1;
		Student s2=(Student)o2;
		int num=s1.getName().compareTo(s2.getName());
		if(num==0)
		{
       			return newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。

好处

1、将运行时期出现的问题ClassCastException，转移到编译时期。方便于程序员解决问题。让运行时期问题减少，安全；

2、避免了强制转换麻烦。

泛型格式：通过<>定义要操作的引用数据类型

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到 <>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

class GenericDemo
{
       publicstatic void main(String[] args)
       {
              ArrayList<String> al=newArrayList<String>();
              al.add(“abc01”);
              al.add(“abc0991”);
              al.add(“abc014”);
              Iterator<String> it=al.iterator();
              while(it.hasNext())
              {
                     Strings=it.next();
                     Stirng.out.println(s+”:”+s.length());
		}
	}
}

泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不被确定的时候

早期定义Object来完成扩展，现在定义泛型来完成扩展。

class Utils<QQ>
{
       privateQQ q;
       publicvoid setObject(QQ q)
       publicQQ getObject()
       {
              return q;
	}
}
class GennricDemo3
{
       publicstatic void main(String[] args)
       {
              Utils<Worker> u=newUtils<Worker>();
              u.setObject(new Worker());
              Worker w=u.getObject();
	}
}

泛型方法

class Demo<T>
{
       publicvoid show(T t)
       {
              System.out.println(“show:”+t);
	}
	public voidprint(T t)
	{
       		System.out.println(“print:”+t);
	}
}

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，那么将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo
{
       Public<T> void show(T t)
       {
       		System.out.println(“show”+t);
	}
	Public <Q>void print(Q q)
	{
      		 System.out.println(“print:”+q);
	}
	public static<W> void method(W t)
	{
       		System.out.println(“method:”+t);
	}
}
class GenericDemo4
{
       publicstatic void main(String[] args)
       {
              Demo d=new Demo();
              d.show(“hah”);
              d.show(new Integer(4));
              d.print(“heihei”);
              Demo.method(“hahahhahah”);             
	}
}

泛型定义在接口上。

多态不能预先使用子类中的方法。

泛型不能使用类型中的特有方法。

Interface Inter<T>
{
       Voidshow(T t);
}
Class InterImpl<.T> implementsInter<T>
{
       publicvoid show(T t)
       {
              System.out.println(“show:”+t);
	}
}
Class GenericDemo5
{
       publicstatic void main(String[] args)
       {
              	InterImpl<Integer> i=newInterImpl<Integer>();
              	i.show(4);
		//InterImpl i=new InterImpl();
             	 //i.show(“hahh”);
	}
}
class GenericDemo6
{
       publicstatic void main(String) al=new ArrayList<String>();
       al.add(“abc1”);
	al.add(“abc2”);
	al.add(“abc3”);
	ArrayList<Integer>all=new ArrayList<Integer>();
	all.add(4);
	all.add(7);
	all.add(1);
	printColl(al);
	printColl(all);
}
public static voidprintColl(ArrayList<?> al)//不明确数据类型，占位符
{
       Iterator<?>it=al.iterator();
       while(it.hasNext())
       {
              System.out.println(it.next());
	}
}

泛型限定

?通配符，也可以理解为占位符。

泛型的限定：

? extends E——可以接收E类型或者E的子类型。上限。

? super E——可以接收E类型或者E的父类型。下限

Map集合：该集合存储键值对，一对一对往里存，而且要保证键值的唯一性。

1、添加

put(K key,Vvalue)

putAll(Map<?extends K,? extends V> m)

2、删除

clear()

remove(Objectkey)

3、判断

containsKey(Objectkey)

containsValue(Objectvalue)

isEmpty()

4、获取

get(Object key)

size()

entrySet()

keyset()

Map:

Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，效率低。

HashMap：底层是哈希表数据结构，可以存入null键null值，该集合不是线程同步的，效率高。

TreeMap：底层是二叉树结构，线程不同步，可以用于给map集合中的键排序。

和Set很像，其实Set底层就是用了Map集合。

Map集合的两种取出方式：

1、 Set<ke> keyset：将map中所有的键存入到Set集合，因为Set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

2、 Set<Map.Entry<k,v>> entrySet：将map集合中的关系存入到了set结合中，而这个关系的数据类型就是Map.Entry。

import java.util.*;
class MapDemo2
{
       publicstatic void main(String[] args)
       {
             	 Map<String,String> map=newHashMap<String,String>();
              	map.put(“02”,”zhangsan2”);
		map.put(“03”,”zhangsan3”);
		map.put(“01”,”zhangsan1”);
		map.put(“04”,”zhangsan4”);
		//将Map集合中的映射关系取出，存入到Set集合中
		Set<Map.Entry<String,String>> entrySet=map.entrySet();
		Iterator<Map.Entry<String,String>>it=entrySet.iterator();
		while(it.has.Next())
		{
       			Map.Entry<String,String>ms=it.next();
       			String key=me.getKey()
       			Stringvalue=me.getValue();
       			System.out.println(key+”…”+value);
		}
		//先获取map集合的所有键的Set集合，keySet()
		Set<String> keyset=map.keySet();
		//有了Set集合，就可以获取其迭代器
		Iterator<String> it=keyset.iterator();
		while(it.hasNext())
		{
       			String key=it.next();
			//有了键就可以通过map集合的get方法获取其对应的值
      			 Stringvalue=map.get(key);
       			System.out.println(“key:”+key,”value:”+value);
		}
	}
}

Map.Entry其实Entry也是一个接口，它是map接口中的一个内部接口。

interface Map
{
       publicstatic interface Entry
       {
       public abstract Object getKey();
       public abstract Object getValue();
	}
}
class HashMap implements Map
{
       classHahs implements Map.Entry
       {
		public Object getKey(){}
             	 public Object getValue(){}
       }
}

凡是见到哈希，就要想到哈希表，想到哈希表就要想到元素的两个方法，一个hasCode一个equals。

需求：对学生对象的年龄进行升序排序

因为数据是以键值对形式存在的。所以要使用可以排序的Map集合，TreeMap。

import java.util.*;
//自定义姓名比较器
class StuNameComparator implementsComparator<Student>
{
       publicint compare(Student s1,student s2)
       {
              	int num=s1.getName().compareTo(s2.getName());
              	if(num==0)
              	{
                     returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}
class MapTest2
{
       publicstatic void main(String[] args)
       {
              	TreeMap<Student,String> tm=newTreeMap<Student,String>(new StuNameComparator);
       		tm.put(new Student(“lisi1”,21),”beijing1”);
		tm.put(new Student(“lisi2”,22),”beijing2”);
		tm.put(new Student(“lisi3”,23),”beijing3”);
		tm.put(new Student(“lisi4”,24),”beijing4”);
		Set<Map.Entry<Student,String>> entrySet=tm.entrySet();
		Iterator<Map.Entry<Student,String>>it=netrySet.iterator();
		while(it.hasNext())
		{
       			Map.Entry<Student,String>me=it.next();
       			Student stu=me.getKey();
       			Stringaddr=me.getValue();
       			System.out.println(stu+”:::”+addr);
		} 
	}
}

Collection：集合框架的工具类。

Arrays：用于操作数组的工具类。

里面都是静态方法。

asList：将数组变成list集合。

把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的，可以使用contains，get，indexOf(),subList()。

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合转成数组：

1、指定类型的数组要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会创建新数组，而是使用传递进来的数组。

2、为什么要将集合变数组

为了限定对元素的操作，不需要增删了。

ArrayList取出元素几种方式？迭代和for循环（get，按角标取）。String只有一种，迭代器。

高级for循环

格式：for(数据类型变量名：被遍历的集合（Collection）或者数组)

对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性，必须有被遍历的目标。

JDK1.5版本出现的新特性：方法的可变参数

在使用时注意：可变参数一定要定义在参数列表的最后面。

class ParamMethodDemo
{
       publicstatic void main(String[] args)
       {
       //虽然少定义了多个方法，但是每次都要定义一个数组，作为实际参数可变参数。其实就是上一种数组参数的简写形式，不用每一次都手动建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
	}
	public staticvoid show(int… arr)
	{
       		System.out.println(arr.length);
	} 
}

最后一个1.5版本新特性：StaticImport静态导入

当类名重名时，需要指定具体的包名。

当方法重名时，指定具备所属的对象或者类。

import java.util.*;
static import java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员
import static java.lang.System.*;//导入了System类中所有静态成员
out.println(“hello world”);
class StaticImport
{
       publicstatic void main(String[] args)
       {
              int[] arr={3,1,5};
              sort(arr);
              int index=binarySearch(arr,1);
              System.out.println(Arrays.toString(arr));
              System.out.println(“Index=”+index);
	}
}

System:类中的方法和属性都是静态的。

out：标准输出，默认是控制台。

in：标准输入，默认是键盘。

描述系统一些信息。

获取系统属性信息：PropertiesgetProperties();

import java.util.*;
class SystemDemo
{
       publicstatic void main(String[] args)
       {            
		Properties prop=System.getProperties();
              	//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
             	 //那么可以通过map的方法取出该集合中的元素
		//该集合中存储的都是字符串，没有泛型定义
		//如何在系统中自定义一些特有信息呢？
		System.setProperty(“mykey”,”myvalue”);
		//获取指定属性信息
		String value=System.getProperty(“os.name”);
		System.out.println(“value”+value);
		//获取所有属性信息
             	 for(Object obj:prop.keySet())
		{
       			Stringvalue=(String)prop.get(obj);
       			System.out.println(obj+”::”+value);
		}
	}
}

Runtime对象

该类并没有提供构造函数。说明不可以new对象，那么会直接想到该类中的方法都是静态的。

发现该类中还有非静态方法。说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型

由这个特点可以看出该类使用了单例设计模式完成。

该方法是staticRuntime getRuntime();

class RuntimeDemo
{
       publicstatic void main(String[] args) throws Exception
       {
              Runtime r=Runtime.getRuntime();
              //r.exec(“c:\\winmine.exe”);//打开扫雷
              Process p=r.exec(“winmine.exe”);
              Process p=r.exec(“notepad.exe xx.java”);//记事本打开xx.java文件
              Thread.sleep(4000);//停留四秒
              p.destory();//杀死进程
	}
}