Fatal编程技术网
  • java/
  • Java 从两个数组列表中删除公共值

Java 从两个数组列表中删除公共值

java list collections

Java 从两个数组列表中删除公共值,java,list,arraylist,collections,iterator,Java,List,Arraylist,Collections,Iterator,我有两个数组列表。第一个数组列表包含应从第二个数组列表中删除的ID。第二个数组列表不仅包含ID，还包含其他信息（以制表符分隔） 我想做的是删除ArrayList2中具有相同ID的所有元素。因此，最终输出应该是另一个arrayList，如下所示： ArrayList2=[1002否是41003否13] 你知道怎么解决这个问题吗 如果每个元素的前四位数字都是要检查的整数，则遍历列表，并用正则表达式将每个元素拆分为字符“”（空白） 现在您有了由Object组成的列表元素，您可以确定第一个条目是一个整数

我有两个数组列表。第一个数组列表包含应从第二个数组列表中删除的ID。第二个数组列表不仅包含ID，还包含其他信息（以制表符分隔）

我想做的是删除ArrayList2中具有相同ID的所有元素。因此，最终输出应该是另一个arrayList，如下所示： ArrayList2=[1002否是41003否13]

你知道怎么解决这个问题吗

如果每个元素的前四位数字都是要检查的整数，则遍历列表，并用正则表达式将每个元素拆分为字符“”（空白）

现在您有了由
Object
组成的列表元素，您可以确定第一个条目是一个整数。只需检查整数即可

在伪代码中：

for (Object obj : ArrayList1) {
  String[] result = Regex.split (obj, " ");
  if (result [0] == myIdToCheck) 
     ArrayList2.remove (obj);
}
如果每个元素的前四位数字都是要检查的整数，则遍历该列表，并用正则表达式将每个元素按字符“”拆分（空格）

现在您有了由
Object
组成的列表元素，您可以确定第一个条目是一个整数。只需检查整数即可

在伪代码中：

for (Object obj : ArrayList1) {
  String[] result = Regex.split (obj, " ");
  if (result [0] == myIdToCheck) 
     ArrayList2.remove (obj);
}
您可以尝试下面的代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class Test {
    public static void main(String args[]){
        Integer idArr[] =  {1000, 1001};
        String unitArr2[] = {"1000  Yes 3   33","1001   No  No  22","1002   No  Yes 4","1003    No  No  13"};

        ArrayList<String> list = new ArrayList<String>(Arrays.asList(unitArr2));

        for(int id: idArr){
            Iterator<String> iterator = list.iterator();
            while(iterator.hasNext()){
                String unit = iterator.next();
                if(Integer.parseInt(unit.split("\t")[0]) == id){
                    iterator.remove();
                    break;
                }
            }
        }

        for(String unit: list){
            System.out.println(unit);
        }
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Iterator；
公开课考试{
公共静态void main（字符串参数[]）{
整数idArr[]={10001001}；
字符串unitArr2[]={“1000是33”、“1001否22”、“1002否4”、“1003否13”}；
ArrayList list=新的ArrayList（Arrays.asList（unitArr2））；
用于（内部id:idArr）{
迭代器迭代器=list.Iterator（）；
while（iterator.hasNext（））{
字符串单位=迭代器.next（）；
if（Integer.parseInt（unit.split（“\t”）[0]）==id）{
iterator.remove（）；
打破
}
}
}
用于（字符串单位：列表）{
系统输出打印项次（单位）；
}
}
}
您可以尝试下面的代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class Test {
    public static void main(String args[]){
        Integer idArr[] =  {1000, 1001};
        String unitArr2[] = {"1000  Yes 3   33","1001   No  No  22","1002   No  Yes 4","1003    No  No  13"};

        ArrayList<String> list = new ArrayList<String>(Arrays.asList(unitArr2));

        for(int id: idArr){
            Iterator<String> iterator = list.iterator();
            while(iterator.hasNext()){
                String unit = iterator.next();
                if(Integer.parseInt(unit.split("\t")[0]) == id){
                    iterator.remove();
                    break;
                }
            }
        }

        for(String unit: list){
            System.out.println(unit);
        }
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Iterator；
公开课考试{
公共静态void main（字符串参数[]）{
整数idArr[]={10001001}；
字符串unitArr2[]={“1000是33”、“1001否22”、“1002否4”、“1003否13”}；
ArrayList list=新的ArrayList（Arrays.asList（unitArr2））；
用于（内部id:idArr）{
迭代器迭代器=list.Iterator（）；
while（iterator.hasNext（））{
字符串单位=迭代器.next（）；
if（Integer.parseInt（unit.split（“\t”）[0]）==id）{
iterator.remove（）；
打破
}
}
}
用于（字符串单位：列表）{
系统输出打印项次（单位）；
}
}
}
要迭代并删除元素时，请使用ListIterator。下面的代码应该删除公共值

    ListIterator<String> iter = list2.listIterator();
    while(iter.hasNext()){
        String value = iter.next();
        String [] tokens = value.split("\\s+");
        if(list1.contains(tokens[0].trim())){
            iter.remove();
        }
    }

ListIterator iter=list2.ListIterator（）；
while（iter.hasNext（））{
字符串值=iter.next（）；
字符串[]标记=value.split（\\s+）；
if（list1.contains（标记[0].trim（）））{
iter.remove（）；
}
}
使用流

List<String> filtered = list2.stream()
            .filter(x -> {
                String [] tokens = x.split("\\s+");
                if(list1.contains(tokens[0].trim())){return false;
                }else{return true;}
            }).collect(Collectors.toList());

List filtered=list2.stream（）
.过滤器（x->{
字符串[]标记=x.split（\\s+）；
if（list1.contains（tokens[0].trim（））{返回false；
}else{return true；}
}).collect（Collectors.toList（））；
要迭代并删除元素时，请使用ListIterator。下面的代码应该删除公共值

    ListIterator<String> iter = list2.listIterator();
    while(iter.hasNext()){
        String value = iter.next();
        String [] tokens = value.split("\\s+");
        if(list1.contains(tokens[0].trim())){
            iter.remove();
        }
    }

ListIterator iter=list2.ListIterator（）；
while（iter.hasNext（））{
字符串值=iter.next（）；
字符串[]标记=value.split（\\s+）；
if（list1.contains（标记[0].trim（）））{
iter.remove（）；
}
}
使用流

List<String> filtered = list2.stream()
            .filter(x -> {
                String [] tokens = x.split("\\s+");
                if(list1.contains(tokens[0].trim())){return false;
                }else{return true;}
            }).collect(Collectors.toList());

List filtered=list2.stream（）
.过滤器（x->{
字符串[]标记=x.split（\\s+）；
if（list1.contains（tokens[0].trim（））{返回false；
}else{return true；}
}).collect（Collectors.toList（））；
如果您使用的是Java 8，则可以
筛选
流
：


import java.util.*;
import java.util.stream.*;

public class Quick {
    private static boolean filter(List<Integer> list, String s) {
        boolean result = false;

        // TODO: improve error checking
        String[] tokens = s.split("\t");

        if (tokens.length > 0) {
            int i = Integer.parseInt(tokens[0]);
            result = ! list.contains(i); 
        }

        return result;
    }

    public static void main(String[] args) {
        // setup

        List<Integer> list1 = new ArrayList<>();
        list1.add(1000);
        list1.add(1001);

        List<String> list2 = new ArrayList<>();
        list2.add("1000\tYes\t3\t33");
        list2.add("1001\tNo\tNo\t22");
        list2.add("1002\tNo\tYes\t4");
        list2.add("1003\tNo\tNo\t13");

        // generate 'result' list
        List<String> result = list2.stream()
                                 .filter(s -> filter(list1,s))
                                 .collect(Collectors.toList());

        // print 'result' list
        for (String s : result) { System.out.println("TRACER " + s); }
    }
}



import java.util.*；
导入java.util.stream.*；
公共课快{
专用静态布尔过滤器（列表，字符串s）{
布尔结果=假；
//TODO:改进错误检查
字符串[]标记=s.split（“\t”）；
如果（tokens.length>0）{
inti=Integer.parseInt（标记[0]）；
结果=！list.contains（i）；
}
返回结果；
}
公共静态void main（字符串[]args）{
//设置
List list1=新的ArrayList（）；
清单1.添加（1000）；
列表1.添加（1001）；
List list2=新的ArrayList（）；
列表2.添加（“1000\tYes\t3\t33”）；
列表2.添加（“1001\tNo\tNo\t22”）；
列表2.添加（“1002\tNo\tYes\t4”）；
列表2.添加（“1003\tNo\tNo\t13”）；
//生成“结果”列表
列表结果=list2.stream（）
.filter（s->filter（列表1，s））
.collect（Collectors.toList（））；
//打印“结果”列表
对于（字符串s:result）{System.out.println（“TRACER”+s）；}
}
}

如果您使用的是Java 8，则可以
筛选
流
：


import java.util.*;
import java.util.stream.*;

public class Quick {
    private static boolean filter(List<Integer> list, String s) {
        boolean result = false;

        // TODO: improve error checking
        String[] tokens = s.split("\t");

        if (tokens.length > 0) {
            int i = Integer.parseInt(tokens[0]);
            result = ! list.contains(i); 
        }

        return result;
    }

    public static void main(String[] args) {
        // setup

        List<Integer> list1 = new ArrayList<>();
        list1.add(1000);
        list1.add(1001);

        List<String> list2 = new ArrayList<>();
        list2.add("1000\tYes\t3\t33");
        list2.add("1001\tNo\tNo\t22");
        list2.add("1002\tNo\tYes\t4");
        list2.add("1003\tNo\tNo\t13");

        // generate 'result' list
        List<String> result = list2.stream()
                                 .filter(s -> filter(list1,s))
                                 .collect(Collectors.toList());

        // print 'result' list
        for (String s : result) { System.out.println("TRACER " + s); }
    }
}



import java.util.*；
导入java.util.stream.*；
公共课快{
专用静态布尔过滤器（列表，字符串s）{
布尔结果=假；
//TODO:改进错误检查
字符串[]标记=s.split（“\t”）；
如果（tokens.length>0）{
inti=Integer.parseInt（标记[0]）；
结果=！list.contains（i）；
}
返回结果；
}
公共静态void main（字符串[]args）{
//设置
列表1=ne