精华内容
下载资源
问答
  • java数组包含某个值 如何检查Java数组是否包含值? (How to Check if Java Array Contains a Value?) There are many ways to check if a Java array contains a specific value. 有很多方法可以检查Java数组是否...

    java数组包含某个值

    如何检查Java数组是否包含值? (How to Check if Java Array Contains a Value?)

    There are many ways to check if a Java array contains a specific value.

    有很多方法可以检查Java数组是否包含特定值。

    • Simple iteration using for loop

      使用for循环的简单迭代
    • List contains() method

      列出contains()方法
    • Stream anyMatch() method

      流anyMatch()方法
    • Arrays binarySearch() for sorted array

      数组binarySearch()用于排序的数组

    Let’s look into all these methods one at a time.

    让我们一次研究所有这些方法。

    1.使用For循环 (1. Using For Loop)

    This is the easiest and convenient method to check if the array contains a certain value or not. We will go over the array elements using the for loop and use the equals() method to check if the array element is equal to the given value.

    这是检查数组是否包含特定值的最简便方法。 我们将使用for循环遍历数组元素并使用equals()方法检查数组元素是否等于给定值。

    String[] vowels = { "A", "I", "E", "O", "U" };
    
    // using simple iteration over the array elements
    for (String s : vowels) {
    	if ("E".equals(s)) {
    		System.out.println("E found in the vowels list.");
    	}
    }

    2.使用List contains()方法 (2. Using List contains() method)

    We can use Arrays class to get the list representation of the array. Then use the contains() method to check if the array contains the value. Let’s use JShell to run the example code snippet.

    我们可以使用Arrays类来获取数组的列表表示形式。 然后使用contains()方法检查数组是否包含该值。 让我们使用JShell运行示例代码片段。

    jshell> String[] vowels = { "A", "I", "E", "O", "U" };
    vowels ==> String[5] { "A", "I", "E", "O", "U" }
    
    jshell> List vowelsList = Arrays.asList(vowels);
    vowelsList ==> [A, I, E, O, U]
    
    jshell> vowelsList.contains("U")
    $3 ==> true
    
    jshell> vowelsList.contains("X")
    $4 ==> false
    

    3.使用Stream anyMatch()方法 (3. Using Stream anyMatch() Method)

    If you are using Java 8 or higher, you can create a stream from the array. Then use the anyMatch() method with a lambda expression to check if it contains a given value.

    如果使用Java 8或更高版本,则可以从数组创建 。 然后将带lambda表达式的anyMatch()方法用于检查它是否包含给定值。

    jshell> List vowelsList = Arrays.asList(vowels);
    vowelsList ==> [A, I, E, O, U]
    
    jshell> Arrays.stream(vowels).anyMatch("O"::equals);
    $5 ==> true
    
    jshell> Arrays.stream(vowels).anyMatch("X"::equals);
    $6 ==> false
    

    4.数组binarySearch()用于排序的数组 (4. Arrays binarySearch() for sorted array)

    If your array is sorted, you can use the Arrays binarySearch() method to check if the array contains the given value or not.

    如果对数组进行了排序,则可以使用Arrays binarySearch()方法检查数组是否包含给定值。

    String[] vowels = { "A", "I", "E", "O", "U" };
    
    System.out.println("Unsorted Array = " + Arrays.toString(vowels));
    
    Arrays.parallelSort(vowels);
    
    System.out.println("Sorted Array = " + Arrays.toString(vowels));
    
    int index = Arrays.binarySearch(vowels, "X");
    
    if (index < 0) {
    	System.out.println("X not found in the array");
    } else {
    	System.out.println("X found in the array");
    }

    Output:

    输出

    Unsorted Array = [A, I, E, O, U]
    Sorted Array = [A, E, I, O, U]
    X not found in the array

    检查数组是否包含多个值 (Checking if Array Contains Multiple Values)

    What if we want to check if the array contains multiple values. Let's say you want to check if a given array is the subset of the source array. We can create nested loops and check each element one by one. There is a cleaner way by converting arrays to list and then use the containsAll() method.

    如果我们要检查数组是否包含多个值怎么办。 假设您要检查给定的数组是否是源数组的子集。 我们可以创建嵌套循环并逐个检查每个元素。 有一种更干净的方法,将数组转换为列表,然后使用containsAll()方法。

    String[] vowels = { "A", "I", "E", "O", "U" };
    String[] subset = { "E", "U" };
    
    boolean foundAll = Arrays.asList(vowels).containsAll(Arrays.asList(subset));
    
    System.out.println("vowels contains all the elements in subset = " + foundAll);

    Output: vowels contains all the elements in subset = true

    输出元音包含subset = true中的所有元素

    参考资料 (References)

    1. Arrays binarySearch() API Doc

      数组binarySearch()API文档
    2. Stream anyMatch() API Doc

      流anyMatch()API文档

    翻译自: https://www.journaldev.com/32438/java-array-contains-value

    java数组包含某个值

    展开全文
  • Java判断数组是否包含某个Java获取Map对象指定的key值 ================================ ©Copyright 蕃薯耀2021-07-02 https://www.cnblogs.com/fanshuyao/ 一、Java判断Object对象是否为数组 ...

    Java判断Object对象是否为数组,

    Java判断Object对象是否为集合,

    Java判断数组是否包含某个值

    Java获取Map对象指定的key值

    ================================

    ©Copyright 蕃薯耀 2021-07-02

    https://blog.csdn.net/w995223851

    一、Java判断Object对象是否为数组

    public static String valueCast(Object value) {
            
            String valueString = "";
            
             if(Arrays.isArray(value)) {//数组
                //判断是否为数组(建议优先使用Arrays):
                //1:Arrays.isArray(value)
                //2:value.getClass().isArray()
                valueString = JsonUtil.obj2String(value);
                
            }else {
                valueString = String.valueOf(value);
            }
            
            return valueString;
        }

    1、使用Arrays工具类(建议优先使用)

    Arrays.isArray(value)

    2、通过类反射

    value.getClass().isArray()

    二、Java判断Object对象是否为集合

    1、判断是否为集合:object instanceof Collection

        public static String valueCast(Object value) {
            
            String valueString = "";
            
             if(value instanceof Collection) {//判断是否为集合
                valueString = JsonUtil.obj2String(value);
                
            }else {
                valueString = String.valueOf(value);
            }
            
            return valueString;
        }

    三、Java判断数组是否包含某个值

    1、使用ArrayUtils工具类(优先使用)

    import org.apache.commons.lang3.ArrayUtils;
    
    ArrayUtils.contains(keys, key)

    实际逻辑:

    public static int indexOf(final Object[] array, final Object objectToFind, int startIndex) {
            if (array == null) {
                return INDEX_NOT_FOUND;
            }
            if (startIndex < 0) {
                startIndex = 0;
            }
            if (objectToFind == null) {
                for (int i = startIndex; i < array.length; i++) {
                    if (array[i] == null) {
                        return i;
                    }
                }
            } else {
                for (int i = startIndex; i < array.length; i++) {
                    if (objectToFind.equals(array[i])) {
                        return i;
                    }
                }
            }
            return INDEX_NOT_FOUND;
        }

    2、转换成List集合(比较慢)

    Arrays.asList(arr).contains(targetValue);

    3、自己写循环判断

    ArrayUtils.contains其实就是循环

    四、Java获取Map对象指定的key值

    1、根据指定的keys获取Map中的属性

     /**
         * 根据指定的keys获取Map中的属性
         * @param map
         * @param keys
         * @return
         */
        @SuppressWarnings({ "rawtypes", "unchecked" })
        public static Map<String, Object> getMapByExistKeys(Map map, String[] keys) {
            if(map == null ||  map.isEmpty()) {
                return null;
            }
            
            if(keys == null || keys.length < 1) {
                return null;
            }
            
            Map<String, Object> resultMap = new LinkedHashMap<String, Object>(keys.length);
            
            Set<String> set = map.keySet();
            
            for (String key : set) {
                if(ArrayUtils.contains(keys, key)) {
                    resultMap.put(key, map.get(key));
                }
            }
            return resultMap;
        }

    2、排除指定的keys获取Map中的其它属性

    /**
         * 排除指定的keys获取Map中的其它属性
         * @param map
         * @param excludeKeys 排除的keys
         * @return
         */
        @SuppressWarnings({ "rawtypes", "unchecked" })
        public static Map<String, Object> getMapByExcludeKeys(Map map, String[] excludeKeys) {
            if(map == null ||  map.isEmpty()) {
                return null;
            }
            
            Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
            
            Set<String> set = map.keySet();
            
            for (String key : set) {
                if(ArrayUtils.contains(excludeKeys, key)) {
                    continue;
                }
                resultMap.put(key, map.get(key));
            }
            
            return resultMap;
        }

    (时间宝贵,分享不易,捐赠回馈,^_^)

    ================================

    ©Copyright 蕃薯耀 2021-07-02

    https://blog.csdn.net/w995223851

    展开全文
  • Java中如何高效的判断数组中是否包含某个元素 Arrays.asList Arrays.asList的作用是将数组转化为list,一般是用于在初始化的时候,设置几个值进去,简化代码,省去add的部分。 List<String> ebsCodes = ...

                在Java中如何高效的判断数组中是否包含某个元素

    Arrays.asList

    Arrays.asList的作用是将数组转化为list,一般是用于在初始化的时候,设置几个值进去,简化代码,省去add的部分。

    List<String> ebsCodes = Arrays.asList("USERNAME","REAP","NLS");

    也可以使数组[但是数组类型不能是(byte,short,int,long,float,double,boolean),可以是integer等。

     String[] s = {"aa","bb","cc"};
    List<String> strlist = Arrays.asList(s);

    注意

    (1)该方法不适用于基本数据类型(byte,short,int,long,float,double,boolean),可以是integer。
    (2)该方法将数组与列表链接起来,当更新其中之一时,另一个自动更新
    (3)不支持add和remove方法

    1 List

    public static boolean useList(String[] arr, String targetValue) {
        return Arrays.asList(arr).contains(targetValue);
    }
    

    源码 

    源码List:Arrays.asList(arr).contains(targetValue),使用循环查找
    /**
         * Returns the index of the first occurrence of the specified element
         * in this list, or -1 if this list does not contain the element.
         * More formally, returns the lowest index <tt>i</tt> such that
         * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
         * or -1 if there is no such index.
         */
        public int indexOf(Object o) {
            if (o == null) {
                for (int i = 0; i < size; i++)
                    if (elementData[i]==null)
                        return i;
            } else {
                for (int i = 0; i < size; i++)
                    if (o.equals(elementData[i]))
                        return i;
            }
            return -1;
        }
    

    2 Set

    public static boolean useSet(String[] arr, String targetValue) {
        Set<String> set = new HashSet<String>(Arrays.asList(arr));
        return set.contains(targetValue);
    }
    

     Set使用的是HashSet的contains方法(HashSet底层HashMap实现),通过hash值循环对比查找

    /**
         * Implements Map.get and related methods
         *
         * @param hash hash for key
         * @param key the key
         * @return the node, or null if none
         */
        final Node<K,V> getNode(int hash, Object key) {
            Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
            if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
                if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                    return first;
                if ((e = first.next) != null) {
                    if (first instanceof TreeNode)
                        return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            return e;
                    } while ((e = e.next) != null);
                }
            }
            return null;
        }
    

    3循环判断

    public static boolean useLoop(String[] arr, String targetValue) {
        for(String s: arr){
            if(s.equals(targetValue))
                return true;
        }
        return false;
    }
    

    4 Arrays.binarySearch()

    Arrays.binarySearch()方法只能用于有序数组!!!如果数组无序的话得到的结果就会很奇怪。
    public static boolean useArraysBinarySearch(String[] arr, String targetValue) { 
        int a =  Arrays.binarySearch(arr, targetValue);
        if(a > 0)
            return true;
        else
            return false;
    }
    

    源码 BinarySearch(查找数组必须有序): 源码使用二分查找实现元素查找

    private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
                                         Object key) {
            int low = fromIndex;
            int high = toIndex - 1;
     
            while (low <= high) {
                int mid = (low + high) >>> 1;
                @SuppressWarnings("rawtypes")
                Comparable midVal = (Comparable)a[mid];
                @SuppressWarnings("unchecked")
                int cmp = midVal.compareTo(key);
     
                if (cmp < 0)
                    low = mid + 1;
                else if (cmp > 0)
                    high = mid - 1;
                else
                    return mid; // key found
            }
            return -(low + 1);  // key not found.
        }
    

    5 ArrayUtils

    import org.apache.commons.lang3.ArrayUtils;
    public static boolean useArrayUtils(String[] arr, String targetValue) {
        return ArrayUtils.contains(arr,targetValue);
    }
    

    ArrayUtils.contains的源码 ArrayUtils.contains(arr, targetValue),同样使用循环实现查找

    if(array == null) {
           return -1;
       } else {
           if(startIndex < 0) {
               startIndex = 0;
           }
     
           int i;
           if(objectToFind == null) {
               for(i = startIndex; i < array.length; ++i) {
                   if(array[i] == null) {
                       return i;
                   }
               }
           } else if(array.getClass().getComponentType().isInstance(objectToFind)) {
               for(i = startIndex; i < array.length; ++i) {
                   if(objectToFind.equals(array[i])) {
                       return i;
                   }
               }
           }
     
           return -1;
       }
    

    总结

    使用一个简单的循环方法比使用任何集合都更加高效。许多开发人员为了方便,都使用第一种方法,但是他的效率也相对较低。因为将数组压入Collection类型中,首先要将数组元素遍历一遍,然后再使用集合类做其他操作

     

    展开全文
  • 用于个人记录免得以后再百度: ... import org.apache....import java.util.Arrays; public class t { public static void main(String[] args) { int gen[]={1,2,3,4}; System.out.println("**************

    用于个人记录免得以后再百度:

    package com.guomo.app.controller;
    
    import org.apache.commons.lang.ArrayUtils;
    
    import java.util.Arrays;
    
    public class t {
    
    
    
        public static void main(String[] args) {
            int gen[]={1,2,3,4};
            System.out.println("*******************************");
            ArrayUtils.contains(gen,5);
            //包含为true 不包含为 false
            System.out.println("不包含"+ ArrayUtils.contains(gen,5));
            System.out.println("包含"+ ArrayUtils.contains(gen,1));
    
    //集合判断是否存在某个值 。包含为true 不包含为 false
     		ArrayList<Integer> objects = new ArrayList<>();
            objects.add(1);
            objects.contains(1);
    
    
            System.out.println( objects.contains(1));
        }
    
    }
    
    
    展开全文
  • 比如说:如何检查Java数组中是否包含某个值 ?像这类灵魂拷问的主题,非常值得深入地研究一下。 另外,我想要告诉大家的是,作为程序员,我们千万不要轻视这些基础的知识点。因为基础的知识点是各种上层技术共同的...
  • // 下面的代码 是 动态判断 一个 对象数组中 是否包含 某个对象 currentSelectOption(row) { if (!row) return // 判断如果传入对象为空 下面代码不执行 let arrayObject = [ // 对象数组 {name:"小明",age:18}...
  • Java数组

    千次阅读 多人点赞 2018-07-28 09:59:47
    数组属引用类型,数组型数据是对象(object),数组中的每个元素相当于该对象的成员变量。 数组是多个相同类型数据的组合,实现对这些数据的统一管理。一个数组实际上就是一连串的变量,数组按照使用可以分为一维数组...
  • 作者 | 沉默王二本文经授权转载自沉默王二(ID:cmower)在逛 programcreek 的时候,我发现了一些专注细节但价值连城的主题。比如说:如何检查Java数组中是否包含某个...
  • Java 数组

    2016-02-04 14:38:38
    Java数组声明、创建、初始化 Java数组的声明、创建和初始化,并给出其对应的代码。 一维数组的声明方式: type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中...
  • js判断数组对象中的对象是否包含某个值 var arr = [ { key:1, name: '牛百叶' }, { key:2, name: '虾滑' } ]; // bool 为true说明数组包含这个对象 为false则不包含 var bool1 = arr.some(item=> item....
  • 作者 | 沉默王二责编| Elle在逛 programcreek 的时候,我发现了一些专注细节但价值连城的主题。比如说:如何检查Java数组中是否包含某个值 ?像这类灵魂拷问的主题,...
  • Java数组详解1. 数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。2. ...
  • java 数组

    2018-08-06 11:45:24
    java 数组 1.数组创建 java数组创建有两种方式分别如下: type arrName[]=new type[arrSize]; type[] arrName=new type[arrSize]; type为元素数据类型,arrName为数组名,arrSize为数组大小,数据类型可以...
  • java数组

    2017-09-04 17:30:26
    数组数组简介 数组概念 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。 数组既可以存储基本数据类型,也可以存储引用数据类型。 为什么要有数组(容器)为了存储同种数据类型的多个值 数组定义格式...
  • java数组作业

    2016-09-16 19:46:31
    //合并两个字节数组对象 public MyByteArray concat(MyByteArray another) { } //返回部分字节数组 public MyByteArray subByteArray(int beginIndex, int endIndex) { } //返回部分字节数组 public...
  • Java数组基础

    2021-07-23 11:55:14
    数组 Java语言中的数组是一种引用数据类型。不属于基本数据类型。...数组当中如果存储的是“java对象”的话,实际上存储的是对象的“引用(内存地址)”,数组中不能直接存储java对象数组一旦创建,在jav
  • 6Java数组

    2020-08-11 11:24:05
    Java数组 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型,也可以存储引用数据类型。▪数组一旦初始化,长度不可变。长度确定下来了!!! 一维数组的声明方式:...
  • /*这是一个静态函数,不用声明对象就可以用的,如你的类名为Test,在任何情况下都可以调用Test.isHave函数*/  public static boolean isHave(String[] strs,String s){  /*此方法有两个参数,第一个是要查找的...
  • 需求:选中checkbox时需要把该元素的name,code,value等值...// 对JSON数组进行判重,key表示以对象中的某个字段来作为判断重复的依据,value表示重复的值 Array.prototype.indexOfJson = function (key, value) {...
  • hello你好我是辰兮,很高兴你能来阅读,本篇关于前端数组移除对象的相关知识点,也是自己项目中遇到的一点问题,分享获取新知,大家一起进步! 业务场景:表格删除数据后实现刷新表格 场景描述:前端通常情况下获取...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 214,047
精华内容 85,618
关键字:

java数组里包含某个对象

java 订阅