JAVA学习第四十四课 — 集合框架工具类（二）

Collections操控集合的工具类，Arrays操控数组的工具类

Arrays中方法大多是重载

重点掌握asList();将数组转为集合

static <T> List<T>

asList(T... a) 返回一个受指定数组支持的固定大小的列表。

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
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。 
前者倾向于操作数组的单个元素，后者倾向于操作整个数组

注意，数组长度是固定的，所以集合中的增删方法是不能使用的，抛出异常

如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为元素进行集合存储

如果数组中的元素是基本类型数值，那么会将数组作为集合中的元素进行存储

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 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

同样集合变数组也不能增删

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

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就是这样用的

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

静态导入

静态导入用的不多，虽然方便了一点，但阅读性变差很多

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