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