可变参数
可变参数是如果类型确定,参数个数不确定,需要用可变参数来定义,参数的具体个数在方法调用时才能确定java把可变参数当做数组处理
可变参数的定义是jdk1.5加入的,比如main方法 public static void main(String [] args)
特点:
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个。
- ...(三个点)位于变量类型和变量名之间，前后有无空格都可以；
- 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数
可变参数一般用一个数组来包裹要传递的实参,首先，为方法定义一个数组型的参数；然后在调用时，生成一个包含了所有要传递的实参的数组；最后，把这个数组作为一个实参传递过去。
定义方式为
修饰符 返回值类型 方法名(数据类型… 变量名){}示例:
public class VariableTest {
public static void main(String[] args) {
addTest(1, 2, 3, 4, 5);
addTest("The vars's sum is : ", 1, 2, 3, 4);
}
public static void addTest(int... args) {
// 可变参数 参数类型 ... 多个参数,实际是一个数组
int sum = 0;
for (int i = 0; i < args.length; i++) {
sum += args[i];
}
System.out.println(sum);
}
public static void addTest(String str, int... args) {
// 方法有多个参数，有可变参数，可变参数要放在最后
int sum = 0;
for (int i = 0; i < args.length; i++) {
sum += args[i];
}
System.out.println(str + sum);
}
}
out:
15
The vars's sum is : 10
集合与数组的互转
集合转数组
使用集合的toArray方法,toArray()是集合的一个重载的方法,当然也可以遍历每个集合的元素,添加到数组中
如果定义的数组的长度大于集合的size,那么最后的数组的长度就是指定的大小,多出来的位置填充null
如果定义的数组的长度小于等于集合的size,转换后的数组长度等于集合的size
import java.util.ArrayList;
import java.util.List;
public class TransformTste01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//定义的数组的长度比集合size小,转换后的数组长度和集合的size一样
String[] strs = list.toArray(new String[3]);
//定义的数组的长度比集合的size大,最后数组多出来的部分补null
String[] strs1 = list.toArray(new String[6]);
for (String s : strs) {
System.out.print(s + " ");
}
System.out.println();
for (String s : strs1) {
System.out.print(s + " ");
}
}
}
out:
a b c d
a b c d null null 数组转集合
调用数组工具类Arrays类的Arrays.asList((T… a)静态方法,asList(T...a)的源码如下:
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
//Arrays类中的内部类
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
//有参构造方法
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
//省略其他方法的源码
}可以看到,返回的ArrayList不是java.util.ArrayList这个类,而是Arrays中自定义的内部类,所以转换出来的集合的操作方式和之前和集合类有所不同,
通过Arrays.asList转换出来的ArrayList不是集合框架中的ArrayList,不支持add()remove()等操作,但可以通过集合框架的ArrayList的有参构造方法,将其转换为集合框架中的ArrayList
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TransformTest02 {
public static void main(String[] args) {
String[] strs = { "a", "b", "c", "d" };
// asList(T ... a)将数组转换为集合对象
List<String> list = Arrays.asList(strs);
System.out.println(list);
// list.add("d");
//list.remove(2);// 不能使用add(),remove()等方法,报错UnsupportedOperationException,
// 因为这时的List是Arrays类中自定义的类ArrayList
// 通过以下方式,将内部类的ArrayList转换为集合框架中的ArrayList
List<String> list1 = new ArrayList<>(list);
list1.add("e");
System.out.println(list1);
}
}
out:
[a, b, c, d]
[a, b, c, d, e]
注意:将数组转化为集合,数组中的元素必须为引用数据类型,如果数组是基本数据类型,转换时会将整个数组当成一个元素
import java.util.Arrays;
import java.util.List;
public class TransformTest03 {
public static void main(String[] args) {
Integer[] inis = { 1, 2, 3, 4, 5 };
List<Integer> list1 = Arrays.asList(inis);
System.out.println(list1);//[1, 2, 3, 4, 5]
int[] ins = { 1, 2, 3, 4, 5, 6 };
List<int[]> listArr = Arrays.asList(ins);
System.out.println(listArr);//[[I@512ddf17]
}
}
out:
[1, 2, 3, 4, 5]
[[I@512ddf17]
静态导入:
导包时，如果想导入一个 (在类中是static修饰的) 方法,可以用直接导入的方式将这个方法导入进来,了解即可
import static java.util.Arrays.asList;//静态导入
import static java.util.Arrays.sort; //静态导入
import java.util.List;
public class StaticImportTest01 {
public static void main(String[] args) {
String[] strs = { "a", "b", "c", "d" };
List<String> list = asList(strs);
System.out.println(list);//[a, b, c, d]
int[] arr = { 1, 2, 5, 4 };
sort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
//1 2 4 5
}
}
out:
[a, b, c, d]
1 2 4 5