精华内容
下载资源
问答
  • /** ArrayUnique.java* Version 1.0.0* Created on 2017年12月16日* Copyright ReYo.Cn*/packagereyo.sdk.utils.test.array;/*** 创 建 人:AdministratorReyoAut * 创建时间:2017年12月16日 下午3:32:23**@...

    /** ArrayUnique.java

    * Version 1.0.0

    * Created on 2017年12月16日

    * Copyright ReYo.Cn*/

    packagereyo.sdk.utils.test.array;/*** 创 建 人:AdministratorReyoAut

    * 创建时间:2017年12月16日 下午3:32:23

    *

    *@authorReYo

    *@version1.0*/

    importjava.util.Arrays;importjava.util.HashSet;importjava.util.Set;/*** ArrayUniue 数组去重的问题

    *

    *@authorwait

    **/

    public classArrayUnique {/*** 方法1 就是申请一个和nums大小一样的数组tmpNums,

    * 然后遍历nums中的元素,对每个元素判断是否在tmpNums出现过,

    * 如果出现过,那么就不放到新数组里面,也就是不做处理;

    * 如果没有出现过,那么就把它放到新的数组里面

    * 这种方法数组原来的相对顺序可以保证

    * 时间复杂度是n^2和空间复杂度是n

    *

    *@paramnums 输入需要去重的数组

    *@return返回去重后数组的长度*/

    public static int unique1(int[] nums) {if (nums.length == 0) {return 0;

    }int[] tmpNums = new int[nums.length];

    tmpNums[0] = nums[0];int index = 1;for (int i = 1, len = nums.length; i < len; i++) {int j = 0;for (; j < index; j++) {if (tmpNums[j] ==nums[i]) {break;

    }

    }if (j ==index) {

    tmpNums[index++] =nums[i];

    }

    }

    nums=tmpNums;returnindex;

    }/*** 方法2 先对nums排序,排序后重复的元素一定相邻,

    * 然后遍历nums,并用index来表示不重复的元素应该存放的下标,

    * 如果当前遍历的元素和他的前一个元素相等,那么他是重复的,遍历下一个;

    * 如果不等,说明不是重复,那么当前元素存放到数组中下标为index的地方,index++

    * 这样遍历下来,不同的元素都放到元数组的前面去了。

    * 这种方法,得出来的是排序过得,数组原来的相对位置改变了。

    * 时间复杂度和空间复杂度都是对应排序算法的复杂度

    *

    *@paramnums 输入需要去重的数组

    *@return返回去重后数组的长度*/

    public static int unique2(int[] nums) {if (nums.length == 0) {return 0;

    }

    Arrays.sort(nums);int index = 1;for (int i = 1, len = nums.length; i < len; i++) {if (nums[i] != nums[i - 1]) {

    nums[index++] =nums[i];

    }

    }returnindex;

    }/*** 方法3 利用直接插入排序的思想,把数组分成两部分,

    * 左边认为是满足要求的不重复的部分,初始为1个元素nums[0];

    * 而右边是等待遍历的部分,不断遍历右边的元素。

    * 同样用index来表示左边部分不重复的元素应该存放的下标

    * 对于当前遍历的元素,通过第二层循环遍历左边部分0到index的元素,

    * 如果有元素和当前元素相等,说明是重复的,那么不处理;

    * 否则,说明是不重复,那么插入到下标index的地方,index++

    * 同样,遍历下来,不重复的元素被放到前面部分。

    * 这种方法没有经过排序,数组原来的相对顺序可以保证。

    * 这种方法,是对方法1的改进,用本数组的前部分替代新的数组

    * 时间复杂度是n^2,空间复杂度是1

    *

    *@paramnums 输入需要去重的数组

    *@return返回去重后数组的长度*/

    public static int unique3(int[] nums) {if (nums.length == 0) {return 0;

    }int index = 1;for (int i = 1, len = nums.length; i < len; i++) {int j = 0;for (; j < index; j++) {if (nums[j] ==nums[i]) {break;

    }

    }if (j ==index) {

    nums[index++] =nums[i];

    }

    }returnindex;

    }/*** 方法4 利用Java中容器来帮助判断元素是否重复。可以使用Set Map List等

    * 这里我们利用Set容器不能存放相同的元素的特性,

    * 同样用index来表示不重复的元素应该存放的下标

    * 当前元素如果能够成功加入到Set容器中,说明这个元素还没有重复的,

    * 那么当前元素就可以放到下标index的地方,index++;

    * 如果add失败,那么说明重复了,不做操作。

    * 这种方法,同样是把不重复的数组放到数组的前面, 并可以保证元素的相对位置不变, 不过需要额外的Set容器的空间。

    * 时间复杂度是n,空间复杂度也是n

    *

    *@paramnums 输入需要去重的数组

    *@return返回去重后数组的长度*/

    public static int unique4(int[] nums) {if (nums.length == 0) {return 0;

    }

    Set set = new HashSet();int index = 0;for (int i = 0, len = nums.length; i < len; i++) {if(set.add(nums[i])) {

    nums[index++] =nums[i];

    }

    }returnindex;

    }/*** printNums 打印数组的从0到length元素

    *

    *@paramnums 输入数组

    *@paramlength 打印长度*/

    public static void printNums(int[] nums, intlength) {for (int i = 0; i < length - 1; i++) {

    System.out.print(nums[i]+ " ");

    }

    System.out.println(nums[length- 1]);

    }/*** main 函数

    *

    *@paramargs*/

    public static voidmain(String[] args) {int[] nums = { 221, 3321, 4342, 2513, 436, 263, 2163, 44, 2351, 23261, 432, 12, 3, 123, 23, 12, 3, 2, 4, 23, 1,2312, 4, 33, 21, 31, 23};

    printNums(nums, nums.length);int len =unique4(nums);

    printNums(nums, len);

    }

    }

    展开全文
  • import java.util.ArrayList;import java.util.HashSet;import java.util.Iterator;import java.util..../*去除重复的数组:* 方法一:需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容...

    import java.util.ArrayList;

    import java.util.HashSet;

    import java.util.Iterator;

    import java.util.LinkedHashSet;

    import java.util.List;

    import java.util.Set;

    /*去除重复的数组:

    * 方法一:需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组。方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);可以直接复制数组,既然这样,我就没必要纠结新数组的长度了,直接声明一个跟原数组长度一样的临时数组,只要记录下去重后的元素个数,然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。

    * 方法二:只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。

    * 方法三:最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。

    * 方法四:链表的哈希集合:有顺序,不重复。

    */

    public class ShijuanDa1 {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    String[] strs ={"2007-1-01","2007-1-06",

    "2007-1-01","2007-1-08","2007-1-08"};

    printArr(strs);

    System.out.println("------------");

    Object[] newArr = ifRepeat(strs);

    printArr(newArr);

    System.out.println("------------");

    ifRepeat2(strs);

    System.out.println("------------");

    Object[] newArr3 = ifRepeat3(strs);

    printArr(newArr3);

    System.out.println("------------");

    ifRepeat4(strs);

    }

    public static void printArr(Object[] arr) {

    for (Object object : arr) {

    System.out.println(object);

    }

    }

    //方法一:需要传入一个Object数组,然后返回去重后的数组

    public static Object[] ifRepeat(Object[] arr){

    //用来记录去除重复之后的数组长度和给临时数组作为下标索引

    int t = 0;

    //临时数组

    Object[] tempArr = new Object[arr.length];

    //遍历原数组

    for(int i = 0; i < arr.length; i++){

    //声明一个标记,并每次重置

    boolean isTrue = true;

    //内层循环将原数组的元素逐个对比

    for(int j=i+1;j

    //如果发现有重复元素,改变标记状态并结束当次内层循环

    if(arr[i]==arr[j]){

    isTrue = false;

    break;

    }

    }

    //判断标记是否被改变,如果没被改变就是没有重复元素

    if(isTrue){

    //没有元素就将原数组的元素赋给临时数组

    tempArr[t] = arr[i];

    //走到这里证明当前元素没有重复,那么记录自增

    t++;

    }

    }

    //声明需要返回的数组,这个才是去重后的数组

    Object[] newArr = new Object[t];

    //用arraycopy方法将刚才去重的数组拷贝到新数组并返回

    System.arraycopy(tempArr,0,newArr,0,t);

    return newArr;

    }

    /*

    * 方法二:只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。

    */

    public static void ifRepeat2(Object[] arr){

    //创建一个集合

    List list = new ArrayList();

    //遍历数组往集合里存元素

    for(int i=0;i

    //如果集合里面没有相同的元素才往里存

    if(!list.contains(arr[i])){

    list.add(arr[i]);

    }

    }

    //toArray()方法会返回一个包含集合所有元素的Object类型数组

    Object[] newArr = list.toArray();

    //遍历输出一下测试是否有效

    for(int i=0;i

    System.out.println(" "+newArr[i]);

    }

    }

    /*

    * 方法三:最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤。

    */

    public static Object[] ifRepeat3(Object[] arr){

    //实例化一个set集合

    Set set = new HashSet();

    //遍历数组并存入集合,如果元素已存在则不会重复存入

    for (int i = 0; i < arr.length; i++) {

    set.add(arr[i]);

    }

    //返回Set集合的数组形式

    return set.toArray();

    }

    /*

    * 方法四:链表的哈希集合:有顺序,不重复。

    */

    public static void ifRepeat4(Object[] arr){

    LinkedHashSet haoma = new LinkedHashSet();

    for (int i = 0; i < arr.length; i++) {

    haoma.add(arr[i]);

    }

    // 创建迭代器

    Iterator iterator = haoma.iterator();

    int a = 0;

    // 迭代集合

    while (iterator.hasNext()) { // true

    Object c = iterator.next();

    System.out.println(c);

    }

    }

    }

    展开全文
  • 实例如下:package org.company.project.test;...public class ArraysDelete { public static void main(String[] args) {//删除数组中的某一个元素的方法://把最后一个元素替代指定的元素,然后数组缩容Scann...

    实例如下:

    package org.company.project.test;

    import java.util.Arrays;

    import java.util.Scanner;

    public class ArraysDelete { public static void main(String[] args) {

    //删除数组中的某一个元素的方法:

    //把最后一个元素替代指定的元素,然后数组缩容

    Scanner sc =new Scanner(System.in);

    int[] arr = new int[]{1,2,4,5,9,8,0};

    System.out.println(Arrays.toString(arr));

    System.out.println("请输入要删除第几个元素:");

    int n = sc.nextInt(); sc.close();

    //把最后一个元素替代指定的元素

    arr[n-1] = arr[arr.length-1];

    //数组缩容

    arr = Arrays.copyOf(arr, arr.length-1);

    System.out.println(Arrays.toString(arr));

    } }

    运行结果:

    [1, 2, 4, 5, 9, 8, 0]

    请输入要删除第几个元素:

    3

    [1, 2, 0, 5, 9, 8]

    以上就是小编为大家带来的java删除数组中的某一个元素的方法全部内容了,希望大家多多支持脚本之家~

    展开全文
  • java 去除数组中重复的元素

    万次阅读 多人点赞 2016-12-08 23:23:22
    要求:清除数组中重复的元素思路:因为开始时我以为是不能用集合,所以绞尽脑汁在不用集合的情况下去除数组中重复的元素,需要些一个去除重复内容的方法,我首先想到的的需要一个存储去重后元素的数组,然后两层循环...

    要求:清除数组中重复的元素

    思路:因为开始时我以为是不能用集合(使用集合的方式在文章底部),所以绞尽脑汁在不用集合的情况下去除数组中重复的元素,需要些一个去除重复内容的方法,我首先想到的的需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组。

    走的弯路:因为数组是有长度的,在使用数组之前一定要先初始化数组给定长度,我在确定去重后数组长度这里纠结和很久,最后想起了有个方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);可以直接复制数组,既然这样,我就没必要纠结新数组的长度了,直接声明一个跟原数组长度一样的临时数组,只要记录下去重后的元素个数,然后就可以确定去重后数组长度再去将临时数组拷贝到新数组就行了。

    方法代码:

    //需要传入一个Object数组,然后返回去重后的数组
    public static Object[] ifRepeat(Object[] arr){
            //用来记录去除重复之后的数组长度和给临时数组作为下标索引
            int t = 0;
            //临时数组
            Object[] tempArr = new Object[arr.length];
            //遍历原数组
            for(int i = 0; i < arr.length; i++){
                //声明一个标记,并每次重置
                boolean isTrue = true;
                //内层循环将原数组的元素逐个对比
                for(int j=i+1;j<arr.length;j++){
                    //如果发现有重复元素,改变标记状态并结束当次内层循环
                    if(arr[i]==arr[j]){
                        isTrue = false;
                        break;
                    }
                }
                //判断标记是否被改变,如果没被改变就是没有重复元素
                if(isTrue){
                    //没有元素就将原数组的元素赋给临时数组
                    tempArr[t] = arr[i];
                    //走到这里证明当前元素没有重复,那么记录自增
                    t++;
                }
            }
            //声明需要返回的数组,这个才是去重后的数组
            Object[]  newArr = new Object[t];
            //用arraycopy方法将刚才去重的数组拷贝到新数组并返回
            System.arraycopy(tempArr,0,newArr,0,t);
            return newArr;
        }

    测试一下,可行
    这里写图片描述

    如果使用集合,那么去重复就简单多了。
    只需要创建一个集合,然后遍历数组逐一放入集合,只要在放入之前用contains()方法判断一下集合中是否已经存在这个元素就行了,然后用toArray转成数组一切搞定。

    代码:

    import java.util.*;
    public class Demo {
    
        public static void main(String[] args) {
            //声明一个需要去重的数组
            Object[] arr = {1,1,1,2,3,3,4,5,"夏","夏","冬","春",};
            //创建一个集合
            List list = new ArrayList();
            //遍历数组往集合里存元素
            for(int i=0;i<arr.length;i++){
                //如果集合里面没有相同的元素才往里存
                if(!list.contains(arr[i])){
                    list.add(arr[i]);
                }
            }
            //toArray()方法会返回一个包含集合所有元素的Object类型数组
            Object[] newArr = list.toArray();
            //遍历输出一下测试是否有效
            for(int i=0;i<newArr.length;i++){
                System.out.print(" "+newArr[i]);
            }
    
        }
    
    }

    最后,最简单的方法就是利用Set集合无序不可重复的特性进行元素过滤;

    public static Object[] unique(Object [] arr){
            //实例化一个set集合
            Set set = new HashSet();
            //遍历数组并存入集合,如果元素已存在则不会重复存入
            for (int i = 0; i < arr.length; i++) {
                set.add(arr[i]);
            }
            //返回Set集合的数组形式
            return set.toArray();
        }
    展开全文
  • JAVA数组去除重复数据

    2019-07-03 23:10:21
    如果一个数组中有重复元素,用什么方法可以去重?一时间会想到用一种方法,但是后来查阅资料后发现,有好多方法可以实现,现在就总结一下,比较简单几种。 一.用List集合实现 int[] str = {5, 6, 6, 6, 8, 8, 7,4...
  • java去除数组重复元素的四种方法

    万次阅读 多人点赞 2018-11-18 10:38:16
    需要一个存储去重后元素的数组,然后两层循环,外层遍历原数组,内容逐个判断是否和之后的元素重复,然后再提出来存入新的数组方法System.arraycopy(被复制的数组,起始下标,接收的新数组,起始下标,结束下标);...
  • 本文实例讲述了Java实现数组去除重复数据的方法。分享给大家供大家参考,具体如下:前一段时间被面试问到:如果一个数组中有重复元素,用什么方法可以去重?一时间会想到用一种方法,但是后来查阅资料后发现,有好多...
  • java去除数组中重复元素的方法

    千次阅读 2020-07-21 20:08:01
    请设计一个方法,将一个int数组arr中重复的元素去除,并且返回新数组newArr。 解法一 保留重复数字中第一次出现的元素 首先建立一个与原数组等长标记数组flag[],它下标与原数组下标相同,而我们只要改变它...
  • * ArrayUnique.java * Version 1.0.0 * Created on 2017年12月16日 * Copyright ReYo.Cn */ package reyo.sdk.utils.test.array; /** * <B>创 建 人:</B>AdministratorReyoAut <BR>...
  • Java实现数组去除重复数据的方法

    千次阅读 2018-03-29 08:54:15
    本文实例讲述了Java实现数组去除重复数据的方法。分享给大家供大家参考,具体如下:前一段时间被面试问到:如果一个数组中有重复元素,用什么方法可以去重?一时间会想到用一种方法,但是后来查阅资料后发现,有好多...
  • /** 需求:去除整型数组中重复的元素,不能使用集合等方法** 解决思路:* 1、对数组中的元素进行从小到大的顺序排序* 2、获取数组中重复元素的个数* 3、获取数组中重复元素的索引位置,并存入创建的索引数组* 4、...
  • java去除数组重复元素

    千次阅读 2012-05-24 14:30:16
    java去除数组重复元素 String[] data = {"江剑臣","武凤楼","李鸣","曹玉","侯国英","李文莲","马小倩","李鸣","曹玉","侯国英"}; 1.用HashSet(去除重复元素后,数组也无序) /**  * HashSet方法(去除重复...
  • 主要为大家详细介绍了java去除已排序数组中重复元素的方法,感兴趣的小伙伴们可以参考一下
  • 【填空题】java 应用程序中有一个main()方法,它前面有三个修饰符是 ______、______、______【简答题】为了了解岩石力学特性,人们在实验室通常开展哪些实验?了解岩石哪些力学特性?这些力学特性通常用哪些指标来...
  • 一个去除重复元素的方法 ``` /** * remove list duplicate element * @param list */ public static List removeListDuplicateElement(List list) { if (list.size() > 1) { for (int i = 0; i () - ...
  • 本文实例讲述了Java实现数组去除重复数据的方法。分享给大家供大家参考,具体如下: 前一段时间被面试问到:如果一个数组中有重复元素,用什么方法可以去重?一时间会想到用一种方法,但是后来查阅资料后发现,有...
  • java去除数组重复元素的四种方法

    万次阅读 2017-11-30 09:49:26
    [java] view plain copy  print? package com.yzycool.test;    import java.util.ArrayList;  import java.util.HashSet;  import java.util.Iterator;  import java.util.LinkedHashSet;
  • Java去除数组中重复元素的两种实现

    千次阅读 2017-05-04 22:47:56
    今日去面试,被问到要求手写一段代码,实现去除数组中重复的元素。我第一反应是用 Set,因为 Set中的元素是不能重复,但是大叔又说不让用 Set。明明感觉很简单一个算法题,但是最后也没能写让人满意。于是...
  • /** 需求:去除整型数组中重复的元素,不能使用集合等方法** 解决思路:* 1、对数组中的元素进行从小到大的顺序排序* 2、获取数组中重复元素的个数* 3、获取数组中重复元素的索引位置,并存入创建的索引数组* 4、...
  • java中删除数组元素与过滤重复数组元素我们都会需要去遍历数组然后根据我们设置值或方法进行去除数组

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

java数组去除数组元素的方法

java 订阅