黑马程序员----java基础--集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

　　面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。数组很难对其数据进行操作，而集合可以很方便对存储的对象进行增删改查等操作。可以说集合比数组功能更加强大而且使用起来也更加方便。所以我们有必要深入的学习一下集合类。

集合的特点：

(1)、用于存储对象的容器

(2)、集合的长度是可变的

(3)、集合中不可以存储基本数据类型值

(4)、集合中存储的都是对象的引用(地址)

根据数据结构的不同，可以分为不同的集合(容器)。下图是集合框架构成图。

从途中可以看出集合类主要分为两大接口：1、Collection接口 2、Map接口。

Collection接口

　　|--List集合：元素都是有序的(存入和取出的顺序一致)，元素是可以重复的，因为该集合体系具有索引。

　　　　|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度快，但增删稍慢，线程不同步。

　　　　|--LinkedList:底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步。

　　　　|--Vector:底层是数组数据结构，线程同步，已被ArrayList替代了，因为效率低。

　　|--Set集合：元素是无序的(存入和取出的顺序不一定一致)，元素不可重复。Set接口中的方法和Collection接口中的方法一致。

　　　　|--HashSet集合：底层数据结构是哈希表，线程不安全，不同步。

　　　　　　|--LinkedHashSet:底层是链式的哈希表，该集合特点：存入数据和取出数据顺序一致，而且元素不重复，线程不同步。

　　　　|--TreeSet:底层是二叉树数据结构，可以对Set集合中的元素进行排序，线程不同步。

Map接口

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

　　　　|--PRoperties集合:用来存储键值对型的配置文件的信息，可以和IO技术相结合。

　　|--HashMap集合：底层是哈希表数据结构，允许使用null键null值，该集合是不同步的。该集合替换了Hashtable集合，效率高。JDK1.2出现的。

　　　　|--LinkedHashMap集合：底层是链式的哈希表结构，使用LinkedHashMap存入和取出的顺序是一致的。

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

Java集合类大部分的都增加了泛型，已增加程序的安全性，以后会详细的介绍的。了解了集合类的大致下面我们具体的介绍这几大集合类。

Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

1、Collection集合集成体系:

　　|--Lsit

　　　　|--ArrayList

　　　　|--LinkedList

　　　　|--Vector

　　|--Set

　　　　|--HashSet

　　　　　　|--LinkedHashSet

　　　　|--TreeSet

2、Collection接口常见的方法

(1)、添加元素

1 boolean  add(Object obj);//往集合中添加元素2 boolean  addAll(Collection c);//将另一Collection集合中的所有元素添加进Collection集合中

(2)、删除元素

1 boolean  remove(Object obj);//删除指定元素2 boolean  removeAll(Collection  con);//调用者只保留另一集合中没有的元素3 void clear();//清空Collection集合全部元素

(3)、判断

1 boolean  contains(Object obj);//判断集合中是否包含指定元素2 boolean  containsAll();//判断此Collection集合中是否包含另一个Collection集合3 boolean  isEmpty();//判断集合是否有元素

(4)、获取

1 int  siez();//获取集合的大小,其实就是在判断集合是否为空2 Iterator<E>   iterator();//获取Collection集合的迭代器

(5)、获取交集

1 boolean   retainAll(Collection c);//调用者只保留两集合的共性元素

(6)、集合变数组

1 Object[]   toArray();//把集合转换成数组2  <T> T[]  toArray(T[] a);//把集合转换成数组

代码演示：

 1 import java.util.*; 2 class CollectionDemo  3 { 4     public static void main(String[] args)  5     { 6         //因为Collection是接口无法创建对象，所以找子类来创建对象，多态的应用。 7         Collection<String> c1=new ArrayList<String>(); 8         Collection<String> c2=new ArrayList<String>(); 9         add(c1);        10         addAll(c1,c2);11         remove(c1);12         removeAll(c1,c2);13     }14     //演示add方法15     public static void add(Collection<String> con){16         con.add("小明");17         con.add("赵四");18         con.add("王五");19         con.add("老王");20         con.add("黑马");21         con.add("安卓");22         //获取集合的大小23         System.out.println("size="+con.size());24         //打印一下集合25         System.out.println(con);26     }27     //演示addAll方法28     public static void addAll(Collection<String> co1,Collection<String>co2){29         co1.add("小明");30         co1.add("赵四");31         co1.add("王五");32         co1.add("钱峰");33 34         co2.add("黑马");35         co2.add("赵四");36         co2.add("钱峰");37         //将co2中的元素添加到co1中38         co1.addAll(co2);39         System.out.println("addAll:"+co1);40 41         //获取两个集合的交集，保留和指定的集合相同的元素42         co1.retainAll(co2);43         System.out.println("co1和co2取交集："+co1);44     }45     //演示remove方法46     public static void remove(Collection<String> con){47         con.add("小明");48         con.add("赵四");49         con.add("王五");50         con.add("老王");51         con.add("黑马");52         con.add("安卓");53         System.out.println(con.remove("老王"));54         System.out.println(con.remove("java"));55         System.out.println("remove:"+con);56 57         //清空集合58         con.clear();        59         //判断集合是否为空60         System.out.println("con是否为空:"+con.isEmpty());61     }62     //演示removeAll方法63     public static void removeAll(Collection<String> co1,Collection<String>co2){64         co1.add("小明");65         co1.add("赵四");66         co1.add("王五");67         co1.add("老王");68 69         co2.add("老王");70         co2.add("赵四");71         co2.add("钱峰");72         //从co1集合中删除与co2集合相同的元素73         co1.removeAll(co2);74         System.out.println("removeAll:"+co1);75     }76     77 }

3、Collection集合迭代器：Iterator<E>接口

迭代器：是一个接口。作用：用于取集合中的元素。

　　每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。

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

获取Collection集中中元素的三种方式：

 1 import java.util.*; 2 class CollectionDemo  3 { 4     public static void main(String[] args)  5     { 6         //因为Collection是接口无法创建对象，所以找子类来创建对象，多态的应用。 7         Collection<String> c=new ArrayList<String>(); 8         c.add("小明"); 9         c.add("黑马");10         c.add("安卓");11         c.add("小明");12         c.add("王五");13         //用Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。14         //这种方式比较占用内存，因为循环结束后it变量还在内存中没有被释放        15         Iterator<String> it=c.iterator();16         while (it.hasNext())17         {18             String name=it.next();19             System.out.println(name);20         }21         22         //建议使用这种方法，不消耗内存空间，it变量在for循环中，循环结束变量也就消失了23         for (Iterator<String> it=c.iterator();it.hasNext() ; )24         {　　　　　　　　//Iterator中不能使用add添加方法，因为没有该方法，只能删除(remove)25             System.out.println(it.next());26         }27         28         //这种方式是增强for循环，是Iterator迭代器的简写，但是这种方式有很大的弊端29         //如果遍历Collection集合过程中还需要对元素进行操作，比如删除，需要使用迭代器。30         for(String name:c){            31             System.out.println(name);32 33         }34 }

迭代注意事项

　　(1)、迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

　　(2)、迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

　　(3)、迭代器的next方法返回值类型是Object，所以要记得类型转换。加上泛型后则不需要转换。

List集合继承体系：

　　|--ArrayList

　　|--LinkedList

　　|--Vector

　　List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。

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

1、List集合特有的方法

(1)、添加

1 void  add(int index,E element);//在指定索引位置上添加元素2 void  addAll(int index,Collection<? extends E> c);//在指定索引位置上添加一堆元素

(2)、删除

1 Object  remove(int index);//删除指定索引位置上的元素

(3)、修改

1 Object  set(int index, E  element);//对指定索引位进行元素的修改

(4)、获取

1 Object  get(int index);//获取指定索引位置上的元素2 int  indexOf(Object obj);//获取指定元素第一次出现的索引位，如果该元素不存在返回-1；所以通过-1，可以判断一个元素是否存在。3 int  lastIndexOf(Object obj);//反向索引指定元素的位置。4 List  subList(int from,int to);//获取子列表,包含头不包含尾5 Iterator  listIterator();//List集合特有的迭代器6 Iterator  listIterator(int index);//从列表的指定位置开始返回List集合迭代器

注意：对于List集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的。所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。

代码演示：

 1 import java.util.*; 2 class ListDemo  3 { 4     public static void main(String[] args)  5     { 6         List<String> list=new ArrayList<String>(); 7         list.add("黑马"); 8         list.add("安卓"); 9         list.add("小明");10         list.add("王武");11         list.add("安卓");12         System.out.println("list:"+list);13         //在指定位置上添加元素14         list.add(3,"我爱黑马");15         System.out.println("listadd:"+list);16 17         //删除指定位置上的元素18         list.remove(4);19         System.out.println("listremove:"+list);20 21         //设置元素        22         System.out.println("listset:"+list.set(2,"我爱安卓"));23 24         //获取指定位置上的元素25         System.out.println("listget"+list.get(2));26 27         //获取元素第一次出现的位置。28         System.out.println("indexOf="+list.indexOf("安卓"));29 30         //获取子列表，包含头不包含尾31         System.out.println(list.subList(2,4));32     }33     34 }

2、List集合元素取出方式

(1)、List集合第一种取出方式：因为List集合有索引(角标)这个特殊的原因，所以List集合有自己特有的迭代方式，get方法。

 1 import java.util.*; 2 class ListIteratorDemo  3 { 4     public static void main(String[] args)  5     { 6         List<String> list=new ArrayList<String>(); 7         list.add("黑马"); 8         list.add("安卓"); 9         list.add(".NET");10         list.add("IOS");11         //用集合的长度做循环条件，get方法取出元素12         for (int x=0;x<list.size() ;x++ )13         {            14             System.out.println(list.get(x));15         }16     }17 }

(2)、List集合第二种取出方式：用Collection集合中的iterator()方法，这种方法有弊端只能遍历的过程中对集合删除操作。

 1 import java.util.*; 2 class ListIteratorDemo  3 { 4     public static void main(String[] args)  5     { 6         List<String> list=new ArrayList<String>(); 7         list.add("黑马"); 8         list.add("安卓"); 9         list.add(".NET");10         list.add("IOS");11         //Collection接口中的iterator方法。12         for (Iterator<String> it=list.iterator();it.hasNext() ; )13         {14             String s=it.next();15             if(s.equals("IOS")){16 //                list.add("JAVA");//ConcurrentModificationException异常，出现并发操作。17                 it.remove();//将IOS的引用从集合中删除了18             }19             System.out.println(s);20         }21 22     }23 }

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

(3)、List集合取出方式第三种方式：Lsit集合特有迭代器:ListIterator

ListIterator迭代器中的方法：

 1 import java.util.*; 2 class ListIteratorDemo  3 { 4     public static void main(String[] args)  5     { 6         List<String> list=new ArrayList<String>(); 7         list.add("黑马"); 8         list.add("安卓"); 9         list.add(".NET");10         list.add("IOS");11         //获取ListIterator迭代器对象12         for (ListIterator<String> li=list.listIterator();li.hasNext() ; )13         {14             //它可以实现在迭代过程中完成对元素的增删改查。15             //注意：只有list集合具备该迭代功能。16             String s=li.next();17             if(s.equals("IOS"))18                 li.add("JAVA");//增加元素19             if(s.equals(".NET"))20                 li.remove();//删除元素21             if(s.equals("安卓"))22                 li.set("JAVAEE");//修改元素23         }24         System.out.println(list);25 26     }27 }

1、ArrayList集合的方法和List集合的方法差不多一样。所以可参照List的方法。

2、LinkedList集合

LinkedList集合中特有的方法：

(1)、添加元素

1 addFirst();//将指定元素插入集合元素的开头2 addLast();//将指定元素插入集合元素的末尾

------JDK1.6版本后新的方法----------------

1 offerFirst();//与addFirst方法没有区别2 offerLast();//与addLast方法没有区别

(2)、获取但不删除元素

1 //获取但不删相互，如果链表为空，抛出NoSuchElementException2 E  getFirst();//返回此集合的第一个元素3 E  getLast();//返回此集合的最后一个元素

------JDK1.6版本后新的方法----------------

1 //获取但不移除，如果链表为空，返回null。2 peekFirst();3 peekLast();

(3)、获取并删除元素

1 //获取并移除，如果链表为空，抛出NoSuchElementException。2 E   removeFirst();//移除并返回此集合的第一个元素3 E   removeLast();//移除并返回此集合的最后一个元素

------JDK1.6版本后新的方法----------------

1 //获取并移除，如果链表为空，返回null;2 pollFirst();3 pollLast();

　　因为LinkedList中有特有的方法removeFirst()或者removeLast()(pollFirst、pollLast)，所以LinkedList有4种迭代的方法。一种是:Iterator，一种是：iterator，一种是for循环遍历get方法，一种是LinkedList特有的方法。

 1 //LinkedList特有取出方式 2 import java.util.*; 3 class LinkedListDemo  4 { 5     public static void main(String[] args)  6     { 7         LinkedList<String> list=new LinkedList<String>(); 8         list.add("黑马"); 9         list.add("安卓");10         list.add(".NET");11         list.add("IOS");12         while(!(list.isEmpty()))//通过判断集合是否为空来循环删除元素，知道为空停止循环13             System.out.println(list.removeFirst());    //获取元素并且删除元素    14     }15 }

3、Vector集合

(1)、Vector中特有的方法：

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

1 //获取枚举接口的方法2 Enumeration<E>   elements();//返回此集合的枚举

而Eumeration枚举接口中的方法:

1 boolean  hasMoreElements();//相当于Iterator中的hasNext()2 E  nextElement();//相当与Iterator中的next()

另外Collections集合工具类中也提供了Collection集合获取枚举接口的方法

1  static Enumeration< T>   enumeratio(Collection<T> c);//返回一个指定 collection 上的枚举。

代码演示：

 1 import java.util.*; 2 class VectorDemo  3 { 4     public static void main(String[] args)  5     { 6         Vector<String> v=new Vector<String>(); 7         v.add("黑马"); 8         v.add("安卓"); 9         v.add("IOS");10         v.add("JAVAEE");11 12         //用Iterator迭代器方法取出元素13         for (Iterator<String> it=v.iterator();it.hasNext() ; )14         {15             System.out.println(it.next());16         }17 18         //用Enumeration枚举的方法取出元素19         for (Enumeration<String> en=v.elements();en.hasMoreElements() ; )20         {21             System.out.println(en.nextElement());22         }23 24         //Collections.enumeration()方法获取枚举Enumeration接口25         for (Enumeration<String> en=Collections.enumeration(v);en.hasMoreElements() ; )26         {27             System.out.println(en.nextElement());28         }29     }30 }

4、List集合综合练习

(1)、请使用LinkedList来模拟一个堆栈或者队列数据结构。

　　堆栈：先进后出 First In Last Out FILO　　队列：先进先出 First In First Out FIFO

思路：应该自定义一个LinkedList类，把要LinkedList封装到自己的类中。

 1 import java.util.*; 2 class DuiLie 3 { 4     private LinkedList link; 5     //对象一初始化就创建了LinkedList集合 6     DuiLie(){ 7         link=new LinkedList(); 8     } 9     //队列的添加元素的功能。10     public void myAdd(Object obj){11         link.addFirst(obj);12     }13     //队列的删除元素的功能。14     public Object myRemove(){15         return link.removeLast();16     }17     //判断队列是否为空18     public boolean isNull(){19         return link.isEmpty();20     }21 22 }23 class DuiLieDemo24 {25     public static void main(String[] args) 26     {27         DuiLie dl=new DuiLie();28         dl.myAdd("黑马");29         dl.myAdd("IOS");30         dl.myAdd("安卓");31         dl.myAdd(".NET");32         dl.myAdd("JAVAEE");33         while (!(dl.isNull()))34         {35             System.out.println(dl.myRemove());36         }37 38     }39 }

(2)、将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象，同姓名同年龄，视为同一个人。为重复元素。

 1 /* 2 List集合中必须定义一个新的容器来过滤重复元素. 3 而set集合则不用，因为set集合是无序的，不可重复的。 4 */ 5 import java.util.*; 6 class Person 7 { 8     private String name; 9     private int age;10     Person(String name,int age)11     {12         this.name=name;13         this.age=age;14     }15     public void setName(String name){16         this.name=name;17     }18     public String getName(){19         return name;20     }21     public void setAge(int age){22         this.age=age;23     }24     public int getAge(){25         return age;26     }27     public String toString(){28         return "name="+name+"....."+"age="+age;29     }30     public boolean equals(Object obj){//即使使用了泛型，equals方法中的参数也是Object obj，31         if(!(obj instanceof Person))//因为复写的Object类中的方法,Object类的equals方法参数就是Object obj。32             throw new RuntimeException("类型转换异常");33         Person p=(Person)obj;34         return this.name.equals(p.name)&&this.age==p.age;//判断name和age是否相同35     }36 }37 class ArrayListDemo38 {39     public static void main(String[] args) 40     {41         List<Person> list=new ArrayList<Person>();42         list.add(new Person("黑马",120));43         list.add(new Person("安卓",110));44         list.add(new Person("IOS",45));45         list.add(new Person(".NET",97));46         list.add(new Person("JVAEE",12));47         list.add(new Person("IOS",45));48         list.add(new Person("黑马",120));49         //迭代原集合50         printCollection(list);        51         System.out.println("---去除重复元素后的集合---------");52         list=getSingleElement(list);53         printCollection(list);54 55     }56     public static List<Person> getSingleElement(List<Person> list){57         //1、定义一个临时容器用来装过滤后的数据58         List<Person> newList=new ArrayList<Person>();59         //2、迭代list集合60         for (Iterator<Person> it=list.iterator();it.hasNext() ;)61         {62             Person p=it.next();63         //3、判断被迭代到的元素是否在临时容器存在64         //contains方法内部依靠的是equals方法,其实remove方法也调用equals方法的   65             if(!(newList.contains(p)))66                 newList.add(p);67         }68         return newList;69 70     }71     //迭代器取出集合中的元素72     private static void printCollection(List<Person> list){73         for (Iterator<Person> it=list.iterator();it.hasNext() ; )74         {75             System.out.println(it.next());76         }77     }78 }

Set接口中的方法和Collection中方法一致的。Set集合元素不可重复且无序。Set接口取出方式只有一种：迭代器。

Set集合继承体系

　　|--HashSet

　　　　|--LinkedHashSet

　　|--TreeSet

 1 import java.util.*; 2 class  SetDemo 3 { 4     public static void main(String[] args)  5     { 6         //Set集合无需并且不可重复，方法和Collection方法一样 7         Set<String> set=new HashSet<String>(); 8         set.add("黑马");//添加元素 9         set.add("JAVAEE");10         set.add("安卓");11         set.add("IOS");12         set.add(".NET");13         set.add("JAVAEE");14         set.remove("IOS");//删除元素15 16         //Iterator迭代器取出元素17         for (Iterator<String> it=set.iterator();it.hasNext() ; )18         {19             System.out.println(it.next());20         }21     }22 }

(1)、HashSet集合

HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。

哈希表确定元素是否相同:因为集合本身不可重复的特点所以不用定义新的Set集合来存放不重复元素。(1)、 先判断的是两个元素的哈希值是否相同。如果相同，再判断两个对象的内容是否相同。

(2)、 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。如果哈希值不同，不需要判断equals。

判断HastSet集合中的元素是否相同，一般要复写对象的hashCode方法和equals方法。

哈希表的原理：

(1)、对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值 称为哈希值。

(2)、哈希值就是这个元素的位置。

(3)、如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。

(4)、存储哈希值的结构，我们称为哈希表。

(5)、既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。

需求：往HashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人，视为相同元素。

 1 /* 2 如果姓名和年龄相同，视为同一个人，视为相同元素 3 */ 4  5 import java.util.*; 6 class Person 7 { 8     private String name; 9     private int age;10     Person(String name,int age)11     {12         this.name=name;13         this.age=age;14     }15     public void setName(String name){16         this.name=name;17     }18     public String getName(){19         return name;20     }21     public void setAge(int age){22         this.age=age;23     }24     public int getAge(){25         return age;26     }27     public String toString(){28         return "name="+name+"....."+"age="+age;29     }30     public int hashCode(){//复写了hashCode方法31         return name.hashCode()+age*37;32     }33     public boolean equals(Object obj){//即使使用了泛型，equals方法中的参数也是Object obj，34         if(!(obj instanceof Person))//因为复写的Object类中的方法,Object类的equals方法参数就是Object obj。35             throw new RuntimeException("类型转换异常");36         Person p=(Person)obj;37         return this.name.equals(p.name)&&this.age==p.age;//建立了自己的比较方式38     }39 }40 class HashSetDemo41 {42     public static void main(String[] args) 43     {44         Set<Person> set=new HashSet<Person>();45         set.add(new Person("黑马",98));46         set.add(new Person("安卓",76));47         set.add(new Person("IOS",67));48         set.add(new Person(".NET",34));49         set.add(new Person("JAVAEE",21));50         set.add(new Person("IOS",67));51         set.add(new Person("安卓",76));52         for (Iterator<Person> it=set.iterator();it.hasNext() ; )53         {54             System.out.println(it.next());55         }56     }57 }

2、LinkedHashSet集合

LinkedHashSet这个集合不仅存入的顺序和取出的顺序一致，并且该集合可以自动去除重复元素。

需求：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}

 1 import java.util.*; 2 class LinkedHashSetDemo 3 { 4     public static void main(String[] args)  5     { 6         int[] arr={4,2,4,6,1,2,4,7,8}; 7         Integer[] in=getSingleElement(arr); 8         for (int x=0;x<in.length ;x++ ) 9         {10             if(x<in.length-1)11                 System.out.print(in[x]+",");12             else13                 System.out.print(in[x]);14         }15 16     }17     public static Integer[] getSingleElement(int[] arr){18         //无序变有序,并且去重19         LinkedHashSet<Integer> lhs=new LinkedHashSet<Integer>();20         for (int x=0;x<arr.length ;x++ )21         {22             lhs.add(arr[x]);23         }24         //集合变成数组返回25         return (Integer[])lhs.toArray(new Integer[lhs.size()]);26     }27 }

3、TreeSet集合

用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。如果元素不具备比较性，在运行时会发生ClassCastException异常。

TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否为0，是0就是相同元素，不存。

TreeSet集合排序的两种方式：

(1)、TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo(T)方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。

(2)、TreeSet的第二种排序方式：让集合具备比较性。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。集合需要传入比较器(Comparator接口)，让集合具备比较行为。定义一个Comparator的子类对象，复写compare(T o1, T o2)方法。 将该类对象作为参数传递给TreeSet集合的构造函数。如果自定义类实现了Comparable接口，并且TreeSet的构造函数中也传入了比较器，那么将以比较器的比较规则为准。记住，排序时，当主要条件相同时，一定判断一下次要条件。Comparable<T>、Comparator<T>都带着泛型的。第二种方式较为灵活。

注：只有TreeSet和TreeMap集合的构造函数能接收Comparator比较器。

需求：往TreeSet集合中存储Student对象，并按照学生的姓名排序。

第一种方式：让学生自身具备比较性，实现Comparable接口,复写compareTo方法

 1 import java.util.*; 2 class Student implements Comparable<Student> 3 { 4     private String name; 5     private int age; 6     Student(String name,int age){ 7         this.name=name; 8         this.age=age; 9     }10     public void setName(String name){11         this.name=name;12     }13     public String getName(){14         return name;15     }16     public void setAge(int age){17         this.age=age;18     }19     public int getAge(){20         return age;21     }22     public String toString(){23         return "name="+name+"....."+"age="+age;24     }25     //复写Comparable接口的compareTo方法26     public int compareTo(Student stu){27         int num=this.name.compareTo(stu.name);//先按照姓名排序，如果姓名相同然后再按照年龄排序28         if(num==0)29             return new Integer(this.age).compareTo(new Integer(stu.age));//按照年龄排序30         return num;31     }32 }33 class TreeSetDemo 34 {35     public static void main(String[] args) 36     {37         Set<Student> set=new TreeSet<Student>();38         set.add(new Student("黑马",120));39         set.add(new Student("安卓",43));40         set.add(new Student("IOS",87));41         set.add(new Student(".NET",21));42         set.add(new Student("JAVAEE",12));43         set.add(new Student("php",98));44         set.add(new Student("黑马",34));45         for (Iterator<Student> it=set.iterator();it.hasNext() ; )46         {47             System.out.println(it.next());48         }49     }50 }

第二种方式：学生自身不具备比较性，这时候就可以定义一个类实现Comparator接口，覆盖compare(T o1, T o2)方法。

 1 //Student类接上例 2 //实现Comparator接口，复写compare方法。比较器 3 class StuComparator implements Comparator<Student> 4 { 5     public int compare(Student s1,Student s2){ 6         int num=s1.getAge()-s2.getAge();//先按照年龄排序 7         if(num==0) 8             return s1.getName().compareTo(s2.getName());//年龄相同的再按照姓名排序 9         return num;10     }11 }12 class TreeSetDemo 13 {14     public static void main(String[] args) 15     {16         Set<Student> set=new TreeSet<Student>(new StuComparator());//两种方式同时存在以比较器为主17         set.add(new Student("黑马",120));18         set.add(new Student("安卓",43));19         set.add(new Student("IOS",87));20         set.add(new Student(".NET",21));21         set.add(new Student("JAVAEE",12));22         set.add(new Student("PHP",98));23         set.add(new Student("黑马",34));24         for (Iterator<Student> it=set.iterator();it.hasNext() ; )25         {26             System.out.println(it.next());27         }28     }29 }

练习：对字符串进行长度排序。

 1 import java.util.*; 2 class LenComparator implements Comparator<String> 3 { 4     public int compare(String s1,String s2){ 5         int num=s1.length()-s2.length();//按照长度排序 6         return (num==0)?s1.compareTo(s2):num;//如果长度相同，按照字符串自然排序 7     } 8 } 9 class StringLength 10 {11     public static void main(String[] args) 12     {13         TreeSet<String> ts=new TreeSet<String>(new LenComparator());14         ts.add("aaaa");15         ts.add("zz");16         ts.add("nbag");17         ts.add("cba");18         ts.add("abc");        19         for (Iterator it=ts.iterator();it.hasNext() ; )20         {21             System.out.println(it.next());22         }23 24     }25 }

Map集合该集合存储键值对。一对一对往里存。而且要保证键的唯一性。Map也称为双列集合;Collection集合称为单列集合，Collection一次存一个元素。和Set很像,Set底层就是使用了Map集合。

Map集合继承体系：

　　|--Hashable

　　　　|--Properties

　　|--HashMap

　　　　|--LinkedHashMap

　　|--TreeMap

1、Map集合常用方法

(1)、添加元素

1 Value  put(key,value);//返回前一个和key关联的值，如果没有返回null。如果出现添加相同的键，那么后添加的值会覆盖原有键对应的值，并且put方法会返回被覆盖的值

(2)、删除

1 void  clear();//清空map集合2 value  remove(Object key);//根据指定的key删除这个键值对

(3)、判断

1 boolean  containsKey(key);//判断集合中是否存在指定的键2 boolean  containsValue(value);//判断集合中是否存在指定的值3 boolean  isEmpty();//判断集合是否为null

(4)、获取

1 value  get(Key);//通过键获取值，如果没有该键返回null，可以通过返回null来判断是否存在指定键。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。2 int  size();//获取键值对个数，也就是Map集合的长度3 Set<Key>  keySet();//返回Set集合，该集合中存放的是Map集合中的全部键(Key)的值4 Set<Map.Entry<Key,Value>>  entrySet();//返回Set集合，该集合存放的是Map集合的映射关系，关系的数据类型就是：Map.Entry。5 Collection<Value>   values();//返回Collection集合，该集合中存放的是Map集合中的全部值。返回的Collection集合可以通过Iterator迭代器获取到全部值

map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

2、Map集合的三种取出方式

(1)、取出map集合中所有元素的方式一： Set<Key> keySet()方法。

将Map集合中的所有键存入到Set集合中。因为Set集合具备迭代器，所以可以通过迭代方式取出所有的键，然后根据Map集合中的get方法获取每一个键所对应的值。

 1 import java.util.*; 2 class KeySetDemo  3 { 4     public static void main(String[] args)  5     { 6         Map<Integer,String> map=new HashMap<Integer,String>(); 7         map.put(1,"王武"); 8         map.put(7,"孙琦"); 9         map.put(6,"李四");10         map.put(4,"赵四");11         map.put(2,"钱枫");12         //先获取map集合的所有键的Set集合,keySet();13         Set<Integer> keyset=map.keySet();14         //有了Set集合。就可以获取其迭代器。15         for (Iterator<Integer> it=keyset.iterator();it.hasNext() ; )16         {17             Integer key=it.next();18             //有了键可以通过map集合的get方法获取其对应的值。19             String value=map.get(key);20             System.out.println("key="+key+":::"+"value="+value);21         }22     }23 }

(2)、取出map集合中所有元素的方式二：Set<Map.Entry<Key,Value>> entrySet()方法。

将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry. Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

接口 Map.Entry<K,V>中的方法：

 1 import java.util.*; 2 class EntrySetDemo  3 { 4     public static void main(String[] args)  5     { 6         Map<Integer,String> map=new HashMap<Integer,String>(); 7         map.put(1,"王武"); 8         map.put(7,"孙琦"); 9         map.put(6,"李四");10         map.put(4,"赵四");11         map.put(2,"钱枫");12         //将Map集合中的映射关系(Map.Entry)取出。存入到Set集合中。13         Set<Map.Entry<Integer,String>> entryset=map.entrySet();14         //用迭代器进行迭代Set集合15         for (Iterator<Map.Entry<Integer,String>> it=entryset.iterator();it.hasNext() ; )16         {17             //it.next()返回的是Map集合中的映射关系(Map.Entry<K,V>)18             Map.Entry<Integer,String> en=it.next();19             //通过Map.Entry中的getKey()和getValue()取到Map集合键和值。20             int key=en.getKey();21             String value=en.getValue();22             System.out.println("key="+key+":::"+"value="+value);23         }24     }25 }

(3)、取出map集合中所有元素的方式三：Collection<Value> values();返回Collection集合，然后在用Iterator迭代器来取出元素

 1 import java.util.*; 2 class ValuesDemo  3 { 4     public static void main(String[] args)  5     { 6         Map<Integer,String> map=new HashMap<Integer,String>(); 7         map.put(1,"王武"); 8         map.put(7,"孙琦"); 9         map.put(6,"李四");10         map.put(4,"赵四");11         map.put(2,"钱枫");12         //用values方法取到Map集合中的全部的值，存放到Collection中13         Collection<String> value=map.values();14         //用迭代器进行迭代这个存放Map集合全部值的Collection集合15         for (Iterator<String> it=value.iterator();it.hasNext() ; )16         {17             System.out.println("value="+it.next());18         }19     }20 }

3、Map集合综合练习

(1)、需求：描述一个学生，学生属性：姓名，年龄。每一个学生都有对应的归属地。学生Student，地址String。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

 1 import java.util.*; 2 class Student  3 { 4     private String name; 5     private int age; 6     Student(String name,int age){ 7         this.name=name; 8         this.age=age; 9     }10     public void setName(String name){11         this.name=name;12     }13     public void setAge(int age){14         this.age=age;15     }16     public String getName(){17         return name;18     }19     public int getAge(){20         return age;21     }22     public String toString(){23         return "name="+name+"....."+"age="+age;24     }25     public int hashCode(){26         return name.hashCode()+age*37;27     }28     public boolean equals(Object obj){29         if(!(obj instanceof Student))30             throw new RuntimeException("类型转换异常");31         Student stu=(Student)obj;32         return this.name.equals(stu.name)&&this.age==stu.age;33     }34 }35 class HashMapDemo36 {37     public static void main(String[] args) 38     {39         //将学生对象和学生的归属地通过键与值的形式存储到map集合中40         Map<Student,String> map=new HashMap<Student,String>();41         map.put(new Student("张三",20),"北京");42         map.put(new Student("钱枫",21),"深圳");43         map.put(new Student("王武",19),"郑州");44         map.put(new Student("赵四",33),"香港");45         map.put(new Student("孙琦",29),"广州");46         map.put(new Student("钱枫",21),"上海");47         //第一种方式：keySet();48         for (Iterator<Student> it=map.keySet().iterator();it.hasNext() ; )49         {50             Student stu=it.next();51             String address=map.get(stu);52             System.out.println(stu+":::"+address);53         }54         //第二种取出方式55         for (Iterator<Map.Entry<Student,String>> it=map.entrySet().iterator();it.hasNext() ; )56         {57             Map.Entry<Student,String> me=it.next();58             Student stu=me.getKey();59             String address=me.getValue();60             System.out.println(stu+":::"+address);61         }62     }63 }

(2)、需求：对学生对象的年龄进行升序排序。因为数据是以键值对形式存在的。所以要使用可以排序的Map集合中TreeMap集合。

 1 import java.util.*; 2 class Student implements Comparable<Student> 3 { 4     private String name; 5     private int age; 6     Student(String name,int age){ 7         this.name=name; 8         this.age=age; 9     }10     public void setName(String name){11         this.name=name;12     }13     public void setAge(int age){14         this.age=age;15     }16     public String getName(){17         return name;18     }19     public int getAge(){20         return age;21     }22     public String toString(){23         return "name="+name+"....."+"age="+age;24     }25     public int compareTo(Student stu){26         int num=this.age-stu.age;//按年龄排序27         if(num==0)28             return this.name.compareTo(stu.name);//按姓名排序29         return num;30     }31     /*32     因为写的Student类，使用者有可能存放到HashMap集合中。33     所以有必要复写hashCode方法和equals方法。34     而且即使你不写，这两个方法都会存在Student类中，因为Object类中有这两个方法35     public int hashCode(){36         return name.hashCode()+age*37;37     }38     public boolean equals(Object obj){39