java数组中删除元素或一个数组元素
 
删除数组中单个元素
删除数组中多个元素（数组表示）
 


 这里直接介绍两种情况：

 1、删除数组中单个元素

 2、删除数组中多个元素（数组表示）
 
删除数组中单个元素
 
1、
 新建一个数组，
 将原数组中值写入新数组时进行判断是否为要删除的元素，
 如果是就直接跳过进行下一个循环，
 否则直接写入新数组，
 最后将新数组赋值给原数组
 以下给出简要代码
 
//ints是原数组，temp是新数组，err是要删除的元素 
	j=0；
	for(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

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

  

  

 
 
 如何检查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)
 
 
Arrays binarySearch() API Doc
 数组binarySearch（）API文档 
Stream anyMatch() API Doc
 流anyMatch（）API文档 
 

  
翻译自: https://www.journaldev.com/32438/java-array-contains-value
 
 
java数组包含某个值