java List操作

package shaohv.List;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class ListOperate {
	/*
	 * 1、List支持泛型
	 * 2、List是个接口不能实例化，其具有ArrayList,LinkedList,Vector,Stack四个实现类
	 */
	public static void main(String[] args) {
		/*
		 * 1. java List的基本用法
		 */
		//1.1 ArrayList类实现一个可增长的动态数组
		System.out.println("\n1.1 ***************************");
	    List<String> list = new ArrayList<String>();
	    // 插入元素
	    list.add("list1");
	    list.add("list2");
	    // 打印list的大小
	    System.out.println(list.size());
	    // 按索引移除元素
	    list.remove(0);
	    // 按对象移除元素
	    list.remove("list2");
	    // 打印list的大小
	    System.out.println(list.size());
	    // 清空list
	    list.clear();
	    
	    
        //1.2 LinkedList类实现了链表，可初始化化为空或者已存在的集合
	    System.out.println("\n1.2 ***************************");
        LinkedList<String> list2 = new LinkedList<String>();
        // 插入元素
        list2.add("list2");
        list2.add("list3");
        // 向链表头插入数据
        list2.addFirst("list1");
        // 向链表尾插入数据
        list2.addLast("list4");
        for (String str : list2) {
            System.out.println(str);
        }
        // 获取链表头数据
        System.out.println("链表头数据:" + list2.getFirst());
        // 获取链表尾数据
        System.out.println("链表尾数据:" + list2.getLast());
        
        
        /*
         * 2. java List的排序
         */
        //2.1 数字排序
        System.out.println("\n2.1 ***************************");
        // 创建list
        List<Integer> list3 = new ArrayList<Integer>();
        // 插入元素
        list3.add(2);
        list3.add(0);
        list3.add(3);
        list3.add(4);
        list3.add(1);
        Collections.sort(list3);
        for (int i : list3) {
            System.out.println(i);
        }
        
        //2.2 中文排序
        System.out.println("\n2.2 ***************************");
        ArrayList<String> list4 = new ArrayList<String>();
        list4.add("一鸣惊人-Y");
        list4.add("人山人海-R");
        list4.add("海阔天空-H");
        list4.add("空前绝后-K");
        list4.add("后来居上-H");
        Comparator<Object> cmp = Collator.getInstance(java.util.Locale.CHINA);
        Collections.sort(list4, cmp);
        for (String str : list4) {
            System.out.println(str);
        }
        
        //2.3 实体排序
        System.out.println("\n2.3 ***************************");
        List<User> userlist = new ArrayList<User>();
        userlist.add(new User("易小星 ", 33));
        userlist.add(new User("王大锤", 33));
        userlist.add(new User("tom", 3));
        userlist.add(new User("bob", 3));
        userlist.add(new User("王大大", 33));
        Comparator<User> cmp2 = new ComparatorUser();
        Collections.sort(userlist, cmp2);
        for (User user : userlist) {
            System.out.println(user.getName());
        }
        
        
        /*
         * 3. List 遍历
         */
        System.out.println("\n3. ***************************");
        List<String> list5 = new ArrayList<String>();
        // 插入元素
        list5.add("list1");
        list5.add("list2");
        list5.add("list3");
        System.out.println("第一种遍历方法 - >");
        for (String str : list5) {
            System.out.println(str);
        }
        System.out.println("第二种遍历方法 - >");
        for (int i = 0; i < list5.size(); i++) {
            System.out.println(list5.get(i));
        }
        System.out.println("第三种遍历方法 - >");
        Iterator<String> iter = list5.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
        
        /*
         * 4. Stack
         */
        System.out.println("\n4. ***************************");
        Stack<String> s = new Stack<String>();
        s.push("abc");
        s.push("xyz");
        s.push("zzz");
        s.pop();
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
        	System.out.println(it.next());
        }
        
        Stack<Integer> s2 = new Stack<Integer>();
        s2.push(1);
        s2.push(2);
        s2.push(3);
        s2.pop();
        Iterator<Integer> it2 = s2.iterator();
        while(it2.hasNext()){
        	System.out.println(it2.next());
        }
	}
}

class ComparatorUser implements Comparator<User> {
    @Override
    public int compare(User u1, User u2) {
        // 先按年龄排序
        int flag = u1.getAge().compareTo(u2.getAge());
        // 年龄相等比较姓名
        if (flag == 0) {
            return u1.getName().compareTo(u2.getName());
        } else {
            return flag;
        }
    }
}
class User {
    private String name;
    private Integer age;
    public User() {
        super();
    }
    public User(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

结果输出：

1.1 ***************************
2
0

1.2 ***************************
list1
list2
list3
list4
链表头数据:list1
链表尾数据:list4

2.1 ***************************
0
1
2
3
4

2.2 ***************************
海阔天空-H
后来居上-H
空前绝后-K
人山人海-R
一鸣惊人-Y

2.3 ***************************
bob
tom
易小星 
王大大
王大锤

3. ***************************
第一种遍历方法 - >
list1
list2
list3
第二种遍历方法 - >
list1
list2
list3
第三种遍历方法 - >
list1
list2
list3

4. ***************************
abc
xyz
1
2