JAVA自学教程之集合框架工具类（二）。
Collections操控集合的工具类，Arrays操控数组的工具类
Arrays中方法大多是重载
重点掌握asList();将数组转为集合
static
<T> List<T> asList(T… a)
返回一个受指定数组支持的固定大小的列表。
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.Arrays;
import java.util.List;
public class Main
{
public static void main(String[] args) {
String[] str = {“e”,”bn”,”gr”,”asd”,};
List<String> list = Arrays.asList(str);
System.out.println(list.contains(“e”));
list.add(“asd”);//错误
System.out.println(list.size());
}
}
好处：可以使用集合中的方法操控数组元素
关于Array和Arrays的区别？注意
java.lang.reflect.Array
此类提供了动态创建和访问 Java 数组的方法。
java.util.Arrays
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
前者倾向于操作数组的单个元素，后者倾向于操作整个数组
注意，数组长度是固定的，所以集合中的增删方法是不能使用的，抛出异常
如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为元素进行集合存储
如果数组中的元素是基本类型数值，那么会将数组作为集合中的元素进行存储
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main
{
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
System.out.println(a.length);
List<int[]> list2 = Arrays.asList(a);//泛型就需要写成数组形式了
System.out.println(list2.size());
}
}
集合转数组
使用的就是Collection接口中的toArray方法
Object[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[] toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
同样集合变数组也不能增删
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main
{
public static void main(String[] args) {
List<String > list = new ArrayList<String>();
list.add(“asd”);
list.add(“ef”);
list.add(“rg”);
String[] strings = list.toArray(new String[5]);
//toArray方法需要传入一个指定类型的数组
//而数组的长度 如果小于集合的size，那么该方法会创建一个指定类型，长度和几个size一样的数组
// 如果大于集合的size，那么该方法会使用指定的数组，存储集合中的元素，其他位置默认null
System.out.println(Arrays.toString(strings));
}
}
建议，指定的长度为集合的size
JDK 1.5新特性
高级for循环
for(String : arr)
但是高级for不能遍历，map集合这样的双列集合，可以把map变单列的set，再用for
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.HashMap;
import java.util.Map;
public class Main
{
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, “asd”);
map.put(5, “ad”);
map.put(4, “sd”);
for(Integer i : map.keySet()){
String va = map.get(i);
System.out.print(i+”:”+va+” “);
}
System.out.println(“————————”);
for(Map.Entry<Integer, String> me : map.entrySet()){
System.out.print(me.getKey()+”:”+me.getValue()+” “);
}
}
}
函数可变参数
其实就是一个数组，但是接收的是数组元素。且自动将这些元素，简化了调用者的书写
注意，可变参数类型，必须定义在参数列表的后面
往上看，asList就是这样用的
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.HashMap;
import java.util.Map;
public class Main
{
public static void main(String[] args) {
int arr[] = {1,2,3,4,5,6,7,8,9};
int sum = add(arr);
System.out.println(sum);
int sum1 = newadd(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);
System.out.println(sum1);
}
//public static int newadd(int… arr，int a) 错误
//public static int newadd(int a，int… arr) 正确
public static int newadd(int… arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
public static int add(int a,int b,int c){
return a+b+c;
}
public static int add(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
}
静态导入
静态导入用的不多，虽然方便了一点，但阅读性变差很多
[html] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.sort;//静态导入
import static java.util.Collections.*;//导入Collections所有
import static java.lang.System.*;//同样System也可以
//其实导入的类中的静态成员
public class Main
{
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add(“a4″);
list.add(“a2″);
list.add(“a1″);
list.add(“a42″);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
sort(list);//就不需要每次都写Collections
out.println(list);
}
}