java之14天 集合 (一)

Collection集合框架

Java代码  收藏代码
  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. import java.util.List;
  4. import java.util.ListIterator;
  5. /***
  6.  *Cellection
  7.  *    |–List:元素是有序的,元素可以重复,因为该集合体系有索引.
  8.  *        |–ArrayList   :底层的数据结构使用的是数组结构,特点: (查询,修改)速度很快,但是(插入删除)很慢 ,线程不同步
  9.  *        |–LinkedList  :底层使用的是链表数据结构,特点: (查询,修改)慢,(插入,删除)快! 线程不同步
  10.  *        |–Vector      :元老级干部 1.0的时候 就是Vector天下,1.2后 集合框架才出来.
  11.  *                          特点 :线程同步,
  12.  *                              底层是数据结构是数组结构.被ArrayList替代了.
  13.  *                              如果后期要用到同步的,那么也不使用vector,需要自己加锁.
  14.  *
  15.  *        数组结构 的    ArrayList  和   Vector 一般数组长度是不变的
  16.  *           ArrayList:默认长度为10,以后使用 50%的增加,超过后,将原来的10个元素复制到 长度为15的数组中,然后再在后面添加新的元素(可变长度数组,就是不断new数组完成的)
  17.  *           Vector:默认长度为 10,超过后100%延长,这样就变成了20,比较浪费空间
  18.  *
  19.  *
  20.  *    |–Set : 元素是无序,元素不可以重复,该集合中没有索引.
  21.  *
  22.  * List:
  23.  *    特有方法: 凡是可以操作角标的方法都是该体系中特有的方法.
  24.  *
  25.  * 增
  26.  *   add(index,element)
  27.  *   addAll(index,Collection);
  28.  * 删
  29.  *   remover(index);
  30.  * 改
  31.  *   set(index,element);
  32.  * 查
  33.  *   get(index)
  34.  *   subList(from,to);
  35.  *   listIterator();
  36.  *
  37.  * list集合特有的迭代器 叫做 listIterator 是Iterator的子接口.
  38.  *
  39.  * 在迭代时,不可以通过集合对象的方法操作集合中的呀un苏.因为会发生ConcurrentModificationException
  40.  *
  41.  * 所以,在迭代时,只能使用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作.
  42.  * 如果想要其他的操作如,添加  修改 等就需要使用  listIterator 子接口
  43.  *
  44.  * 该接口只能通过list集合的listIterator 获取
  45.  *
  46.  *
  47.  *
  48.  */
  49. public class ListDemo {
  50.     public static void sop(Object obj){
  51.         System.out.println(obj);
  52.     }
  53.     public static void main(String[] args) {
  54.         method_1();
  55.         method_2();
  56.     }
  57.     public static void method_2(){
  58.         //演示列表迭代器
  59.         ArrayList al=new ArrayList();
  60.         al.add(“java01”);
  61.         al.add(“java02”);
  62.         al.add(“java03”);
  63.         sop(“原集合:”+al);
  64.         //跌带动的时候  找到后想删除 发现 使用普通的 Iterator 不能做到
  65.         /*Iterator it=al.iterator();
  66.         while(it.hasNext()){
  67.             Object obj=it.next();
  68.             if(obj.equals(“java02”)){
  69.                 //发现 有问题  .因为在使用it时候,同时对集合al进行了操作,这样就有可能出现安全问题
  70.                 al.add(“java08”);
  71.                 //it.remove(); //在使用 Iterator 的只能使用  Iterator的方法.
  72.             }
  73.             sop(“obj=”+obj);
  74.         }*/
  75.         //正向遍历
  76.         ListIterator li=al.listIterator();
  77.         while(li.hasNext()){
  78.             Object obj=li.next();
  79.             if(obj.equals(“java02”)){
  80.                 li.add(“java007”);
  81.             }
  82.         }
  83.         sop(“obj=”+al);
  84.         //逆向遍历
  85.         while(li.hasPrevious()){
  86.             sop(“previous:”+li.previous());//是否有前一个
  87.         }
  88.     }
  89.     public static void method_1(){
  90.         ArrayList al=new ArrayList();
  91.         al.add(“java01”);
  92.         al.add(“java02”);
  93.         al.add(“java03”);
  94.         sop(“原集合:”+al);
  95.         //在制定的位置添加元素
  96.         al.add(1,”java09″);
  97.         sop(“添加:”+al);
  98.         //删除指定位置上的元素
  99.         al.remove(2);
  100.         sop(“删除:”+al);
  101.         //修改元素
  102.         al.set(2, “java007”);
  103.         sop(“修改:”+al);
  104.         //通过角标获取元素
  105.         sop(“get(1):”+al.get(1));
  106.         //获取所有元素
  107.         for(int x=0;x<al.size();x++){
  108.             System.out.println(“al(“+x+”)=”+al.get(x));
  109.         }
  110.         Iterator it=al.iterator();
  111.         while(it.hasNext())
  112.             it.next();
  113.         //通过indexOf获取对象的位置
  114.         sop(“indexOf=”+al.indexOf(“java09”));
  115.         List sub=al.subList(1, 2);
  116.         sop(“sub”+sub);
  117.     }
  118. }

Collection的操作

Java代码  收藏代码
  1. /**
  2.  *集合类
  3.  * 1.add方法 的参数类型是Object,以便于接受任意类型对象
  4.  * 2.集合中存储的都是对象的引用  (地址)
  5.  *
  6.  * 什么是迭代器呢 ?
  7.  *   其实就是  集合的取出元素的方式.
  8.  *
  9.  *
  10.  */
  11. public class CollectionDemo {
  12.     public static void main(String[] args) {
  13.         base_method2();
  14.         method_get();
  15.     }
  16.     //取出元素
  17.     public static void method_get(){
  18.         ArrayList al=new ArrayList();
  19.         al.add(“java01”);
  20.         al.add(“java02”);
  21.         al.add(“java03”);
  22.         al.add(“java04”);
  23.         al.add(“java05”);
  24.         /*
  25.          *
  26.         Iterator it=al.iterator(); //获取迭代器 用于取出集合中的元素
  27.         while(it.hasNext())
  28.             sop(it.next());
  29.          */
  30.         //这种有优势, 增加了 内存优化,使用完后  it就会被回收.
  31.         for(Iterator it=al.iterator();it.hasNext();){
  32.             sop(it.next());
  33.         }
  34.     }
  35.     //取交集 批量删除
  36.     public static void base_method2(){
  37.         ArrayList al=new ArrayList();
  38.         al.add(“java01”);
  39.         al.add(“java02”);
  40.         al.add(“java03”);
  41.         al.add(“java04”);
  42.         al.add(“java05”);
  43.         ArrayList al2=new ArrayList();
  44.         al2.add(“java01”);
  45.         al2.add(“java02”);
  46.         al2.add(“java05”);
  47.         al2.add(“java06”);
  48.         //al.retainAll(al2); //取交集,al中只会保留和 al2中相同的元素
  49.         al.removeAll(al2);// 一次删除一堆元素
  50.         sop(“al1″+al);
  51.         sop(“al2″+al2);
  52.     }
  53.     public static void base_method(){
  54.         //创建一个集合容器,使用Collection接口的子类.ArrayList
  55.         ArrayList al=new ArrayList();
  56.         al.add(“java01”);
  57.         al.add(“java02”);
  58.         al.add(“java03”);
  59.         al.add(“java04”);
  60.         al.add(“java05”);
  61.         //1.获取集合的长度
  62.         sop(“size:”+al.size());
  63.         //2.打印集合
  64.         sop(“原集合:”+al);
  65.         //3.删除元素
  66.         al.remove(“java02”);
  67.         sop(“现集合:”+al);
  68.         //判断元素
  69.         sop(“java03是否存在:”+al.contains(“java03”));
  70.         sop(“集合是否为空:”+al.isEmpty());
  71.         //清空集合
  72.         al.clear();
  73.         sop(“现集合:”+al);
  74.     }
  75.     public static void sop(Object obj){
  76.         System.out.println(obj);
  77.     }
  78. }

Vector

Java代码  收藏代码
  1. /**
  2.  * 元老级
  3.  * Vector类中 带有Element的就是 Vector的特有方法
  4.  *
  5.  * Enumeration 枚举 就是早起Vector特有的取出方式.
  6.  * 发现 枚举和 迭代器很像
  7.  *
  8.  * 其实枚举和 迭代器是一样的.
  9.  * 因为枚举的名称以及方法的名称都过长,所以被迭代器取代了 枚举郁郁而终了
  10.  *
  11.  */
  12. public class VectorDemo {
  13.     //Vector中 带有Element的就是 Vector的特有方法
  14.     public static void main(String[] args) {
  15.         // TODO Auto-generated method stub
  16.         Vector v=new Vector();
  17.         v.add(“java01”);
  18.         v.add(“java02”);
  19.         v.add(“java03”);
  20.         v.add(“java04”);
  21.         Enumeration en=v.elements();
  22.         while(en.hasMoreElements()){
  23.             System.out.println(en.nextElement());
  24.         }
  25.     }
  26. }

ArrayList的使用 

Java代码  收藏代码
  1. /**
  2.  * 将自定义对象最为元素存储到ArrayList集合中,并除去重复元素
  3.  * 比如 :存人对象, 同姓名 同年龄,视为同一个人,为重复元素
  4.  *
  5.  * 思路:
  6.  *   1.对人描述,将数据封装进人对象
  7.  *   2.定义容器,将人存如
  8.  *   3.取出
  9.  *
  10.  * List判断元素是否相同,依据的是元素的equals
  11.  *
  12.  */
  13. class Person{
  14.     private String name;
  15.     private int age;
  16.     Person(String name,int age){
  17.         this.name=name;
  18.         this.age=age;
  19.     }
  20.     public String getName(){
  21.         return name;
  22.     }
  23.     public int getAge(){
  24.         return age;
  25.     }
  26.     @Override
  27.     public boolean equals(Object obj) {
  28.         if(!(obj instanceof Person))
  29.             return false;
  30.         Person p=(Person)obj;
  31.         return this.getName().equals(p.getName()) && this.getAge()==p.age;
  32.     }
  33. }
  34. public class ArrayListDemo {
  35.     public static void main(String[] args) {
  36.         ArrayList al=new ArrayList();
  37.         al.add(new Person(“admin”,12));
  38.         al.add(new Person(“BBBBB”,12));
  39.         al.add(new Person(“CCCCC”,12));
  40.         al.add(new Person(“admin”,12));
  41.         al=singleElement(al);
  42.         Iterator it=al.iterator();
  43.         while(it.hasNext()){
  44.             //sop(it.next().getName()+”::”+it.next().getAge());//编译失败 父类引用指子类对象
  45.             Person p=(Person)it.next();
  46.             sop(p.getName()+”:::”+p.getAge());
  47.         }
  48.         sop(“remove 03:”+al.remove(new Person(“BBBBB”,12)));
  49.         sop(al);
  50.     }
  51.     public static void sop(Object obj){
  52.         System.out.println(obj);
  53.     }
  54.     public static ArrayList singleElement(ArrayList al){
  55.         //定一个容器
  56.         ArrayList newAl=new ArrayList();
  57.         Iterator it=al.iterator();
  58.         while(it.hasNext()){
  59.             Object obj=it.next();
  60.             if(!newAl.contains(obj))  //判断的是对象是否相同
  61.                 newAl.add(obj);
  62.         }
  63.         return newAl;
  64.     }
  65. }

ArrayList的练习

Java代码  收藏代码
  1. /**
  2.  * 去除ArrayList中的重复元素
  3.  */
  4. public class ArrayListTest {
  5.     public static void sop(Object obj){
  6.         System.out.println(obj);
  7.     }
  8.     public static void main(String[] args) {
  9.         ArrayList al=new ArrayList();
  10.         al.add(“java01”);
  11.         al.add(“java01”);
  12.         al.add(“java02”);
  13.         al.add(“java01”);
  14.         al.add(“java02”);
  15.         al.add(“java03”);
  16.         sop(“原集合:”+al);
  17.         sop(al=singleElement(al));
  18.         /*在迭代时循环中next调用一次,就要使用hasNext判断一次
  19.         Iterator it=al.iterator();
  20.         while(it.hasNext()){
  21.             System.out.println(it.next()+”…”+it.next());
  22.         }
  23.         */
  24.     }
  25.     public static ArrayList singleElement(ArrayList al){
  26.         //定一个容器
  27.         ArrayList newAl=new ArrayList();
  28.         Iterator it=al.iterator();
  29.         while(it.hasNext()){
  30.             Object obj=it.next();
  31.             if(!newAl.contains(obj))
  32.                 newAl.add(obj);
  33.         }
  34.         return newAl;
  35.     }
  36. }

标签

发表评论

评论已关闭。

评论列表(1)