精华内容
下载资源
问答
  • Java数组删除指定元素

    2014-09-18 11:30:09
    [code="java"] package com.zas.util; import java.util.Arrays;... * 删除数组的第 i 个元素(从0开始) * @param arr * @param pos * @return 成功 true 失败 false */ ...

    package com.zas.util;

    import java.util.Arrays;

    public class ArrayUtil {

    /**
    * 删除数组的第 i 个元素(从0开始)
    * @param arr
    * @param pos
    * @return 成功 true 失败 false
    */
    public static Boolean arrayDeleteByPos(Object[] arr, int pos) {
    if(arr == null || pos < 0 || (pos + 1) > arr.length){
    return false;
    }
    for (int j = pos; j < arr.length - 1; j++) {
    arr[j]= arr[j + 1];
    }
    arr[arr.length - 1] = null;
    return true;
    }

    /**
    * 删除数组元素 obj (相同元素只删除一个)
    * @param arr
    * @param i
    * @return 成功 true 失败 false
    */
    public static Boolean arrayDeleteByObj(Object[] arr, Object obj) {
    if(arr == null){
    return false;
    }
    int pos = -1;
    for (int j = 0; j < arr.length; j++) {
    if(obj == null){
    if(arr[j] == null){
    pos = j;
    }
    }else{
    if(obj.equals(arr[j])){
    pos = j;
    }
    }
    }
    if(pos == -1){
    return false;
    }
    return arrayDeleteByPos(arr, pos);
    }

    public static void main(String[] args) {
    Object[] mks = {1, "2", 3, "4", 5, 6};
    System.out.println(Arrays.toString(mks));
    arrayDeleteByObj(mks, 4);
    System.out.println(Arrays.toString(mks));
    arrayDeleteByObj(mks, "4");
    System.out.println(Arrays.toString(mks));
    arrayDeleteByPos(mks, 2);
    System.out.println(Arrays.toString(mks));
    }
    }
    展开全文
  • java数组删除数组元素When we create an array in Java, we specify its data type and size. This is used by JVM to allocates the necessary memory for array elements. There are no specific methods to ...

    java数组删除数组元素

    When we create an array in Java, we specify its data type and size. This is used by JVM to allocates the necessary memory for array elements. There are no specific methods to remove elements from the array.

    在Java中创建数组时,我们指定其数据类型和大小。 JVM使用它为数组元素分配必要的内存。 没有从数组中删除元素的特定方法。

    1.使用for循环从数组中删除一个元素 (1. Removing an element from Array using for loop)

    This method requires the creation of a new array. We can use for loop to populate the new array without the element we want to remove.

    此方法需要创建一个新的数组。 我们可以使用for循环来填充新数组,而无需删除想要删除的元素。

    
    package com.journaldev.java;
    
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,3,4,5};
            int[] arr_new = new int[arr.length-1];
            int j=3;
            for(int i=0, k=0;i<arr.length;i++){
                if(i!=j){
                    arr_new[k]=arr[i];
                    k++;
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" + Arrays.toString(arr_new));
    
        }
    }
    
    Arr Delete

    The code removes the element at index 3. This method simply copies all the elements except the one at index 3 to a new array.

    代码将删除索引3处的元素。此方法将索引3处的元素以外的所有元素简单地复制到新数组中。

    2.按其值删除数组元素 (2. Deleting an array element by its value )

    Unlike the previous case, this code will delete the element based on its value. This will not work with duplicates since the size of the array after deletion has to be known.

    与前一种情况不同,此代码将根据其值删除该元素。 这不适用于重复项,因为必须知道删除后阵列的大小。

    
    package com.journaldev.java;
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,2,3,4,5};
            int[] arr_new = new int[arr.length-1];
            int j=3;
            for(int i=0, k=0;i<arr.length;i++){
                if(arr[i]!=j){
                    arr_new[k]=arr[i];
                    k++;
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" + Arrays.toString(arr_new));
    
        }
    }
    
    Arr Delete based on value

    The only difference between this and the previous case is arr[i]!=j in the if condition in place of i!=j.

    这种情况与前一种情况之间的唯一区别是在if条件下代替i!=j arr[i]!=j i!=j

    3.当数组包含重复项时,通过其值删除元素 (3. Deleting element by its value when the array contains duplicates )

    Performing deletion based on the value in case of duplicates requires using ArrayList. Since ArrayList doesn’t require the size to be now in advance, it allows us to expand dynamically.

    在重复的情况下,根据值执行删除操作需要使用ArrayList。 由于ArrayList不需要现在预先指定大小,因此它允许我们动态扩展。

    
    package com.journaldev.java;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            ArrayList<Integer> arr_new = new ArrayList<>();
            int j=3;
            for(int i=0;i<arr.length;i++){
                if(arr[i]!=j){
                    arr_new.add(arr[i]);
    
                }
            }
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After deletion :" +arr_new);
    
        }
    }
    
    array-deletion-duplicates

    4.移位相同数组中的元素 (4. Shifting elements in the same array)

    This method involves shifting the elements in the same array. Shifting of elements replaces the element to be deleted by the element at the next index.

    此方法涉及移动同一阵列中的元素。 元素的移动将替换下一个索引处要删除的元素。

    
    package com.journaldev.java;
    import java.util.Arrays;
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            int j=3;
            System.out.println("Before deletion :" + Arrays.toString(arr));
            int count =0;
            for(int i = 0; i < arr.length; i++){
                if(arr[i] == j){
                    count++;
    
                    // shifting elements
                    for(int k = i; k < arr.length - 1; k++){
                        arr[k] = arr[k+1];
                    }
                    i--;
                   // break;
                }
            }
    
            System.out.print("After Deletion :" );
            for(int i = 0; i < arr.length-count; i++){
                System.out.print(" " + arr[i]);
            }
            System.out.println();
            System.out.println("Whole array :" + Arrays.toString(arr));
    
        }
    }
    

    Count variable indicates the number of elements deleted. This variable is essential to keep a track of index till which the array should be printed. This method takes care of duplicates as well.

    Count变量指示删除的元素数。 该变量对于跟踪要打印数组的索引至关重要。 此方法也处理重复项。

    Shifting Elements In Array

    5.从ArrayList中删除元素 (5. Deleting elements from ArrayList)

    ArrayList is backed by arrays. The deletion of an element in the ArrayList is straight forward. It requires one simple call to an inbuilt function.

    ArrayList由数组支持。 直接删除ArrayList中的元素。 它仅需简单调用一个内置函数。

    
    package com.journaldev.java;
    import java.util.ArrayList;
    import java.util.Arrays;
    public class Main {
    
        public static void main(String[] args) {
            int[] arr = new int[]{1,3,3,4,5};
            ArrayList<Integer> arr_new = new ArrayList<Integer>();
            for (int i : arr)
            {
                arr_new.add(i);
            }
            arr_new.remove(3);
            System.out.println("Before deletion :" + Arrays.toString(arr));
            System.out.println("After Deletion:" + arr_new);
        }
    }
    

    A call to the remove(i) function removes the element at index i. Deletion in ArrayLists is relatively easier as compared to Arrays.

    调用remove(i)函数将删除索引i处的元素。 与Arrays相比,ArrayLists中的删除相对容易。

    ArrayList Deletion

    结论 (Conclusion)

    We saw some examples of deleting elements in an array using different methods. The difference between the deletion of an element in an Array and an ArrayList is clearly evident. If deletion is to be performed again and again then ArrayList should be used to benefit from its inbuilt functions. Same is the case with the addition of elements to an array. ArrayList due to its dynamic nature provides easier and less cumbersome ways to alter an array.

    我们看到了一些使用不同方法删除数组中元素的示例。 删除Array中的元素和ArrayList之间的区别很明显。 如果要一次又一次地执行删除操作,则应使用ArrayList来受益于其内置功能。 将元素添加到数组的情况也是如此。 ArrayList由于其动态特性而提供了更轻松,更省力的方式来更改数组。

    翻译自: https://www.journaldev.com/42212/java-remove-array-elements

    java数组删除数组元素

    展开全文
  • JAVA删除数组指定元素

    千次阅读 2018-12-28 16:41:42
    //返回剔除指定元素数组 public int[] getThree(int[] scores){ //剔除不符要求的元素(此处为 &lt;0 或 &gt;100) for(int i = 0 ; i &lt; scores.length ; i++ ){ if(scores...
    //记得在开头引用Arrays类
    import java.util.Arrays;
    //返回剔除指定元素的数组
    public int[] getThree(int[] scores){
         //剔除不符要求的元素(此处为 <0 或 >100)
         for(int i = 0 ; i < scores.length ; i++ ){
            if(scores[i]<0 || scores[i]>100){
                //把数组最后一个元素拿来补充不符的元素的位置,因为后面一步需要删除最后一个元素
                scores[i] = scores[scores.length-1];
                //删除数组最后一个元素
                //实现方法是 用 Arrays类中的copyOf()方法得到数组前(length-1)个元素组成的新数组
                scores = Arrays.copyOf(scores,scores.length-1);
            }
         }
         return scores;
    }

     

    展开全文
  • 主要介绍了Java数组中的元素删除并实现向前移的代码的相关资料,需要的朋友可以参考下
  • JAVA中的数组插入与删除指定元素

    万次阅读 热门讨论 2017-08-02 19:28:30
    今天学了Java数组,写了数组的插入和删除,本人小白,写给不会的小白看,大神请忽略,有错请大家指出来; /** 给数组指定位置数组的插入 */ import java.util.*; public class ArrayInsert{ public static ...

    今天学了Java的数组,写了数组的插入和删除,本人小白,写给不会的小白看,大神请忽略,有错请大家指出来;

    /**
    给数组指定位置数组的插入
    */
    import java.util.*;
    public class ArrayInsert{
    	public static void main(String []args){
    		System.out.println("请用键盘输入5个数:");
    		int [] array =new int[10];
    		Scanner sc=new Scanner(System.in);
    		
    		//通过键盘向数组输入数
    		for(int i=0;i<array.length-5;i++){
    			array[i]=sc.nextInt();
    		}
    		//遍历数组
    		System.out.print("原数组为:");
    		for(int a:array){
    			System.out.print("  "+a);
    		}
    		//向指定的位置插入数
    		System.out.println("\n请输入插入位置:有效位置为0-----"+(array.length-1));
    		int index=sc.nextInt();
    		System.out.println("\n请输入插入的值-----");
    		int num=sc.nextInt();
    		
    		
    		//调用静态函数index
    		//遍历插入后的数组
    			System.out.println("插入元素之后的数组遍历:");
    			Insert(index,num,array);
    		     for(int i=0;i<array.length;i++){
    			System.out.print("  "+array[i]);
    		}
    		
    	}
    	//向数组指定位置插入数据方法
    	public static int[] Insert(int index,int num,int a[]){
    			//如果有元素,在索引之后的元素向后移一位,
    			for(int   a[i]=a[i-1];
    			}
    			a[index]=num;
     return a;		
    	}
    }
    
    //删除数组指定位置的数字。
    import java.util.*;
    public class ArrayDelete{
    	public static void main(String args[]){
    		System.out.println("请用键盘输入5个数:");
    		int [] array =new int[10];
    		Scanner sc=new Scanner(System.in);
    		
    		//通过键盘向数组输入数
    		for(int i=0;i<array.length-5;i++){
    			array[i]=sc.nextInt();
    		}
    		//遍历数组
    		System.out.print("原数组为:");
    		for(int a:array){
    			System.out.print("  "+a);
    		}
    		//删除在指定位置的数字
    		System.out.println("\n输入你要删除的位置: 范围在0---"+(array.length-1));
    		int index=sc.nextInt();
    		delete(index,array);//调用delete方法
    		//删除之后的遍历
    		System.out.println("删除之后的遍历:");
    		for(int i=0;i<array.length;i++){
    			System.out.print("  "+array[i]);
    		}
    	}
    	 //数组的特性是,一旦初始化,则长度确定,所以要删除数组中元素,并且长度也随着删除而改变,则要重新建立数组
    	 /**
    *删除方式1
    */
        public int[] delete(int index, int array[]) {
            //数组的删除其实就是覆盖前一位
            int[] arrNew = new int[array.length - 1];
            for (int i = index; i < array.length - 1; i++) {
                array[i] = array[i + 1];
            }
            System.arraycopy(array, 0, arrNew, 0, arrNew.length);
            return arrNew;
        }
    /* *删除方式2
         * 比如有数组
         * int[] ints = {1, 2, 3};
         *
         * @param index 注意:下标是从0开始的
         * @param array 数组;
         * @return 删除之后的数组
         */
        public static int[] deleteByIndex(int index, int array[]) throws Exception {
            if (index < 0 || index > array.length-1) {
                throw new Exception("您输入的下标不在数组的边界内,请数组" + 0 + "到" + (array.length - 1) + "的范围");
            }
            //数组的删除其实就是覆盖前一位
            int[] arrNew = new int[array.length - 1];
            for (int i = 0; i < array.length - 1; i++) {
                if (i < index) {
                    arrNew[i] = array[i];
                } else {
                    arrNew[i] = array[i + 1];
                }
            }
            return arrNew;
        }
    }
    
    展开全文
  • * 原地删除重复出现的有序数组,使得每个元素只出现一次,返回删除重复元素后的数组长度 * 如:给定nums = {0,0,1,1,1,2,2,3,3,3} * 返回:{0,1,2,3} * 思路: * 根据题目数组是有序的,所以只需比较相邻两个元素...
  • 1.数组增加元素练习 /*在指定位置插入指定元素【难点】 存在一个数组数组中的元素为 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, ... 在该数组中的指定下标位置放入指定元素 */ class Demo8 { public st...
  • Java 实现从数组删除指定位置元素

    千次阅读 2016-04-02 17:37:37
    Java 实现从数组删除指定位置元素,比较通过遍历和copy array两种方式的性能差别
  • Java删除数组指定元素,并压缩数组

    千次阅读 2017-11-02 18:06:17
    定义原数组和接收结果的数组 int[] array1 = new int[]{1, 8, 6, 5, 7, 12, 31, 89, 100}; int[] result; printArray(array1); result = resetArray(array1, 31); printArray(result); //下面是具体实现方法 ...
  • class Solution { public int removeElement(int[] nums, int val) { int number=0,exchangNumber=0; for(int i=nums.length-1;...i--){//将检测到的每一个指定元素移到数组的最后 if(val==nums...
  • Remove Element(删除数组指定元素)」 Question: Given an array and a value, remove all instances of that value in place and return the new length. The order of elements can be changed. It ...
  • 下面小编就为大家带来一篇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数组插入与删除指定元素的实例代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 已知一个二维整型数组已初始化a[5][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{0,1,2,3,4},{6,7,8,9,0}},请删除数组中所有等于指定值的元素删除后,各元素依次前移。 请注意,C语言二维数组的行优先方式存储。...
  • Java删除数组中的指定元素

    千次阅读 2019-03-27 14:44:56
    3.遍历数组,判断每个数与要删除元素是否相等,如果不相等就将此数重新赋值给这个数组 把不需要移除的数字依次写入原来的数组中,要删除的数字不做任何操作即可 代码 : public static void main(String[] args) {...
  • php的数组比较好,既有C的风格(可以[]索引),又有java的追加新元素。...又查了查,发现系统居然没有提供能删除数组指定元素,索引还能自动排序的函数, 好吧,没有就自己写一个 (PS:这里主要是借助了array_
  • Java 中有一种特殊的数组引用类型,它具有以下特性: 1、java 数组本身来说是一个引用类型,定义以及初始化之后数组的长度不再改变。 2、java 数组不变是说由array variable 所指向的内存中的数组不会发生变化,而...
  • 题目: 删除scores数组索引index位置的值 思路: 1. 创建一个临时比scores 小1的临时数组tempArray 2. 将index前面的数据复制到tempArray前面 3. 将index后面的数组依次复制到 tempArray 后面 4. 将t...
  • JAVA删除数组中某个元素

    万次阅读 2017-01-21 13:23:51
    JAVA删除数组中某个元素
  • Java数组

    2020-06-04 15:48:48
    Java数组数组排序及元素位置查找数组添加元素获取多维数组长度数组反转数组获取最大值和最小值数组合并数组填充数组扩容查找数组中的重复元素删除数组元素判断数组是否相等数组查找指定元素数组的差集数组的交集数组...
  • 因为在java数组的长度是不可变的,所以不能直接删除数组元素。所以,可以用arraycopy方法,来实现这个功能。 arraycopy它可以实现将一个数组指定个数元素复制到另一个数组中。 语法 public static void ...
  • java数组--数组中删除指定某个值

    千次阅读 2019-09-27 21:24:21
    1 Arrays.asList() public static void main(String[] args) { String[] str={"11","22","33","44","55","66"}; List<String> list=Arrays.asList(str...//将数组转换为list集合 //*********************...
  • Java数组删除指定元素

    千次阅读 2011-10-26 14:22:34
    java"] /** * 已知一组有序数列,输入任意数,从这个数列中删除这个数, 显示删除后数列 */ public static void main(String[] args) { int num[] = new int[] { 1, 2, 3, 4, 5, 6, 7 }; int...
  • JAVA中String[]数组删除指定元素

    万次阅读 2018-08-24 10:55:15
    if(list.contains("支付宝")) {//加入集合中包含这个元素  List<String> arrayList = new ArrayList(list);  arrayList.remove("支付宝");  Log.e("arrayList", arrayList+"");  Name = arrayList.toArray...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,834
精华内容 60,733
关键字:

java数组删除指定元素

java 订阅