JAVA之list使用

1.定義和初始化

（1）創建空list，然後逐一添加

List<Integer> list=new ArrayList<>();
list.add(1);list.add(2);

如果不規定List的類型，是可以添加不同的元素的，但是會使代碼可讀性下降。

List list=new ArrayList<>();
list.add(1);list.add("str");list.add(false);
System.out.println(list);
//>[1, str, false]

（2）雙大括號法（匿名內部類法）

List<Integer> list1=new ArrayList(){{
	add(1);add(2);
}};

List list2=new ArrayList(){{
    add(1);add("str");add(false);
}};

（3）Arrays.asList

List<Integer> list=Arrays.asList(1,2,3);

這裏有一個問題：
Arrays.asList返回的不是List，也不是ArrayList，而是Arrays.ArrayList。
Arrays重寫了ArrayList，裏面沒有add、insert、remove等方法，返回的是一個定長數組。如果調用add、insert、remove等方法會報錯。

List<Integer> list= Arrays.asList(1,2,3);
list.add(5);
//>>Exception in thread "main" java.lang.UnsupportedOperationException
//這個異常來自於Arrays.ArrayList繼承的AbstractList

改善的方法如下，用ArrayList再包裝一層，這樣最後獲得的就是ArrayList了

List<Integer> list1=new ArrayList<>(Arrays.asList(1,2,3));
List<String> list2=new ArrayList<>(Arrays.asList("a,b,c".split(",")));

還有一個問題：
List指定的類型只能是引用類型或包裝類型，比如List<Integer>、List<String>等，所以當用Arrays.asList給List賦值時不能用基礎類型，因爲類型不對等。

int[]arr={1,2,3};
List<Integer> list= Arrays.asList(arr);
//會報錯，編譯不過

Integer[] arr=new Integer[]{(Integer)1,(Integer)2};
List<Integer> list=Arrays.asList(arr);
//這樣纔對，但很麻煩，仍然是一個不可變長的list

String[] arr=new String[]{"a","b","c"};
List<String> list=Arrays.asList(arr);
//這也是對的，但仍然是一個不可變長的list

當然如果List不指定類型的話，這樣編譯可以通過，但是出來的結果很弔詭。

int[] arr=new int[]{1,2,3};
List L=Arrays.asList(arr);
System.out.println(L);
//>[[I@71bc1ae4]
System.out.println(L.size());
//>1
System.out.println(L.get(0));
//>[I@71bc1ae4
System.out.println(L.get(0).getClass().toString());
//>class [I

如果用ArrayList再包一層出來的結果也是一樣的

int[] arr=new int[]{1,2,3};
List<Integer> L=new ArrayList(Arrays.asList(arr));
System.out.println(L);
//>[[I@71bc1ae4]
System.out.println(L.size());
//>1

所以如果是基本類型要賦值給list的話，只能一個一個逐一添加。

int[] arr={4,5,6};
List<Integer> L=new ArrayList<>();
for(int i:arr){
	L.add(i);
}

如果要賦值給引用類型，就可以用ArrayList再包一層，就是正常的ArrayList了

Integer[] arr1=new Integer[]{(Integer)1,(Integer)2};
String[] arr2 = new String[]{"a", "b", "c"};
List<Integer> list1=new ArrayList<>(Arrays.asList(arr1));
List<String> list2 = new ArrayList<>(Arrays.asList(arr2));
list1.add(3);
System.out.println(list1);
//>[1, 2, 3]
list2.add("d");
System.out.println(list2);
//>[a, b, c, d]

（4）list.addAll
List除了add函數還有addAll函數，可以一次添加整個容器進來

int[] arr=new int[]{1,2,3};
Integer[] arr2=new Integer[]{(Integer)1,(Integer)2};
List<Integer> list1=new ArrayList<>();
list1.addAll(arr);
//>報錯，編譯不通過
list1.addAll(arr2);
//>報錯，編譯不通過

List<Integer> list2=new ArrayList(Arrays.asList(1,2,3));
Set<Integer> set1=new HashSet(){{
	add(4);add(5);
}};
list1.addAll(list2);
System.out.println(list1);
//>[1, 2, 3]
list1.addAll(set1);
System.out.println(list1);
//>[1, 2, 3, 4, 5]

（5）Collections.addAll
可以利用Collections工具包添加，但使用很有限

List<Integer> list1=new ArrayList();
List<Integer> list2=new ArrayList(Arrays.asList(1,2,3));
int[] arr=new int[]{1,2,3};
Integer[] arr2=new Integer[]{(Integer)1,(Integer)2};
Collections.addAll(list1,list2);
//>報錯，編譯不通過
Collections.addAll(list1,arr);
//>報錯，編譯不通過
Collections.addAll(list1,arr2);
System.out.println(list1);
//>[1, 2]

String[] arr3=new String[]{"a","b","c"};
List<String> list3=new ArrayList<>();
Collections.addAll(list3,arr3);
System.out.println(list3);
//>[a, b, c]

（6）com.google.guava工具類

List<Integer> list1=Lists.newArrayList();
list1.add(1);list1.add(2);

String[] arr2=new String[]{"a","b","c"};
List<String> list2=Lists.newArrayList(arr2);
System.out.println(list2);
//>[a, b, c]
list2.add("d");
System.out.println(list2);
//>[a, b, c, d]
        
int[] arr3=new int[]{1,2,3};
List<Integer> list3 = Lists.newArrayList(arr3);
//>報錯，編譯不通過
List<Integer> list3 = Ints.asList(arr3);
System.out.println(list3);
//[1, 2, 3]
list3.add(4);//不可變長數組
//>Exception in thread "main" java.lang.UnsupportedOperationException

List<Integer> list3 = Lists.newArrayList(Ints.asList(arr3));
System.out.println(list3);
//[1, 2, 3]
list3.add(4);
System.out.println(list3);
//[1, 2, 3, 4]成功！！！！！

（7）stream—Java8之後

int[] arr=new int[]{1,2,3};
List<Integer> list= IntStream.of(arr).boxed().collect(Collectors.toList());
System.out.println(list);
//[1, 2, 3]
list.add(4);
System.out.println(list);
//[1, 2, 3, 4]成功！！！！！

2.新增

（1）添加到末尾

list.add("a");

（2）添加到指定位置

list.add(1,"a");
list.add(2,list2);

3.刪除

（1）刪除第一個匹配的元素

list.remove("a");

（2）刪除指定位置的元素

list.remove(1);

這裏有一個問題:
如果list裏面存的本來就是Integer，那remove(1)只會刪掉位置爲1的元素，不會刪掉數字是1的元素，如果想刪掉應該這麼寫：list.remove((Integer)1);

4.訪問元素

 list.get(1); //以下標來訪問

5.查詢元素

 list.indexOf("a"); //沒有會返回-1

6.獲取大小

 list.size();

7.清空

 list.clear();

8.判斷是否爲空

 list.isEmpty();

9.打印

（1）逐個遍歷然後打印

for(int i=0;i<list.size();i++)
	System.out.println(list.get(i));

（2）直接打印

System.out.println(list);

10.遍歷

（1）Iterator迭代器

Integer value=null;
Iterator iter=list.iterator();
while(iter.hasNext()){
	value=(Integer)iter,next();
	System.out.println(value);
 }

（2）for循環

for(int i=0;i<list.size();i++)
	System.out.println(list.get(i));

（3）foreach循環

for(Integer i:list)
	System.out.println(list);

11.排序

Integer[] arr=new Integer[]{(Integer)4,(Integer)2,(Integer)3};
List<Integer> list1=Lists.newArrayList(arr);
Collections.sort(list1);
System.out.println(list1);
//>[2, 3, 4]

12.list、數組、字符串之間的各種轉換

• 數組轉list，其實也就是初始化

System.out.println("int[]轉List<Integer>");
int[] arr=new int[]{1,2,3};
List<Integer> list = Lists.newArrayList(Ints.asList(arr));
//or
int[] arr=new int[]{1,2,3};
List<Integer> list= IntStream.of(arr).boxed().collect(Collectors.toList());

System.out.println("Integer[]轉List<Integer>");
Integer[] arr1=new Integer[]{(Integer)1,(Integer)2,(Integer)3};
List<Integer> list1=new ArrayList<>(Arrays.asList(arr1));
//or
List<Integer> list1=new ArrayList<>();
Collections.addAll(list1,arr1);
//or
List<Integer> list1=Lists.newArrayList(arr1);

System.out.println("String[]轉List<String>");
String[] arr2 = new String[]{"a", "b", "c"};
List<String> list2 = new ArrayList<>(Arrays.asList(arr2));
//or
List<String> list2 = new ArrayList<>();
Collections.addAll(list2,arr2);
//or
List<String> list2=Lists.newArrayList(arr2);

• list轉數組

//List<Integer>轉[]
System.out.println("List<Integer>轉Integer[]");
Integer[] arr1=list1.toArray(new Integer[]{});
System.out.println("List<Integer>轉int[]");
int[] arr2=list1.stream().mapToInt(Integer::intValue).toArray(); 
System.out.println("List<Integer>轉String[]");
String[] arr3=list1.stream().map(Objects::toString).toArray(String[]::new);

//——————————————————————————————————————————————————————————————————   

//List<String>轉[]
System.out.println("List<String>轉Integer[]");
Integer[] arr1=list2.stream().mapToInt(Integer::parseInt).boxed().toArray(Integer[]::new);
System.out.println("List<String>轉int[]");
int[] arr2=list2.stream().mapToInt(Integer::parseInt).toArray();
System.out.println("List<String>轉String[]");
String[] arr3=list2.toArray(new String[]{}); 

• list轉list

System.out.println("List<Integer>轉List<String>");
List<String> list2=list1.stream().map(String::valueOf).collect(Collectors.toList());

System.out.println("List<String>轉List<Integer>");
List<Integer> list1=list2.stream().mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());

• 數組轉數組

Integer[] arr=new Integer[]{(Integer)1,(Integer)2,(Integer)3};
System.out.println("Integer[]轉int[]");
int[] arr1=Arrays.stream(arr).mapToInt(Integer::intValue).toArray();
//or
int[] arr2=ArrayUtils.toPrimitive(arr);
       
System.out.println("Integer[]轉String[]");
String[] arr3=Arrays.stream(arr).map(String::valueOf).toArray(String[]::new);

//——————————————————————————————————————————————————————————————————
String[] arr=new String[]{"1","2","3"};
System.out.println("String[]轉int[]");
int[] arr1=Stream.of(arr).mapToInt(Integer::parseInt).toArray();
       
System.out.println("String[]轉Integer[]");
Integer[] arr2=Stream.of(arr).mapToInt(Integer::parseInt).boxed().toArray(Integer[]::new);
   
//——————————————————————————————————————————————————————————————————
int[] arr=new int[]{1,2,3};
System.out.println("int[]轉Integer[]");
Integer[] arr1=IntStream.of(arr).boxed().toArray(Integer[]::new);
//or
Integer[] arr2= ArrayUtils.toObject(arr);

System.out.println("int[]轉String[]");
String[] arr3=Arrays.stream(arr).boxed().map(String::valueOf).toArray(String[]::new);

• list轉String

System.out.println("List<Integer>轉String");
String str1=list1.toString();
System.out.println(str1);
//>[1, 2, 3]
System.out.println(str1.substring(1,str1.length()-1));
//>1, 2, 3
String str2=list1.stream().map(String::valueOf).collect(Collectors.joining());
System.out.println(str2);
//>123
     
System.out.println("List<String>轉String");
System.out.println(list2.toString());
//>[a, b, c]
System.out.println(StringUtils.join(list2,""));
//>abc

• 數組轉String

System.out.println("無論什麼數組都一樣");
String str1=Arrays.toString(arr);

• int、Integer、String的轉換

int i=1;
System.out.println("int轉Integer");
Integer I=(Integer) i;
System.out.println("int轉String");
String str=String.valueOf(i);

Integer I=2;
System.out.println("Integer轉int");
int i=(int)I;
//or
int i=I.intValue();
System.out.println("Integer轉String");
String str=I.toString();

String str="3";
System.out.println("String轉int");
int i=Integer.parseInt(str);
System.out.println("String轉Integer");
Integer I=Integer.parseInt(str);

13.線程安全

list線程不安全，線程之間互相操作可能會擦除數據。解決方法有三種：
（1）改用vector
（2）繼承list並重寫方法，加上synchronized關鍵字。
（3）List<Integer> list=Collections.synchronizedList(new ArrayList());