Java集合系列(二)

最新推荐文章于 2021-11-03 19:05:29 发布

Bryce李小白

最新推荐文章于 2021-11-03 19:05:29 发布

阅读量277

点赞数

分类专栏： Java知识体系文章标签： java 集合类 ArrayList

本文链接：https://blog.csdn.net/lijizhi19950123/article/details/78106703

版权

Java知识体系专栏收录该内容

27 篇文章 3 订阅

订阅专栏

前言

通过上一篇Java集合系列(一)的介绍，想必读者们应该已经掌握好集合的基本概念了吧，接下来这篇文章笔者将会着重介绍一下集合各个接口及其常用子类的作用。

Collecton接口的定义

Collection接口的定义如下所示：

public inteface Collection<E> extends Iterable

从接口的定义中可以发现，此接口使用了泛型的定义，在操作时必须指定具体的操作类型。这样可以保证集合操作的安全性，避免发生ClassCastException异常。

小知识点

在JDK1.5之后才增加了泛型的支持，目的是为了保证集合中所有元素的类型一致

Collection接口是单值存放的最大父接口，可以向其中保存多个单值（单个对象）数据。
这里写图片描述

注意：在一般开发中，往往很少直接使用Collection接口进行开发，基本上都是使用其子接口。子接口主要有List，Set，Queue和SortedSet。

Collection子接口的定义

List:可以存放重复的内容
Set：不能存放重复的内容，所有的重复内容靠hashCode()和equals()两个方法区分。
Queue：队列接口
SortedSet：可以对集合中的数据进行排序。

List接口

List接口的定义

List是Collection的子接口，其中可以保存各个重复的内容。此接口的定义如下:`

public interface List<E> extends Collection<E>`

这里写图片描述

List接口的常用子类

新的子类：ArrayList

ArrayList是List子类，可以直接通过对象的多态性为List接口实例化。此类的定义

public  class ArrayList<E> extends AbstractList<E>
implements List<E>,RandomAccess,Cloneable,Serializable

从定义中可以发现ArrayList类继承了AbstractList类，AbstractList类的定义如下：

public abstract class Abstract<E> extends AbstractCollection<E> implements List<E>

此类实现了List接口，所以可以直接使用ArrayList为List接口实例化。

操作一：增加数据

代码示范

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class ArrayListDemo01{
public static void main(String[] args){
List<String> allList=null; //定义List对象
Collection<String> allCollection=null;//定义Collection对象
allList=new ArrayList<String>(); //实例化List对象，只能是String类型
allCollection=new ArrayList<String>();//实例化Collection对象 ，只能是String类型
allList.add("Hello"); //从Collection继承的方法
allList.add(0,"world");//此方法为List扩充的方法
System.out.println(allList);//输出集合中的内容
allCollection.add("LJZ");//增加数据
allCollection.add("www.baidu.com");//增加数据
allList.addAll(allCollection); //从Collection继承的方法，增加一组对象
allList.addAll(0,allCollection);//此方法是List自定义的，增加一组对象
System.out.println(allList);//输出对象，调用toString（）方法
   }
}

程序输出结果：

[world, Hello]
[LJZ, www.baidu.com, world, Hello, LJZ, www.baidu.com]

从程序的运行结果中可以发现，使用List中的add(int index,E element)方法可以在集合中的指定位置增加元素，而其他的两个add()方法只是在集合的最后进行内容的追加。

操作二：删除对象

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo02{
public static void main(String[] args){
List<String> allList=null; //声明List对象
allList=new ArrayList<String>()//实例化List对象，只能是String类型
allList.add("Hello");//增加元素
allList.add(0,"world"); //添加指定位置的元素
allList.add(1,"LJZ");  //添加指定位置的元素
allList.remove(1);  //删除指定位置的元素
allList.remove("world");  //删除指定内容的元素
System.out.println(allList); //输出对象，调用toString()方法
  }
}

程序运行结果：[Hello]

操作三：输出List中的内容

在Collection接口中定义了取得全部数据长度的方法size(),而在List接口中存在取得集合中指定位置元素的操作get（int index），使用这两个方法即可输出集合中的全部内容。

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo03{
public static void main(String[] args){
List<String> allList=null;  //定义List接口对象
allList=new ArrayList<String>(); //实例化List对象，只能是String类型
allList.add("Hello");
allList.add('L');
allList.add('J');
allList.add('Z');
allList.add(0,"Hello");
allList.add(1,"world");
System.out.print("由前向后输出")；
for(int i=0;i<allList.size();i++){
System.out.print(allList.get(i)+",");
}
System.out.print("\n由后向前输出");
for(int i=allList.size();i>=0;i--){
System.out.print(allList.get(i)+",");
  }
 }
}

程序运行结果：

由前向后输出Hello,world,Hello,L,J,Z,
由后向前输出Z,J,L,Hello,world,Hello,

从程序的运行结果可以看出，在List集合中数据增加的顺序就是输出后的顺序，本身顺序不会发生变化。

操作四：将集合变为对象数组

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo04{
public static void main(String[] args){
List<String> allList=null;
allList=new ArrayList<String>();
allList.add("A");
allList.add("B");
allList.add("C");
allList.add(0,"D");
allList.add(4,"E");
String str[]=allList.toArray(new String[]{});
System.out.print("指定数组类型：");
for(int i=0;i<str.length;i++ ){
System.out.print(str[i]+",");
}
System.out.print("\n返回对象数组：");
Object obj[]=allList.toArray();
for(int i=0;i<obj.length;i++){
String temp=(String)obj[i];
System.out.print(temp+",");
  }
 }
}

程序运行结果：

指定数组类型：D,A,B,C,E,
返回对象数组：D,A,B,C,E,

操作五：截取集合，查找元素位置，判断元素是否存在，集合是否为空等操作

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo05{
public static void main(String[] args){
List<String> allList=null;
allList=new ArrayList<String>();
System.out.print("集合操作前是否为空？"+allList.isEmpty());
allList.add("A");
allList.add("B");
allList.add("C");
allList.add("D");
System.out.println(allList.contains("Hello")?"\"Hello\"字符串存在！":"\"Hello\"字符串不存在！");
List<String> allSub= allList.subList(1,2);
System.out.print("集合截取：");
for(int i=0;i<allSub.size();i++){
System.out.print(allList.get(i)+",");
}
System.out.println("");
System.out.println("C字符的位置"+allList.indexOf("C"));
System.out.println("集合操作后是否为空？"+allList.isEmpty());
}
}

程序运行结果：

集合操作前是否为空？true”Hello”字符串不存在！
集合截取：A,
C字符的位置2
集合操作后是否为空？false

挽救的子类：Vector

> 在List接口中还有一个子类Vector，Vector类属于一个挽救的子类，从整个Java的集合发展历史来看，Vector算是一个元老级的类，在JDK1.0时就已经存在此类。到了Java2之后重点强调了集合框架的概念，所以先后定义了很多新接口（如List等），但是考虑到一大部分用户已经习惯了使用Vector类，所以Java的设计者就让Vector类多实现了一个List接口，这才保留下来。但是因为其是List的子类，所以Vector类的使用与之前的并没有太大的区别。

这里写图片描述

以上对两个类进行简单的对比，但是从实际的应用开发来看，ArrayList类使用较多，读者应该重点掌握。

LinkedList子类与Queue接口

LinkedList表示的是一个链表的操作类，即Java中已经为开发者提供了一个链表程序，开发者直接使用即可，无需重新开发。LinkedList类的定义如下：

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Queue<E>,Cloneable,Serializable

从定义不难看出，此类虽然实现了List接口，但也同时实现了Queue接口，所以也就能够调用Queue接口定义的方法。
这里写图片描述

操作一：为链表增加数据

package ljz;
import java.util.LinkedList;
public class LinkedListDemo01{
public static void main(String[] args){
LinkedList<String> link=new LinkedList<String>();
link.add("A");
link.add("B");
link.add("C");
link.add("D");
System.out.println("初始化链表："+link);
link.addFirst("X");
link.addLast("Y");
System.out.println("增加头和尾之后的链表："+link);
}
}

程序运行结果：

初始化链表：[A, B, C, D]
增加头和尾之后的链表：[X, A, B, C, D, Y]

操作二：找到链表头

找到表头：public E peek()
找到不删除表头：public E peek()
找到并删除表头：public E poll()

import java.util.LinkedList;
public class LinkedListDemo02{
public static void main(String[] args){
LinkedList<String> link=new LinkedList<String>();
link.add("A");
link.add("B");
link.add("C");
link.add("D");
System.out.println("1,element()方法找到表头："+link.element());
System.out.println("2,找到之后的链表内容" +link);
System.out.println("3.peek()方法找到表头" +link.peek());
System.out.println("4.找到之后的链表内容："+link);
Ststem.out.println("5.poll()方法找到表头"+link.poll());
System.out.println("6.找到之后的链表内容："+link);
 }
}

程序运行结果：

1,element()方法找到表头：A
2,找到之后的链表内容[A, B, C, D]
3.peek()方法找到表头A
4.找到之后的链表内容：[A, B, C, D]
5.poll()方法找到表头A
6.找到之后的链表内容：[B, C, D]

操作三：以先进先出的方式取出全部的数据

在LinkedList类中存在poll()方法，通过循环此操作，就可以把内容全部取出来（以FIFO的方式）。

package ljz;
import java.util.LinkedList;
public class LinkedListDemo03 {
    public static void main(String[] args){
    LinkedList<String> link=new LinkedList<String>();
    link.add("A");
    link.add("B");
    link.add("C");
    link.add("D");
    System.out.print("以FIFO的方式输出：");
    for(int i=0;i<link.size()+1;i++){
    System.out.print(link.poll());  
    }

    }

}