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