java 可變引數,集合與陣列的互轉,靜態匯入
可變引數
可變引數是如果型別確定,引數個數不確定,需要用可變引數來定義,引數的具體個數在方法呼叫時才能確定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);//[[[email protected]]
}
}
out:
[1, 2, 3, 4, 5]
[[[email protected]]
靜態匯入:
導包時，如果想匯入一個 (在類中是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