黑马程序员_集合框架（一）

最新推荐文章于 2018-03-10 10:45:34 发布

taoshengyijiu_

最新推荐文章于 2018-03-10 10:45:34 发布

阅读量413

点赞数

文章标签： java 黑马程序员

本文链接：https://blog.youkuaiyun.com/taoshengyijiu_/article/details/48028209

版权

——- android培训、java培训、期待与您交流！ ———-
一、集合框架体系概述
1、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
2、数组和集合类同是容器，二者有何区别？
数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。
数组中可以存储基本数据类型，集合只能存储对象。
3、集合类的特点
（1）集合只用与存储对象
（2）集合长度是可变的
（3）集合可以存储不同类型的对象。
4、集合框架图
这里写图片描述

二、集合中的共性方法
1、添加
示例：

public static void main(String[] args)
    {
        //创建一个集合容器，使用collection接口的子类，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、获取个数，集合长度。
        sop("size:"+al.size());
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
Add方法的参数类型是Object以便于接收任意类型的对象。
集合中存储的都是对象的引用（地址）。
2、删除

public static void main(String[] args)
    {
        //创建一个集合容器，使用collection接口的子类，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、获取个数，集合长度。
        sop("size:"+al.size());
        //打印原集合
        sop(al);
        //删除
        al.remove("java02");
        //打印改变后的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
清空

public static void main(String[] args)
    {
        //创建一个集合容器，使用collection接口的子类，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、获取个数，集合长度。
        sop("size:"+al.size());
        //打印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        al.clear();

        //打印改变后的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
3、判断元素
示例：

public static void main(String[] args)
    {
        //创建一个集合容器，使用collection接口的子类，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、获取个数，集合长度。
        sop("size:"+al.size());
        //打印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        //al.clear();
        //判断元素
        sop("java03是否存在"+al.contains("java03"));

        //打印改变后的集合
        //sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
boolean retainAll(Collection

public static void main(String[] args)
    {
        method();
    }
    public static void method()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");

        ArrayList al2 = new ArrayList();
        al2.add("java01");
        al2.add("java02");
        al2.add("java05");
        al2.add("java06");

        al1.retainAll(al2);//取交集。al1中只会保留和al2中相同的部分

        sop("al1:"+al1);
        sop("al2:"+al2);
    }
    public static void base_method()
    {
        //创建一个集合容器，使用collection接口的子类，Arraylist。
        ArrayList al = new ArrayList();
        //1、添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //2、获取个数，集合长度。
        sop("size:"+al.size());
        //打印原集合
        sop(al);
        //删除
        //al.remove("java02");
        //清空
        //al.clear();
        //判断元素
        sop("java03是否存在"+al.contains("java03"));

        //打印改变后的集合
        //sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
4、取出元素
方法一：

public static void main(String[] args)
    {
        method_get();
    }
    public static void method_get()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        sop(al1);

    }
    public static void base_method()
    {

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
方法二：

public static void main(String[] args)
    {
        method_get();
    }
    public static void method_get()
    {
        ArrayList al1 = new ArrayList();
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        //sop(al1);
        Iterator  it = al1.iterator();//获取迭代器[迭代器其实就是集合取出元素的方式]，用于取出集合中的元素。
        while(it.hasNext())
        {
        sop(it.next());
        }

    }
    public static void base_method()
    {

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
三、List集合
1、List集合的特点
（ 1 ）元素是有序的
（ 2 ）元素可以重复（因为该集合体系有索引）
2、List集合的常见方法
特有方法：凡是可以操作脚标的方法都是该体系特有的方法。
（1）增： al.add(); 在指定位置添加 al.(index,”“);
示例：

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
                sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");
                sop(al);
            }

结果为：
这里写图片描述
（2）删：al.remove(index);

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
                sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove(2);
                sop(al);

    }

结果为：
这里写图片描述
（3）改：a1.set(index,”“)

public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove(2);
        //修改元素
        al.set(2, "java07");

        sop(al);

    }

结果为：
这里写图片描述
（4）查：get(index);
subList(from,to);

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通过脚标获取元素
        sop("get(1):"+al.get(1));
                sop(al);
            }

结果为：
这里写图片描述

获取所有元素：

 for(int x=0;x<al.size();x++)  
   {        al.get(x)     }   
    第二种方式：     
    Iterator it=a1.iterator();       while(it.hasNext())     
      {             it.next();        }

 public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是："+al);
        //在指定位置添加元素
        al.add(1,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通过脚标获取元素
        //sop("get(1):"+al.get(1));
        //获取所有的元素。
        for(int x=0;x<al.size();x++)
        {
            System.out.println("al("+x+")="+al.get(x));
        }

        //sop(al);

    }

结果为：
这里写图片描述
（5）通过indexof获取对象的位置：
al.indexof(“字符串”);获取列表中两个位置之间的数：返回List
List sub=al.subList（1,3）返回角标1和3之间的数在迭代集合过程中，不能对集合进行其他操作，如添加删除等，这时就需要迭代器可以对迭代器的对象进行操作，但是由于Iterator迭代器只有 remove功能，所以建议使用其子接口ListIterator,它具备删除 remove 添加 add 修改 set 等功能，但此功能是List特有 ListIterator列表迭代器：是List集合特有的迭代器，是Iterator的子接口。可以对集合列表进行各种操作。

ListIterator it=a1.ListIterator();       
   while(it.hasNext())//正向遍历       {            
    it.next();           
     it.set();//修改        }

3、集合中的对象
（1）ArrayList：底层使用是的数组结构。
特点：查询速度很快，但是增删稍慢。线程不同步的
练习：

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



//去除ArrayList中的重复元素
public class arraylisttest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop(al);

        al = singleElement(al);
        sop(al);
    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList newal = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }

}

结果为：
这里写图片描述
（2）LinkedList：底层使用的是链表结构。
特点：增删速度快，但是查询稍慢。
LinkedList()集合;
特有方法：
();往前添加

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");

        sop(link);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
addlast(）;往后添加

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");

        sop(link);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
getFirst();//获取头值，永远是第一个值 getLast();//获取尾值
获取元素但不删除元素

   public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");

        sop(link.getFirst());
        sop(link.getLast());
            }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
removeFirst();//删除并返回头元素出现NuSuchElementException异常 removeLast();//删除并返回尾元素可以获取元素，但是元素被删除。如果集合中没有元素会出现NuSuchElementException异常，在JDK1.6中出现了替代方法。

public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");


        sop(link.size());
        sop(link.removeFirst());
        sop(link.size());
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

结果为：
这里写图片描述
1.6中出现了替代方法: 添加 offerFirst() offerlast() 获取 peekFirst() peekLast()
可以获取元素，但是元素不被删除。如果集合中没有元素会返回null 删除 pollfirst() polllast() LinkedList llist=new LinkedList();可以获取元素，但是元素被删除。如果集合中没有元素会返回null
练习：
堆栈：先进后出杯子
队列：先进先出水管

import java.util.LinkedList;


public class duilie {
    private LinkedList link;

    duilie()
    {
          link = new LinkedList();
    }
    public void myAdd(Object obj)

    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeLast();
    }
    public boolean isNull()
    {
        return link.isEmpty(); 
    }
    public static void main(String[] args)
    {
        duilie dl = new duilie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        System.out.println(dl.myGet());
    }
}

结果为：
这里写图片描述
（3）Vecctor：底层使用是的数组结构。线程同步的。被ArrayList替代了。
Vector 使用：

Vector v=new Vector（）；v.add（）；v.add();Enumeration en=new Enumeration ()while(en.hasMoreElements()){   en.nextElement();}

public static void main(String[] args)
        {
            Vector v = new Vector();
            v.add("java01");
            v.add("java02");
            v.add("java03");
            v.add("java04");
            Enumeration  en= v.elements();

            while(en.hasMoreElements())
            {
               System.out.println(en.nextElement());
            }
  }

结果为：
这里写图片描述

import java.util.ArrayList;
import java.util.Iterator;
//去除ArrayList中的重复元素
public class arraylisttest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
    //在迭代时循环中next调用一次，就要用hasNext判断一次
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            sop(it.next()+"....."+it.next());
        }

    }
    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList newal = new ArrayList();
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newal.contains(obj))
                newal.add(obj);
        }
        return newal;
    }

}