Java：常用标准库算法

排序 sort

Collection类中的sort方法可以对实现了List接口的集合进行排序。

List staff = new LinkedList<>();
...
Collections.sort(staff);

如果想采用其他方式对列表进行排序，可以将Comparator对象作为第二个参数传递给sort方法。
例如，如果想按照降序对列表进行排序，可以使用静态方法Collections.reverseOrder()，它将返回b.compareTo(a)：

Collections.sort(staff,Collections.reverseOrder());

---

如果要自定义比较函数，应该建立一个实现了Comparator接口的自定义类，在该类中实现compare方法。然后，在调用sort函数时，将自定义类的一个对象作为第二个参数传入，例如：

public class Test {   

public static void main(String[] args){   
  List points=new ArrayList();   

  Point point1=new Point();   
  point1.setX(1324);   
  point1.setY(345);   
  point1.setZ(436);   
  points.add(point1);   

  Point point2=new Point();   
  point2.setX(23);   
  point2.setY(8941.656);   
  point2.setZ(431412);   
  points.add(point2);   

  Point point3=new Point();   
  point3.setX(786584);   
  point3.setY(23452);   
  point3.setZ(43563);   
  points.add(point3);   

  //根据X排序   
  Collections.sort(points,new SortByX());   
}     
}   

class Point{   
private double x;   
private double y;   
private double z;   
public double getX() {   
  return x;   
}   
public void setX(double x) {   
  this.x = x;   
}   
public double getY() {   
  return y;   
}   
public void setY(double y) {   
  this.y = y;   
}   
public double getZ() {   
  return z;   
}   
public void setZ(double z) {   
  this.z = z;   
}   
public Point(){}   
}   

//根据X排序   
class SortByX implements Comparator{   
public int compare(Object obj1,Object obj2){   
  Point point1=(Point)obj1;   
  Point point2=(Point)obj2;   
  if(point1.getX()>point2.getX())   
   return 1;   
  else  
   return 0;   
}   
}   

生成随机数 Random类

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。相同种子数的Random对象，相同次数生成的随机数字是完全相同的。

Random对象的实现

Random类包含两个构造方法，下面依次进行介绍：

public Random()

该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数，然后使用这个种子数构造Random对象。

public Random(long seed)

该构造方法可以通过制定一个种子数进行创建。

示例代码：

Random r = new Random();

Random r1 = new Random(10);

常用方法

public boolean nextBoolean()
//生成一个随机的boolean值，生成true和false的值几率相等

public double nextDouble()
//生成一个随机的double值，数值介于[0,1.0)之间。

public int nextInt()
//生成一个随机的int值，该值介于int的区间，也就是-231到231-1之间。

public int nextInt(int n)
//生成一个随机的int值，该值介于[0,n)的区间，也就是0到n之间的随机int值，包含0而不包含n。

public void setSeed(long seed)
//重新设置Random对象中的种子数。设置完种子数以后的Random对象和相同种子数使用new关键字创建出的Random对象相同。

生成指定区间的随机数

[0,1.0)区间的小数

double d1 = r.nextDouble();

直接使用nextDouble方法获得。

[0,5.0)区间的小数

double d2 = r.nextDouble() * 5;

因为nextDouble方法生成的数字区间是[0,1.0)，将该区间扩大5倍即是要求的区间。
同理，生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。

[1,2.5)区间的小数

double d3 = r.nextDouble() * 1.5 + 1;

生成[1,2.5)区间的随机小数，则只需要首先生成[0,1.5)区间的随机数字，然后将生成的随机数区间加1即可。
同理，生成任意非从0开始的小数区间[d1,d2)范围的随机数字(其中d1不等于0)，则只需要首先生成[0,d2-d1)区间的随机数字，然后将生成的随机数字区间加上d1即可。

[0,10)区间的整数

int n2 = r.nextInt(10);
//或
n2 = Math.abs(r.nextInt() % 10);

[-3,15)区间的整数

int n4 = r.nextInt(18) - 3;
//或
n4 = Math.abs(r.nextInt() % 18) - 3;

生成非从0开始区间的随机整数，可以参看上面非从0开始的小数区间实现原理的说明。

二分查找 binarySearch

对于排好序的集合，用二分查找的方式查找一个元素是效率很高的。Collections类的binarySearch方法实现了这个算法。

i = Collections.binarySearch(c,element);
i = Collections.binarySearch(c,element,comparator);

如果匹配成功，i将大于等于0，用c.get(i)可以得到查找的元素；如果匹配失败，i将是负数。但这个负数也是有意义的，可以利用它计算应该将element插入到集合的那个位置，如：

if(i < 0)
    c.add(-i-1,element);

将把元素插入到正确的位置上。

其他算法

e=min(c);
e=max(c); //返回集合中最小或最大的元素

copy(c1,c2); //将原列表中的元素复制到目标列表的相应位置上

fill(c,e); //将列表中所有位置设置为相同的值e

replaceAll(c,oldValue,newValue); //用newValue取代所有值为oldValue的元素

i = indexOfSubList(l,s);
i = lastIndexOfSubList(l,s);
// 返回l中第一个或最后一个等于s子列表的索引，如果不存在，返回-1

swap(l,i,j); //交换i和j位置上的元素

reverse(l); //逆置列表l中的元素

rotate(l,d); //将d位置之前和之后的元素交换一下顺序

frequency(c,e); //返回c中e出现的次数

boolean b = disjoint(c1,c2); //如果两个集合没有共同的元素，则返回true