Java集合框架-1.【集合类】【Collection接口】【List】【ArrayList】【Vector】【LinkedList】

最新推荐文章于 2022-11-30 15:39:48 发布

it_shine

最新推荐文章于 2022-11-30 15:39:48 发布

阅读量733

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/mayor125/article/details/39099623

版权

Java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

一、集合类(集合框架)

1、集合类：是一种容器。用于封装存储对象，并提供一些功能方法来操作这些对象数据。

2、特点：

①、集合只用于存储对象。

②、集合的长度是可变的。

③、集合可以存储不同类型的对象。

3、数组和集合的区别：

相同点：数组和集合都是容器，都可以用于存储对象。

不同点：数组的长度是固定的，集合的长度是可变的。

数组中可以存储基本数据类型，而集合中只能存储对象。

4、集合框架体系图：

5、集合框架中为什么会出现这么多的容器？

因为每一个容器对数据的存储方式都有所不同，这个存储方式称之为：数据结构。

二、Collection接口

1、是Java的Collection集合框架中的根接口。可以向其中加入多个单值数据。

2、Collection接口中常用的共性方法：

①、添加元素：boolean add(E e)

示例代码：

public static void addMethod()
{
       //创建一个集合容器。使用Collection接口的子类。ArrayList
       ArrayList al = new ArrayList();
       //1、添加元素。
       al.add("java01");
       al.add("java02");
       al.add("java03");
       al.add("java04");
       System.out.println("集合："+al);  //打印集合。
}

②、获取长度/获取交集：int size() / booleanretainAll(Collection<?> c)

示例代码：

public static void getSize()
{
       //创建一个集合容器。使用Collection接口的子类ArrayList。
       ArrayList al1 = new ArrayList();
       al1.add("java01");
       al1add("java02");

       ArrayList al2 = new ArrayList();
       al2.add("java01");
       al2.add("java03");

       System.out.println("集合长度="+al1.size());  //打印集合al1的长度。
       System.out.println(“交集：”+al1.retainAll(al2));  //输出集合al1和集合al2的中相同的元素，即取交集。
}

③、删除元素：boolean remove(Object o)

booleanremoveAll(Collection<?> c)

void clear()

示例代码：

public static void delete()
{
       //创建一个集合容器。使用Collection接口的子类ArrayList。
       ArrayList al1 = new ArrayList();
       al1.add("java01");
       al1add("java02");
       ArrayList al2 = new ArrayList();
       al2.add("java01");
       al2.add("java03");
 
       al1.remove("java02");       //删除指定的元素。
       al1.clear();        //清空集合。
       al1.removeAll(al2);        //删除集合al1和集合al2中相同的元素。
}

④、判断元素：boolean contains(Object o)

boolean isEmpty()

示例代码：

public static void isMethod()
{
       ArrayList al = new ArrayList();
       al.add(“java01”);
       al.add(“java02”);
       System.out.println(“java02在集合中是否存在？”+al.contains(“java02”));
       System.out.println(“集合是否为空？”+al.isEmpty());  //false。
}

3、集合中对象的存储方式：

示例代码：

Person p = new Person();

ArrayList al = new ArrayList();

al.add(p);

总结/注意：

①、add方法的参数类型是Object，以便于接收任意类型对象。

②、集合中存储的都是对象的引用(地址)。

4、迭代器(Iterator)：

①、迭代器：其实就是取出集合中元素的一种方式。

②、迭代器适用范围：Collection接口以及其子类集合对象。

③、迭代器取出元素示例：

public static void method_get()
       {
              ArrayList al = new ArrayList();
              al.add("java01");
              al.add("java02");
              al.add("java03");
              al.add("java04");
 
              Iterator it = al.iterator();  //获取迭代器用于取出集合中的元素。
              while(it.hasNext()) //使用循环以及hasNext()方法判断集合中是否有元素。
              {
                     System.out.println(it.next());  //使用next()方法取出集合中的元素。
              }
       }

/*
输出结果：java01
  java02
  java03
  java04
*/

④、迭代器内部实现方式：

迭代器规则：把从容器中取出元素的方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素，而这种方式就被定义成了内部类。

由于每一个容器的数据结构不同，所以取出的动作细节也不一样，但是它们都有共性的内容：判断和取出。那么就可以将共性内容进行抽取，则这些内部类符合的规则就是迭代器规则。

⑤、迭代器用法：

for(Iterator iter = iterator(); iter.hasNext();)
{
       System.out.println(iter.next());
}
 
Iterator iter = l.iterator();
while(iter.hasNext())
{
       System.out.println(iter.next());
}

三、List集合

1、List集合特点：元素是有序的，且可以重复。因为该集合体系有索引。

2、List集合体系结构：

Collection

|--List

|--ArrayList：底层的数据结构使用的是数组结构。

|--LinkedList：底层使用的链表数据结构。

|--Vector：底层是数组数据结构。

3、List集合的特有方法：凡是可以操作角标的方法都是List体系特有的方法。

4、List集合中的常用方法：

增

void add(int index, E element)

boolean addAll(int index, Collection<?extends E> c)

删

E remove(int index)

改

E set(int index, E element)

查

E get(int index)

List<E> subList(int fromIndex, inttoIndex)

ListIterator<E> listIterator()

代码示例：

public static void method()
       {
              List al = new ArrayList();
 
              //添加元素。
              al.add("java01");
              al.add("java02");
              al.add("java03");
 
              System.out.println("原集合是："+al);
              //在指定位置添加元素。
              al.add(1,"java09");
 
              //删除指定位置的元素。
              al.remove(2);
 
              //修改元素。
              //al.set(2,"java007");
 
              //通过角标获取元素。
             System.out.println("get(1):"+al.get(1));
 
              System.out.println(al);
 
              //获取所有元素。
              for(int x=0; x<al.size(); x++)
              {
                    System.out.println("al("+x+")="+al.get(x));
              }
 
              Iterator it = al.iterator();
              while(it.hasNext())
              {
                     System.out.println("next："+it.next());
              }
 
              //通过indexOf获取对象的位置。
              System.out.println("index="+al.indexOf("java02"));
 
              List sub = al.subList(1,3);
              System.out.println("sub="+sub);
       }

5、ListIterator迭代器

是List集合特有的迭代器，是Iterator的子接口。

注意：在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断、取出、删除的操作。

如果想要操作其它的操作，如：添加、修改等，就需要使用其子接口ListIterator。该接口只能通过List集合的listIterator方法获取。

代码示例：

public static void method()
{
       //演示列表迭代器。
       List al = new ArrayList();
 
       //添加元素。
       al.add("java01");
       al.add("java02");
       al.add("java03");
 
       System.out.println("原集合："+al);
 
       ListIterator li = al.listIterator();
       System.out.println("hasPrevious():"+li.hasPrevious());     //true
 
       while(li.hasNext())
       {
              Object obj = li.next();
 
              if(obj.equals("java02"))
              {
                     //li.add("java0009");
                     li.set("java006");
              }
       }
 
       while(li.hasPrevious())  //通过hasPrevious方法逆向判断集合中的元素。
       {
              System.out.println("pre:"+li.previous());  //通过previous方法逆向取出元素。
       }
       //System.out.println("hasNext():"+li.hasNext());  //false
       //System.out.println("hasPrevious():"+li.hasPrevious());  //true
       System.out.println(al);
 
       /*
       //在迭代过程中，准备添加获取删除元素。
       Iteratorit = al.iterator();
       while(it.hasNext())
       {
              //System.out.println("next："+it.next());
 
              Objectobj = it.next();
              if(obj.equals("java02"))
                     //al.add("java008");
                     it.remove();
 
              System.out.println("obj="+obj);
       }
       System.out.println(al);
       */
}

6、ArrayList的特点：

底层的数据结构使用的是数组结构。
查询速度很快，但是增删速度稍慢。
JDK1.2版本出现，线程不同步，不安全，但效率高，可以手动加锁。
默认初始长度为10，当超过10个元素的长度以后，它会new一个新的数组，做50%的延长变成长度为15，再将多出来的元素添加到新数组里去。

7、Vector的特点：

底层是数组数据结构。
查询速度慢，已经被ArrayList所取代。
JDK1.0版本出现，线程同步，安全，但效率很低。
默认初始化长度为10，超过10个元素之后，新new的数组做100%延长变成20，比较浪费内存空间。

Vector的特有操作——枚举Enumeration

import java.util.*;
class VectorDemo
{
       public static void main(String[] args)
       {
              Vector v = newVector();
 
              v.add("java01");  //往Vector集合中添加元素。
              v.add("java02");
              v.add("java03");
              v.add("java04");
 
              Enumeration en = v.elements();  //使用枚举从集合中取出元素。
              while(en.hasMoreElements())  //通过hasMoreElements方法判断集合中是否有元素。
              {
                     System.out.println(en.nextElement());  //通过nextElement方法取出元素。
              }
       }
}

总结：枚举就是Vector特有的取出方式。和迭代器的功能是一样的。（由于枚举的名称和方法名称过长，所以被Iterator迭代器所取代了）

8、LinkedList的特点：

底层使用的是链表数据结构。
增删速度快，查询稍慢。
线程不同步，不安全。

LinkedList特有方法：

①、添加元素

addFirst();

addLast();

②、获取元素

getFirst();

getLast();

注：获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException异常。

③、删除元素

removeFirst();

removeLast();

注：获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException异常。

代码示例：

import java.util.*;
class LinkedListDemo
{
       public static void main(String[] args)
       {
              LinkedList link = new LinkedList();
              link.addLast("java01");
              link.addLast("java02");
              link.addLast("java03");
              link.addLast("java04");
 
              sop(link);
              sop(link.getFirst());     //java01
              sop(link.getLast());     //java04
              sop(link.removeFirst());      //java01
              sop(link.removeLast());      //java04
 
              sop("size="+link.size());
              while(!link.isEmpty())
              {
                     sop(link.removeFirst());  //循环取出，并删除集合中的元素。
                    //sop(link.removeLast());  //逆向循环取出并删除集合中的元素。
              }
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}

在JDK1.6中出现了替代方法：

①、添加元素

offerFirst();

offerLast();

②、删除元素：

注：获取元素，但是不删除元素。如果集合中没有元素，会返回null。

peekFirst();

peekLast();

注：获取元素，但是元素被删除。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

LinkedList集合的队列和堆栈数据结构：

队列：先进先出。Firstin First out--->FIFO。如同水管里的球，先进去的先出来。

堆栈：先进后出。如同水杯里的球，先进去的后出来。

FIFO代码示例：

import java.util.*;
class DuiLie
{
       private LinkedList link;
       DuiLie()
       {
              link = new LinkedList();
       }
       public void myAdd(Object obj)
       {
              link.addFirst(obj);
       }
       public Object myGet()
       {
              return link.removeLast();       //将先存进去的元素先取出来。
             //return link.removeFirst();      //演示先进后出。先存进去的元素后取出来。
       }
       public boolean isNull()      //判断集合是否为空。
       {
              return link.isEmpty();
       }
}
 
class LinkedListTest
{
       public static void main(String[] args)
       {
              DuiLie dl = new DuiLie();
              dl.myAdd("java01");
              dl.myAdd("java02");
              dl.myAdd("java03");
              dl.myAdd("java04");
 
              while(!dl.isNull())
              {
                     sop(dl.myGet());
              }
       }
       public static void sop(Object obj)
       {
              System.out.println(obj);
       }
}


输出结果：java01
  java02
  java03
  java04
验证了先存进集合中的元素先取出来了。

it_shine

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合框架-1.【集合类】【Collection接口】【List】【ArrayList】【Vector】【LinkedList】

一、集合类(集合框架)1、集合类：是一种容器。用于封装存储对象，并提供一些功能方法来操作这些对象数据。2、特点：①、集合只用于存储对象。②、集合的长度是可变的。③、集合可以存储不同类型的对象。3、数组和集合的区别：相同点：数组和集合都是容器，都可以用于存储对象。不同点：数组的长度是固定的，集合的长度是可变的。数组中可以存储基本数据类型，而集合中只能存储对
复制链接

扫一扫