精华内容
下载资源
问答
  • java数组中删除元素或一数组元素

    千次阅读 2020-03-13 17:55:47
    java数组中删除元素或一数组元素删除数组中单个元素删除数组中多个元素(数组表示) 这里直接介绍两种情况: 1、删除数组中单个元素 2、删除数组中多个元素(数组表示) 删除数组中单个元素 1、 新建一数组, 将...

    java数组中删除元素或一个数组元素


    这里直接介绍两种情况:
    1、删除数组中单个元素
    2、删除数组中多个元素(数组表示)

    删除数组中单个元素

    1、
    新建一个数组,
    将原数组中值写入新数组时进行判断是否为要删除的元素,
    如果是就直接跳过进行下一个循环,
    否则直接写入新数组,
    最后将新数组赋值给原数组
    以下给出简要代码

    //ints是原数组,temp是新数组,err是要删除的元素 
    	j=0for(int in: ints){
    		if(int == err)
    			continue;
    		else
    			temp[j++] = in;
    	}
    	ints=temp
    

    2、
    比较常见的遍历一遍数组,
    找到需要删除的元素,(这只限于删除第一个找到err元素,如果需要删除数列中全部的err元素,看代码中注释)
    后面所有的元素向前一个位置覆盖之前的元素,达到删除元素的效果
    以下是完整的函数代码
    (为了达到统一输出的效果,加了一个flag判定是否删除)

    public static int[] delete(int[] ints,int err) {
    		boolean flag = false;
    		int length = ints.length;
    		//这里只进行了找到第一个需要删除元素位置,
    		//并用后面的元素逐次向前覆盖,并不是真正的删除
    		//(删除是通过底下重新建立数组赋值进行的)
    		for(int i = 0; i < length; i++) {
    			if(err == ints[i]) {
    				for(int j = i; j < length - 1; j++) {
    					ints[j] = ints[j + 1];
    				}
    				length--;
    				flag = true;
    				break;//如果要删除全部的err元素 这里改为 i--;
    				//为了防止相邻相同的情况
    			}
    		}
    		if (flag)
    			System.out.println("删除" + err + "成功!");
    		else
    			System.out.println("输入err有误,不存在" + err +",无法删除");
    		
            //将删除后数组进行重新保存 并返回
            int[] result = new int[length];
            System.arraycopy(ints,0,result,0,length);
            return result;
    	}
    

    删除数组中多个元素(数组表示)

    新建一个数组
    将原数组写入新数组的同时对写入的元素进行判断是否在需要删除的数组中
    运用flag进行标记是否需要写入(即该元素是否在需要删除的数组中)
    通过fiag的标识,在新的数组中写入元素,
    最后将中间的temp数组通过copy再返回,原因是 删除元素后的数组长度是需要测量出来的,即为代码中的index。

    //在ints数组中删除包含res数组元素
        public static int[] delete(int[] ints,int[] errs) {
            int index = 0;
            int[] temp = new int[ints.length];
            //通过foreach的循环只能够进行遍历 并不能进行删除修改操作
            for (int in: ints){
                boolean flag = true;
                for (int err: errs)
                    if (in == err){
                        flag = false;
                        break;
                    }
                if(flag)
                    temp[index++]=in;
            }
            //将中间保存的temp数组进行重新保存(删除后面多余的长度) 并返回
            //index 也代表着长度 因为在每次获取值后++了
            //所以最终是比实际下标多1
            int[] result = new int[index];
            System.arraycopy(temp,0,result,0,index);
            return result;
        }
    

    另外也可以通过万能的Arrays.asList(ints) 将数组转化为list ,然后就直接运用循环加上remove函数删除就好了。

    附上一段测试的代码

    
        public static void main(String[] args) {
            int[] ints = new int[10];//初始数组
            for (int i = 0; i < ints.length; i++){
                ints[i] = i;
            }
            int[] err = new int[3];//初始数组
            for (int i = 0; i < err.length; i++){
                err[i] = i + 1 ;
            }
            err[2] = 52;//测试一下err不在ints中
            int[] result = delete(ints,err);
            System.out.println(Arrays.toString(err));
            System.out.println(Arrays.toString(ints));
            System.out.println(Arrays.toString(result));
        }
    

    以及结果:
    在这里插入图片描述

    第一篇博客,纪念一下🐶
    然而 各种小bug挺多的 第三次修改了。

    以下是最初的时候,直接进行写的,没有写方法。

      public static void main(String[] args) {
            int[] res = new int[2];//要求删除的元素值
            for (int i = 0; i < res.length; i++){
                res[i]=i + 2;
            }
    		int err = 5;
            int j = 0;
            int[] temp = new int[8];//用来存放新元素的数组
    		//在ints数组中删除包err元素
    		for(int in: ints){
    			if(int == err)
    				continue;
    			else
    				temp[j++] = in;
    		}
    		j = 0;
    		 for (int te: ints){
                System.out.println(te);
            }
    		
    		//在ints数组中删除包含res数组元素
            for (int in: ints){
                boolean flag = true;
                for (int re: res)
                    if (in == re)
                        flag = false;
                if(flag)
                    temp[j++]=in;
            }
            ints = temp;
    	
            for (int te: ints){
                System.out.println(te);
            }
        }
    

    这应该是结局了把enmmm

    展开全文
  • java数组元素为String和Integer时的==判断问题

    String共享池和Integer享元模式不再说了,参看:Integer应用了享元模式  JAVA --String类笔试面试题

    这里看一下在数组中作为元素时,String和Integer是否还有这样的特点?

    	public static void main(String[] args) {
    		String[] a = new String[10];
    		a[0] = "a";
    		a[1] = "a";
    		System.out.println(a[0] == a[1]);//true
    		a[2] = new String("a");
    		a[3] = new String("a");
    		System.out.println(a[2]==a[3]);//false
    		System.out.println(a[2]==a[1]);//false
    		System.out.println(a[2].intern()==a[1]);//true
    		
    		Integer[] i = new Integer[10];
    		i[0] = 97;
    		i[1] = 97;
    		System.out.println(i[0]==i[1]);//true
    		i[2] = 128;
    		i[3] = 128;
    		System.out.println(i[2]==i[3]);//false
    		System.out.println(i[4]);//null
    	}
    由结果可以看出,数组容器中的String还是有常量池特点,Integer也还是有享元模式的特点的。


    展开全文
  • 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类型中,首先要将数组元素遍历一遍,然后再使用集合类做其他操作

     

    展开全文
  • Java文件中实现了统计数组中相同元素个数的功能以及统计数组中小于某个元素的所有元素的数量功能
  • 有一个数组,有一个数x,是否存在数组中两个数之和等于x 两种方法实现,时耗对比 方法1: 先sort, head位置=0, tail位置=x的位置 如果 array[head]+ array[tail] > x; tail--; else head++; 方法2: 暴力破解,两...
  • Java语言怎么判断个数组元素全部包含在另一个数组中了? 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数组是否...

    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数组包含某个值

    展开全文
  • 用于个人记录免得以后再百度: ... 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("**************
  • Java数组

    2020-06-04 15:48:48
    Java数组数组排序及元素位置查找数组添加元素获取多维数组长度数组反转数组获取最大值和最小值组合并数组填充数组扩容查找数组中的重复元素删除数组元素判断数组是否相等数组查找指定元素数组的差集数组的交集数组...
  • Java数组插入或删除元素

    万次阅读 多人点赞 2018-04-09 00:44:21
    Java数组插入或删除元素 **练习1.随机生成一整数型数组(1-10数组长度随机,0-50数组元素随机) 在其数组的最后追加一1-50随机数值** public class ArrayInsert1{ public static void main(String[] args){ ...
  • Java 数组 是否 包含元素

    千次阅读 2019-10-02 11:49:25
    最有效率的是循环的方式: public boolean ... } } //第四种:binarySearch(Arrays的binarySearch方法必须应用于有序数组) int res = Arrays.binarySearch(args, str); if (res > 0){ return true; } return result; }
  • Java判断数组中是否包含某个元素

    千次阅读 2020-05-29 11:37:28
    import java.util.Arrays; /** * 判断数组中是否包含某个值的方法 * //注:Java有两种数据类型,基本数据类型和引用数据类型,判断基本数据类型是否... //第一种利用循环遍历进行操作,如果数组中存在一个元素
  • 比较两个数组中的元素是否相同,在项目中经常会使用到,下面与大家分享最简单的方法
  • java数组

    2020-10-09 11:33:30
    java数组 数组是相同数据类型(数据类型可以为任意类型)的有序集合 特点 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的 其元素必须是相同类型,不允许出现混合类型 数组中的元素可以是任何数据类型...
  • String[] arr = {"1", "2", "3", "4", "5", "6", "9"}; System.out.println(ArrayUtils.contains(arr, "8"));
  • java数组中重复元素的去重方式①数组转集合转数组偷懒的方法方式②创建一临时数组存放去重后的数组 方式① 数组转集合转数组 方式一,我们就先说最简单,最常用的,数组 转 集合 转 数组 public static void main...
  • java:判断数组中是否包含元素

    万次阅读 2017-11-24 09:40:39
    方法一 private static boolean isContainKey(String[] keys, String targetValue) { if (keys == null || keys.length == 0) { ... } 方法二(基础数据类型的数组不推荐) Arrays.asList(arr).contains(targetValue);
  • java 数组的行数和列

    千次阅读 2017-09-20 10:48:36
    java 是按行存储数组的假如一二维数组 a,它的行数为 a.length它的列为 a[0].length三维数组则分别为: a.length, a[0].length, a[0][0].length
  • 其实写循环判断就可以了,如果懒得写代码可以直接用apache库的ArrayUtils.contains方法 import org.apache.commons.lang3.ArrayUtils; int[] array = {1, 2, 3}; boolean b = ArrayUtils.contains(array, 1); ...
  • Java:如何判断个数组中是否包含某个元素

    万次阅读 多人点赞 2019-03-04 17:15:40
    Java:如何判断个数组中是否包含某个元素 方法一、使用List public static boolean useList(String[] arr, String targetValue) { return Arrays.asList(arr).contains(targetValue); } 方法二、使用Set public...
  • 主要介绍了Java封装数组实现包含、搜索和删除元素操作,结合实例形式分析了java针对数组元素的查找、删除、判断等相关操作封装与使用技巧,需要的朋友可以参考下
  • Java数组详解1. 数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干数据,按照一定的先后次序排列组合而成。其中,每一数据称作一数组元素,每数组元素可以通过一下标来访问它们。2. ...
  • Java 数组实例

    千次阅读 2018-05-22 17:00:53
    数组排序及元素查找 数组添加元素 获取数组长度 数组反转 数组输出 数组获取最大和最小值 组合并 数组填充 数组扩容 查找数组中的重复元素 删除数组元素 数组差集 数组交集 数组并集 在数组中查找...
  • Java判断个数组是否有相同的元素

    千次阅读 2019-10-27 22:11:11
    1.如果只是需要判断是否包含相同元素而不需要找出相同元素是哪些,直接放在set集合中,然后看set集合和数组长度是否一致即可 import java.util.HashSet; import java.util.Set; public class Test { public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 179,875
精华内容 71,950
关键字:

java数组包含元素个数判断

java 订阅