java课堂笔记------集合api

Posted 2020-10-05 yuer629

         Collection c = new ArrayList();

         * boolean add(E e)
         * 将当前集合中添加给定的元素
         * 若成功添加则返回true
         c.add("one");
         c.add("two");

        
         * int size()
         * 获取当前集合中的元素个数
         c.size();
        
         * boolean isEmpty()
         * 判断当前集合是否不包含任何元素
         * 当集合中没有元素时返回true
         boolean isEmpty = c.isEmpty();
        
         * void clear()
         * 清空集合元素
     c.clear();
    
    
         * boolean contains(E e)
         * 判断当前集合是否包含给定元素，包含则返回true
         * 判断依据是看给定的元素与集合中现有的元素是否
         * 存在equals比较为true的，有则认为包含!
         boolean contains = c.contains(e);
         
         
         * 集合提供了一个方法可以删除集合中的现有元素
     * boolean remove(E e)
     * 将给定的元素从集合中删除，成功删除返回true
         * 删除元素的判断依据是，删除当前集合中第一个与
         * 给定元素equals比较为true的。
     c.remove(e);
         
              
         * 并集
         * boolean addAll(Collection c)
         * 将给定的集合中的所有元素添加到当前集合中
         * 当执行完毕后，当前集合中的元素发生了改变
         * 就返回true
         c2.addAll(c1);
        

         * 判断当前集合中是否包含给定集合里的所有
         * 元素，全部包含则返回true。这里判断依据
         * 依然是依靠元素的equals比较的。
         * boolean containsAll(Collection c)
       boolean contains = c1.containsAll(c3);





     * 由于集合的具体实现类各不相同，Set集合大部分实现
     * 又是无序的，所以不能像数组那样根据下标位置获取
     * 具体的某一个元素。
     * 集合提供了统一的获取集合元素方式:遍历集合，而
     * 遍历是使用迭代器来完成的。
     * java.util.Iterator是迭代器的接口，定义了用于遍历
     * 集合的相关方法。不同的集合都实现了一个可以遍历自身
     * 的迭代器实现类。我们无需记住实现类的名字，只当是
     * 迭代器使用即可。
     * 迭代器迭代元素需要遵循:问，取，删。这个步骤。
     * 其中删除不是必须的。
     

         * 若需要遍历集合，可以调用集合的方法:
         * Iterator iterator()
         * 该方法会返回可以遍历当前集合的迭代器。
         Iterator it = c.iterator();

         * boolean hasNext()
         * 询问迭代器，其遍历的集合是否还有元素没有
         * 遍历过，有则返回true
         while(it.hasNext()){
             * E next()
             * 取出集合中下一个元素。
            String str = (String)it.next();
            /*
             * 删除"#"
             */
            if("#".equals(str)){
                /*
                 * 在使用迭代器遍历集合的过程中，不能通过
                 * 集合的方法改变集合元素，否则可能抛出异常
                 */
//                c.remove(str); 集合的方法
                /*
                 * 删除的是刚通过next()方法取出的元素。
                 */
                it.remove();//迭代器方法
            }
        }
        
        
        
        
         * java 5.0以后推出了一个新的特性:增强for循环
     * 又叫做:新循环，增强循环，for each
     * 新循环不能代替传统循环重复工作的需求。
     * 新循环是用来遍历集合或数组的。

        String[] array 
            = new String[]{"one","two","three"};
            
        for(String str:array){
            System.out.println(str);
        }

         * 新循环并不是JVM认可的新语法。而是编译器认可
         * 的。编译器在编译源程序时若发现我们使用新循环
         * 来遍历集合时，会将代码改变为使用迭代器的方式
         * 遍历集合。所以新循环遍历集合本质上就是迭代器
         * 遍历。
         * 所以新循环在遍历集合的过程中不允许通过集合的
         * 方法修改元素数量。

        for(Object obj:c){
            if("#".equals(obj)){
                c.remove(obj);//错误
                i.remove(obj);//没有显示迭代，错误
            }
        }


         
         
         
         
         
     * List集合
     * 有序集，可重复集。
     * List的特点是可以像数组一样，根据下标操作元素。
     * 所以List提供了一些独有的方法。
     * 常用实现类:
     * ArrayList:内部由数组实现，查询快。
     * LinkedList:内部由链表实现，增删快。

        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        
        
         *    E get(int index)
         *    获取指定下标对应的元素。     
         String str = list.get(1);
    
        //通过下标操作遍历集合
        for(int i=0;i<list.size();i++){
            str = list.get(i);
            System.out.println(str);
        }
        

         * E set(int index,E e)
         * 将给定的元素设置到指定的位置上，返回值为
         * 原位置上的元素。所以该操作时替换元素操作
         String old = list.set(1, "2");
    
    




     * List提供的另一对方法:
     * void add(int index,E e)
     * 向指定位置插入给定元素，原位置及后续元素顺序向后
     * 移动
     * 
     * E remove(int index)
     * 删除并返回给定位置的元素。
 
        List<String> list = new LinkedList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        
        
         * void add(int index,E e)
         list.add(2,"3");
        
            
         * E remove(int index)
     * 删除并返回给定位置的元素。
         String old = list.remove(3);
        


         
         
         
     * 集合转换为数组
     * Collection中提供了一个方法toArray
     * 允许我们将现有的集合转换为数组。

        Collection<String> c = new ArrayList<String>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        
//        Object[] array = c.toArray(); 转换的是Object数组，所以一般不用这种，而用下面的那种
        
        String[] array 
            = c.toArray(new String[c.size()]);



         
         
     * 数组转换为集合
     * 使用Arrays的静态方法asList()
     * 需要注意，数组只能转换为List集合。不能转换为Set
     * 原因在于:
     * 1:Set大部分是无序实现
     * 2:Set不允许存放重复元素，所以转换后可能丢失元素。

        String[] array = new String[]{"one","two","three"};
        List<String> list = Arrays.asList(array);
    
         * 修改该集合元素内容，原数组内容也会发生改变

         list.set(0, "1");
        //数组第一个元素也变为了"1"

         * 对于由数组转换的集合来说，添加新元素是不受支持的!所以下面代码会抛出异常
          list.add("four");
          
        
         * 所有的集合都支持一个构造方法，参数要求传入另一个集合。
         * 这个构造方法的作用是:
         * 创建当前集合的同时将给定的集合中的所有元素添加到当前集合中。
        List<String> list1 = new ArrayList<String>(list);
        

         
         
         
         
    * 获取List集合中的子集

        List<Integer> list = new ArrayList<Integer>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        //[0,1,2,3,4,5,6,7,8,9]
        
         * List subList(int start,int end)
         * 获取当前集合中给定范围内的部分子集。
        List<Integer> subList = list.subList(3, 8);
        
        

         * 对子集的任何操作都会影响原集合
         * 清空子集，原集合中该部分内容也被删除。
         
         
         
         
         
         
 * 泛型
 * JDK5.0开始支持的新特性
 * 泛型是参数化类型，可以对一个类中的属性，
 * 方法的参数，方法的返回值类型进行约束，
 * 在使用时指定类型。
 
 
public class Point<T> {
    private T x;
    private T y;
    
    public Point(){
        
    }
    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }


    public static void main(String[] args) {
        Point<Integer> p1 
            = new Point<Integer>(1,2);
        int x1 = p1.getX();
        
        Point<Double> p2
            = new Point<Double>(1.1,2.2);
        double x2 = p2.getX();
        
        Point<String> p3
            = new Point<String>("1","2");
        String x3 = p3.getX();
    }
}


 * 泛型的注意事项

         * 当使用一个具有泛型的类时，若不指定，则就
         * 按照默认的Object作为实际类型
        


         
         
         
     * 泛型在集合中的应用
     * 集合中的泛型是用来约束集合中元素的类型。
 
         Collection<String> c = new ArrayList<String>();
         c.add("one");
        
         * 迭代器也支持泛型，泛型与该迭代器遍历的集合
         * 的泛型类型一致即可。
         
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String str = it.next();
        }
    







     * Collections: 集合的工具类
     * 该类提供了若干静态方法，可以方便操作集合。
     * 其中sort方法是用来排序List集的。进行自然排序
 
         * sort会对给定的List集合中的元素进行自然排序
         * 即:从小到大的顺序
         * Collections.sort(list);
         
         * 面试题：
         * Collection与Collections的区别?
         * 或分别说明它们
         
    
    
    
    
         * Collections的sort方法若希望对集合进行
         * 排序，必须保证集合中的元素是可比较大小的。
         * 所以要求元素必须实现Comparable接口，并
         * 重写其中的比较大小方法，才可以进行排序。
        
         * 虽然sort方法可以对集合中的元素进行自然排序
         * 但是必须要求元素实现Comparable接口，这就出现
         * 了由于想使用排序功能而必须改变我们定义的类的
         * 内容，这中现象称为"侵入性"。
         

    
    
    
    
 * 当集合中存放的是自定义类型元素时，使用Collections的sort方法排序的注意事项:
 * 
 * 当前元素若希望可以比较大小，需要实现Comparable
 * 接口
 * Comparable支持泛型，而泛型的实际类型就是当前
 * 类。意思是说，哪个类实现Comparable接口，泛型
 * 就是哪个类。


public class Point implements Comparable<Point>{
    private int x;
    private int y;
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    
    public String toString(){
        return "(" + x + "," + y + ")";
    }
    /**
     * CompareTo方法的作用是使当前对象与给定的对象o进行比较大小。
     * 返回值不关注具体值，而是关注取值范围:
     * 当返回值>0:当前对象比参数对象大
     * 当返回值<0:当前对象比参数对象小
     * 当返回值=0:两个对象相等
     */
    public int compareTo(Point o) {
        int len = this.x*this.x+this.y*this.y;
        int olen = o.x*o.x+o.y*o.y;
        return len-olen;
    }
}


    
    



         * 字符串String实现了Comparable接口
         * 排序规则:按照首字母的编码比大小。
         
    
         * Collections的重载sort方法要求我们传入两个
         * 参数:
         * 1:待排序的集合
         * 2:比较器
         * 通常有两种情况会使用该方法排序集合:
         * 1:元素已经实现了Comparable接口，但是比较大小
         *   的规则不能满足我们对于排序的需求时
         * 2:元素没有实现Comparable接口，并且也不希望为
         *   了这里排序而强制修改元素，要求其实现接口时  
         *
         
//        MyComparator com = new MyComparator();
      
      Comparator<String> com
        = new Comparator<String>(){
          public int compare(String o1, String o2) {
            return o1.length()-o2.length();
          }
        
      };
      Collections.sort(list,com);
      
        
     class MyComparator implements Comparator<String>{
      /**
       * 字符串比较大小的规则:
       * 字符数量多的大
       */
      public int compare(String o1, String o2) {
        return o1.length()-o2.length();
      }
    }