黑马程序员---集合框架工具类Collections,数组工具类Arrays常见方法以及1.5版本新特性（高级for，可变参数和静态导入）

------- android培训、java培训、期待与您交流！ ----------

集合框架工具类：Collections
通过程序练习常用方法：

import java.util.*;
public class CollectionsDemo
{
public static void main(String[] args)
{

//fill(l,"x");将l集合内元素替换成x
//replaceAll(l,old,new);将l内的old值替换成new值
//reverse(l);将l集合顺序反转
//swap(l,1,2);将集合的1,2角标元素互换。
sortDemo();

//MaxDemo();

//binarySearchDemo();
}
//sort();不能给Set排序，因为Set有TreeSet
public static void sortDemo()
{
List<String> l=new ArrayList<String>();

l.add("rgdsh");
l.add("dg");
l.add("gfdhth");
l.add("dsggr");
l.add("nhm");

sop(l);
Collections.sort(l);//重复的也能存。因为ArrayList是数组结构。
sop(l);
Collections.shuffle(l);//随机顺序
sop(l);
Collections.sort(l,new LengthComparator());//将自定义的比较器传入sort方法
sop(l);
}

//max()
public static void MaxDemo()
{
List<String> l=new ArrayList<String>();

l.add("rgdsh");
l.add("dg");
l.add("gfdhth");
l.add("dsggr");
l.add("nhm");

sop(Collections.max(l));
//将自定义长度比较器传入max方法，结果是最大长度
sop(Collections.max(l,new LengthComparator()));//注意要“new”对象
}

//binarySearch();要用到此方法，集合必须是有序的。
public static void binarySearchDemo()
{
List<String> l=new ArrayList<String>();

l.add("rgdsh");
l.add("dg");
l.add("gfdhth");
l.add("dsggr");
l.add("nhm");

Collections.sort(l);//先让集合有序
int index= Collections.binarySearch(l,"dg");
sop(index);
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

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

 

集合变数组：

import java.util.*;

public class CollectionsToArray
{
public static void main(String[] args)
{
//为什么要将集合变成数组？ 为了限制操作，不让增删。
ArrayList<String> al=new ArrayList<String>();

al.add("123");
al.add("eg");
al.add("tre");
al.add("er");
String[] arr=al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}

 reverseOrder()方法

import java.util.*;
//其实reverseOrder()返回的比较器就是将接口颠倒后，如下

class mfreverseOrder implements Comparator<String>
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);//此处颠倒
}
}

public class CollectionsDemo2
{
public static void main(String[] args)
{
orderDemo();
}

public static void orderDemo()
{
//如果TreeSet传入自定义的长度比较器则按长度排序完成后还按照TreeSet的默认自然顺序次排序。
//还可以将自定义的比较器传入reverseOrder(),如Collections.reverseOrder(new LengthComparator());将自定义的比较器反转
TreeSet<String> t=new TreeSet<String>(Collections.reverseOrder());//此处传入reverseOrder();返回的比较器会反转顺序

t.add("fagh");
t.add("adrfgr");
t.add("cvd");
t.add("egh");
t.add("h");
//TreeSet用迭代器是自然顺序。
Iterator<String> it=t.iterator();
while(it.hasNext())
{
sop(it.next());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

数组工具类： Arrays;

里面都是静态方法

 

import java.util.*;
public class ArraysDemo
{
public static void main(String[] args)
{
Integer[] arr={3,42,5};
sop(Arrays.toString(arr));//直接用Arrays里的toString()实现打印，以前使用StringBuffer实现。

//asList();将数组变成集合
//好处：可以用集合的方法操作数组，但不可以增删，其他不影响长度的方法都可以使用。
List<Integer> l=Arrays.asList(arr);//数组元素是对象则变成集合元素，是基本数据类型则该数组变成元素。
sop(l);
}
public static void sop(Object obj)
{
System.out.println(obj);
}

}

 

高级for循环：

public class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al=new ArrayList<String>();

al.add("123");
al.add("eg");
al.add("tre");
al.add("er");

//ArrayList集合取出元素有两种方式：Set只有一种取出方式
/*
*用高级for只能获取不能操作
*用iterator可以进行remove
*用ListIterator可以进行增删改查 */
//1.Iterator
Iterator<String> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}//2.for循环
for(int x=0;x<100;x++)//可以定义初始化值和条件，在数组遍历时使用传统for，可以定义数组角标

//1.5以后 高级for   不改变集合中的元素  也可以操作数组
for(String s: al)
{
System.out.println(s);
}
HashMap<Integer,String> h=new HashMap<Integer, String>();
h.put(1,"a");
h.put(2,"d");
h.put(3,"f");
//取出HashMap先变成Set

Set<Integer> keySet=h.keySet();
//keySet()
for(Integer i: keySet)
{
System.out.println(i+h.get(i));
}//entrySet()
for(Map.Entry<Integer,String> e: h.entrySet())
{
System.out.println(e.getKey()+e.getValue());
}
}}

 

1.5版本新特性

1，可变参数

public class ParamMethodDemo
{
public static void main(String[] args)
{
show(1,3,5);
}public static void show(int... arr)//可变参数的，不用new了，简化书写。可以写成(String str,int... arr)可变参数定义在后边
{
System.out.println(arr.length);
}}

 

2，静态导入

import java.util.*;
import static java.util.Arrays.*;
public class StaticImport
{
public static void main(String[] args)
{
int[] arr={2,44,6};

/*Arrays.*/sort(arr);
int index=/*Arrays.静态导入后就可以不写了*/binarySearch(arr,44);
System.out.println(Arrays./*这个得写，为了区分*/toString(arr));
}}