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

——- 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(,"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(,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove();
                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(,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove();
        //修改元素
        al.set(, "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(,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通过脚标获取元素
        sop("get(1):"+al.get());
                sop(al);
            }

结果为：

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

获取所有元素：

for(int x=;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(,"java09");
        sop(al);
        //删除指定位置的元素
        //al.remove(2);
        //修改元素
        //al.set(2, "java07");
        //通过脚标获取元素
        //sop("get(1):"+al.get(1));
        //获取所有的元素。
        for(int x=;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;
    }

}

枚举是Vector特有的取出方式

枚举和迭代是一样的

因为枚举的名称以及方法的名称都过长

枚举郁郁而终了

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

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method