码讲——List

/**===============List======================
* List集合是可重复集，有序，可根据下标操作元素
* ArrayList：数组实现，利于查询不利于增删
* LinkedList:链表实现，利于增删不利于查询
==========================================================*/
public class ListDemo {
private static final long LEVEL = 20150701;//本码讲版本
/*
* ArrayList基本操作
*/
public void ArrayListTest() {
//创建及添加
List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");
list.add("four");
//get 遍历
printList(list);
//set 返回值为原位置上的元素，用于替换操作
System.out.println("原位置："+list.set(3, "five"));
System.out.println("现位置："+list.get(3));
//add(int,E) 用于插入操作
System.out.println("=======插入");
list.add(3, "four");
printList(list);
//remove 删除操作 返回所删除的元素
System.out.println("=======删除"+list.remove(4));
printList(list);
}
private void printList(List<String> list){
for (int i = 0; i < list.size(); i++) {
String str = list.get(i);
System.out.println("遍历"+str);
}
System.out.println("End=========");
}

/**
* 子集合操作
*/
public void test2(){
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
//subList
List<Integer> sub = list.subList(3, 8);
System.out.println(sub);
//扩大10倍
for (int i = 0; i < sub.size(); i++) {
sub.set(i, sub.get(i)*10);
}
System.out.println(sub);
//sub出来子集与原集合中的操作的是同一个内容，所以操作子集相当于操作原集合
System.out.println(list);
//删除原集合中的一部分内容的方法
sub = list.subList(3, 8);
sub.clear();
System.out.println(list);
}
/**
* 集合与数组的互相转换
*/
public void test3(){
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
//List to Array
//这里数组大小给多少都可以，这样最好，不够会自动创建够的，多出会为null，
Integer[] arr  = list.toArray(new Integer[list.size()]);
System.out.println("List to Array:"+Arrays.toString(arr));

//数组转为集合 只能转换为List 转为集合后不能做增删元素操作(可以修改)，因为集合和数组操作的是相同的元素，修改集合元素等于修改数组
String [] array = {"one","two","three"};
List<String> listS = Arrays.asList(array);
System.out.println("Array to List:"+listS);
listS.set(0, "1");
//若想进行增删操作，可新建list，copy过去进行操作
//该构造方法的参数只要是集合就可以，不限定必须是同类集合，但将list传给set有可能丢失元素
List<String> listCopy = new ArrayList<String>(listS);
listCopy.add("four");
System.out.println("修改后list:"+listS+" array："+Arrays.toString(array)+" \n复制更改的："+listCopy);
}
/**
* 集合的排序 Collections
*/
public void test4(){
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(new Random().nextInt(100));
}
System.out.println(list);
Collections.sort(list);
System.out.println("list 排序："+list);
}
/**
* 集合的排序 排序器
*/
@Test
public void testCom(){
//排序对象提供了比较方法
System.out.println("对象自带比较器：");
List<Point> list = new ArrayList<Point>();
list.add(new Point(5,6));
list.add(new Point(1,2));
list.add(new Point(7,9));
list.add(new Point(4,7));
//未实现前编译出错，sort方法要求比较的集合必须实现类Comparable接口
//<T extends Comparable<? super T>>
System.out.println("排序前："+list);
Collections.sort(list);
System.out.println("排序后："+list);
//排序对象为提供排序方法
System.out.println("自定义比较器：");
List<String> list2 = new ArrayList<String>();
list2.add("囧浪费多个");
list2.add("到泛赛");
list2.add("单例");
System.out.println("排序前："+list2);
Collections.sort(list2, new Comparator<String>(){
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
System.out.println("排序前："+list2);

}
}