java中操作多个List

Posted 2023-03-26

比如List<P> A; List <P> B; List<P> C

A,B,C大小不同
怎样把A,B,C放入总的List<P> D里面

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

import java.util.Stack;

import java.util.Vector;

public class Lession6

　 public static void main(String[] args)


　　 // 下面是List里面常用的实现类

　　 // 大小可变列表的实现，允许任何数据加入

　　 ArrayList arrayList = new
ArrayList();

　　 // 同样是大小可变列表的实现.

　　 //
与ArrayList的最大区别就是这个类的方法是同步(synchronized)的

　　 // 详细的区别，请参考

　　 // 看源代码理解ArrayList和Vector 的真正区别

　　 // http://www.java2000.net/p9750

　　 Vector vector = new Vector();

　　 // 实现了双向队列的控制，包括头尾的操作

　　 // 可用于堆栈和FIFO操作等

　　 LinkedList linkedList = new
LinkedList();

　　 // 集成自 Vector

　　 // 提供了LIFO的堆栈操作方式

　　 Stack stack = new Stack();

　　 // -----------------

　　 // 下面以ArrayList作为例子，看看列表的各个方法

　　 List list = new ArrayList();

　　 // 构建第二个列表

　　 List list2 = new ArrayList();

　　 // 向列表的尾部添加指定的数据

　　 list.add(123);

　　 // 在列表的指定位置插入指定数据

　　 // 我们在最前面插入数据

　　 // 列表的位置索引从0开始

　　 list.add(0, 456);

　　 // 将list2里面的数据，全部放到list1的尾部去

　　 // 注意此处可以是任何集合类，不限于列表

　　 list.addAll(list2);

　　 // 将list2里面的数据，全部放到list1指定位置的后面

　　 // 等于插入一段数据

　　 list.addAll(2, list2);

　　 // 清空列表，删除里面所有的数据

　　 list.clear();

　　 // 判断列表里是否包含某个数据

　　 boolean found = list.contains(123);

　　 // 判断列表是否包含了另一个集合的所有数据

　　 // 注意此处可以是任何集合类，不限于列表

　　 boolean ok =
list.containsAll(list2);

　　 // 获得指定位置的数据

　　 // 如果位置超过了列表的范围 0 到 list.size()-1

　　 // 则抛出异常：IndexOutOfBoundsException

　　 Object obj = list.get(3);

　　 // 得到数据在列表中的位置

　　 // 如果没找到，返回-1

　　 // 位置索引从0开始

　　 int index = list.indexOf(456);

　　 // 判断列表是不是空的

　　 boolean empty = list.isEmpty();

　　 // 列表的迭代器操作

　　 // 顺序严格按照列表的保存的顺序

　　 Iterator it = list.iterator();

　　 // 得到数据在列表最后一次出现的位置

　　 // 适合于有重复数据的列表

　　 index = list.lastIndexOf(456);

　　 // 列表的另一个迭代器

　　 ListIterator listIT =
list.listIterator();

　　 // 列表的另一个迭代器，可以指定起始位置

　　 ListIterator listIT2 =
list.listIterator(3);

　　 // 删除某个位置的数据

　　 list.remove(3);

　　 // 删除指定对象的第一个出现的位置

　　 // 注意，如果是整数，要区分其与remove(int)的区别

　　 // 建议用 remove(new Integer(123));
来删除数据对象

　　 list.remove(new Integer(123));

　　 // 删除列表里在另一个集合里存在的数据

　　 list.removeAll(list2);

　　 // 只保留在另一个集合里存在的数据，等于交集

　　 list.retainAll(list2);

　　 // 替换指定位置的数据

　　 list.set(3, 999);

　　 // 列表数据的数量

　　 int size = list.size();

　　 // 得到一个子数组

　　 List subList = list.subList(2, 10);

　　 // 将集合转化为数组

　　 Object[] objs = list.toArray();

　　 // 将集合转化为指定格式的数组

　　 // 比如集合里保存的都是String

　　 String[] objs2 = (String[])
list.toArray(new String[0]);

　

参考技术A List<Objecct> listA = new ArrayList<Objecct>();
List<Objecct> listB = new ArrayList<Objecct>();
List<Objecct> listC = new ArrayList<Objecct>();
List<Objecct> listD = new ArrayList<Objecct>();  
1：  
listD.add(listA);
listD.add(listB);
listD.add(listC);
2：
listD.addAll(listA);
listD.addAll(listB);
listD.addAll(listC);

参考技术B 可以使用集合类的 addAll 方法，比如 D.addAll(A) 就可以把 A 中的元素添加到 D 中。 参考技术C 创建一个 List<List> 的对象 然后添加 就ok啦！ 采纳吧！ 参考技术D 创建一个新的List<P> D

将他们中的内容　添加到D中，list.addll()方法

Java 2 个 List 集合数据求并补集操作

开发过程中，我们可能需要对 2 个 或多个 List 集合中的数据进行处理，比如多个 List 集合数据求 相同元素，多个 List 集合数据得到只属于本身的数据，如图示：

这里写图片描述

 

 

这里以 2 个 List 介绍，有一些业务要求我们处理得到图上的 3 中情况
* 只属于 A
* 共同的元素
* 只属于 B

这种处理方式在数学上并不陌生，只属于 A ，相当于集合上 B 关于 A 的相对补集；相同的元素，A 和 B 的并集；只属于 B ，相当于集合上 A 关于 B 的相对补集。明白了这几个概念，下面我们就介绍 Java 代码该如何为实现，代码如下

public static void test() {

    List<Integer> A = new ArrayList<Integer>();
    A.add(1);
    A.add(2);
    A.add(3);
    A.add(4);

    List<Integer> B = new ArrayList<Integer>();
    B.add(2);
    B.add(4);
    B.add(5);
    B.add(6);

    Collection C = new ArrayList<Integer>(A);
    C.retainAll(B);
    System.out.println("A 与 B 并集：" + C);

    B.removeAll(C);
    System.out.println("A 关于 B 的相对补集：" + B);

    A.removeAll(C);
    System.out.println("B 关于 A 的相对补集：" + A);

  }

　　运行得到的结果：

 

本文引自：https://blog.csdn.net/gnf_cc/article/details/71214126