java基础整理十七（常用工具类）

第十七天

集合框架的工具类:

Collections:方法都是静态的无需对象直接类名调用

public static<T extends Comparable<? super T>> void sort(List<> list)为了能用此功能泛型限定为必须是Comparable子类,这样才能具备比较性

Collections.sort()集合元素自然排序.

Collections.binarySearch(list,"tt");//查找集合中元素并返还应存在位置

import java.util.*;

class CollectionsDemo

{

 public static void sop(Object obj)

 {

  System.out.println(obj);

 }

 public static void main(String[]args)

 {

  sortDemo();

  maxDemo();

 }

 public static void maxDemo()//最大值

 {

  List<String> list = new ArrayList<String>();

  list.add("acvd");

  list.add("aey");

  list.add("tt");

  list.add("wrt");

  list.add("qq");

  Collections.sort(list);

  String max = Collections.max(list);

  sop(max);//打印结果是其中最后的“wrt”.

 }

 

 public static void binarySearchDemo()//查找集合中元素位置

 {

  ArrayList<String> list = new ArrayList<String>();

  list.add("acvd");

  list.add("aey");

  list.add("tt");

  list.add("wrt");

  list.add("qq");

  Collections.sort(list);

  int index = Collections.binarySearch(list,"tt");//查找集合中元素并返还应存在位置

  int index = halfSearch(list,"aaaa");

 }

 Collections.binarySearch();原理折半查找:

  public static int halfSearch(List<String> list,String key)

 {

  int max,min,mid;

  max = list.size();

  min = 0;

  while(min<max)

  {

   mid =(min+max)>>1;

   String str = list.get(mid);

   int num = str.compareTo(key);

   if(num>0)

    max = mid -1;

   else if(num<0)

    min = mid+1;

   else

    return mid;

  }

  return -min-1;//返回值为负的插入点位置-1；

 }

如果元素不具备比较性或不是需要的

 public static int halfSearch(List<String> list,String key,Comparator<String> cmp)

 {

  int max,min,mid;

  max = list.size();

  min = 0;

  while(min<max)

  {

   mid =(min+max)>>1;

   String str = list.get(mid);

   int num = cmp.compare(str,key);

   if(num>0)

    max = mid -1;

   else if(num<0)

    min = mid+1;

   else

    return mid;

  }

  return -min-1;//返回值为负的插入点位置-1；

 }

 

 public static void sortDemo()//按照指定方法排序

 {

  List<String> list = new ArrayList<String>();

  list.add("acvd");

  list.add("aey");

  list.add("tt");

  list.add("wrt");

  list.add("qq");

  sop(list);

  Collections.sort(list);//对List集合元素进行自然排序

  Collections.sort(list,new StrLenComparator());//按照指定方法排序

  sop(list);

 }

}

class StrLeComparator implements Comparator<String>//自定义排序方法

{

 public int compare(String s1,String s2)

 {

  if(s1.length()>s2.length())

   return 1;

  if(s1.length()<s2.length())

   return -1;

  return s1.compareTo(s2);

 }

}

Collections.fill(list,"pp");//将list集合中的元素都替换成"pp".

List<String> list = new ArrayList<String>();

  list.add("acvd");

  list.add("aey");

  list.add("tt");

  Collection.fill(list,"pp");

变成"pp","pp","pp"

Collections.replaceAll(List list,"aaa","pp");将list集合中的aaa替换成pp

Collections.reverse(List list);//将list集合中元素反转

Collections.reverseOrder();//对比较器方式强行逆转

class Demo

{

 public static void main(String[]args)

 {

  TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());

  //如果想将自己建立的比较器逆转，例如自建的为new Comp();

  //TreeSet<String> ts = new TreeSet<String>(Collection.reverseOrder(new Comp()));

  ts.add("refre");

  ts.add("wwed");

  ts.add("effdff");

  ts.add("qee");

 }

}

Collections.synchroinzedList(List list)//将List不同步的集合变为同步.

Collections.swap(List list,int i,int j);置换list集合中两个元素的位置

Collections.shuffle(List list);对list进行重新随机排序.

Arrays数组工具类:

Arrays.toString(arr)将数组转为字符串。

asList:将数组变成List集合。

把数组变成集合的好处:可以使用集合的思想和方法操作数组中元素.注意:但是不可以使用集合的增删方法.因为数组长度一定

UnsupportedOperationException//不支持操作异常

import java.util.*;

class Demo

{

 public static void main(String[]args)

 {

  int []arr ={3,4,5};

  System.out.printlin(Arrays.toString(arr));

 }

}

int[] nums = {2,3,4}

List<int[]> li = Arrays.asList(nums);

sop(li);结果为数组[LL@II3C]

如果数组中的元素都是对象,那么变成集合时,数组中的元素直接转成集合中的元素

如果数组中的元素都是基本数据类型,那么会将该数组作为集合的元素存在

Integer[] nums ={2,3,4};

List<Integer> li = Arrays.asList(nums);//注意泛型，因为现在集合中元素师以Integer对象为对象的。

sop(li);结果为数组[2,3,4]

集合变数组:Collection接口中的toArray方法必须指定转完后的数组类型

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");

  /*1,当指定类型的数组长度小于了集合的size,该方法内部会创建一个新的长度为集合size的数组

  当数组长度大于集合的size,不会创建新数组.所以创建数组时直接创建集合size长度的就ok了

  2,为什么将集合变数组?

  为了限定元素的操作,不需要进行增删了.

  */

  String[]arr =al.toArray(new String[al.size()]);

  System.out.println(Array.toString(arr));

 }

}

高级for循环:相当于迭代器

格式:

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

{

}

对集合进行遍历只能获取元素不能对集合进行操作,有局限性.迭代器可以remove集合中元素

ListIterator可以增删改查.

ArrayList<String> al = new ArrayList<String>();

 al.add("abc1");

 al.add("abc2");

 al.add("abc3");

 for(String s : al)只能取出元素不能修改

 {

  System.out.println(s);

 }

 int[]arr={2,3,4}

 for (int i:arr)

 {

  System.out.println(i);

 }

以前的for循环和高级for循环的区别：高级for循环必须有遍历的目标。

建议在遍历数组时仍使用原来的for因为可以定义角标。

JDK1.5新特性：

可变参数,不用每一次建立数组对象,只需将操作数据传递即可

在使用时注意:可变参数一定要定义在参数列表的最后边.

show(2,3);

show(3,3,4)

public static void show(int... arr)//不用函数重载

{

}

静态导入:

import java.util.*;

import static java.util.Arrays.*;//导入的是Array这个类中的所以静态成员

import static java.uril.System.*;//导入System类中的所有静态成员

class StaticImport

{

 public static void main(String[]args)

 {

  out.println("haha");

  int[]arr = {3,1,4};

  sort(arr);

  int index = binarySearch(arr,1);

 }

}