(10)Java泛型-Map集合-集合框架工具类-可变参数-静态导入

--

部分1.5新特性Java泛型-Map集合-集合框架工具类

泛型

概述：

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

对于泛型可以这样理解：

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

好处：

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

2， 避免了强制转换的麻烦。

泛型格式：

通过<>来定义要操作的引用数据类型。

放到返回类型的前面，修饰符的后面不然会报错

示例：ArrayList<String> al = new ArrayList<String>();

泛型类

什么是泛型类，简单的说就是带泛型的类。

在泛型出现之前，比如对于定义工具类，接收的类型不一样，比较通用的方法是采用多态的形式来实现。因为要让任意类的实例都可以使用所以设置所有类的父类Object。

示例：

class Student{}class Worker{}class Tool{private Object obj;public void setObject(Object obj){this.obj = obj;}public Object getObject(){return obj}}class  {public static void main(String[] args) {Tool t = new Tool();t.setObject(new Student());Student s = (Student)t.getObject()//需要对其向下转型object转student//t.setObject(new worker());//Student s = (Student)t.getObject()就会报类型转换错误异常}}

因为早期使用Object来完成扩展，后面还需要对其转型使用，若不注意容易导致编译时期JVM看不出来问题但是用户运行时会报错。

所以在JDK1.5升级后我们就可以定义泛型类实现，原理一样。

示例：

class Student{}class Worker{}class Tool<W>{private W w;public void setW(W w){this.w = w;}public W getW(){return w;}}class  {public static void main(String[] args) {Tool<Student> t = new Tool Student> ()<;　　//加上泛型由我们指定哪个类型来使用工具类t.setW(new Student());Student s = t.getW();//不用再强转。}}

那什么时候定义泛型类？

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

泛型除了定义在类上还可以定义在方法上

泛型方法：

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

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

示例：

lass Demo{public <T> void show(T t)//泛型定义在方法上{System.out.println("Hello show!"+t);}public <T> void run(T t)//泛型定义在方法上{System.out.println("Hello run!"+t);}}class FanXingDemo {public static void main(String[] args) {Demo d = new Demo();d.show("kj");d.show(3);d.run(3);}}

使用泛型方法，你传什么类型他就是什么类型了

注意：静态方法不可以访问类上定义的泛型。

为什么？因为Demo<T>类上的T是new对象后才能明确，静态方法使用时，对象还没有建立所以就不能使用。

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

泛型接口代码示例：

Interface Iner<T>{Void show(T t);}Class InerImp<T> implements Iner<t>{Public void show(T t){System.out.println(“show:”+t);　　}}Class FanXingDemo2{Public static void main(Sting[] args){InerImp<String> in = new InerImp<String> ();In.show(“rtyu”);　　}}

泛型高级应用

泛型限定：是用于泛型的扩展用的。

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

？ extends E：可以接收E类型或者E 的子类型，向上限定。

？ super E：可以接收E类型或者E的父类型，向下限定。

示例：

import java.util.*;class Person{private String name;Person(String name){this.name = name;}public String getName(){return name;}}class Student extends Person{Student(String name){super(name);}}class FanXingDemo3{public static void main(String[] args) {ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("lisi"));al.add(new Person("lisi"));al.add(new Person("lisi"));al.add(new Person("lisi"));getIt(al);ArrayList<Student> al1 = new ArrayList<Student>();al1.add(new Student("lisi1"));al1.add(new Student("lisi2"));al1.add(new Student("lisi3"));al1.add(new Student("lisi4"));getIt(al1);}public static void getIt(Collection< ?extends Person> al){for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){System.out.println(it.next().getName());}}}

泛型限定2

如：在TreeSet集合中，需要对其存储对象比较

若只是指定当前类型就只能比较当前对象，

但是指定他们的父类型，就都可以指定了，不用再多写比较器了

示例：

import java.util.*;class Person{private String name;Person(String name){this.name = name;}public String getName(){return name;}}class Student extends Person{Student(String name){super(name);}}class Worker extends Person{Worker(String name){super(name);}}class Cmp implements Comparator<Person>{//定义比较器，若只是指定当前类型就只能比较当前对象，//但是指定他们的父类型，就都可以指定了，不用再多写比较器了public int compare(Person p1,Person p2){return p1.getName().compareTo(p2.getName());}}class Demo {public static void main(String[] args) {TreeSet<Person> al = new TreeSet<Person>(new Cmp());al.add(new Person("lisi2"));al.add(new Person("lisi3"));al.add(new Person("lisi4"));al.add(new Person("lisi2"));getIt(al);TreeSet<Student> al1 = new TreeSet<Student>(new Cmp());al1.add(new Student("lisi1"));al1.add(new Student("lisi23"));al1.add(new Student("lisi43"));al1.add(new Student("lisi64"));getIt(al1);}public static void getIt(Collection< ?extends Person> al){for (Iterator<?extends Person> it = al.iterator();it.hasNext() ; ){System.out.println(it.next().getName());}}}打印结果：

Map集合

概述：

Map<K,V>，Map集合和Collection接口一样是顶层接口。

基本特点：

该集合是存储键值对，是一对一对忘集合里面存储，而且要保证键的唯一性。

常用方法：

添加：

1， put(K ket,Value) 添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原     有键对应值，并put方法会返回被覆盖的值。

2， putAll(Map<? Extends K,?extends V> m)添加一个集合

删除：

1， clear()清空

2， remove(Objet key) 删除集合里的指定元素

判断：

1， containsValue(Obect value)判断指定值是否存在

2， containsKey(Object key)判断指定键是否存在

3， isEmpty()判断是否为空

获取：

1， V get(Object obj)通过键获取值

2， size()获取集合长度

3， Collection<V>values()返回此集合中所有的值，返回类型是一个集合

Set<Map.entry<K,V>>entrySet()返回包含的映射关系视图

Set<K>keyset();返回映射中包含的键Set视图。

Map集合的子类

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键，集合是线程同步的。JDK1.0效率第。

|--HashMap:底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。JDK1.2效率高

|--TreeMap;底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

注意：

1， 在添加元素，如果出现添加时相同的键，那么后添加的值会覆盖原有键对应的值。并put方法会返回被覆盖的值。

2， 在通过get方法的返回值来判断一个键是否存在，通过返回null来判断。

Map集合的两种取出方式：

方式一：

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

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

示例：

import java.util.*;class  MapDemo1{public static void main(String[] args) {HashMap<String,String>map = new HashMap<String,String>();map.put("lisi","22");map.put("zhangsan","34");map.put("wangwu","56");map.put("xiaoba","11");Set<String>keyset = map.keySet();//把map集合里的所有键取出。Iterator<String>it = keyset.iterator();while (it.hasNext()){String key = it.next();//获取每一个键String value = map.get(key);//根据键获取值。System.out.println("key:"+key+"value:"+value);}}}

方式二：

Set<Map.Entry<k,v>> entrySet()：将map集合的映射关系存入到了set集合中，而这个关系的数据类型就是Map.Entry，我们可以根据这个关系来获取键和对应的值。

简单说：关系是结婚证，可以根据结婚证来获取丈夫和妻子。

示例：

import java.util.*;class  MapDemo2{public static void main(String[] args) {HashMap<String,String>map = new HashMap<String,String>();map.put("lisi","22");map.put("zhangsan","34");map.put("wangwu","56");map.put("xiaoba","11");//通过entrySet()方法，获取器映射关系即Map.Entry,同时还要知道键值的泛型是String类型Set<Map.Entry<String,String>> sme = map.entrySet();//迭代取出关系，返回类型一样Iterator<Map.Entry<String,String>> it = sme.iterator();while (it.hasNext()){Map.Entry<String,String> me = it.next();String key = me.getKey();取出键String value = me.getValue();取出值System.out.println("key:"+key+"value:"+value);}}}

深入分析：

为什么映射关系的类型是Map.Entry?

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

interface Map{public static interface Entry{public abstract Object getKey();public abstract Object getValue();}}

为什么把Entry定义成Map的内部接口？

因为Entry代表一种关系，但是现有Map才有关系，是属于Map的内部事物，所以才定义成内部规则。比如，心脏是人体内的事物，必须要定义内部规则，一样道理。

Map练习：

*需求：每一个学生都有一个对应的归属地，学生Student，地址String学生属性：姓名，年龄注意姓名和年龄相同的视为同一个学生，保证唯一性*/import java.util.*;class Student implements Comparable<Student>{//实现Comparable接口并定义泛型private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public int compareTo(Student s){//复写compareTo方法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*77;}public boolean equals(Object obj){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 HashMapDemo3{public static void main(String[] args) {HashMap<Student,String> hm = new HashMap<Student,String>();hm.put(new Student("lisi1",33),"beijing");hm.put(new Student("lisi2",23),"shanghai");hm.put(new Student("lisi3",11),"wuhan");hm.put(new Student("lisi4",44),"sichuan");hm.put(new Student("lisi5",22),"beijing");//第一种取出方式Set<Student>ss1 = hm.keySet();//将学生键存储进集合Iterator<Student> it1 = ss1.iterator();while (it1.hasNext()){Student key = it1.next();String value = hm.get(key);System.out.println(key+"地址是："+value);}//第二种取出方式Set<Map.Entry<Student,String>> ss2 = hm.entrySet();Iterator<Map.Entry<Student,String>> it2 = ss2.iterator();while (it2.hasNext()){Map.Entry<Student,String> myentry = it2.next();Student stu = myentry.getKey();String str = myentry.getValue();System.out.println(stu+"地址是      ："+str);}}}

打印结果如图：

如果需要对学生对象进行年龄进行升序排序。我们可以加入比较器，因为数据是以键值对形式存在的，所以要使用可以排序的Map集合，TreeMap

练习：

/*

需求：获取字符串中字母出现的次数，“qwertyuiasdfghjqwertyusdfghjsdf”

希望打印结果是a(1)c(2).....

通过结果发现每一个字母都对应相应的次数，说明字母和次数键存在映射关系

这时需要使用Map集合

思路：

1，因为要对每一个字母操作，所以需要字符串转成字符数组

2，对应map集合，因为打印结果的字母有顺序，所以使用trremap集合

3，遍历数组，将每一个字母作为键去map集合中查找

若返回null就将字母和1存入map集合

若返回！null说明该字母在集合中有对应的次数那么就将该次数自增一次，

再存入map集合覆盖原有次数

4，将map集合中的数据转变成指定字符串输出。

*/

import java.util.*;class MapDemo4{public static void main(String[] args) {String s = Demo_1("qwertyuqwertyusdfsgdsdsfsdf");System.out.println(s);}public static String Demo_1(String str){//将传进来的字符串转成字符数组char[] ch = str.toCharArray();//建立TreeMap集合，因为不能接受基本数据类型，所以使用数据包装类。TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();int count = 0;//计数器记录次数for (int x=0;x<ch.length ;x++ ){//遍历到的数据不是字母时，就继续循环if(!(ch[x]>='a'&&ch[x]<='z')||((ch[x]>='A'&&ch[x]<='Z')))continue;//根据键获取值Integer value = tm.get(ch[x]);//若值不为null将自增后的次数赋值if (value!=null)count = value;//如果值为nullcount++;tm.put(ch[x],count);count=0;//清零}//定义缓冲区存储键和值StringBuilder sb = new StringBuilder();//将键值映射关系存储进集合Set<Map.Entry<Character,Integer>> s = tm.entrySet();Iterator<Map.Entry<Character,Integer>> it = s.iterator();//取出映射关系while (it.hasNext()){Map.Entry<Character,Integer> ss = it.next();Character key = ss.getKey();Integer value = ss.getValue();sb.append(key+"("+value+")");//添加进缓冲区}return sb.toString();}}打印结果如图：

Map集合的扩展知识

因为map集合具备映射关系，而在实际中许多都是一对多的关系，比如一个学校对应多个班级，一个班级对应多个学生对象，一个学生对象对应其多个属性。这样的映射关系，就形成了一个映射体系。相当于大集合套小集合，把小集合作为映射的对象

示例：

班级对应学生

"yureban" student("01","wangwu")

"yureban" student("01","zhouqi")

 

"jiuyeban" student("12","lisi")

"jiuyeban" student("13","zhangsan")

学校对应班级

"czbk" "yureban"

"czbk" "jiuyeban"

打印全校学生的信息：

import java.util.*; class Demo5{public static void main(String[] args) {//预热班学生集合HashMap<String,String>yureban = new HashMap<String,String>();//就业班学生集合HashMap<String,String>jiuyeban = new HashMap<String,String>();//学校班级集合HashMap<String,HashMap<String,String>>czbk = new HashMap<String,HashMap<String,String>>();//添加班级进学校班级集合czbk.put("yureban",yureban);czbk.put("jiuyeban",jiuyeban);//添加预热班学生进集合yureban.put("01","wangwu");yureban.put("02","zhouqi");//添加就业班学生进集合jiuyeban.put("12","lisi");jiuyeban.put("13","zhangsan");getAllStudent(czbk);}//定义一个获取全部学生信息的集合,public static void getAllStudent(HashMap<String,HashMap<String,String>> hm){Iterator<String> it1 = hm.keySet().iterator();while (it1.hasNext()){//返回班级名称String s = it1.next();System.out.println(s+"：");//返回班级学生集合HashMap<String,String> hs = hm.get(s);getStudent(hs);}}public static void getStudent(HashMap<String,String> hm){Iterator<String> it2 = hm.keySet().iterator();while (it2.hasNext()){//返回学生姓名String name = it2.next();//返回学生idString id = hm.get(name);System.out.println(name+":"+id);}}}打印结果：

集合框架工具类之Conllections

概述：

Conllections是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。

在Conllections工具类中，大部分方法是用于对List集合进行操作。

常见特有操作

查找：

1，T max(Conllectin<? extends T>coll);根据coll集合里面的自然顺序查找集合里的最大元素。

2，T max(Conllection<? extends T>coll,Comparator<? Super T>comp);根据指定的comp比较器查找coll集合里的最大元素。

替换：

1， void fill(List<? Super T>list,T obj);将list集合里的全部元素替换成指定对象obj。

2， boolean replaceAll(List<T>list,T oldvalue,T newvalue);把list集合中的旧值用新值替换

3， void swap(List list,int I,int b);指定列表集的指定两个位置进行置换。

排序：

1， void shuffle(List<T> list);对指定list集合中的元素进行默认随机排序。

2， void sort(List<T> list);对指定list集合中的元素进行自然顺序的排序。

3， void sort(List<T> list,Comparator<?super T>comp);根据指定比较器的排序方式来对指定list集合进行排序。

反转：

1， reverse(List<?> list);对指定list集合进行反转。

2， Comparator reverseOrder();返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

3， Comparator reverseOrder(Comparator<T> comp)；返回一个比较器，强行逆转了指定比较器的顺序

集合同步：

通常常用的集合都是不安全的，因为高效，如果多线程要操作这些集合，可以通过Collections提供的同步方法，将线程不安全的集合转换成安全的。

1， List<T>synchronizedList(List<T> list);返回支持的同步（线程安全的）List集合。

2， Map<K,V>synchronizedList(Map<K,V> m);返回支持的同步（线程安全的）Map集合。

示例练习：

/*

需求：对指定list集合中的指定部分元素进行替换，

  要求使用Collections中的fill方法。

分析：

1，需要对集合指定的部分元素取出，存储进新的集合

2，使用fill方法对新集合的元素进行替换

3，新集合的元素添加进list集合。

*/

import java.util.*;class  FillDemo{public static void main(String[] args) {ArrayList<String>list = new ArrayList<String>();list.add("rytuy");list.add("fdsd");list.add("yrt");list.add("cv");//替换前集合System.out.println(list);//对集合指定部分替换fillSome(list,0,2,"java");//替换后集合System.out.println(list);}public static void fillSome(List<String>list,int start,int end,String str){if(start>end)throw new RuntimeException("插入位置非法");//定义临时集合List<String> list1 = new ArrayList<String>();//获取list集合中指定的要置换的元素//因为在start取一个，后面的一个就变成了start，而让y控制次数for (int x=start,y=start;y<=end ;y++){//获取一个就往临时集合存储一个list1.add(list.get(x));//移除list集合需要替换的元素list.remove(x);}//将临时集合的元素替换Collections.fill(list1,str);//从start位置开始把临时集合里的元素插入进原集合list.addAll(start,list1);}}打印结果如图：

集合框架工具类之Arrays

概述

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

Arrays是集合框架中的一个工具类，该工具内的方法都是静态方法，不需要创建对象，没有封装特有数据。

常见方法：具体查看API文档java.util.Arrats类的方法

binarySearch():使用二分查找

copyOf():

copyOfRange():

deepToString():如果两个指定数组彼此是深层相等 的，则返回 true。

equals()判断某类型数组彼此是否相等

fill()将指定的某类型值分配给某类型数组

hashCode():对指定数组内容返回哈希码值

sort():对指定的数组进行排序

toString();将指定数组内容以字符串形式返回

数组变集合

static<T> List<T> asList(T…a);将指定数组转变为集合

注意：

1， 将谁转换成集合，不可以使用集合的增删方法，因为数组的长度是固定了。如果进行了增删操作，会发生不可以操作异常UnsupportedOperationException

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

3， 如果数组中的元素是基本数据类型，那么变成集合时，数组将作为集合元素存在。

示例：

import java.util.*;class ArraysDemo {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {asListDemo();}public static void asListDemo(){//字符串数组转集合String[] str = {"wer","sdg","java","array","nihao"};List list = Arrays.asList(str);sop(list);/*基本数据类型不能转集合int[] in = {1,2,3,4,5};List list = Arrays.asList(in);sop(list);*/}}

集合变数组

Collection接口中的toArray方法

<T> T[] toArray(T[] a);返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

注意：

1， 指定类型的数组到底要定义多长呢？

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

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

2， 为什么将集合变数组？

为了限定对元素的操作。不需要进行增删了。和数组变集合道理一样。

示例：

import java.util.*; class  CollectionToArray{     public static void main(String[] args){         ArrayList<String> al = new ArrayList<String>();{        al.add("abc1");          al.add("abc2");         al.add("abc3");         //将集合变为String数组         String[] arr = al.toArray(new String[al.size()]);         //利用Arrays操作数组的方法         System.out.println(Arrays.toString(arr));     } }

1.5版本新特性

增强for循环

用于对集合的遍历，和iterator功能类似，他的底层结构还是iterator，是为了简化书写。 

格式：

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

{执行语句}

注意：

高级for循环对集合进行遍历时，只能获取集合元素，但是不能对集合进行操作。

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

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

传统for和高级for有神马区别？

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

建议在遍历数组的时候，还是希望用传统for，因为传统for可以定义角标。

示例：

import java.util.*;class  AdvForDemo{public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {HashMap<Integer,String> hs = new HashMap<Integer,String>();hs.put(1,"java1");hs.put(2,"java2");hs.put(3,"java3");hs.put(4,"java4");getFor_1(hs);getFor_2(hs);}public static void getFor_1(HashMap<Integer,String> is){//用keySet方法取出键Set<Integer>keyset = is.keySet();for (Integer i: keyset){String value = is.get(i);sop(i+":"+value);}}public static void getFor_2(HashMap<Integer,String> is2){//用entrySet方法取出键值for(Map.Entry<Integer,String> keyset2:is2.entrySet()){Integer in = keyset2.getKey();String str = keyset2.getValue();sop(in+":       "+str);}}}

1.5版本新特性

可变参数

如果一个方法在参数列表中传入多个参数，当参数个数不确实时，每次都要重载其方法比较麻烦，这时可以用数组作为形式参数传入，但是每次还是要定义一个数组对象，所以在1.5版本后，java提供了一个新特性即可变参数。

其实可变参数就是数组参数的简写形式，不用每次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。他是隐式的将这些参数封装成了数组。

注意：

可变参数一定要定义在参数列表的最后面。

示例：

class  ParamMethodDemo{        public static void main(String[] args){            show("haha",2,3,4,5,6);        }        public static void show(String str,int... arr)//...就表示可变参数{            System.out.println(arr.length);        }    }  

1.5版本新特性

静态导入

静态导入类似于import导入java相关类，它导入的是静态成员，这样在编写程序时可以减少书写

格式：

import static java.util.Arrays.*;//导入了Arrays类中的所有静态成员。

Import static java.lang.System.*;//导入了System类中的所有静态成员。

注意：

1，当导入没有加上static时导入的是某一类  

当加上static时导入的是某一类中的静态成员。

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

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

示例：

import java.util.*;    import static java.util.Arrays.*; //导入了Arrays类中的所有静态成员。   import static java.lang.System.*; //导入了System类中的所有静态成员。      class  StaticImport    {        public static void main(String[] args){            out.println("haha");//省略书写System.            int[] arr = {3,1,5};                sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.                int index = binarySearch(arr,1);         out.println("Index="+index);               //当没有指定继承时，所以类默认继承了Object，           //因为toString方法object都具备，所以为了区分，必须写上具体调用者           System.out.println(Arrays.toString(arr));        }    }

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net