集合 Collection List Set 迭代器 Iterator 元素排序

/**
 * java.util.Collection 接口
 * 集合框架
 * 集合是用来保存一组元素的，不同的实现类实现了不同数据结构。
 * Collection是所有集合的顶级接口，规定了所有集合都必须具备的功能。
 * 
 * 集合与数组一样，保存一组元素，但是操作元素的方法集合已经提供了。
 * 
 * Collection下面有两个常见的子接口(分类)
 * java.util.List:线性表，特点是可以存放重复元素，并且有序。
 * java.util.Set:不可以重复的集合，大部分实现类是无序的。
 * 
 * 是否为重复元素是根据元素自身equals比较的结果判定的。
 */
public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        /*
         * boolean add(E e)
         * 向集合中添加元素
         * 若成功添加则返回值为true。
         */
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);
        /*
         * int size()
         * 返回当前集合的元素个数
         */
        int size = c.size();
        System.out.println("size:"+size);    
        /*
         * boolean isEmpty()
         * 判断当前集合是否为空集
         */
        boolean isEmpty = c.isEmpty();    
        System.out.println("是否为空集:"+isEmpty);    
        /*
         * 清空集合
         */
        c.clear();
        System.out.println("集合以清空");    
        System.out.println(c);
        System.out.println("size:"+c.size());
        System.out.println("是否为空集:"+c.isEmpty());
    }
}

/**
 * 集合存放元素的引用
 */
public class CollectionDemo2 {
    public static void main(String[] args) {
        Point p = new Point(1,2);
        Collection c = new ArrayList();        
        c.add(p);
        System.out.println("p:"+p);//(1,2)
        System.out.println("c:"+c);//[(1,2)]        
        p.setX(2);
        System.out.println("p:"+p);//(2,2)
        System.out.println("c:"+c);//[(2,2)]
    }
}

/**
 * 集合操作
 */
public class CollectionDemo3 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("c++");
        c1.add("c");
        System.out.println("c1:"+c1);        
        Collection c2 = new ArrayList();
        c2.add("php");
        c2.add(".net");
        c2.add("java");
        System.out.println("c2:"+c2);
        /*
         * boolean addAll(Collection c)
         * 将给定集合中的所有元素添加到当前集合当调用后当前集合元素发生改变则返回true
         */
        c1.addAll(c2);
        System.out.println("c1:"+c1);    
        Collection c3 = new ArrayList();
        c3.add("c++");
        c3.add("php");
//        c3.add("ios");
        System.out.println("c3:"+c3);
        /*
         * 判断当前集合是否包含给定集合中的所有元素。
         */
        boolean contains = c1.containsAll(c3);
        System.out.println("全包含:"+contains);        
        /*
         * 删除当前集合中与给定集合的共有元素
         * 给定的集合元素不发生变化。
         */
        c1.removeAll(c3);
        System.out.println("c1:"+c1);
        System.out.println("c3:"+c3);
    }
}

/**
 * boolean contains(Object o)
 * 判断集合是否包含给定元素
 */
public class ContainsDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Point(1,2));
        c.add(new Point(3,4));
        c.add(new Point(5,6));
        c.add(new Point(7,8));
        System.out.println(c);    
        Point p = new Point(1,2);
        /*
         * contains的判断依据是用给定的元素与集合每一个元素进行equals比较，只要有为true的，就认为包含。
         * 因此元素的equals方法直接影响contains的判断结果。
         */
        boolean contains = c.contains(p);
        System.out.println("是否包含:"+contains);        
    }
}

/**
 * 泛型是JDK5之后推出的一个特性，又称为参数化类型，允许我们在使用一个类时指定它的属性，
 * 方法的参数和返回值的类型，使得我们使用起来更灵活。
 * 泛型的原型是Object，不指定时就使用它。
 * 泛型在集合中广泛使用，用于规定集合中的元素类型
 */
public class CollectionDemo4 {
    public static void main(String[] args) {
        //规定当前集合元素为String
        Collection<String> c = new ArrayList<String>();
        //添加元素时只能传入String类型元素
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        System.out.println(c);
        //遍历时可以直接用String类型接收元素
        for(String str : c) {
            System.out.println(str);
        }
        /*
         * 迭代器的泛型与其遍历的集合指定的泛型一致即可。
         */
        Iterator<String> it = c.iterator();
        while(it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        int a = 1;
        String s = "hello";
        Point p = new Point(1,2);
        Collection c = new ArrayList();
        c.add(p);
        test(a,s,p,c);
        System.out.println("a:"+a);//1
        System.out.println("s:"+s);//hello
        System.out.println("p:"+p);//(2,2)
        System.out.println("c:"+c);//[(2,6)]        
    }
    public static void test(int a,String s,Point p,Collection c) {
        a++;
        s = s+"world";
        p.setX(2);
        p = new Point(5,6);
        c.clear();
        c.add(p);
        p.setX(a);
        c = new ArrayList();
        c.add(new Point(7,8));
    }
}

/**
 * 遍历集合
 * 集合提供了统一的遍历操作，无论哪种数据结构实现的集合都提供了该遍历方式:迭代器模式
 * 
 * Iterator iterator()
 * Collection提供的iterator方法可以获取一个用于遍历当前集合的迭代器
 * 
 * java.util.Iterator接口
 * 该接口是迭代器接口，规定了遍历集合的相关操作所有集合都有一个用于遍历自身的迭代器实现类，
 * 我们无需关注它们的类名，以多态的角度用该接口看待并调用相关遍历方法即可。
 * 
 * 使用迭代器遍历集合的统一方式遵循为:
 * 问->取->删
 * 其中删除元素不是必须操作
 */
public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add("four");
        c.add("#");
        c.add("five");
        System.out.println(c);        
        Iterator it = c.iterator();
        /*
         * 问
         * boolean hasNext()
         * 通过迭代器查看是否还有元素可以遍历
         */
        while(it.hasNext()) {
            /*
             * 取
             * E next()
             * 通过迭代器遍历下一个元素
             */
            String str = (String)it.next();
            System.out.println(str);
            if("#".equals(str)) {
                /*
                 * 迭代器有一个要求，就是遍历的过程中不能通过集合的方法
                 * 增删元素。否则遍历时会抛出异常
                 */
//                c.remove(str);
                /*
                 * 迭代器提供了remove方法，该方法不需要传入参数，删除
                 * 的就是本次遍历通过next获取的元素
                 */
                it.remove();
            }
        }
        System.out.println(c);
    }
}

/**
 * JDK5之后推出了一个特性:增强型for循环
 * 也称为新循环，它不取代传统for循环的工作，仅用来遍历集合或数组使用
 */
public class NewForDemo1 {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four"};
        for(int i=0;i<array.length;i++) {
            String str = array[i];
            System.out.println(str);
        }
        /*
         * 新循环是编译器认可，而不是虚拟机，编译器在编译源代码时会将新循环遍历
         * 数组改为传统for循环遍历。
         */
        for(String str:array) {
            System.out.println(str);
        }    
    }
}

/**
 * 使用新循环遍历集合
 */
public class NewForDemo2 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        /*
         * 使用新循环遍历集合会被编译器编译时改为使用迭代器遍历，因此要遵循迭代器
         * 使用规范，遍历过程中不能通过集合的方法增删元素
         */
        for(Object o : c) {
            String str = (String)o;
            System.out.println(str);
            if("#".equals(str)) {
                c.remove(str);
            }
        }
        System.out.println(c);
    }
}

/**
 * java.util.List 线性表
 * List集合是有个可以重复的集合，并且有序，特点是提供了一组通过下标操作元素的方法。
 * 
 * 常用实现类:
 * java.util.ArrayList
 * 内部使用数组实现，查询性能更好，但是增删元素性能差
 * 
 * java.util.LinkedList
 * 内部使用链表实现，增删元素性能好，尤其首尾
 * 增删元素性能最佳，但是查询性能差
 * 
 * 如果对性能没有特别苛刻的要求时，通常使用ArrayList即可。
 */
public class ListDemo1 {
    public static void main(String[] args) {
        /*
         * JDK7之后，右侧的<>指定泛型部分可以不再写具体的类型了，编译器会理解为
         * 与前面指定的一致。
         */
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println(list);
        /*
         * E get(int index)
         * 获取给定下标处对应的元素
         */
         String str = list.get(1);
         System.out.println(str);
         //传统for循环可以遍历List集合
         for(int i=0;i<list.size();i++) {
             str = list.get(i);
             System.out.println(str);
         }
         
         /*
          * E set(int index,E e)
          * 将给定元素设置到指定位置上，返回值为原位置对应的元素。
          * 所以set是替换元素操作
          */
         //[one,2,three,four,five]
         String old = list.set(1, "2");
         System.out.println(list);
         System.out.println("old:"+old);         
         /*
          * 在不创建新集合的前提下，将list集合元素颠倒位置
          * [five,2,three,four,one]
          * [five,four,three,2,one]
          */
         for(int i=0;i<list.size()/2;i++) {
             //获取正数位置的元素
             str = list.get(i);
             //设置到倒数位置并获取替换的元素
             old = list.set(list.size()-1-i, str);
             //将替换的元素设置到正数位置完成交换
             list.set(i, old);

//             list.set(i, list.set(list.size()-1-i, list.get(i)));
         }
         System.out.println(list);
         
    }
}

/**
 * List提供了一对重载的add,remove方法
 */
public class ListDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println(list);        
        /*
         * void add(int index,E e)
         * 将给定元素插入到指定位置
         */
        list.add(2,"2");
        System.out.println(list);    
        /*
         * E remove(int index)
         * 删除并返回给定位置上的元素
         */
        String old = list.remove(1);
        System.out.println(list);
        System.out.println(old);        
    }
}

/**
 * List subList(int start,int end)
 * 获取当前集合中指定范围的子集
 */
public class ListDemo3 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++) {
            list.add(i);
        }
        System.out.println(list);        
        List<Integer> subList = list.subList(3, 8);
        System.out.println(subList);        
        //将子集元素扩大10倍
        for(int i=0;i<subList.size();i++) {
            int num = subList.get(i);
            num = num*10;
            subList.set(i, num);
        }
        System.out.println(subList);
        /*
         * 修改子集元素就是修改原集合对应元素
         */
        System.out.println(list);    
        //删除2-8
        list.subList(2, 9).clear();
        System.out.println(list);    
    }
}

/**
 * Collection中定义了一个方法toArray
 * 可以将当前集合转换为数组
 */
public class CollectionToArrayDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        System.out.println(c);    
//        Object[] array = c.toArray();        
        String[] array = c.toArray(new String[c.size()]);        
        System.out.println(array.length);
        System.out.println(Arrays.toString(array));
    }
}

/**
 * 数组转换为List集合
 * 数组的工具类Arrays提供了一个静态方法asList
 * 可以将给定的数组转换为一个List集合
 */
public class ArrayToListDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four"};        
        List<String> list = Arrays.asList(array);    
        System.out.println(list.size());
        System.out.println(list);
        /*
         * 对数组转换而来的集合的元素操作就是对原数组对应元素的操作。
         */
        list.set(1, "2");
        System.out.println(list);
        System.out.println(Arrays.toString(array));    
        /*
         * 由于数组的定长的，因此会改变数组元素个数的操作都是不支持的，会抛出异常
         */
//        list.add("five");
        /*
         * 若希望对集合元素增删操作，可以另外创建一个集合
         * 
         * 所有的集合都支持一个参数为Collection类型的构造方法，作用是创建该集合的同
         * 时包含给定集合中的所有元素
         */
        List<String> list2 
            = new ArrayList<>(list);
        list2.add("five");
        System.out.println(list2);
    }
}

/**
 * List集合的排序
 */
public class SortListDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        for(int i=0;i<10;i++) {
            list.add(random.nextInt(100));
        }        
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);        
    }
}

public class SortListDemo2 {
    public static void main(String[] args) {
        /*
         * 对一组人进行自定义排序
         * 课后任务：实现对一组连衣裙进行自定义排序按照价格排序，尺码排序 
         */
        List<Person> list=new ArrayList<>();
        list.add(new Person("熊大",3,200));
        list.add(new Person("熊二",2,220));
        list.add(new Person("光头强",30,120));
        list.add(new Person("范传奇",35,300));
        //自定义排序必须提供比较器！
        //Collections.sort(list, 比较器);
        Collections.sort(list, new ByAge()); 
        System.out.println(list);         
        Collections.sort(list, new ByWeight()); 
        System.out.println(list);     
        /*
         * 使用匿名内部类实现排序 
         */
        //利用匿名内部类声明按照年龄比较
        Comparator<Person> byAge=
                new Comparator<Person>(){
            public int compare(Person o1, 
                    Person o2) {
                return o1.age-o2.age;
            }
        };
        Collections.sort(list, byAge); 
        System.out.println(list);         
        //最终版本, 最简洁版本
        Collections.sort(list, 
                new Comparator<Person>(){
            public int compare( 
                Person o1, Person o2) {
                return -(o1.age-o2.age);
            }
        }); 
        System.out.println(list);    
        //最终版本: 按照重量比较
        Collections.sort(list, 
            new Comparator<Person>() {
            public int compare(Person o1, Person o2) {
                return -(int)Math.signum(o1.weight-o2.weight);
            }
        });
        System.out.println(list);
    }
}
class ByWeight implements Comparator<Person>{
    public int compare(Person o1, Person o2) {
        return -(int)Math.signum(o1.weight-o2.weight);
    }
    //符号函数
    public int sgn(double d){ 
        if(d==0) {
            return 0;
        }else if(d<0){
            return -1;
        }else {
            return 1;
        }
    }
}

/*
 * 实现按照人的年龄比较大小的比较器
 * age 年龄
 * Comparator 比较器
 * Person 人 
 */
class ByAge implements Comparator<Person>{
    public int compare(Person o1, Person o2) {
        //按照两个人的年龄比较
        //o1 代表某人1， o2代表某人2
        return -(o1.age - o2.age);
    }
}
class Person{
    String name;
    int age;
    double weight;
    public Person(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", weight=" + weight + "]";
    }
}

public class SortListDemo3 {
    public static void main(String[] args) {
        /*
         * 字符串大小比较问题
         * 字符串提供了比较函数，其规则是按照字符中的字符编码进行比较
         * 返回0 表示两个字符串相等返回正数表示第一个字符串大
         * 返回负数表示第一个字符串小
         */
        int code1 = ‘熊‘;
        int code2 = ‘光‘;
        int code3 = ‘范‘; 
        System.out.println(code1);
        System.out.println(code2);
        System.out.println(code3);        
        String s1 = "熊大"; //29066
        String s2 = "光头强";//20809
        //字符串提供比较大小方法，
        //比较两个字符串时候，返回0表示相等返回正数表示第一个字符串大
        //返回负数表示第一个字符串小
        int n = s1.compareTo(s1);
        System.out.println(n); //0 相等
        n = s1.compareTo(s2);
        System.out.println(n); //正数，s1大
        n = s2.compareTo(s1); 
        System.out.println(n); //负数，s2小        
        List<Person> list=new ArrayList<>();
        list.add(new Person("范传奇",1,2));
        list.add(new Person("熊大",3,5));
        list.add(new Person("熊二",4,9));
        list.add(new Person("光头强",7,9));
        list.add(new Person("李大嘴",8,8));
        Collections.sort(list, 
                new Comparator<Person>() {
            public int compare(
                Person o1, Person o2) {
                //利用字符串提供的方法，按照名字比较大小
                return o1.name.compareTo(o2.name);
            }
        });
        System.out.println(list);
    }
}