黑马程序员----java基础--集合
一、集合类的描述
二、集合框架的构成以及分类
三、Collection接口
四、List集合(接口)
五、ArrayList、LinkedList、Vector集合
六、Set集合(只能用Iterator迭代器取数据)
七、HashSet、LinkedHashSet、TreeSet集合
八、Map接口
九、Collections工具类
十、Arrays工具类
十一、将集合转成数组
------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<E>接口
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<E>集合(接口)
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 }
五、ArrayList、LinkedList、Vector集合
1、ArrayList集合的方法和List集合的方法差不多一样。所以可参照List的方法。
2、LinkedList集合
LinkedList集合中特有的方法：
(1)、添加元素
1 addFirst();//将指定元素插入集合元素的开头 2 addLast();//将指定元素插入集合元素的末尾
------JDK1.6版本后新的方法----------------
1 offerFirst();//与addFirst方法没有区别 2 offerLast();//与addLast方法没有区别
(2)、获取但不删除元素
1 //获取但不删相互，如果链表为空，抛出NoSuchElementException 2 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 DuiLieDemo 24 { 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 ArrayListDemo 38 { 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<E>集合(只能用Iterator迭代器取数据)
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 }
七、HashSet、LinkedHashSet、TreeSet集合
(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 HashSetDemo 41 { 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 else 13 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<K,V>接口
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 HashMapDemo 36 { 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 if(!(obj instanceof Student)) 40 throw new RuntimeException("类型转换异常"); 41 Student stu=(Student)obj; 42 return this.name.equals(stu.name)&&this.age==stu.age; 43 } 44 */ 45 } 46 class StuComparator implements Comparator<Student> 47 { 48 public int compare(Student s1,Student s2){ 49 int num=s1.getAge()-s2.getAge(); 50 return (num==0)?s1.getName().compareTo(s2.getName()):num; 51 } 52 } 53 class TreeMapDemo 54 { 55 public static void main(String[] args) 56 { 57 TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuComparator()); 58 tm.put(new Student("张三",20),"北京"); 59 tm.put(new Student("钱枫",21),"深圳"); 60 tm.put(new Student("王武",19),"郑州"); 61 tm.put(new Student("赵四",33),"香港"); 62 tm.put(new Student("孙琦",29),"广州"); 63 tm.put(new Student("钱枫",21),"武汉"); 64 tm.put(new Student("王武",19),"上海");//键相同值就会覆盖原来的键的值 65 Set<Map.Entry<Student,String>> entryset=tm.entrySet(); 66 for (Iterator<Map.Entry<Student,String>> it=entryset.iterator();it.hasNext() ; ) 67 { 68 Map.Entry<Student,String> en=it.next(); 69 Student stu=en.getKey(); 70 String address=en.getValue(); 71 System.out.println(stu+":::"+address); 72 } 73 } 74 }
(3)、需求： 使用LinkedHashMap则是跟原来存入的顺序是一致的。
1 import java.util.*; 2 class LinkedHashMapDemo 3 { 4 public static void main(String[] args) 5 { 6 LinkedHashMap<Integer,String> lhm=new LinkedHashMap<Integer,String>(); 7 lhm.put(1,"王武"); 8 lhm.put(7,"孙琦"); 9 lhm.put(6,"李四"); 10 lhm.put(4,"赵四"); 11 lhm.put(2,"钱枫"); 12 lhm.put(2,"黑马");//覆盖原来相同键的值 13 Set<Map.Entry<Integer,String>> entryset=lhm.entrySet(); 14 for (Iterator<Map.Entry<Integer,String>> it=entryset.iterator();it.hasNext() ; ) 15 { 16 Map.Entry<Integer,String> en=it.next(); 17 Integer key=en.getKey(); 18 String value=en.getValue(); 19 System.out.println(key+":::"+value); 20 } 21 } 22 }
运行结果：
(4)、需求："sdfgzxcvas--==,.?dfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....
通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择Map集合。因为Map集合中存放就是映射关系。
什么使用Map集合呢？
当数据之间存在这映射关系时，就要先想Map集合。
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个Map集合，因为打印结果的字母有顺序，所以使用Treemap集合。
3，遍历字符数组。将每一个字母作为键去查Map集合。如果返回null，将该字母和1存入到Map集合中。
如果返回不是null，说明该字母在Map集合已经存在并有对应次数。 那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到Map集合中。覆盖掉原来键所对应的值。
4，将Map集合中的数据变成指定的字符串形式返回。
1 //"sdfgzxcvas--==,.?dfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2)..... 2 import java.util.*; 3 class TreeMapTest 4 { 5 public static void main(String[] args) 6 { 7 String str="sdfgzxcvas--==,.?dfxcvdf"; 8 str=getCharCount(str); 9 System.out.println(str); 10 } 11 public static String getCharCount(String str){ 12 TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>(); 13 //把字符串转换成字符数组 14 char[] arr=str.toCharArray(); 15 for (int x=0;x<arr.length ;x++ ) 16 { 17 //程序健壮性的判断，如果是除了字母以外的字符直接过滤掉 18 if(!((arr[x]>='a'&& arr[x]>='z') || (arr[x]>='A'&& arr[x]>='Z'))) 19 continue; 20 //将数组中的字母作为键去查map表中的值 21 Integer value=tm.get(arr[x]); 22 int count=0; 23 //判断值是否为null,如果不为空记录这个值 24 if(value!=null) 25 count=value; 26 //如果不为空，count加1存进集合中，如果count=0，也加1存进去 27 count++; 28 tm.put(arr[x],count); 29 /* 30 if(value==null) 31 tm.put(arr[x],1); 32 else{ 33 value=value+1; 34 tm.put(arr[x],value); 35 } 36 */ 37 } 38 //创建字符串缓冲区用来修改成固定的字符串格式。 39 StringBuilder sb=new StringBuilder(); 40 for (Iterator<Map.Entry<Character,Integer>> it=tm.entrySet().iterator();it.hasNext() ; ) 41 { 42 Map.Entry<Character,Integer> en=it.next(); 43 Character key=en.getKey(); 44 Integer value=en.getValue(); 45 sb.append(key+"("+value+")"); 46 } 47 return sb.toString(); 48 } 49 }
(5)、Map集合扩展
在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
1 import java.util.*; 2 class Student 3 { 4 private String id; 5 private String name; 6 Student(String id,String name) 7 { 8 this.id = id; 9 this.name = name; 10 } 11 public String toString() 12 { 13 return id+":::"+name; 14 } 15 } 16 class MapDemo3 17 { 18 public static void demo() 19 { 20 HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>(); 21 List<Student> reyu = new ArrayList<Student>(); 22 List<Student> jiuye = new ArrayList<Student>(); 23 czbk.put("yureban",reyu); 24 czbk.put("jiuyeban",jiuye); 25 reyu.add(new Student("01","zhagnsa")); 26 reyu.add(new Student("04","wangwu")); 27 jiuye.add(new Student("01","zhouqi")); 28 jiuye.add(new Student("02","zhaoli")); 29 Iterator<String> it = czbk.keySet().iterator(); 30 while(it.hasNext()) 31 { 32 String roomName = it.next(); 33 List<Student> room = czbk.get(roomName); 34 System.out.println(roomName); 35 getInfos(room); 36 } 37 } 38 public static void getInfos(List<Student> list) 39 { 40 Iterator<Student> it = list.iterator(); 41 while(it.hasNext()) 42 { 43 Student s = it.next(); 44 System.out.println(s); 45 } 46 } 47 public static void main(String[] args) 48 { 49 demo(); 50 } 51 public static void getStudentInfo(HashMap<String,String> roomMap) 52 { 53 Iterator<String> it = roomMap.keySet().iterator(); 54 while(it.hasNext()) 55 { 56 String id = it.next(); 57 String name = roomMap.get(id); 58 System.out.println(id+":"+name); 59 } 60 } 61 }
(6)、 Map在有映射关系时，可以优先考虑,在查表法中的应用较为多见。
1 import java.util.*; 2 class MapTest1 3 { 4 public static void main(String[] args) 5 { 6 System.out.println(getWeek(1)); 7 } 8 public static String getWeek(int num){ 9 if(num<1 || num>7) 10 throw new RuntimeException("没有这个星期，请重新输入"); 11 String[] weeks={"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"}; 12 String s=weeks[num]; 13 TreeMap<String,String> tm=new TreeMap<String,String>(); 14 tm.put("星期一","Mon"); 15 tm.put("星期二","Tue"); 16 tm.put("星期三","Wes"); 17 tm.put("星期四","Sta"); 18 tm.put("星期五","Wek"); 19 tm.put("星期六","Sun"); 20 tm.put("星期日","Sun"); 21 return tm.get(s); 22 } 23 }
总结：
使用集合的技巧：
(1)、看到Array就是数组结构，有角标，查询速度很快。
(2)、看到Link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
(3)、看到Hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
(4)、看到Tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。 保证唯一，就用Set。不保证唯一，就用List。
九、Collections工具类
Collections：集合框架的工具类。里面定义的都是静态方法。
1、Collection和Collections有什么区别？
Collection是集合框架的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口：List对元素都有定义索引，是有序的，可以重复元素；Set不可以重复元素，无序的。
Collections是集合框架中的一个工具类。该类中的方法都是静态的，提供的方法中有可以对List集合进行排序、二分查找等方法。
2、Collections中的常用静态方法
(1)、对List集合进行排序
1 Collections.sort(List<T> list);//List集合进行元素的自然顺序排序 2 Collections.sort(List<T> list,Comparator<?super T> c);//按指定的比较器方法排序
(2)、对List集合进行二分查找
1 int Collections.binarySearch(List list, T key);//对List集合进行二分查找，返回角标。 2 int Collections.binarySearch(List list,T key,Comparator<T> c);//传入自定义的比较器进行查找
(3)、对List集合中的对象进行置换
1 Collections.swap(List list,int i,int j);// 在指定集合的指定位置处交换元素
(4)、fill方法可以将list集合中所有元素替换成指定元素。
1 Collections.fill(List<T> list, T obj);//使用指定元素替换指定集合中的所有元素。
(5)、获取Collection集合中的最大元素
1 T Collections.max(Collection coll);//根据元素的自然顺序，返回最大元素 2 T Collections.max(Collection coll, Comparator<T> comp);//根据指定比较器产生的顺序，返回最大元素。
(6)、List集合中新值替换老值
1 Collections.replaceAll(List list, T oldValue,T newValue);// 使用另一个值替换列表中出现的所有某一指定值。
(7)、集合进行反转
1 Collections.reverse(List list);//反转指定集合中元素的顺序 2 Comparator<T> reverseOrder();//返回一个比较器，它强行逆转实现了 Comparable 接口的对象。 3 Comparator<T> reverseOrder(Comparator<T> comp);// 返回一个比较器，该比较器将强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
(8)、使用指定的随机源对指定列表进行置换。
1 Collections.shuffle(List list);//使用默认随机对集合进行置换。 2 Collections.shuffle(List list,Random rnd);//使用默认随机对集合进行置换
(9)、不同步的集合转成同步的集合。
//原理：定义一个类，将集合所有的方法加同一把锁后返回。 Collection Collections.synchronizedCollection(Collection coll); List Collections.synchronizedList(List list); Set Collections.synchronizedSet(Set set); Map Collections.synchronizedMap(Map);
代码演示：
(1)、
1 import java.util.*; 2 class CollectionsDemo 3 { 4 public static void main(String[] args) 5 { 6 List<String> list = new ArrayList<String>(); 7 list.add( "abcde"); 8 list.add( "cbad"); 9 list.add( "bb"); 10 list.add( "zzz"); 11 list.add( "cba"); 12 list.add( "a"); 13 sort(list); 14 binarySearch(list); 15 swap(list); 16 fill(list); 17 max(list); 18 replaceAll(list); 19 reverse(list); 20 shuffle(list); 21 } 22 //对List集合进行默认排序，因为TreeSet和TreeMap都能排序了 23 public static void sort(List<String> list){ 24 //List集合默认排序 25 Collections.sort(list); 26 sop(list);//运行结果：[a, abcde, bb, cba, cbad, zzz] 27 28 //指定比较器，按照比较器的比较方式进行比较 29 Collections.sort(list,new StringLenComp()); 30 sop(list);//运行结果：[a, bb, cba, zzz, cbad, abcde] 31 } 32 33 //二分查找 34 public static void binarySearch(List<String> list){ 35 //二分查找在查找之前必须根据元素的自然顺序对集合进行升序排序。 36 //如果没有对列表进行排序，则结果是不确定的。 37 //如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。 38 Collections.sort(list); 39 sop(list);//[a, abcde, bb, cba, cbad, zzz] 40 int index=Collections.binarySearch(list,"bb"); 41 sop("index="+index);//index=2 42 43 //指定比较器进行二分查找 44 int num=Collections.binarySearch(list,"bb",new StringLenComp()); 45 sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a] 46 sop("index="+num);//运行结果：index=2 47 48 } 49 50 //对List集合中的对象进行置换 51 public static void swap(List<String> list){ 52 sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a] 53 Collections.swap(list,4,2); 54 sop(list);//运行结果：[abcde, cbad, cba, zzz, bb, a] 55 } 56 57 //fill方法可以将list集合中所有元素替换成指定元素。 58 public static void fill(List<String> list){ 59 sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a] 60 Collections.fill(list,"我爱黑马"); 61 sop(list);//运行结果：[我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马] 62 } 63 64 //获取Collection集合中的最大元素 65 public static void max(List<String> list){ 66 String str=Collections.max(list); 67 sop(str);//运行结果：zzz 68 69 String s=Collections.max(list,new StringLenComp()); 70 sop(s);//运行结果：abcde 71 } 72 73 //List集合中新值替换老值 74 public static void replaceAll(List<String> list){ 75 sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a] 76 Collections.replaceAll(list,"cba","我要去黑马"); 77 sop(list);//运行结果：[abcde, cbad, bb, zzz, 我要去黑马, a] 78 } 79 80 //对集合进行反转 81 public static void reverse(List<String> list){ 82 sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a] 83 Collections.reverse(list); 84 sop(list);//运行结果：[a, cba, zzz, bb, cbad, abcde] 85 86 87 } 88 89 //使用指定的随机源对指定列表进行置换。 90 public static void shuffle(List<String> list){ 91 sop(list); 92 Collections.shuffle(list); 93 sop(list); 94 } 95 public static void sop(Object obj){ 96 System.out.println(obj); 97 } 98 } 99 class StringLenComp implements Comparator<String> 100 { 101 public int compare(String s1,String s2){ 102 int num=s1.length()-s2.length(); 103 if(num==0) 104 return s1.compareTo(s2); 105 return num; 106 } 107 }
(2)、
1 import java.util.*; 2 class ReverseOrderDemo 3 { 4 public static void main(String[] args) 5 { 6 //返回一个比较器，它强行逆转实现了 Comparable 接口的对象。 7 TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder()); 8 ts.add( "abcde"); 9 ts.add( "cbad"); 10 ts.add( "bb"); 11 ts.add( "zzz"); 12 ts.add( "cba"); 13 ts.add( "a"); 14 System.out.println(ts);//运行结果：[zzz, cbad, cba, bb, abcde, a] 15 16 //对集合进行了两次的反转就又变成了自然排序的顺序了 17 ts=new TreeSet<String>(Collections.reverseOrder(Collections.reverseOrder())); 18 ts.add( "abcde"); 19 ts.add( "cbad"); 20 ts.add( "bb"); 21 ts.add( "zzz"); 22 ts.add( "cba"); 23 ts.add( "a"); 24 System.out.println(ts);//运行结果：[a, abcde, bb, cba, cbad, zzz] 25 } 26 }
十、Arrays工具类
此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态的方法。
(1)、数组按照升序进行排序
1 Arrays.sort(基本数据类型[]或者 对象[]);
2 eg:Arrays.sort(int[] arr);// 对指定的 int 型数组按数字升序进行排序。
(2)、数组进行二分查找
1 int Arrays.binarySearch(基本数据类型[] 或者 对象[],key); 2 eg: Arrays.binarySearch(int[] arr,int key);
(3)、将数组转换成集合
1 List asList(T...a);//T...a可变长度的数组
2 eg:String[] arr = {"abc","kk","qq"};
3 List<String> list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合。
可以通过List集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
1 import java.util.*; 2 class ArraysDemo 3 { 4 public static void main(String[] args){ 5 int[] arr1 = {31,11,51,61}; 6 List< int[]> list1 = Arrays.asList(arr1); 7 System.out.println(list1);//运行结果：[[I@659e0bfd] 8 Integer[] arr2 = {31,11,51,61}; 9 List list2 = Arrays.asList(arr2); 10 System.out.println(list2);//运行结果：[31, 11, 51, 61] 11 } 12 }
(4)、将数组内容变成字符串打印出去
1 String Arrays.toString(基本数据类型[] 或者 对象[]);
代码演示：
1 import java.util.*; 2 class ArraysDemo 3 { 4 public static void main(String[] args){ 5 int[] arr={34,54,2,5,7,8}; 6 char[] ch={'a','g','j','h','l'}; 7 double[] dou={7.45,0.15,45.12,45,1256,4}; 8 byte[] by={0,1,5,3,5,0}; 9 String[] str={"nihao","hah","heihei"}; 10 System.out.println(Arrays.toString(arr));//运行结果：[34, 54, 2, 5, 7, 8] 11 System.out.println(Arrays.toString(ch));//运行结果：[a, g, j, h, l] 12 System.out.println(Arrays.toString(dou));//运行结果：[7.45, 0.15, 45.12, 45.0, 1256.0, 4.0] 13 System.out.println(Arrays.toString(by));//运行结果：[0, 1, 5, 3, 5, 0] 14 System.out.println(Arrays.toString(str));//运行结果：[nihao, hah, heihei] 15 } 16 }
十一、将集合转成数组
使用的就是Collection接口中的toArray方法。
1 Object[] toArray(); 2 T[] toArray(T[] a);//返回数组的运行时类型与指定数组的运行时类型相同
集合转成数组，可以对集合中的元素操作的方法进行限定，不允许对其进行增删。只要获取这些元素即可。 toArray方法需要传入一个指定类型的数组，那么长度该如何定义呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组。
所以建议，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。
1 import java.util.*; 2 class ArraysDemo 3 { 4 public static void main(String[] args){ 5 List<Integer> list=new ArrayList<Integer>(); 6 list.add(5); 7 list.add(4); 8 list.add(10); 9 list.add(12); 10 list.add(54); 11 Integer[] arr=list.toArray(new Integer[list.size()]);//刚刚好的数组长度 12 for (int x=0;x<arr.length ;x++ ) 13 { 14 System.out.println(arr[x]); 15 } 16 } 17 }
未完待续.............
注：菜鸟日记，如有错误欢迎大神指正，欢迎探讨！！
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------