码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2016-12-28 01:23:25      阅读：242      评论：0      收藏：0      [点我收藏+]

标签：原型   alt   new   遍历   推出   add   hashset   getx   地方   

　　　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);
    }
}
Collection_Remove.java

集合操作

技术分享 
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);
    }
}
Collection_Methods.java

遍历集合

技术分享 
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);
    }
}
Collection_Iterator.java

增强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);
        }
    }
}
NewFor_Array.java

使用新循环遍历集合

技术分享 
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);
        }
    }
}
NewFor_Collection.java

测试泛型的使用

技术分享 
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);
        
    }
}
TestPoint.java

泛型  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+")";
    }
}
Point.java

泛型并非虚拟机认可，而是编译器认可,泛型的原型就是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);//?
    }
}
TestPoint2.java

泛型在集合中的应用

技术分享 
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);
        }
    }
}
Collection_Type.java

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_Get_Set.java

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_Add_Remove.java

截取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);
    }
}
List_Sublist.java

集合转换为数组

技术分享 
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);
        }
    }
}
CollectionToArray.java

数组转换为集合

技术分享 
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);
    }
}
ArrayToList.java

使用集合的工具类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);
    }
}
SortList.java

 

技术分享

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

标签：原型   alt   new   遍历   推出   add   hashset   getx   地方   

原文地址：http://www.cnblogs.com/tangshengwei/p/6227829.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！