黑马程序员——Collections、Arrays、增强for、可变参数、静态导入
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
工具类：Collections 、Arrays。全部是静态方法。
sort（）：对List集合排序。
public static
{
}
list必须实现Comparable接口的compareTo方法。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
List list = new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("kkkk");
list.add("qq");
list.add("z");
System.out.println(list);
Collections.sort(list);//String本身包含了CompareTo方法。
System.out.println(list);
}
} Static
根据指定比较器产生的顺序对指定列表进行排序。
class myComparator implements Comparator
{
public int compare(String o1, String o2)
{
int num = ((Integer)o1.length()).compareTo(o2.length());
if(num == 0)
return o1.compareTo(o2);
return num;
}
} public static
根据元素的自然顺序，返回给定collection的最大元素。
String m = Collections.max(list);
static
使用二分搜索指定列表，已获得指定对象。必须是有序集合。
当元素存在比较方法时，可以传入一个比较器。
int index = Collections.binarySearch(list,"aaa");
如果传入的是aaaa，这返回的是(-(插入点) - 1)。
例如：aaa，abcd，kkkkk，qq，z，zz
index = -2；
则aaaa的插入点因该为1，也就是插在aaa与abcd之间。
用程序写一个二分搜索：
public static int mybinarySearch(List list,String key)
{
int start = 0;
int end = list.size()-1;
int index=(end+start)/2;
int num;
do
{
num = list.get(index).compareTo(key);//比较
if(num>0)//左边搜索
{
end = index-1;
}
else if(num<0)//右边搜索
{
start = index+1;
}
else
return index;
index = (end+start)/2;//计算中点
}while(end != start && end !=-1);
num = list.get(index).compareTo(key);
if(num>0)
return (-(index))-1;
else if(num<0)
return (-(index+1))-1;
else
return index;
}
} public static int halfSearch(List list, String key)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<=max)
{
mid = (max+min)>>1;// /2
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;
} static
使用指定元素替换指定列表中的所有元素。
Collections.fill(list,"pp");
用pp替换列表中所有元素。
练习：
将list集合中部分元素替换成指定元素。
public static void fillDemo(List list,int start,int end,String str)
{
List list1 =list.subList(start, end);
Collections.fill(list1, str);
} static
使用另一个替换列表中出现的所有某一指定值。
Collections.replaceAll(list,"aaa","pp");
static void reverse(List list)
反转指定列表中元素的顺序。
static
返回一个比较器，它强行逆转实现了Comarable接口的对象Collection的自然顺序。
public static
返回一个比较器，它强行逆转指定比较器的顺序。
TreeSet
static
返回指定列表支持的同步（线程安全的）映射。
static void swap(List list, int i, int j)
在指定列表的指定位置处交换元素。
static void shuffle(List list)
使用默认随机源对指定列表进行置换。
Arrays： 用于操作数组的工具类。
里面都是静态方法。
static String toString（数组 a）
返回指定数组内容的字符串表示形式。
public class ArraysDemo {
public static void main(String[] args)
{
int[] arr = {1,2,3};
System.out.println(Arrays.toString(arr));
}
}打印结果：
[1, 2, 3]
asList：将数组变成list集合。
static
public class ArraysDemo {
public static void main(String[] args)
{
String[] arr1 = {"abc","cc","kkkk"};
List list = Arrays.asList(arr1);
System.out.println(list);
}
} [abc, cc, kkkk]
//把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
list.contains("cc");
判断cc是否存在于数组中。
list.add("qq").//UnsupportedOperationException 不支持的操作异常。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定的。
可以使用：
contains。
get
indexOf（）
subList（）
如果你增删了，那么会发生UnsupportedOperationException。
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
例如：
int[] nums = {2,4,5};
List
list集合中只有一个元素，这个元素就是这个nums数组。
Integer[] nums = {2,4,5};
List
list集合中存在三个元素。
集合变数组：
Collection接口中的toArray（）方法。
Object[] toArray()
返回包含此Collection中所有元素的数组。
返回包含此Collection中所有元素的数组；可以指定类型。
import java.util.ArrayList;
import java.util.Arrays;
/*
* 集合变数组。
* Collection接口中的toArray方法。
*/
public class CollectionToArray {
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
/*
* 1.指定类型的数组到底要定义多次呢？
* 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
* 当指定类型的数组长度大于了集合的size，就不会新创建数组。但是该数组多出的部分都为空。
* 所以得创建一个刚刚好的数组，达到最优。
*
*2.为什么要将集合变数组？
* 为了限定对元素的操作。限定对集合的增删。
*
*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
List类型的集合有两种元素取出方式，因为有角标。
Set类型的集合只有一种取出方式，就是interator。
public interface Iterable
实现这个接口允许对象成为foreach语句的目标。 JDK1.5版本开始。
高级for循环
格式：
for（数据类型 变量名： 被遍历的集合(Collection)或者数组）
｛｝
//方法一
for(String s : al)//s相当于指针，指向集合中的元素。
System.out.println(s);
//方法二
Iterator it = al.iterator();
while(it.hasNext())
System.out.println(it.next()); 对集合进行遍历。
只能获取元素。但是不能对集合进行操作。
迭代器除了遍历还可以remove集合中的元素。
如果使用的是ListIterator，还可以在遍历过程中进行增删改查的动作。
传统for和高级for有什么区别？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义脚表。
//两种遍历Map集合的方法
HashMap hm = new HashMap();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
//方法一
Set keySet = hm.keySet();
for(Integer i : keySet)
System.out.println(i+"::"+hm.get(i));
//方法二
for(Map.Entry me : hm.entrySet())
System.out.println(me.getKey()+"::"+me.getValue()); /*
* JDK1.5版本出现的新特性。
* 方法的可变参数。
* 在使用时注意：可变参数一定要定义在参数列表最后面。
*/
public class ParamMethodDemo {
public static void main(String[] args)
{
/*
* 可变参数。
* 一种数组参数的简写形式。
* 不用每一次都手动的建立数组对象。
* 只要将要操作的元素作为参数传递即可。
* 隐式的将这些参数封装成了数组。
*/
show(2,3,4,5,6,7);
show("haha",2,3,4,5,6);
}
public static void show(int... arr)
{
System.out.println(arr.length);
}
public static void show(String str,int... arr)
{
System.out.println(str+"::"+arr.length);
}
}静态导入：
/*
* StaticImport 静态导入。
* 当类名重名时，需要指定具体的包名。
* 当方法重名时，指定具备所属的对象或者类。
*/
import static java.util.Arrays.*;//导入的是Arrays这个类中所有静态成员。
import static java.lang.System.*;//导入System这个类中所有的静态成员。
import java.util.Arrays;
public class StaticImport {
public static void main(String[] args)
{
int[] arr = {3,1,5};
sort(arr);
int index = binarySearch(arr,1);
//当方法重名时，指定具备所属的对象或者类。
out.println(Arrays.toString(arr));
out.println("Index="+index);
}
}
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------