java笔记之集合框架

绪

最近需要做一个老师给的项目，前提是得看懂已有得代码，于是又重新开始苦逼的看书日子了。每次看完书总是容易忘，于是想着写个博客笔记来记录督促一下自己总结算了。今天看得少只有两章，先梳理集合框架第一章吧。

集合框架

集合是将其他对象组织在一起的一个对象，它提供了一种方法来存储、访问和操作里面的元素，也就是一堆对象。为了操作一组对象更加方便，，Java里面带有一组接口和类，这些接口和类就是集合框架（collections framework），集合框架的核心类型中主要类型就是java.util.Collection（list 、set、Queue）接口和Map接口。Java集合工具包位于java.util包下面，今天的内容代码实施前准确的说应该导入java utill包。

下面是一些很常见很重要的类型，这里给出一个概览图。

里面的下层的类型或接口都是扩展上层接口而来，上层接口统筹地定义了下面的类和接口的一些公共操作。可以说下层是上层的实现类。

集合框架里面最主要的类型是collection接口。常见的collection的方法有add（添加元素），addAll（添加另一个collection成员），clear（删除所有元素），size（查询collection中元素数目），isEmpty（看collection中是否包含一个元素），toArray(把集合元素放入一个数组)。

围绕这个概览图，重点讲list，Iterator，set，Queue，Map和comparable&Comparator（可比较和可排序）。

list

list：最常用的接口，Arraylist是最为常用的List的实现。list是一个有序集合，采用索引访问其元素，第一个元素的索引为零，类似数组地址访问。

list方法：首先是创建一个list即构造方法：方法：List mylist = new Arraylist() & public Arraylist(int initialCapacity)（这个是是设定了容量的构造方法，前者是默认10个元素，不够再加；后一种更快） 。其次是继承了collection的方法，1,add；直接添加元素到末尾，方法签名：public boolean add(java.lang.Object element) ;添加元素到指定的位置，public void add(int index, java,lang.Object. element) 2，set & remove替换和删除；方法签名：public java,lang.Object set(int index, java,lang.Object. element) & public java.lang.Object remove (int index)。再然后是java.util.collections提供的类：sort,排序方法，举例：List numbers;Collections.sort(numbers),这就是对list对象numbers进行从小到大排序。续：搜索集合的方法：indexOf & lastindexOf.都是返回匹配成功后元素的引用，不同的是前者从第一个开始匹配着走，后者从最后一个开始匹配着走 。

list小记：允许存储重复的元素，实际上是存储的指向同一个元素的引用，但是set不允许。

Iterator

这里Iterator主要讲使用Irerator和for一起遍历collections集合，Iterator解释过来就是遍历集合的迭代器，。Iterator是Iterable下的一个方法，而Iterable是被Collections扩展了的，方法返回的是一个java.util.Iterator.Iterator有三个方法：1. hasNext(),Iterator内部的指针最初是指向第一个元素之前的位置，如果后面还有更多的元素，hasNext()返回true，指针直接调向下一个元素。2.next.将内部指针移动到下一个元素并返回该元素。最后一个元素返回之后还在调用next的话，就会抛出java,util.NoSuchElementException. 3.remove ,删除指针指向的元素。

遍历Collection常用方式：while&for。

while：

Iterator iterator = mylist.iterator();

while (iterator,hasNext() ){

string element =(string) iterator .next();

system. out .println(element);

}

Iterator iterator = mylist.iterator();

while (iterator,hasNext() )    等价于

for ( Iterator iterator = mylist.iterator(); iterator.hasNext(); )

for:

for可以遍历一个collection不需要调用iterator方法，

语法:

for( Type identifier : expression){                         

statement(s);

}

实例：for（Iterator iterator = mylist.iterator(); iterator.hasNext();）{

string element =(string) iteraotor.next();

system.out.println(element);

}

根本上for遍历一个集合时，编译器会编译成一个采用Iterator的方法，可以参考while遍历时相等的for代码。

set

set就是相当于一个数学的集，不允许相同的元素存在，最多允许一个空元素，，同时hashset是set的首选，但是hashset不能保证元素的顺序保持不变。

Queue

Queue就是collection的扩展，上面的框架图已经说明了这点。在数据结构里面Queue是队列，具有先进先出的特征，在这里具有一样的特征(FIFO），意味着获取元素时最先得到是第一个元素，添加元素时是添加在最末尾，不同于List里面采用索引来确定访问元素的方式。

Queue添加的方法：

offer：就是添加元素，添加失败的话，offfer返回false,同时不抛出异常，对比与add,add添加元素错误的话是会抛出异常的。

Remove：有两个同步的操作，即删除Queue头部元素的同时，返回头部头部元素。头部没有元素的情况下抛出java.util.NoSuchElementException。

poll：和remove一样，只不过头部空的情况下直接返回空并不抛出异常。

element：只返回头部元素不删除，头部没有元素的情况下抛出java.util.NoSuchElementException异常。

peek：只返回头部元素不删除，头部没有元素就直接返回空。

Queue小记：必须按照顺序来。java.util.Stack类也是个collection，特征是先进后出（LIFO）

Map

就是让你定义一个按键对应于什么值，不允许存在重复的元素，每个键最多只能定义一个值。

方法：

put：添加键/值, 方法签名：public void put (java.lang.Object key, java.lang.Object value ) 实现实例：map.put(1, 3000)表示按键1对应于值3000。

putAll：传入Map参数， 方法签名：public void putAll(Map map) 

remove：传递键来删除一个值， 方法签名：public void remove (java.lang.Object key)

clear：删除所有映射。

size：得到映射的数目。

isEmpty：检查映射数目是否为0，如果为0，就返回true。

keySet：返回包含Map中的所有键的一个set。

values：返回包含Map中的所有值得一个collection。

entrySet：返回包含了Map.Entry对象的一个set，每个Map.Entry对象表示一个键值对，这个对象提供getValue返回值得部分，提供getKey返回键的部分。

Map小记：Java.util包里面最常使用 HashMap&Hashtable,前者是非同步的，后者是同步的，所以前者更快更常用。

集合转换

讲了collection里面的种种东西，有没有可能里面的东西相互转换呢，当然可能啦。这就是集合装换，将一个collection对象转换为另一个不同的集合类型，比如将collection接口下的list转换为Queue:

List mylist = new Arraylist();
mylist.add("hello");
mylist.add("hello");
mylist.add("world");
Queue queue= new Linkedlist(mylist);

comparable&comparator使对象可比较和可排序

comparable

举个如下的例子：

Object a =new Object();
Object b =new Object();
if (a==b)

很多时候你是关心a b引用的这两个对象本身是否相等，但是在java里面，a,b代表的意思是这两个对象在内存中的地址，这就会 造成两者不相等（实例都不同，内存当然分配两个不同的地址来存储这两个实例了啊）。所以为了比较对象本身，我们需要在Java提供的方法里面找专门比较对象，string类型可以调用equals方法。能不能比较两个对象归根结底你得看这个对象的类支不支持。基本上一个类可以继承java.lang.Object继承而来的equals和hashCode方法来支持对象的比较。今天这里讲使对象可比较，当然除了这种方法还有一种了啦----实现java.lang.Comparable&java.lang.Comparator来让对象可比较。

为了更好的理解呢，我们先来说下数组里面的排序，sort方法。java.util.Arrays类提供了静态的方法sort，其可以排序对象的一个数组。以下是它的方法签名：

public static void sort(java.lang.Objecta[])

因为java对象都是java.lang.Object类型的，所以可以将任何对象的数组传递给sort方法。

和数组相似，java.util.collections类也有一个sort方法来排序list，可以进行简单的数字和字符串排序。假设我们现在需要进行一个排序，那么任意调用一个sort方法，我们怎么让它知道去按照怎样的要求来排序这些对象们呢。先看下sort方法实现的原理吧，两种sort方法都定义了他们自身和需要排序的对象之间的协议，这个协议就是java.lang.Comparable的。

package java.lang;
public interface Comparable{
public int compareTo(Object obj)   //这里的obj就是引用了需要和该对象比较的对象，称为参数对象，如果该对象比参数对象大就返回正值，相等就返回0，小就返回负值。
}

需要通过Arrays.sort或者Collections.sort来支持排序的任何类，都必须实现Comparable接口。这里给出一个实现了Comparable的Elephant类的代码实例：

public class Elephant implements Comparable{       //Elephant实现了Comparable接口，可以采用Arrays.sort或者Collections.sort来排序Elephant对象的一个数组或者list了。
  public float weight;
  public int age;
  public float tusklength;
  public int compareTo(Object obj){                 //这就是sort方法定义的他们自己的对象和参数对象相比较的协议
  Elephant anotherElephant =(Elephant)obj;
  if (this.weight>another.weight){
   return 1;
   }else if(this.weight<another.weight){
   return -1;
   }else{
   //both elephants hava the same weight,
   //compare their age.
   return (this.age-anotherElephant.age); 
   }
 }  
}   
------------------------------------------
分隔符；
import java.util.Arrays;
public class ElephantTest{
  public static void mian(string[] args){
  Elephant elephant1= new elephant();
  elephant1.weight=100.12F;
  elephant1.age=20;
  Elephant elephant2= new elephant();
  elephant2.weight=120.12F;
  elephant1.age=20;
  Elephant elephant3= new elephant();
  elephant3.weight=100.12F;
  elephant3.age=25;
  Elephant[] elephants =new Elephant[3];
  elephants[0]=elephant1;
  elephants[1]=elephant2;
  elephants[2]=elephant3;
  system.out println("before sorting");
  for(Elephant elephant :elephants){
  system.out.println(elephant.weight+":"+
   elephant.age);
    }
  Arrays.sort(elephants);
  system.out.println("After sorting");
  for(Elephant elephant : elephants){
  system.out.println(elephant.weight+":"+
  elephant.age);
  }
}
}

sort方法会将Elephant类当作一个Comparable对象，然后在该对象上调用compareTo方法，然后重复调用直至按照体重和年龄正确的组织好了。这便解决了按照一定的要求来排序这些对象的问题。分隔符以下的代码即排序实例。

Comparable小记：它就是让你可以定义一种你想要比较的方式让你比较类的实例。

Comparator

讲完了Comparable,我们不要忘了还有个叫Comparator的东西，comparable提供了一种方式进行比较，但是有可能有些时候对象需要更多的方式进行比较。例如：两个person类对象需要按照年龄、姓氏和名字来进行比较，这个时候我们就需要创建一个Comparator实例，让它定义应该如何比较两个对象。有了Comparator,即使他们的类并没有实现Comparable都没有关系。

顺序：编写实现了Comparator接口的类，实现compare方法，创建Comparator对象。方法签名：

public int compare (java.lang.Object o1, java.lang.Object o2) //o1和o2相等，返回0，o1<o2,返回负数，否则返回整数

以下给出lastnamecomparator的实例：

import java.util.Comparator;
public class LastnameComparator implements Comparator{
   public int compare (Object person,Object anotherperson){
       string Lastname1=((person)person).getLastname().toUpperCase();
       string Firstname1=((person)person).getFirstname().toUpperCase();
       string Lastname2=((person)person).getLastname().toUpperCase();
       string Firstname2=((person)person).getFirstname().toUpperCase();
       if (LastName1.equals(LastName2)){
            return firstname1.compareTo(firstname2);
             }else{return lastname1.compareTo(Lastname2);
                  }
          }
}
//firstnameComparator类同理