java 接口传list怎么接受 java中list接口

文章目录

• 一、List 接口的定义
• 二、List接口的常用子类

• 1. 新的子类：ArrayList

• （1）向集合中增加元素
• （2）实例操作二：删除元素
• （3）实例操作三：输出 List 中的内容
• （4）实例操作四：将集合变为对象数组
• （5）实例操作五：集合的其他相关操作

• 2. LinkedList 子类与 Queue 接口

• （1）实例操作一：在链表的开头和结尾增加数据
• （2）实例操作二：找到链表头
• （3）实例操作三：以先进先出的方式取出全部的数据

一、List 接口的定义

List 是 Collection 的子接口，其中可以保存各个重复的内容：

public interface List<E> extends Collection<E>

相对于 Collection，在 List 接口中大量地扩充了 Collection 接口，拥有比 Collection 接口中更多的方法定义：

如果想使用List 接口，需要通过其子类对其进行实例化

二、List接口的常用子类

1. 新的子类：ArrayList

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

（1）向集合中增加元素

public class Test{
    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("Java");//增加数据
        allCollection.add("Lanuage");//增加数据
        allList.addAll(allCollection);//从 Collection 继承的方法增加一组对象
        allList.addAll(0,allCollection);//List 自定义的方法，增加一组对象
        System.out.println(allList);
    }
}

（2）实例操作二：删除元素

public class Root{
    public static void main(String[] args) {
        List<String> allList = null;
        allList = new ArrayList<String>();//实例化 List对象，只能是 String 类型
        allList.add("Hello");
        allList.add(0,"World");
        allList.add("Java");
        allList.remove(0);//删除指定位置的元素
        allList.remove("Hello");//删除指定内容的元素
        System.out.println(allList);
    }
}

（3）实例操作三：输出 List 中的内容

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

public class Test{
    public static void main(String[] args) {
        List<String> allList = null;
        allList = new ArrayList<String>();//实例化 List 对象，只能是 String 类型
        allList.add("Hello");
        allList.add("Hello");
        allList.add(0,"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()-1;i>=0;i--){
            System.out.print(allList.get(i) + "、");
        }
    }
}

（4）实例操作四：将集合变为对象数组

在 Collection 中定义了 toArray() 方法，此方法可以将集合变为对象数组，但是由于在类集声明时已经通过泛型指定了集合中的元素类型，所以在接收时要使用泛型指定的类型

public class Root{
    public static void main(String[] args) {
        List<String> allList = null;
        allList = new ArrayList<String >();
        allList.add("Hello");
        allList.add(0,"World");
        allList.add("Java");
        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];//每一个对象都是 String 类型实例
            System.out.print(temp + "、");
        }
    }
}

（5）实例操作五：集合的其他相关操作

在 List 中还有 截取集合、查找元素位置、判断元素是否存在、集合是否为空等操作。

public class Test{
    public static void main(String[] args) {
        List<String > allList = null;//声明 List 对象
        allList = new ArrayList<String>();
        System.out.println("集合操作前是否为空 ？" + allList.isEmpty());
        allList.add("Hello");
        allList.add(0,"World");
        allList.add("Java");
        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("Java 字符串的位置：" + allList.indexOf("Java"));
        System.out.println("集合操作后是否为空？" + allList.isEmpty());
    }
}

2. LinkedList 子类与 Queue 接口

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

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

这个类不但实现了 List接口，也实现了 Queue 接口（队列操作接口，FIFO先进先出）
Queue 接口是 Collection 的子接口：

public interface Queue<E> extends Collection<E>

Queue 接口也可以增加元素并输出

在 LinkedList 类中除了实现上表的方法外，还提供了以下几个操作方法：

（1）实例操作一：在链表的开头和结尾增加数据

import java.util.LinkedList;
public class Root{
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        link.add("A");
        link.add("B");
        link.add("C");
        System.out.println("初始化链表：" + link);//输出链表内容，调用 toString()
        link.addFirst("X");//在链表的表头增加内容
        link.addLast("Y");//在链表的表尾增加内容
        System.out.println("增加头和尾之后的链表：" + link);//输出链表内容，调用 toString()
    }
}

（2）实例操作二：找到链表头

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

import java.util.LinkedList;

public class Root{
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        link.add("A");
        link.add("B");
        link.add("C");
        System.out.println("1-1、element() 方法找到表头：" + link.element());
        System.out.println("1-2、找完之后的链表内容：" + link);
        System.out.println("2-1、peek() 方法找到表头：" + link.peek());
        System.out.println("2-2、找完之后的链表内容：" + link);
        System.out.println("3-1、poll() 方法找到表头：" + link.poll());
        System.out.println("3-2、找完之后的链表内容：" + link);
    }
}

（3）实例操作三：以先进先出的方式取出全部的数据

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

import java.util.LinkedList;

public class Root{
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        link.add("A");
        link.add("B");
        link.add("C");
        System.out.print("以 FIFO 的方式输出：");
        int len = link.size();
        for (int i=0;i< len;i++){//循环输出
            System.out.print( link.poll()+ "、");//取出表头
        }
    }
}