集合相关代码

public class Test05 {
    public static void main(String[] args) {
        //Collection 集合只能存储引用类型
        //泛型
        //Integer 是int类型对应的数字包装类
        List list1 = new ArrayList<Integer>();
    //    ArrayList list2 = new ArrayList<Integer>();//既可以访问接口的方法，也可以访问自己的方法
        System.out.println(list1.size());//打印长度
        
        //Integer 类会自动打包int型数据为Interger对象
        list1.add(5);
        list1.add(100);
        list1.add(13);
        System.out.println(list1.get(1));//输出下标为1的数
        list1.set(1, 200);//设置下标为1的值为200
        System.out.println(list1.get(1));
        
        list1.add(0, 2222);//在下标为0的位置添加2222
        //遍历
        for(int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }
        System.out.println("-----------");
        //迭代器 为了遍历集合而存在
        Iterator<Integer> it = list1.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------");
        //forEach
        list1.forEach(new Consumer<Integer>() {

            @Override
            public void accept(Integer t) {
                // TODO Auto-generated method stub
                System.out.println(t + 100);
            }
        });
        
        System.out.println("---------------");
        foreach(list1, new Consumer<Integer>() {

            @Override
            public void accept(Integer t) {
                // TODO Auto-generated method stub
                System.out.println(t + 10000);
            }
        });
        
        list1.sort(new Comparator<Integer>() {
            //类似提供了升序降序的方法
            @Override
            public int compare(Integer o1, Integer o2) {
                // TODO Auto-generated method stub
                return o1 - o2;//升序 ，反过来则降序
            }
        });
        list1.forEach(new Consumer<Integer>() {

            @Override
            public void accept(Integer t) {
                // TODO Auto-generated method stub
                System.out.println(t);
            }
        });
    }
    //自定义的foreach
    public static void foreach(List<Integer> list, Consumer<Integer> t) {
        for(int i = 0; i < list.size(); i++) {
            t.accept(list.get(i));
        }
    }
}

public class Test06 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
//        for(int i = 0; i < 20; i++) {
//            int r = (int)(Math.floor(Math.random() * (80 - 20 + 1))) + 20;
//            arrayList.add(r);
//        }
//        //数组 下标遍历 forin遍历
//        //下标遍历， forin遍历，foreach遍历，迭代器遍历   效率最高的是下标遍历
//        //forin循环
//        //element in collection
//        for(Integer integer: arrayList) {
//            System.out.println(integer);
//        }
        
        
        //foreach遍历的方法
        for (int i = 1; i < 10; i++) {
            arrayList.add(i);
        }
        arrayList.forEach(new Consumer<Integer>() {

            @Override
            public void accept(Integer t) {
                // TODO Auto-generated method stub
                System.out.println(t);
            }
        });
        System.out.println("--------------");
        //删除下标为5的数 有删除动作最好用迭代器遍历 导致访问下下个元素
//        for(int i = 0; i < 8; i++) {
//            System.out.println(arrayList.get(i));
//            if(i == 5) {
//                arrayList.remove(i);
//            }
//        }
        
        //用迭代器删除不会造成下标混乱
        Iterator<Integer> it = arrayList.iterator();
        while (it.hasNext()) {
            Integer integer = (Integer) it.next();
            System.out.println(integer);
            if(integer == 6) {
                it.remove();
            }
        }
        for (Integer integer : arrayList) {
            System.out.println(integer);
        }
    }
}

public class Test07 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>(100);
        System.out.println(arrayList.size());//没有加元素，所以为0
        for(int i = 0; i < 20; i++) {
            arrayList.add(i);
        
        }
        //和下面的while循环一样
        for (Iterator iterator = arrayList.iterator(); iterator.hasNext();) {
            Integer integer = (Integer) iterator.next();
            System.out.println(integer);
        }
        
        Iterator<Integer> it = arrayList.iterator();
        while(it.hasNext()) {
            Integer integer = it.next();
            System.out.println(integer);
        }
        
        //下标遍历 简单快捷 第一选择
        //forin 非顺序集合不能使用下标，只能forin，还有下标在遍历中不需要可以使用
        //迭代器 集合遍历操作有删除添加的时候必须使用
        //foreach 一旦使用，元素操作就会进入其他对象的空间，不是函数编程的情况下慎用
    }
    
}

字符串类型

public class Test08 {
    public static void main(String[] args) {
        List<String> aList = new ArrayList<String>();
        aList.add("wang");
        aList.add("liu");
        aList.add("sun");
        aList.add("zhang");
        aList.add("liuhui");
        
        aList.sort(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                return o1.compareTo(o2);//字符串排序 按字母顺序排序
                //    return o1.length() - o2.length();//按长度升序
            }
        });
        
        for (Iterator iterator = aList.iterator(); iterator.hasNext();) {
            String string = (String) iterator.next();
            System.out.println(string);
        }
    }
}