List集合

一、数组与集合之间的相互转换

（1）数组转换为集合
通过工具类Arrays的静态方法asList可以将一个数组转换为List集合

String[] array=new String[]{"one","two","three"};
//数组转换为集合，但是对象还是同一个队形
List<String> list=Arrays.asList(array);
list.set(0,"1");//将下标为0的元素该为1
//对集合元素的操作就是对原数组的操作
System.out.println("源数组"+Arrays.toString(array));

不能直接添加或者删除元素，会导致数组扩容或者缩容，这样是不被支持（list.add(“five”）或者list.remove(“three”);如果需要添加时，可以选择复制集合的方式来添加。

List<String> list2 = new ArrayList<String>(list);
		list2.add("five");
		System.out.println("list2集合："+list2);

（2）集合转换为数组
Collection 提供了一个方法，toArray,可以将当前集合转换为数组

public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		list.add("four");
		list.add("five");
		//把集合转化为数组
		String[] s=new String[0];
		String[] str=list.toArray(s);
		for(String st:str){
			System.out.println(st);
		}
}

二、集合排序
排序集合可以使用集合的工具类
java.untl.Collections
其定义很多静态方法，用于操作集合，其中sort()方法是对list集合进行自然排序（升序）
1）对list集合进行升序排列

List<Integer> list=new List<Integer>();
for(int i=0;i<10;i++){
	list.add((int)(Math.Random()*100));
}
System.out.println(list);
//对集合进行升序排列
Collections.sort(list);
System.out.println(list);
}

2）使用比较器进行自定义比较
推荐的排序方式
当遇到排序自定义类型元素，或者集合元素自身的比较规则不满足排序时，都建议使用下面的方式排序。自定义排序方式。
该sort方法要求额外传入一个比较器规则比较集合元素并进行排序，因此排序方法不要求集合实现Comparable接口。

List<Point2> list = new ArrayList<Point2>;
list.add(new Point2(2,8));
list.add(new Point2(4,8));
list.add(new Point2(5,5));
list.add(new Point2(7,8));
list.add(new Point2(3,1));
list.add(new Point2(9,4));
System.out.println("原集合"+list);
Collection.sort(list,Comparator<String>(){
	public int compare(Point2 o1,Point2 o2){
		int len=o1.getX()*o1.getX()+o1.getY()*o1.getY();
		int olen=o2.getX()*o2.getX()+o2.getY()*o2.getY();
		return olen-len;
	}
});
System.out.println(list);

三、遍历集合
java.util.List线性表
List的特点：可重复并且有序，可以通过下标操作元素。
常用实现类:
ArrayList:内部由数组实现，查询快，增删慢；
LinkedList:内部有链表实现，查询蛮，增删快；
对于不是极端苛刻的情况下，通常使用ArrayList，含头不含尾。

public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("one");
		list.add("two");
		list.add("three");
		System.out.println(list);
		
		//获取指定位置对应的元素
		//E get(int index);
		String str = list.get(2);
		System.out.println(str);
		
		//使用传统的for循环遍历list集合
		for(int i=0;i<list.size();i++){
			String s=list.get(i);
			System.out.println(s);//获取集合中每一个元素的下标返回下标所对应的元素
		}
		
		//使用增强for循环遍历list集合
		for(String ss:list){
			System.out.println(ss);
		}
		
		//用迭代器遍历list集合
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String s=it.next();
		}
		
		//替换元素
		//E set(int index,E e)
		//将指定元素设置到指定位置上，返回原来指定位置上的元素
		String ss=list.set(1, "2");
		System.out.println(ss);
		
		//删除元素操作
		//E remove(int index)
		String old=list.remove(1);
		System.out.println(old);
		
}

四、list集合中套用list集合

public static void main(String[] args) {
		//热门推荐
		List<String> list1=new ArrayList<String>();
		list1.add("iphone");
		list1.add("honor");
		list1.add("vivo");
		
		List<String> list2=new ArrayList<String>();
		list2.add("5G手机");
		list2.add("华为");
		list2.add("小米");
		
		List<String> list3=new ArrayList<String>();
		list3.add("营业厅");
		list3.add("宽带");
		
		List<List<String>> itemize = new ArrayList<List<String>>();
		itemize.add(list1);
		itemize.add(list2);
		itemize.add(list3);
		
		for(List<String> li:itemize){
			for(String l:li){
				System.out.println(l);
			}
		}
	}

五、截取指定范围的子集
List subList(int fromIndex,int toIndex);
含头不含尾

//随机生成10个整数并存储到list集合中
//参与集合中的泛型类型必须是包装类型，因此在这里参与集合的int类型必须是它的包装类型Integer类型
public static void main(String[] args) {
		
		List<Integer> list=new ArrayList<Integer>();
		Random random=new Random();
		for(int i=0;i<10;i++){
			int num=random.nextInt(101);
			list.add(num);
		}
		System.out.println(list);
		
		//截取集合中的下标为3到8的元素
		List<Integer> sublist=list.subList(3, 8);
		System.out.println("截取后的集合子串为："+sublist);
		
		//截取元素的同时并将元素扩大10倍
		List<Integer> sublist2=list.subList(2, 7);
		for(int i=0;i<sublist2.size();i++){
			int s=sublist2.set(i, sublist.get(i)*10);
		}
		System.out.println(sublist2);
		//对子集元素操作，就是对原集合对应元素的操作
		//删除list元素第3个到第7个
		list.subList(3, 8).clear();
	}

六、线程安全的集合：
常用的集合实现类：ArrayList，LinkedList，HashSet他们都不是线程安全的，多线程情况下使用会出现并发问题。
Collections提供了将集合转换为线程安全的方法。

List<String> list=new ArrayList<String>
list.add("one");
list.add("two");
list.add("three");
list.add("four");
//将线程转换为线程安全的
list=Collections.synchronizedList(list);

Set<String> set=new HashSet<String>();
set=Collections.synchronizedList(set);