Java.集合(学习笔记)

学习Java时的代码笔记，排版可能有些问题，代码拿来直接就可以用，毕竟全手打，难免会有错，欢迎指正

/*
集合类(集合框架):存储对象的一种方式
java.util.Collection
为什么出现集合类
	面向对象的语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作
	就对对象进行存储，集合就是存储对象最常用的一种方式
数组和集合类同是容器，有何不同
	数组虽然也可以存储对象，但长度是固定的；而集合长度是可变的
	数组中可以存储基本数据类型，集合只能存储对象
集合类的特点
	集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
*/
import java.util.*;
class CollectionMainDemo1 
{
	public static void main(String[] args) {
		method_retain();
		base_method();
		method_get();

	}

	public static void base_method()
	{
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList al = new ArrayList();
		//1.添加元素
		/*
		add方法的参数类型是Object以便接收任意类型的对象
		集合中存储的都是对象的引用(地址)
		*/
		al.add("java01"); //add(Object obj)
		al.add("java02");
		al.add("java03");
		al.add("java04");
		sop(al);

		//获取个数，集合长度
		sop("size:"+al.size());

		//删除元素
		al.remove("java02");
		//al.clear(); //清空集合
		sop(al);

		//判断元素
		sop("java03是否存在"+al.contains("java03"));
		sop("集合是否为空"+al.isEmpty());		
	}

	public static void method_retain()
	{
		ArrayList al1 = new ArrayList();
		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");
		ArrayList al2 = new ArrayList();
		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");
		al1.retainAll(al2); //取交集，al1中只会保留和al2相同的元素
		al1.removeAll(al2); //移除al1中和al2相同的元素
		sop("al1:"+al1);
		sop("al2:"+al2);		
	}
	/*
	迭代器
	其实就是集合取出元素的方式
	*/
	public static void method_get()
	{
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素
		sop(it.next());
		sop(it.hasNext()); //有元素时返回真
		while(it.hasNext)
		{
			sop(it.next());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
List集合共性方法
Collection
	|--List:元素是有序的,元素可以重复，因为该集合体系有索引
		|--ArrayList:底层是数组数据结构，特点:查询速度很快，增删改速度慢，元素越多越明显
		|--LinkedList:底层是链表数据结构，特点:查询速度慢,增删改速度快
		|--Vector:底层是数组数据结构，Vector是同步的，ArrayList是不同步的
	|--Set:元素是无序的，元素不可以重复,因为该体系没有索引
		|--HashSet:底层数据结构是hash表
				HashSet是如何保证元素的唯一性的呢?
				是通过元素的HashCode值相同，才会判断equals是否为true
				如果元素的hashCode值不同，则不会调用equals
		|--TreeSet:可以对Set集合中的元素进行排序
List:
	特有方法:凡是可以操作角标的方法都是该体系特有的方法
		增
			add(index,element);
			addAll(index,Collection);
		删
			remove(index);
		改
			set(index,element);
		查
			get(index);
			subList(from,to);
			listIterator();
*/
import java.util.*;
class ListMainDemo1
{
	public static void main(String[] args) {
		method_base();
		listIteratorDemo();
	}

	public static void method_base()
	{
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//在指定位置添加元素
		sop("原集合是:"+al);
		al.add(1,"java09"); //在角标1的位置插入元素
		sop("在角标1的位置插入元素后的结果是:"+al);
		//删除指定位置的元素
		al.remove(2);
		sop("删除角标为2的元素后的结果是:"+al);
		//修改元素
		al.set(1,"java10");
		sop("将角标为1的元素修改为java10后的结果:"+al);
		//通过角标获取元素
		sop("通过角标获取元素:"+al);
		sop("获取到的元素:get(2):"+al.get(2));
		//获取所有元素
		sop("利用for循环获取所有元素:");
		for(int x =0; x<al.size(); x++)
		{
			sop("al("+x+")="+al.get(x));
		}
		sop("利用Iterator获取所有元素:");
		for(Iterator it = al.iterator(); it.hasNext(); )
		{
			sop("next:"+it.next());
		}
		//通过indexOf获取对象的位置
		sop("通过indexOf获取java03所在的位置:"+al.indexOf("java03"));
		//取一个子列表
		List sub = al.subList(1,3);//从原集合中取出1到3的元素，包含1，不包含3
		sop("sub="+sub);		
	}

	/*
	列表迭代器
	ListIterator是Iterator的子接口
	在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。
	所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断，取出，删除
	的操作，如果想要其他的操作，如添加，修改等，就需要使用其子接口，ListIterator。
	该接口只能通过List集合的ListIterator方法获取
	*/
	public static void listIteratorDemo()
	{
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		sop("原集合是"+al);
		/*在迭代过程中，准备添加或者删除元素
		这种是有问题的方法
		for(Iterator it = al.iterator(); it.hasNext(); )
		{
			Object obj = it.next();
			if(obj.equals("java02"))
				//al.add("java05"); //这里会抛出异常，因为连个容器在同时操作一个数据
				it.remove();//将java02的引用从集合中删除
		}	
		*/
		
		for(ListIterator li = al.listIterator(); li.hasNext(); x++)
		{
		sop("hasNext():"+li.hasNext());
		sop("hasPrevious():"+li.hasPrevious());
			Object obj = li.next();
			if(obj.equals("java02"))
			{
				//li.add("java05"); //在java02后面添加java05
				li.set("java06"); //把java02修改成java06
			}
		}		
		sop("迭代以后的集合"+al);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
Vector特殊的地方:枚举
枚举，就是Vector的特有取出方式
发现枚举和迭代器很象
此接口的功能与 Iterator 接口的功能是重复的。
此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。
新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。 
*/
class VectorMainDemo1
{
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

		Enumeration ne = v.elments();
		while(en.hasMoreElements())
		{
			System.out.println(en.netElement());
		}
	}
}
/*
LinkedList模拟一个堆栈或者队列数据结构
堆栈:先进后出 First in Last out(FILO) 如同一个杯子
队列:先进先出 First in First out(FIFO) 如同一个水管
*/
import java.util.*;
class QueueMainDemo1
{
	private LinkedList link;
	QueueMainDemo1()
	{
		link = new LinkedList();
	}
	//添加方法
	public void myAdd(Object obj)
	{
		link.addFirst(obj); //将指定元素插入到此列表的开头
	}
	//获取方法
	public Object myGet()
	{
		return link.removeLast(); //返回此列表最后一个元素
	}
	//清空方法
	public boolean isNull()
	{
		return link.isEmpty();
	}
	public static void main(String[] args) {
		
	}
}
class LinkedListMainDemo1
{
	public static void main(String[] args) {
		QueueMainDemo1 q = new QueueMainDemo1();
		q.myAdd("java01");
		q.myAdd("java02");
		q.myAdd("java03");
		q.myAdd("java04");
		System.out.println(q.myGet());

	}
}
/*
练习:去除ArrayList中重复的元素
*/
import java.util.*;
class ArrayListTest1
{
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java01");
		al.add("java02");
		al.add("java02");
		al.add("java03");
		al.add("java03");
		System.out.println(al);
		al = singleElement(al);
		System.out.println(al);

	}
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		
		for(Iterator it = al.iterator(); it.hasNext(); )
		{
			Object obj = it.next();
			if(!newAl.contains(obj))//如果临时容器中，不包含原容器中的元素
				newAl.add(obj); //就存入临时容器中
		}
		return newAl;
	}
}
/*
ArrayList练习2
将自定义对象作为元素，存储到ArrayList集合中，并去除重复元素
比如:存人对象，同姓名同年龄，视为同一个人，为重复元素
List集合判断元素是否相同，依据的是元素的equals方法
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public boolean equals(Object obj) //重写父类的equals方法，因为Object的equals方法比较的是地址
	//为什么重写equals，因为contains底层用的就是equals
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
}
class ArrayListTest2
{
	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01",30));
		al.add(new Person("lisi02",23));
		al.add(new Person("lisi03",32));
		al.add(new Person("lisi03",32));
		al.add(new Person("lisi04",20));
		al.add(new Person("lisi04",20));
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
		ArrayList al1 = singleElement(al);
		System.out.println();
		Iterator it1 = al1.iterator();
		while(it1.hasNext())
		{
			Person p = (Person)it1.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
	}

	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		
		for(Iterator it = al.iterator(); it.hasNext(); )
		{
			Object obj = it.next();
			if(!newAl.contains(obj))//如果临时容器中，不包含原容器中的元素
				newAl.add(obj); //就存入临时容器中
		}
		return newAl;
	}
}
/*
Set: 无序,不可以重复元素.
	|--HashSet: 数据结构是哈希表.线程是非同步的.
				保证元素唯一性的原理:判断元素的hashCode值是否相同.
				如果相同,还会继续判断元素的equals方法
	|--TreeSet: 可以对Set集合中的元素进行排序.
				底层数据结构是二叉树.
				保证元素的唯一性的依据是compareTo方法return 0.
		
				TreeSet排序的第一种方式:让元素自身具备比较性，元素需要实现compareable接口
				覆盖compareTo方法，这种方式也称为元素的自然顺序，或者叫做默认顺序
				
				TreeSet排序的第二种方式:当元素自身不具备比较性或比较性不是所需要的时候
				就需要让集合自身具备比较性，在集合初始化时就有了比较方式，所以我们需要
				参阅集合的构造函数
*/
class HashSetMainDemo1
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) {
		HashSet hs = new HashSet();
		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}
/*
HashSet添加自定义对象
*/
import java.util.*;
/*
在实际开发中，只要描述这个事物要往集合里面存
一般都会重写hashCode() 和 equals()方法
*/
class Person
{
	private String name;
	private int age;
	public static void main(String[] args) {
		
	}
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}

	/*
	重写hashCode，因为hashSet给每个对象赋了不同的hash值，所以equals没有运行
	所以这里重写hash值，让每个对象hash值相同，这时候equals就运行了
	*/
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37; //乘整数是为了保证hash值得唯一性

	}

	/*
	重写equals因为默认的equals是判断地址
	*/
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);
		return this.name.equals(p.name) && this.age == p.age;
	}
}
class HashSetMainDemo2
{
	public static void 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));
		hs.add(new Person("a4",14));

		//对于判断元素是否存在以及删除等操作，都依赖于元素的hashCode()和equals()
		System.out.println(hs.contains(new Person("a1",11))); //
		hs.remove(new Person("a2",12));

		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
	}
}
/*
TreeSet:可以对Set集合中的元素进行排序
默认按照Ascii码表排序
*/
class TreeSetMainDemo1
{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add("cbcd");
		ts.add("bsdf");
		ts.add("aaaa");
		ts.add("ebd");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
/*
存储自定义对象
需求往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序
*/
import java.util.*;
class Student
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetMainDemo2
{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20)); //2个以上对象会报错
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
/*
以上结果会报错，因为TreeSet在排序的时候，我们的对象
根本不具备比较性，说白了就是，TreeSet根本不知道你排
序的依据是什么，那么它怎么知道该如何给你排序呢？所以
会报错，那么因此，如果我们想进行排序该怎么办呢？
答:
	想要进行排序那么我们必须具备比较性，那么我们又如何
	才能具备比较性呢？
	TreeSet给我们提供了一个接口Comparable,你只要实现这个
	接口，那么就具备了比较性，TreeSet就可以帮你进行排序了
*/
import java.util.*;
class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;

	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		System.out.println(this.name+"...compareto..."+s.name); //比较过程

		if(this.age>s.age)
			return 1; //如果大于返回整数
		if(this.age==s.age) //如果等于返回0;0表示两个对象相等
		{
			return this.name.compareTo(s.name); //如果主要比较因素相等，就比较次要因素
			//它返回的也是0、1、或负数
		}
		return -1; //小于返回负数
	}

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetMainDemo3
{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi03",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
/*
二叉树:可以减少比较次数，提高性能
二叉树在元素越多的时候，它会自动取折中值
二叉树默认按照从小到大取数据
*/
//需求,数据怎么存进去的怎么取出来
import java.util.*;
class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;

	public int compareTo(Object obj) //TreeSet集合在比较的时候和compareTo没关系，它只看compareTo的返回值
	{
		return 1; //代表待比较的数比源数据大，因为二叉树默认按照从小到大取数据，所以怎么存进去的怎么取
		//如果想倒序取数据，直接返回-1即可
	}

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetMainDemo4
{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi03",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
/*
TreeSet第二种排序方式:实现Comparator
当元素自身不具备比较性或比较性不是所需要的时候
这时需要让容器自身具备比较性
定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数
当两种排序都存在时以比较器为主
*/
import java.util.*;
class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;

	public int compareTo(Object obj) 
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		System.out.println(this.name+"...compareto..."+s.name); //比较过程

		if(this.age>s.age)
			return 1; //如果大于返回整数
		if(this.age==s.age) //如果等于返回0;0表示两个对象相等
		{
			return this.name.compareTo(s.name); //如果主要比较因素相等，就比较次要因素
			//它返回的也是0、1、或负数
		}
		return -1; //小于返回负数		return 1; 
	}

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class TreeSetMainDemo4
{
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new MyCompare()); //定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi03",40));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
class MyCompare implements Comparator //比较器
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		
		return s1.getName().compareTo(s2.getName()); //以姓名进行排序
	}
}
/*
练习:按照字符串长度排序
字符串本身具备比较性，但是它的比较方式不是所需要的
这时候就只能使用比较器
*/
import java.util.*;
class TreeSetTest1
{
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet(new StringLengthComparator());
		
		al.add("ts01");
		al.add("ts022");
		al.add("ts0312");
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}	
}
class StringLengthComparator implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;
		/*
		if(s1.length()>s2.length());
			return 1;
		if(s1.length()==s2.length())
			return 0;
		return -1;
		*/
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2); //主要条件要是比较不出来就比较次要元素
		return num;
	}
}
/*
当我们向集合中存放不同类型的数据时运行时可能会出错
泛型集合:JDK1.5版本以后出现的新特性。用于解决安全问题，是一种安全机制
好处
1.将运行时期出现的ClassCastException错误，转移到了编译时期，方便于程序员解决问题
让运行时期问题减少，安全
2.避免了强制转换的麻烦.

泛型格式:通过<>来定义要操作的引用数据类型
在使用java提供的对象时,什么时候写泛型呢？
答:
	通常在集合框架中很常见，只要见到<>就要定义泛型，其实<>就是用来接收类型的
	当使用集合时，将集合中要存储的数据类型作为参数传递到<>即可，如同函数传参数一样
*/
import java.util.*;
class GenericDemo1
{
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>(); //定义一个ArrayList容器，该容器是String类型
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");
		
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s+":"+s.length());
		}
	}
}
//泛型在比较器中的应用
import java.util.*;
class GenericDemo2
{
	public static void main(String[] args)
	{
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		
		al.add("ts01");
		al.add("ts022");
		al.add("ts0312");
		
		Iterator<String> it = ts.iterator();
		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s);
		}
	}	
}
class LenComparator implements Comparator<String> //比较器也可以加泛型，避免强转
{
	public int compare(String o1,String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length());//按长度比较
		if(num==0)
			return o1.compareTo(o2);
		return num;
	}
}
/*
泛型类
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候
早期定义Object来完成扩展
现在定义泛型来完成扩展
*/
class Worker
{
}
class Student
{
}
//泛型前
/*
class Tool
{
	private Object obj;
	public void setObject(Object obj)
	{
		this.obj = obj;
	}
	public Object getObject()
	{
		return obj;
	}
}
*/
//泛型后
class Utils<Generics>
{
	private Generics g;
	public void setObject(Generics g)
	{
		this.g = g; 
	}
	public Generics getObject()
	{
		return g;
	}
}
class GenericDemo3
{
	public static void main(String[] args)
	{
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject(); //避免了强转，直接让错误转移到了编译时期
		/*
		Tool t = new Tool();
		t.setObject(new Student());
		Worker w = (Worker)t.getObject(); //在出现泛型之前需要进行强转
		*/
	}
}
/*
泛型方法
*/
class Demo<T>
{
	public void show(T t)
	{
		System.out.println("Show: " + t);
	}
	public void print(T t)
	{
		System.out.println("Print: " + t);
	}
}
class GenericDemo4
{
	public static void mian(String[] args)
	{
		Demo<Integer> d = new Demo<Integer>();
		d.show(new Integer(4));
		d.print("haha"); //这样就会报错，因为new对象时已经指明类型为Integer
	}
}
/*
以上就是泛型类的一个局限性
泛型类定义的泛型，在整个类中有效。如果被方法使用
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
为了让不同方法可以操作不同的类型，而且类型还不确定
那么可以将泛型定义在方法上
*/
class Demo
{
	public<T> void show(T t)
	{
		System.out.println("Show: " + t);
	}
	public<T> void print(T t)
	{
		System.out.println("Print: " + t);
	}
}
class GenericDemo5
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
	}
}
/*
静态泛型方法
静态方法不可以访问类上定义的泛型，如果静态方法操作的的应用数据类型不确定，可以将泛型定义在方法上
*/
class Demo<T>
{
	public void show(T t)
	{
		System.out.println("Show: " + t);
	}
	public<Q> void print(Q q)
	{
		System.out.println("Print: " + t);
	}
	public static<W> void method(W w) //静态泛型方法
	{
	
	}
}
class GenericDemo5
{
	public static void main(String[] args)
	{
		Demo<String> d = new Demo<String>();
		d.show("haha");
		d.print(5);
		d.print("hehe");
		Demo.method("hahaha");
	}
}
/*
泛型接口
*/
interface Inter<T>
{
	void show(T t);
}
/*
class Interimpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("Show: " + t);
	}
}
*/
class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("Show: " + t);
	}
}
class GenericDemo6
{
	public static void main(String[] args)
	{
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
		/*
		InterImpl i = new InterImpl();
		i.show("haha");
		*/
	}
}
/*
泛型限定
?通配符。也可以理解为占位符
泛型的限定:
限定?可接受的类型范围
? extends E: 可以接收E类型或者E的子类型 上限定(上限)
? super E: 可以接收E类型或者E的父类型 下限定(下限)
*/
//上限应用
import java.util.*;
class GenericDemo7
{
	/*
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");
		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(4);
		al1.add(8);
		al1.add(1);
		printColl(al);
		printColl(al1);
	}
//	public static void printColl(ArrayList<String> al) //ArrayList<String> al = new ArrayList<Integer>(); Error
	public static void printColl(ArrayList<?> al) //ArrayList<?> al = new ArrayList<Integer>();
	{
		Iterator<?> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	*/
	class Person
	{
		private String name;
		Persion(String name)
		{
			this.name = name;
		}
		public String getName()
		{
			return name;
		}
	}
	class Student extends Person
	{
		Student(String name)
		{
			super(name);
		}
	}
	public static void main(String[] args)
	{
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc01"));
		al.add(new Person("abc02"));
		al.add(new Person("abc03"));
		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc01"));
		al1.add(new Student("abc02"));
		al1.add(new Student("abc03"));
		printColl(al); //ArrayList<Person> al = new ArrayList<Student>();
	}

	public static void printColl(ArrayList<? extends Person> al) //限定?可接受的类型范围，只能打印Person和Person的子类
	{
		Iterator<? extends Person> it = al.iterator(); //这里只能打印Person和Person的子类
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}
/*
泛型限定2--下限应用
*/
import java.util.*;
class GenericDemo8
{
	public static void main(String[] args)
	{
		/*
		TreeSet<Student> ts = new TreeSet<Student>(new StuComp());
		ts.add(new Student("abc01");
		ts.add(new Student("abc02");
		ts.add(new Student("abc03");
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		
		TreeSet<Worker> ts1 = new TreeSet<Worker>(new WorkComp());
		ts1.add(new Worker("abc-01");
		ts1.add(new Worker("abc-02");
		ts1.add(new Worker("abc-03");
		Iterator<Worker> it1 = ts1.iterator();
		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
		*/
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Student("abc01");
		ts.add(new Student("abc02");
		ts.add(new Student("abc03");
		Iterator<Student> it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}

		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("abc-01");
		ts1.add(new Worker("abc-02");
		ts1.add(new Worker("abc-03");
		Iterator<Worker> it1 = ts1.iterator();
		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}
/*
class StuComp implements Comparator<Student> //Student的比较器
{
	public int compare(Student s1,Student s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
class WorkComp implements Comparator<Worker> //Worker的比较器
{
	public int compare(Worker w1,Worker w2)
	{
		return w1.getName().compareTo(w2.getName());
	}
}
*/
//以上没比较一个对象需要创建一个比较器，非常麻烦
class Comp implements Comparator<Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.getName().compareTo(p2.getName());
	}
}
class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public String toString()
	{
		return "Person: " + name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}
class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}
/*
Map集合,集合存储的是键值对,必须要保证键的唯一性
	1.添加
		put(K key,V value);
		putAll(Map<? extends K,? extends V>m);
	2.删除
		clear();
		remove(Object key);
	3.判断
		containsValue(Object value);
		containsKey(Object key);
		isEmpty();
	4.获取
		get(Object key);
		size();
		values();
		entrySet();
		keySet();
Map:Map和Set很像,Set底层就是使用的Map集合
	|--Hashtable:底层是哈希表数据结构,不可以存入null键或者null值,该集合是线程同步的
	|--HashMap:底层是哈希表数据结构,并允许使用null键或null值,该集合是不同步的
	|--TreeMap:底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键排序
*/
//Map的共性方法
import java.util.*;
class MapDemo1
{
	public static void main(String[] args)
	{
		//添加元素,如果出现相同的键,那么后添加的值会覆盖原有的键对应的值,put方法会返回原有的值
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		//判断
		System.out.println("containsKey:" + map.containsKey("02"));
		//移除
		System.out.println("remove:" + map.remove("03"));
		System.out.println(map);
		//获取
		System.out.println("get:" + map.get("02"));
		map.put("04",null);
		System.out.println("get:" + map.get("04"));//可以通过get方法的返回值来判断一个键是否存在
		//获取map集合中的所有值
		Collection<String> coll = map.values();
		System.out.println(coll);
		System.out.println(map);
	}
}
/*
Map集合的两种取出方式:
1. Set<key> keySet:将Map中所有的键存入到Set集合中,因为Set集合具备迭代器。
所以可以通过迭代方式取出所有的键,然后再根据get方法,获取每一个键对应的值。
map集合的取出原理:将map集合转换成set集合,再通过迭代器取出
*/
import java.util.*;
class MapDemo2
{
	public static void main(String[] args)
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		map.put("04","zhangsan04");
		//先获取map集合中的所有键的set集合,keySet();
		Set<String> keySet = map.keySet();
		//有了Set集合就可以获取其迭代器
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			//有了键就可以通过map集合的get方法获取其对应的值
			String value = map.get(key);
			System.out.println("key:" + key + ",value:" + value);
		}
	}
}
/*
2. Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry
Map.Entry相当于一个关系类型，获取到Map.Entry对象后就可以通过Map.Entry中的getKey和getValue方法获取键和值
*/
import java.util.*;
class MapDemo3
{
	public static void main(String[] args)
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		map.put("04","zhangsan04");

		Set<Map.Entry<String,String>> entrySet = map.entrySet();
		Iterator<Map.Entry<String,String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey(); //getKey方法获取关系映射中的键
			String value = me.getValue(); //getValue方法获取关系映射中的值

			System.out.println(key + ":" + value);
		}
	}
}
/*
Map.Entry其实Entry也是一个接口,它是Map接口中的一个内部接口
它是通过内部类实现的
*/
interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}
class HashMap implements Map
.Entry
{
	class Haha implements Map.Entry
	{
		public Object getKey()
		{

		}
		public Object getValue()
		{
		}
	}
}
/*
Map练习
每一个学生都有对应的归属地
学生Student,地址String
学生属性: 姓名,年龄
注意:姓名和年龄相同的视为同一个学生
保证学生的唯一性

1.描述学生

2.定义map容器,将学生作为键,地址作为值,存入

3.获取map集合中的元素

*/
import java.util.*;
class Student implements Comparable<Student> //实现比较器
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Student s) //重写比较器
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}

	public int hashCode()
	{
		return name.hashCode() + age * 34;
	}
	public boolean equals(Object obj) //重写equals方法
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");

		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name + ":" + age;
	}
}
class MapTest1
{
	public static void main(String[] args)
	{
		HashMap<Student,String> hm = new HashMap<Student,String>();
		hm.put(new Student("lisi1",21),"beijing");
		hm.put(new Student("lisi2",22),"shanghai");
		hm.put(new Student("lisi3",23),"tianjin");
		hm.put(new Student("lisi4",24),"chengdu");
		
		//第一种取出方式keySet 第一种取出方式keySet hash表示无序的
		Set<Student> keySet = hm.keySet();
		Iterator<Student> it = hm.keySet().iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu + " keySet: " + addr);
		}
		//第二种取出方式entrySet 第一种取出方式entrySet
		Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
		Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
		while(iter.hasNext())
		{
			Map.Entry<Student,String> me = iter.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu + " entrySet: " + addr);
		}
	}
}
/*
TreeMap练习
需求:对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的
所以要使用可以排序的Map集合.TreeMap
*/
import java.util.*;
class Student implements Comparable<Student> //实现比较器
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Student s) //重写比较器
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}

	public int hashCode()
	{
		return name.hashCode() + age * 34;
	}
	public boolean equals(Object obj) //重写equals方法
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");

		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age == s.age;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name + ":" + age;
	}
}
class StuNameComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //次要条件
		return num;
	}
}
class MapTest2
{
	public static void main(String[] args)
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
		tm.put(new Student("lisi1",21),"beijing");
		tm.put(new Student("lisi2",22),"shanghai");
		tm.put(new Student("lisi3",23),"tianjin");
		tm.put(new Student("lisi4",24),"chengdu");

		Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
		Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<Student,String> me = it.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu + ":::" + addr);
		}
	}
}
/*
map集合扩展知识:map集合被使用是因为具备映射关系
集合嵌套应用
一个学校有多个教室,每个教室都有名称
学校
	|--教室1
		|--01,zhangsan
		|--02,lisi
	|--教室2
		|--01,wangwu
		|--02,zhaoliu
*/
import java.util.*;
class MapExtend
{
	public static void main(String[] args)
	{
		HashMap<String,HashMap<String,String>> school = new HashMap<String,HashMap<String,String>>(); //创建学校
		HashMap<String,String> classroom1 = new HashMap<String,String>(); //创建教室1
		HashMap<String,String> classroom2 = new HashMap<String,String>(); //创建教室2
		school.put("classroom1",classroom1); //1对多
		school.put("classroom2",classroom2); //1对多
		classroom1.put("01","zhangsan"); //向教室添加学生
		classroom1.put("02","lisi"); //向教室添加学生
		classroom2.put("01","wangwu"); //向教室添加学生
		classroom2.put("02","zhaoliu"); //向教室添加学生

		//变量学校集合,获取所有教室
		Iterator<String> it = school.keySet().iterator();
		while(it.hasNext())
		{
			String roomName = it.next();
			HashMap<String,String> room = school.get(roomName);
			getStudentInfo(room); //获取所有教室的学生
		}
	}
	public static void getStudentInfo(HashMap<String,String> roomMap)
	{
		Iterator<String> it = roomMap.keySet().iterator();
		while(it.hasNext())
		{
			String id = it.next();
			String name = roomMap.get(id);
			System.out.println(id + ":" + name);
		}
	}
}
/*
集合框架的工具类
Collections-binarySearch
Collections-max
Collections-sort
*/
import java.util.*;
class CollectionsDemo1
{
	public  static void main(String[] args)
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("qq");
		list.add("q");
		sop(list);
		int index = halfSearch2(list,"zz",new StrLenComparator());
	}
	public static void binarySearchDemo() 
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("qq");
		list.add("q");
		sop(list);
		Collections.sort(list);
		sop(list);
		int index = Collections.binarySearch(list,"aaa"); //二分查找
		sop("index=" + index);
	}
	public static int halfSearch(List<String> list,String key) //binarySearch原理
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid = (max+min)>>1; // /2
			String str = list.get(mid);
			int num = str.compareTo(key);
			if(num>0)
				max = mid - 1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}
	public static int halfSearch2(List<String> list,String key,Comparator<String> comp) //binarySearch原理带比较器
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid = (max+min)>>1; // /2
			String str = list.get(mid);
			int num = comp.compare(str,key)
			if(num>0)
				max = mid - 1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("qq");
		list.add("q");
		sop(list);
		String max = Collections.max(list); //取最大值
		sop("max:" + max);
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("qq");
		list.add("q");
		sop(list);
		Collections.sort(list,new StrLenComparator()); //给list集合排序
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
class StrLenComparator implements Comparator<String> //实现比较器
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2)
	}
}
/*
Collections-替换反转
*/
import java.util.*;
class CollectionsDemo2
{
	public static void main(String[] args)
	{
	
	}
	public static void replaceAllDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);
		Collections.replaceAll(list,"aaa","www"); //替换
		Collections.reverse(list); //反转
		sop(list);
	}
	/*
	fill方法可以将list集合中的所有元素替换成指定元素
	练习:将list集合中的部分元素替换成指定元素
	*/
	public static void fillDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);
		Collections.fill(list,"pp"); //将集合中的元素全部替换成"pp"
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
Collections-reverseOrder 逆向比较器
reverseOrder还可以强行逆向指定比较器
*/
import java.util.*;
class CollectionsDemo3
{
	public static void main(String[] args)
	{
		reverseOrderDemo();
	}
	public static void reverseOrderDemo()
	{
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()); //传入逆向比较器
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator())); //逆向指定比较器
		ts.add("abcd");
		ts.add("aaa");
		ts.add("zz");
		ts.add("kkkkk");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
class StrLenComparator implements Comparator<String> //实现比较器
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}
/*
Collections-swap	//置换
Collections-shuffle //随机置换
*/
import java.util.*;
class CollectionsDemo2
{
	public static void main(String[] args)
	{
		swapDemo();
	}
	public static void swapDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);
		Collections.swap(list,1,2); //指定角标置换
		sop(list);
	}
	public static void shuffleDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);
		Collections.shuffle(list); //随机置换
		sop(list);	
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*
集合框架工具类Arrays,用于操作数组的工具类
里面都是静态方法
asList: 将数组转换为List集合
*/
import java.util.*;
class ArraysDemo
{
	public static void main(String[] args)
	{
	//	int[] arr = {2,4,5};
	//	System.out.println(Arrays.toString(arr));
		String[] arr = {"abc","cc","kkkk"};
	/*
		把数字变成集合的好处:
		可以使用集合的思想和方法来操作数组中的元素
		注意:将数组变为集合,不可以使用集合的增删方法
		因为数组的长度是固定的
	*/
		List<String> list = Arrays.asList(arr); //将数组转换为List集合
	//list.add("qq"); //UnsupportedOperationException
		System.out.println(list);

	/*
		如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素
		如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
	*/
		int[] nums = {2,4,5};
		List<int[]> li = Arrays.asList(nums); //这里泛型要指定int[]数组类型才行
		System.out.println(li); 
	}
}
/*
集合变数组
Collection接口中的toArray方法
*/
import java.util.*;
class CollectionToArrayDemo
{
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");

		/*
		1.指定类型的数组到底要定义多长呢？
		当指定类型的数组长度小于了集合的size,那么该方法的内部会创建一个新的数组,长度为集合的size。
		当指定类型的数组长度大于了集合的size,那么就不会新创建数组,而是使用传递进来的数组
		所以创建一个刚刚好的数组最为合适

		2.为什么要将集合变数组?
		为了限定对元素的操作.如果你把集合返回给对方,对方依然可以对集合进行增删
		而如果你把集合转成数组返回去,那么数组的长度是固定的,对方就无法对集合进行增删
		*/
		String[] arr = al.toArray(new String[al.size()]); //保证数组长度刚刚好
		System.out.println(Arrays.toString(arr));
	}
}
/*
高级for循环
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
	只能获取集合元素,但是不能对集合进行操作
	迭代器除了遍历,还可以进行remove集合中的元素的动作
	如果是用了ListIterator,还可以在遍历过程中对集合进行增删改查的动作
}
*/
import java.util.*;
class ForEachDemo
{
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");
		/*
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		*/
		/*
		JDK1.5以后可以用for循环遍历集合
		底层还是用的迭代器,为了简化书写
		*/
		for(String s : al) //s第一次指向了集合中的第一个元素
		{
			s = "kk";
			System.out.println(s);
		}
		System.out.println(al);
		//以上循环其实是有局限性的,它只能对集合中的元素做取出,而不能做修改操作
		/*
		传统for循环和高级for循环有什么区别呢？
		高级for循环有一个局限性,必须有被遍历的目标。
		建议在遍历数组的时候,还是希望是用传统的for,因为传统的for循环可以定义角标
		*/
		int[] arr = {3,5,1};
		for(int i : arr)
		{
			System.out.println("i:" + i);
		}
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		Set<Integer> keySet = hm.keySet();
		for(Integer i : keySet)
		{
			System.out.println(i+ "::" + hm.get(i));
		}
		//上面的简写形式
		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			System.out.println(me.getKey()+"---"+me.getValue());
		}

	}
}
/*
JDK1.5版本以后出现的新特性-可变参数
方法的可变参数,在使用时注意:
可变参数一定要定义在参数列表的最后面
*/
class ParamMethodDemo
{
	public static void main(String[] args)
	{
		/*
		int[] arr = {3,4};
		show(arr);
		int[] arr1 = {2,3,5,6};
		show(arr1);
		*/
		show("hell world",2,3,4,5);
	}
	//很麻烦,多一个参数重载一次
	/*
	public static void show(int a,int b)
	{
		System.out.println(a+","+b);
	}
	public static void show(int a,int b,int c)
	{
	}
	*/
	//用数组还不麻烦,因为每次要new一个数组
	/*
	public static void show(int[] arr)
	{
	}
	*/
	/*
	其实这种方法还是数组,但是我们省去了new数组的操作
	这种方法叫可变参数
	*/
	public static void show(String str,int... arr) //可变参数一定要定义在参数列表的最后面
	{
		System.out.println(arr.length); //这里arr是一个数组,长度是你传入的值
	}
}
/*
静态导入
当类名重名时,需要指定具体的包名
当方法重名时,需要指定具备所属的对象或者类
*/
import java.util.*;
import static java.util.Arrays.*; //导入的是Arrays这个类中的所有静态成员
import static java.lang.System.*; //导入了System类中的所有静态成员.
class StaticImport
{
	public static void main(String[] args)
	{
		int[] arr = {3,1,5};
		/*
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr,1);
		System.out.println(Arrays.toString(arr));
		System.out.println("Index=" + index);
		*/
		/*
		导入静态成员后就可以不用再写类名.
		*/
		sort(arr);
		int index = binarySearch(arr,1);
		System.out.println(Arrays.toString(arr)); //这里方法重名,所以不能省略
		System.out.println("Index=" + index);
		
		out.println("Hello World"); //省略System.
	}
}