JAVASE02-Unit04： 集合框架 、 集合操作 —— 线性表

　　　Unit04： 集合框架 、 集合操作 —— 线性表　　　　

操作集合元素相关方法

package day04;

import java.util.ArrayList;
import java.util.Collection;

import day02.Point;

/**
 * 操作集合元素相关方法
 * @author adminitartor
 *
 */
public class Collection_Remove {
    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(1,2));
        
        System.out.println(c);
        
        Point p = new Point(1,2);
        /*
         * boolean remove(E e)
         * 从集合中删除给定元素
         * 将给定元素与集合现有元素顺序进行equals
         * 比较，并删除第一个与之比较为true的元素
         * 若成功删除元素则返回true
         */
        c.remove(p);
        System.out.println(c);
    }
}

集合操作

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

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

遍历集合

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 遍历集合
 * 集合提供了通用的遍历元素方式:迭代器模式。
 * 迭代器java.util.Iterator是一个接口。
 * 不同的集合实现类都提供了一个可以遍历自身元素的
 * 迭代器实现类，我们无需记住每个迭代器实现类的名字
 * 只要当Iterator看待可以操作并遍历集合元素即可。
 * 
 * 迭代器遍历集合元素遵循:
 * 问，取，删 的步骤
 * 其中删除元素操作不是必要操作。
 * @author adminitartor
 *
 */
public class Collection_Iterator {
    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();
            if("#".equals(str)){
                /*
                 * 在使用迭代器遍历集合元素时，
                 * 不要通过集合的方法修改元素数量，
                 * 否则会抛出异常
                 */
//                c.remove(str);
                /*
                 * 迭代器的remove方法可以将刚
                 * 通过next方法取出的元素从集合
                 * 中删除。
                 */
                it.remove();
            }
            System.out.println(str);
        }
        
        System.out.println(c);
    }
}

增强for循环

package day04;
/**
 * 增强for循环
 * 也称为新循环，for each
 * JDK1.5之后推出的新特性
 * 新循环不能替代传统循环的工作，新循环使用来遍历
 * 集合或数组的
 * @author adminitartor
 *
 */
public class NewFor_Array {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        
        for(int i=0;i<array.length;i++){
            String str = array[i];
            System.out.println(str);
        }
        
        for(String str : array){
            System.out.println(str);
        }
    }
}

使用新循环遍历集合

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 使用新循环遍历集合
 * @author adminitartor
 *
 */
public class NewFor_Collection {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        /*
         * 新循环并非新的语法，JVM并不认可新循环
         * 而是编译器认可。
         * 编译器在编译源程序时，会将新循环遍历
         * 集合改为使用迭代器遍历。
         * 为此，新循环在遍历集合时，不能通过集合
         * 的方法修改元素数量。
         */
        for(Object o : c){
//        Iterator it = c.iterator();
//        while(it.hasNext()){
//            Object o = it.next();
            String str = (String)o;
            System.out.println(str);
        }
    }
}

测试泛型的使用

package day04;
/**
 * 测试泛型的使用
 * @author adminitartor
 *
 */
public class TestPoint {
    public static void main(String[] args) {
        Point<Integer> p1 
            = new Point<Integer>(1,2);
        p1.setX(2);
        int x1 = p1.getX();
        System.out.println("x1:"+x1);
        
        Point<Double> p2 
            = new Point<Double>(1.1,2.2);
        p2.setX(2.2);
        double x2 = p2.getX();
        System.out.println("x2:"+x2);
        
        Point<String> p3 
            = new Point<String>("一","二");
        p3.setX("二");
        String x3 = p3.getX();
        System.out.println("x3:"+x3);
        
    }
}

泛型  JDK1.5之后推出的新特性

package day04;
/**
 * 泛型  JDK1.5之后推出的新特性
 * @author adminitartor
 *
 */
public class Point<T> {
    private T x;
    private T y;
    public Point(T x, T y) {
        super();
        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;
    }
    
    @Override
    public String toString() {
        return "("+x+","+y+")";
    }
}

泛型并非虚拟机认可，而是编译器认可,泛型的原型就是Object。

package day04;
/**
 * 泛型并非虚拟机认可，而是编译器认可
 * 泛型的原型就是Object。所以，Point中所有<T>的地方
 * 会被编译器改为Object
 * 编译器在检查使用泛型的地方时做如下操作:
 * 在给一个泛型赋值时，检查实际的值是否满足类型要求
 * 获取一个泛型的值时，会自动添加类型转换代码
 * @author adminitartor
 *
 */
public class TestPoint2 {
    public static void main(String[] args) {
        /*
         * Point里面的x,y实际是Object
         * 由于有泛型，编译器会检查构造方法中
         * 实际传入的值是否符合Integer的类型，
         * 不符合编译不通过
         */
        Point<Integer> p1 
            = new Point<Integer>(1,2);
        
        p1.setX(2);
        /*
         * 编译后的class文件中编译器会补上向下
         * 造型的代码:
         * int x1 = (Integer)p1.getX();
         */
        int x1 = p1.getX();
        System.out.println("x1:"+x1);
        /*
         * 不指定泛型的实际类型那么则使用默认
         * 的Object
         */
        Point p2 = p1;
        p2.setX("二");
        System.out.println("x2:"+p2.getX());//"二"
        
        x1 = p1.getX();//ClassCastException
        System.out.println(x1);//?
    }
}

泛型在集合中的应用

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 泛型在集合中的应用
 * 集合在泛型中是用来规定集合中的元素类型
 * @author adminitartor
 *
 */
public class Collection_Type {
    public static void main(String[] args) {
        Collection<String> c
            = new ArrayList<String>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        
        for(String str : c){
            System.out.println(str);
        }
        /*
         * 迭代器也支持泛型，而泛型的实际类型与
         * 其遍历的集合的泛型类型一致即可
         */
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
    }
}

List集合

package day04;

import java.util.ArrayList;
import java.util.List;

/**
 * List集合
 * List是可重复集，并且有序
 * 特点是可以像数组一样，通过下标操作元素
 * 并且也提供了一系列根据下标操作元素的方法
 * @author adminitartor
 *
 */
public class List_Get_Set {
    public static void main(String[] args) {
        List<String> list 
            = new ArrayList<String>();
        
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        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)
         * 将给定元素设置到指定位置处，返回值
         * 为原位置对应的元素。
         */
        //[one,two,three,four,five]
        String old = list.set(1, "2");
        System.out.println(list);
        System.out.println(old);
    }
}

List提供了一对重载的add,remove方法

package day04;

import java.util.ArrayList;
import java.util.List;

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

截取List集合的子集

package day04;

import java.util.ArrayList;
import java.util.List;

/**
 * 截取List集合的子集
 * @author adminitartor
 *
 */
public class List_Sublist {
    public static void main(String[] args) {
        List<Integer> list
            = new ArrayList<Integer>();
        
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
        //取3-7
        List<Integer> subList 
            = list.subList(3, 8);
        System.out.println(subList);
        
        //将子集元素扩大10倍
        for(int i=0;i<subList.size();i++){
            subList.set(i, subList.get(i) * 10);
        }
        
        System.out.println(subList);
        /*
         * 对子集元素的操作就是对原集合相应内容
         * 的操作
         */
        System.out.println(list);
        
        /*
         * 删除3-7
         */
        list.subList(3, 8).clear();
        System.out.println(list);
    }
}

集合转换为数组

package day04;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 集合转换为数组
 * Collection提供了方法:toArray
 * @author adminitartor
 *
 */
public class CollectionToArray {
    public static void main(String[] args) {
        Collection<String> c
            = new ArrayList<String>();
        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("len:"+array.length);
        for(String str : array){
            System.out.println(str);
        }
    }
}

数组转换为集合

package day04;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 数组转换为集合
 * 使用数组的工具类Arrays的静态方法asList
 * 需要注意，只能将数组转换为List集合。
 * @author adminitartor
 *
 */
public class ArrayToList {
    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);
        
        for(String str : array){
            System.out.println(str);
        }
        /*
         * 添加新元素会导致数组扩容，不允许这样
         * 做，因为这样不能表示原数组了。
         */
//        list.add("five");//会抛出异常
//        System.out.println(list);
        /*
         * 若想添加新元素，可以自行实例化一个集合
         */
        List<String> list1 
            = new ArrayList<String>(list);
//        list1.addAll(list);
        list1.add("five");
        System.out.println(list1);
    }
}

使用集合的工具类Collections的静态方法sort,可以对List集合进行自然排序(从小到大)

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 使用集合的工具类Collections的静态方法sort
 * 可以对List集合进行自然排序(从小到大)
 * @author adminitartor
 *
 */
public class SortList {
    public static void main(String[] args) {
        List<Integer> list
            = new ArrayList<Integer>();
        
        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);
    }
}