第一讲 泛型(Generic)
一、概述
1、JDK1.5版本以后出现的新特性。用于解决安全问题,是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类型的元素,无法加入指定类型以外的数据。
[img]http://dl2.iteye.com/upload/attachment/0108/2094/470cdb5f-5831-3e70-9945-648e8dc746ee.png[/img]
泛型的出现,1方面将ClassCastException的隐患,转移到了编译时期。方便于程序员解决问题。让运行时问题减少,安全。
2同时,避免了强制转换麻烦。
[img]http://dl2.iteye.com/upload/attachment/0108/2096/71f2adec-67cc-3bd9-9178-4cc2969ab2c3.png[/img]
泛型应用示例:
[img]http://dl2.iteye.com/upload/attachment/0108/2098/771ab7c4-f4f4-3c05-8a95-a9354a0b3f18.png[/img]
二、泛型类
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
示例:
三、泛型方法
泛型定义在类上,则在整个类中有效。那么该类对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
四、泛型定义在接口上
示例:
五、泛型的限定
1.? 通配符。也可以理解为占位符。
2.泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
3. ? super E: 可以接收E类型或者E的父类型。下限
第二讲 Collections
一、概述
Collections是对集合框架的一个工具类。它里边的方法都是静态的,不需要创建对象。并未封装特有数据。
在Collections工具类中大部分方法是用于对List集合进行操作的,如比较,二分查找,随机排序等。
二、常见操作
1、查找
T max(Collection<? extends T> coll);//根据集合的自然顺序,获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序,获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
2、替换
void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
3排序:
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4、反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器,强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp);//返回一个比较器,强行逆转了指定比较器的顺序
5、同步的集合
List<T> synchronizedList(List<T> list);//返回支持的同步(线程安全的)List集合
Map<K,V> synchronizedList(Map<K,V> m);//返回支持的同步(线程安全的)Map集合
三、Collections和Collection的区别
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口:
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序,二分查找等方法
通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
第三讲 Arrays
一、概述
Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
把数组变成List集合的好处:可以使用集合的思想和方法来操作数组中的元素。如:contains,get,indexOf,subList等方法。
二、常见方法
1、Lsit<T> asList(T... a);//将数组转换为集合
注意:
a、将数组转换成集合,不可使用集合的增删方法,因为数组的长度是固定的。如果进行增删操作,通过编译,但运行时会因产生UnsupportedOperationException异常而中断运行。
b、如果数组中的元素都是对象,则变成集合时,数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
2、binarySearch():二分查找方法,fill():替换方法,sort():排序方法等
特点:可对数组元素进行相应操作,可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数,且还可以对指定元素的范围,并可根据指定比较器进行相应的操作。
如:sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString();//可以接收各种数组类型参数,并返回指定数组内容的字符串表现形式。
2. 增强for循环
高级for循环
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{ }
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的动作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢?
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候,还是希望是用传统for。因为传统for可以定义脚标。
一、概述
1、JDK1.5版本以后出现的新特性。用于解决安全问题,是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类型的元素,无法加入指定类型以外的数据。
/*
在JDK1.5之前,集合定义时不能预集合将要存入的元素是那种类型,只要是引用类型都能add。
这导致两方面问题,1.取出集合后需要强转;2.程序运行时可能导致java.lang.ClassCastException异常导致程序挂掉;
如下:
*/
class GenericDemo
{
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
al.add(4);//al.add(new Integer(4));
Iterator it = al.iterator();
while(it.hasNext())
{
String s = (String)it.next();
System.out.println(s+":"+s.length());
}
}
}
[img]http://dl2.iteye.com/upload/attachment/0108/2094/470cdb5f-5831-3e70-9945-648e8dc746ee.png[/img]
泛型的出现,1方面将ClassCastException的隐患,转移到了编译时期。方便于程序员解决问题。让运行时问题减少,安全。
2同时,避免了强制转换麻烦。
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
al.add(4);//al.add(new Integer(4));
Iterator<String> it = al.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
[img]http://dl2.iteye.com/upload/attachment/0108/2096/71f2adec-67cc-3bd9-9178-4cc2969ab2c3.png[/img]
泛型应用示例:
/*
TreeSet集合。使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。
定义一个TreeSet集合,使用泛型。向集合中存入字符串,按字符串长度排序,如果字符串长度相同再按字符大小排序 */
import java.util.*;
class GenericDemo2
{
public static void main(String[] args){
TreeSet<String> set = new TreeSet<String>(new LenComparator());
set.add("abcdefabcd");
set.add("hello");
set.add("nihaom");
set.add("aaa");
set.add("aab");
Iterator<String> it = set.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>{//实现public interface Comparator<T>接口,此接口支持泛型
public int compare(String s1, String s2){
int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
if(num==0)
return s2.compareTo(s1);
return num;
}
}
[img]http://dl2.iteye.com/upload/attachment/0108/2098/771ab7c4-f4f4-3c05-8a95-a9354a0b3f18.png[/img]
二、泛型类
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
示例:
/*
//最初做法,对每一种实体类分别定义工具类,通用性差
class Tool
{
private Worker w;
public void setWorker(Worker w)
{
this.w = w;
}
public Worker getWorker()
{
return w;
}
}
*/
class Worker
{
}
class Student
{
}
//泛型前做法。//需要强转,可能产生ClassCastException
class Tool
{
private Object obj;
public void put(Object obj)
{
this.obj = obj;
}
public Object get()
{
return obj;
}
}
//泛型类。
/*
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
*/
class Utils<QQ>
{
private QQ q;
public void put(QQ q)
{
this.q = q;
}
public QQ get()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.put(new Worker());
Worker w = u.get();;
/*
Tool t = new Tool();
t.put(new Student());
Worker w = (Worker)t.get();
*/
}
}
三、泛型方法
泛型定义在类上,则在整个类中有效。那么该类对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
//泛型定义在类上,则在整个类中有效。那么该类对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
class Tool<T>{
public void show(T t){
System.out.println(t);
}
public void print(T t){
System.out.println(t);
}
}
public class Gen{
public static void main(String[] args){
Tool<String> tool = new Tool<String>();
tool.show("abc");
// tool.print(new Integer(12));//编译报错:错误: 无法将类 Tool<T>中的方法 show应用到给定类型;
}
}
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
//泛型定义在类上,则在整个类中有效。那么该类对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
class Tool{
public <T> void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
}
}
//本例中Tool类上定义了泛型,Tool类中的print方法也定义了泛型,则main方法调用print时,可以传入任意引用类型
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
}
}
/*
特殊之处:
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
*/
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
public static void staticmethod(T t){
System.out.println(t);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
tool.staticmethod(" 无法从静态上下文中引用非静态 类型变量 T");
}
}
/*
特殊之处:
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
*/
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
public static <W> void staticmethod(W w){
System.out.println(w);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
tool.staticmethod(" 静态方法操作的应用数据类型不确定,可以将泛型定义在方法上");
}
}
四、泛型定义在接口上
示例:
//泛型定义在接口上
interface MyInterface<T>{
void show(T t);
}
class MyClass implements MyInterface<String>{
public void show(String s){
System.out.println(s);
}
}
class Gen{
public static void main(String[] args){
MyClass mc = new MyClass();
mc.show("hello");
}
}
//泛型定义在接口上
interface MyInterface<T>{
void show(T t);
}
class MyClass<T> implements MyInterface<T>{
public void show(T t){
System.out.println(t);
}
}
class Gen{
public static void main(String[] args){
MyClass<String> mc = new MyClass<String>();
mc.show("hello");
}
}
五、泛型的限定
1.? 通配符。也可以理解为占位符。
//? 通配符。也可以理解为占位符。
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<String> al1 = new ArrayList<String>();
al1.add("abc");
al1.add("def");
al1.add("ghk");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(1);
al2.add(2);
al2.add(3);
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<?> al){
Iterator<?> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//?通配符,此外也可以在静态方法上定义个<T>来实现上例的功能
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<String> al1 = new ArrayList<String>();
al1.add("abc");
al1.add("def");
al1.add("ghk");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(1);
al2.add(2);
al2.add(3);
printColl(al1);
printColl(al2);
}
public static <T> void printColl(ArrayList<T> al){
Iterator<T> it = al.iterator();
while(it.hasNext()){
T t = it.next();
System.out.println(t);
}
}
}
2.泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<Person> al1 = new ArrayList<Person>();
al1.add(new Person("zhangsan"));
al1.add(new Person("lisi"));
al1.add(new Person("wangwu"));
ArrayList<Student> al2 = new ArrayList<Student>();
al1.add(new Student("xuesheng1"));
al1.add(new Student("xuesheng2"));
al1.add(new Student("xuesheng3"));
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<Person> al){
// 此处相当于ArrayList<Person> al = ArrayList<Student> al2
// 错误提示:
// 需要: ArrayList<Person>
// 找到: ArrayList<Student>
// 原因: 无法通过方法调用转换将实际参数ArrayList<Student>转换为ArrayList<Person>
Iterator<Person> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<Person> al1 = new ArrayList<Person>();
al1.add(new Person("zhangsan"));
al1.add(new Person("lisi"));
al1.add(new Person("wangwu"));
ArrayList<Student> al2 = new ArrayList<Student>();
al1.add(new Student("xuesheng1"));
al1.add(new Student("xuesheng2"));
al1.add(new Student("xuesheng3"));
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<? extends Person> al){
Iterator<? extends Person> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
3. ? super E: 可以接收E类型或者E的父类型。下限
import java.util.*;
class Gen{
public static void main(String[] args){
//注意TreeSet的构造方法:Comparator里面比较的可以是E或者E的父类
//TreeSet(Comparator<? super E> comparator)
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("zhangsan"));
ts.add(new Student("a"));
ts.add(new Student("bcd"));
printColl(ts);
}
public static void printColl(TreeSet<? extends Person> ts){
Iterator<? extends Person> it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
//注意TreeSet的构造方法:
//TreeSet(Comparator<? super E> comparator)
//Comparator里面比较的可以是E或者E的父类
//此例中比较器比较的是Student的父类
class Comp implements Comparator<Person>{
public int compare(Person p1,Person p2){
return p1.getName().compareTo(p2.getName());
}
}
第二讲 Collections
一、概述
Collections是对集合框架的一个工具类。它里边的方法都是静态的,不需要创建对象。并未封装特有数据。
在Collections工具类中大部分方法是用于对List集合进行操作的,如比较,二分查找,随机排序等。
二、常见操作
1、查找
T max(Collection<? extends T> coll);//根据集合的自然顺序,获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序,获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
2、替换
void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
3排序:
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4、反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器,强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp);//返回一个比较器,强行逆转了指定比较器的顺序
5、同步的集合
List<T> synchronizedList(List<T> list);//返回支持的同步(线程安全的)List集合
Map<K,V> synchronizedList(Map<K,V> m);//返回支持的同步(线程安全的)Map集合
三、Collections和Collection的区别
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口:
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序,二分查找等方法
通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
/*
需求:使用Collections中的方法fill对List集合中的部分元素进行替换
思路:1、将List集合中要替换的部分元素取出,并存入另一集合中
2、将原集合中的要替换元素移除
3、用fill将要替换的元素进行替换
4、将取出的部分增加进集合
*/
import java.util.*;
class FillTest
{
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("ab");
list.add("abcd");
list.add("a");
list.add("abcde");
try
{
fillSome(list,1,5,"shenma");
}
catch (InputException e)
{
System.out.println(e.toString());
}
System.out.println(list);
}
//替换部分元素方法
public static void fillSome(List<String> list,int start,int end,String s)throws InputException
{
if(start>=end)
throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start,则抛出异常
//定义一个新集合
List<String> li=new ArrayList<String>();
//因为每移除一次,后面的元素就会补上,所以这里用y来控制次数
for (int x=start,y=start;y<end ; y++)
{
li.add(list.get(x));//将需要替换的元素增加到新集合
list.remove(x);//移除需要替换的元素
}
Collections.fill(li,s);//替换成需要的元素s
list.addAll(start,li);//将替换的部分增加进原集合
}
}
//自定义异常
class InputException extends Exception
{
InputException(String Massage)
{
super(Massage);
}
}
第三讲 Arrays
一、概述
Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
把数组变成List集合的好处:可以使用集合的思想和方法来操作数组中的元素。如:contains,get,indexOf,subList等方法。
二、常见方法
1、Lsit<T> asList(T... a);//将数组转换为集合
注意:
a、将数组转换成集合,不可使用集合的增删方法,因为数组的长度是固定的。如果进行增删操作,通过编译,但运行时会因产生UnsupportedOperationException异常而中断运行。
b、如果数组中的元素都是对象,则变成集合时,数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
2、binarySearch():二分查找方法,fill():替换方法,sort():排序方法等
特点:可对数组元素进行相应操作,可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数,且还可以对指定元素的范围,并可根据指定比较器进行相应的操作。
如:sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString();//可以接收各种数组类型参数,并返回指定数组内容的字符串表现形式。
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
int[] arr = {2,4,5};
String s = Arrays.toString(arr);
sop(s);
//把数组变成list集合有什么好处?
/*
可以使用集合的思想和方法来操作数组中的元素。
注意:将数组变成集合,不可以使用集合的增删方法。
因为数组的长度是固定。
contains。
get
indexOf()
subList();
如果你增删。那么会反生UnsupportedOperationException */
String[] ss = {"aaa","bbb","ccc"};
List ls = Arrays.asList(ss);
sop("contains:"+ls.contains("bbb"));
sop("indexof:"+ls.indexOf("bbb"));
// ls.add("UnsupportedOperationException");
/*
如果数组中的元素是对象。那么变成集合时,集合中的元素与数组元素类型相同。
如果数组中的元素是基本数据类型,变成集合时,该数组作为集合中的唯一元素存在。
*/
int[] numbers = {2, 5, 7};
List lnumbers = Arrays.asList(numbers);
sop(lnumbers);//[[I@19e0bfd] List内的元素类型为 int[] 类型
Integer[] num = {2, 5, 7};
List list = Arrays.asList(num);
sop(list);//[2, 5, 7] List内的元素类型为Integer
}
}
/*
集合变数组。
Collection接口中的toArray方法。
*/
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("a");
list.add("b");
list.add("c");
list.add("d");
/*
1,指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size,就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2,为什么要将集合变数组?
为了限定对元素的操作。不需要进行增删了。
*/
String[] ss = list.toArray(new String[5]);
sop(Arrays.toString(ss));
}
}
2. 增强for循环
高级for循环
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{ }
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的动作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢?
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候,还是希望是用传统for。因为传统for可以定义脚标。
/*
例子:用增强for循环遍历HashMap
*/
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
Map<String , Integer> map = new HashMap<String , Integer>();
map.put("abc", 11);
map.put("def", 12);
map.put("hjk", 13);
Set<String> set = map.keySet();
//Iterator<String> it = set.iterator();
for(String s : set){
sop("key: "+ s + " value: "+map.get(s));
}
for(Map.Entry<String, Integer> entry : map.entrySet()){
sop(entry.getKey()+" "+entry.getValue());
}
}
}