精华内容
下载资源
问答
  • 主要介绍了element vue Array数组Map对象的添加与删除功能,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 后端返回的数据类型是list数组 [ { "processStartUser":"1111", "taskCreateTime":1590634371219, "taskCompleteTime":1590634371221, "taskHandler":"1111", "taskHandlerType":null, "taskHandlerOpinion...

    后端返回的数据类型是list数组

    [
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371219,
            "taskCompleteTime":1590634371221,
            "taskHandler":"1111",
            "taskHandlerType":null,
            "taskHandlerOpinion":null,
            "taskHandlerLink":null,
            "taskHandlerDescription":null,
            "taskPractitioner":"1111",
            "taskId":null,
            "taskName":"开始",
            "actId":"start",
            "actName":"开始",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":null,
            "logisticsNum":null
        },
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371221,
            "taskCompleteTime":1590634371236,
            "taskHandler":"1111",
            "taskHandlerType":null,
            "taskHandlerOpinion":null,
            "taskHandlerLink":null,
            "taskHandlerDescription":null,
            "taskPractitioner":"1111",
            "taskId":"472718072751329281",
            "taskName":"代理商申请",
            "actId":"service",
            "actName":"代理商申请",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":null,
            "logisticsNum":null
        },
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371237,
            "taskCompleteTime":null,
            "taskHandler":"刘智慧",
            "taskHandlerType":null,
            "taskHandlerOpinion":null,
            "taskHandlerLink":null,
            "taskHandlerDescription":null,
            "taskPractitioner":"刘智慧",
            "taskId":"472718072835215362",
            "taskName":"商务审批",
            "actId":"business",
            "actName":"商务审批",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":null,
            "logisticsNum":null
        },
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371247,
            "taskCompleteTime":null,
            "taskHandler":"Lisa",
            "taskHandlerType":null,
            "taskHandlerOpinion":null,
            "taskHandlerLink":null,
            "taskHandlerDescription":null,
            "taskPractitioner":"Lisa",
            "taskId":"472718072860381187",
            "taskName":"商务审批",
            "actId":"business",
            "actName":"商务审批",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":null,
            "logisticsNum":null
        },
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371253,
            "taskCompleteTime":null,
            "taskHandler":"KiKi",
            "taskHandlerType":null,
            "taskHandlerOpinion":null,
            "taskHandlerLink":null,
            "taskHandlerDescription":null,
            "taskPractitioner":"KiKi",
            "taskId":"472718072885547009",
            "taskName":"商务审批",
            "actId":"business",
            "actName":"商务审批",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":null,
            "logisticsNum":null
        },
        {
            "processStartUser":"1111",
            "taskCreateTime":1590634371258,
            "taskCompleteTime":null,
            "taskHandler":"",
            "taskHandlerType":"",
            "taskHandlerOpinion":"",
            "taskHandlerLink":"",
            "taskHandlerDescription":"",
            "taskPractitioner":"测试商务",
            "taskId":"472718072906518531",
            "taskName":"商务审批",
            "actId":"business",
            "actName":"商务审批",
            "process_defined_id":null,
            "process_instance_id":null,
            "taskAuditStatus":"approving",
            "taskStatus":"approvePending",
            "logisticsNum":""
        }
    ]

    在js中对list数组进行Map数据结构的改造

    //Map数组中的key集合数组
        $ctrl.allActList = $ctrl.follow.map(function(item){
            return item.actName
        })
    // key数组去重
        $ctrl.equalList = _.uniq($ctrl.allActList)
        // 创建Map并set数据
        $ctrl.mapList = new Map()
        $ctrl.equalList.map(function(item){
            var valueList = []
            $ctrl.follow.map(function(e){
                if(e.actName == item)
                    valueList.push(e)
                    $ctrl.mapList.set(item,valueList) 
            })
        })

    对应的HTML中的代码

    其中在HTML中可以通过$ctrl.mapList.get()获取值

    <div ng-repeat="item in $ctrl.equalList">
        <div style="position:relative;overflow:hidden">
            <div class="app-line" style="top:20px"></div>
            <div class="dib renew-re" style="top:-4px">
                <i class="iconfont icon-time circle-gray" ng-show="!item.taskCompleteTime"></i>
                <i class="iconfont icon-zhengque circle-yellow" ng-show="item.taskCompleteTime"></i>
            </div>
            <div class="dib ml20 vertical-top" style="max-width:90%">
                <p>{{item}}</p>
                <p ng-repeat="e in $ctrl.mapList.get(item)">处理人:{{e.taskHandler}}
                    <span ng-show="!e.taskHandler">等待审核</span>
                    <span ng-show="e.taskHandlerType=='approveReturned'">已退回</span>
                    <span ng-show="e.taskHandlerType=='approveWithdrawed'">已撤回 撤回环节:{{e.taskHandlerLink}}
                    </span>
                    <span>{{e.taskHandlerOpinion}}</span>
                    <span class="ml10">{{e.taskCompleteTime | date:'yyyy-MM-dd HH:mm:ss'}}</span>
                </p>
                       
            </div>
        </div>
    </div>

    循环list套list比较慢,时间复杂度是m*n,list里面用Map取比较快,时间复杂度m+n。

    展开全文
  • 现在老K为大家总结一下ES6中数组的新方法。map方法:可以简单的理解为映射var arr = [1,2,3,4]console.log( arr.map((n)=>n*n) ); //[1,4,9,16]console.log( arr.map((n)=>n-1) );//[0,1,2,3]filter方法:var ...
    c639e3aa158217be459dda2c15f2fc24.png

    在前端开发中,ES6的使用越来越广泛。现在老K为大家总结一下ES6中数组的新方法。

    map方法:

    可以简单的理解为映射

    var arr = [1,2,3,4]console.log( arr.map((n)=>n*n) ); //[1,4,9,16]console.log( arr.map((n)=>n-1) );//[0,1,2,3]

    filter方法:

    var users = [{name:'张三', email:'zhang@email.com'},{name:'李四', email:'li@email.com'},{name:'王五',email:'wang@email.com'}];//获取所有人的emailvar emails = users.map( item => item.email )console.log(emails.join(',')) //"zhang@email.com","li@email.com","wang@email.com"//获取指定人的emailvar wangEmail = emails.filter(email => /^wang/.test(email))console.log(wangEmail.join('')) //"wang@email.com"

    获取用户列表里的所有用户的email,可以用map方法。map方法通过传一个参数,这个参数就代表users里的每一项,map内部通过遍历所有的用户项,获取到每个用户项的email,再push到一个数组,再作为值给我们返回。第二步,我们需要获取指定人的email,filter方法登场了,通过过滤筛选数组emails,给我们返回结果,筛选方法得我们定,这里筛选方法是以正则匹配到wang开头的那一个email,然后返回。

    find方法:

    [1, 4, -1, 10].find(n => n < 0) // -1

    find方法比较好理解,这里的参数n代表数组里的每一项,然后find方法内部通过遍历数组里的每一项,找到<0的这一项( -1 )。

    findIndex方法:

    findIndex方法的回调函数可以接受三个参数,依次为当前的值、当前的位置和原数组。看一个例子:

    [1, 3, -5, 11].findIndex((value,index,arr) => value < 0) //2

    在这个例子当中,value代表这个数组的每一项,1,3,-5,11。index代表每一项的索引值,arr代表这个数组[1, 3, -5, 11],然后我们需要返回的是<0的这一项的索引值,即是2了。

    这4个方法内部机制都有一个遍历过程,比起forEach确实简洁多了。

    every方法:

    let numbers = [2, 4, 10, 4, 8];let a = numbers.every( (item,index) => { if(item%2 === 0){  return true }else{  return false  }} )console.log(a) //true

    every()方法必须所有都返回true才会返回true,哪怕有一个false,就会返回false。

    some方法:

    let numbers = [2, 4, 10, 4, 9];let b=numbers.some((item,index) => { if(item%3 === 0){  return true  }else{  return false  }})console.log(b) //true

    some方法 只要其中一个为true 就会返回true的。

    every()和 some()目的:确定数组的所有成员是否满足指定的条件。


    本文为原创内容,若转载请注明出处,转发感激不尽。

    展开全文
  • js中数组map方法的使用和实现 MDN中定义 map() 方法创建一个新数组,其结果是该数组中的每个元素是调用一次提供的函数后的返回值。 语法 var new_array = arr.map(function callback(currentValue[, index[, ...

    js中数组map方法的使用和实现

    MDN中定义

    map() 方法创建一个新数组,其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

    语法

    var new_array = arr.map(function callback(currentValue[, index[, selfArray]]) {
    // Return element for new_array
    }[, thisArg])

    参数

    callback
    生成新数组元素的函数,使用三个参数:

    (1)currentValue
    callback 数组中正在遍历的当前元素。
    (2)index 可选
    callback 数组中正在遍历的当前元素的索引。
    (3)selfArray 可选
    map 方法调用的数组本身。

    thisArg可选
    执行 callback 函数时值被用作this。

    返回值

    一个由原数组每个元素执行回调函数的结果组成的新数组。(原来数组遍历时调用传入的callback函数的返回值组成的数组)

    详细描述

    map 方法会给原数组中的每个元素都按顺序调用一次传入的callback 函数。callback 函数每次执行后的返回值(包括 undefined和null)组合起来形成一个新数组。(注意:callback 函数只会在有值的索引上被调用;那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。)

    callback 函数会被自动传入三个参数:数组元素,元素索引,原数组本身。

    如果 thisArg 参数提供给map,则会被用作回调函数的this值。否则undefined会被用作回调函数的this值。(这里和forEach中thisArg参数的作用是一致的,用于改变传入callback函数的this指向callback为箭头函数时thisArg参数无效)

    map 方法不修改调用它的原数组本身(可以在 callback 执行时改变原数组)
    map 方法处理数组元素的范围是在 callback 方法第一次调用之前就已经确定了。调用map方法之后追加的数组元素不会被callback访问。如果存在的数组元素改变了,那么传给callback的值是map访问该元素时的值。

    使用示例

        let arr = [1,3, ,7]
        let newArray = arr.map((currentValue, index, selfArray) => {
          console.log(this)
          return { currentValue: currentValue * 2, index}
        }, {a: 9})
        console.log(newArray)
        // Window
        // Window
        // Window
        // [{currentValue: 2, index: 0},{currentValue: 6, index: 1}, empty, {currentValue: 14, index: 2}]
    
    

    上述代码arr数组调用了map方法,传入callback回调函数(箭头函数)和thisArg参数,打印回调函数内部的this并返回一个对象,对象里面是数组循环的当前元素乘2和当前元素索引值。根据打印值可以看出回调函数的this没有改变,新数组里面的值是处理后的对象。下面我们看下无返回值和传入普通函数的使用:

        let arr = [1,3, ,7]
        let newArray = arr.map(function(currentValue, index, selfArray) {
          if (currentValue < 5) {
            console.log(this)
            return { currentValue: currentValue * 2, index}
          }
        }, {a: 9})
        console.log(newArray)
        // {a: 9}
        // {a: 9}
        // [{currentValue: 2, index: 0}, {currentValue: 6, index: 1}, empty, undefined]
    

    上述代码传入了一个普通的函数,根据打印值看出,callback函数传入普通函数的时候,会把callback函数的this指向传入的thisArg参数,并且没有手动设置返回值时会返回undefined。根据callback函数打印的次数来看传入的值为空值时callback回调函数就不会调用并且新数组也会是空值(empty),我们不光可以传入自己定义的函数也可以传入js中已有的方法如:

        let arr = [1,3, ,7]
        let newArray = arr.map(String)
        console.log(newArray)
        // ["1", "3", empty, "7"]
    

    上述代码传入已有的string方法将数组中元素类型转换为字符类型,还有其他许多像这样的方法可以直接使用,让我们在处理数据的时候更加方便和简洁。看完了描述和使用,让我们模拟实现自己的map方法吧

    步骤思路

    1、 在array原型上添加自己的map方法
    2、 传入callback回调函数和thisArg参数
    3、 根据调用的数组长度创建新数组newArry
    4、 循环原来数组并使用hasOwnProperty方法当前元素是否为空值
    5、 是的话新数组就赋值callback函数返回的值
    6、 返回新数组

    实现代码

    
        Array.prototype.myMap = function(callback, thisArg) {
          const length = this.length
          let newArry = new Array(length)
          for (let index = 0; index < length; index++) {
            // 利用hasOwnProperty方法检测空值
            // 利用call方法调用方法并改变this的指向
            if (this.hasOwnProperty(index)) newArry[index] = callback.call(thisArg, this[index], index, this)
          }
          return newArry
        }
    

    验证测试

        Array.prototype.myMap = function(callback, thisArg) {
          const length = this.length
          let newArry = new Array(length)
          for (let index = 0; index < length; index++) {
            // 利用hasOwnProperty方法检测空值
            // 利用call方法调用方法并改变this的指向
            if (this.hasOwnProperty(index)) newArry[index] = callback.call(thisArg, this[index], index, this)
          }
          return newArry
        }
    
        let arr = [1,3, ,7]
        
        newArray = arr.myMap((currentValue, index, selfArray) => {
          console.log(this)
          return { currentValue: currentValue * 2, index}
        }, {a: 9})
        console.log(newArray)
        // Window
        // Window
        // Window
        // [{currentValue: 2, index: 0},{currentValue: 6, index: 1}, empty, {currentValue: 14, index: 2}]
    
        newArray = arr.myMap(function(currentValue, index, selfArray) {
          if (currentValue < 5) {
            console.log(this)
            return { currentValue: currentValue * 2, index}
          }
        }, {a: 9})
        console.log(newArray)
        // {a: 9}
        // {a: 9}
        // [{currentValue: 2, index: 0}, {currentValue: 6, index: 1}, empty, undefined]
    
        newArray = arr.myMap(String)
        console.log(newArray)
        // ["1", "3", empty, "7"]
    

    至此我们模拟实现map方法就完成了。

    展开全文
  • 数组 Map 使用小结

    2017-10-18 15:03:00
    数组的使用 数组在内存中表示一串连续的空间,以保存一行连续的数值 数组的声明 int[] a = new int[5]; int b[] = new int[5]; 声明同时赋初值 int[] d = new int[]{1,2,3,4,5}; int[] c = {1,2,3,4,5};  Arrays....
    数组的使用
    数组在内存中表示一串连续的空间,以保存一行连续的数值

    数组的声明
    int[] a = new int[5];
    int b[] = new int[5];
    声明同时赋初值
    int[] d = new int[]{1,2,3,4,5};
    int[] c = {1,2,3,4,5}; 
    Arrays.sort(d);
    冒泡排序法
    int[] arr = {12,34,23,45,43,22,33,2,1};
    for(int i=0; i<arr.length-1; i++){
    	for(int j =0; j<arr.length-i-1; j++){
    		if(arr[j] > arr[j+1]){
    			int temp = arr[j];
    			arr[j] = arr[j+1];
    			arr[j+1] = temp;
    		}
    	}
    }

    集合与数组的区别?
    1、数组特点高效、保存基本类型,集合带array的底层由数组实现,还有一部分由链表或者树 
    2、数组大小固定(巨大缺点,内存中一定连续),集合各种实现吧! 
    3、数组只能放一种类型,集合不考虑泛型可以存很多类型。 
    4、集合放原始类型其实是通过装箱拆箱来实现的,说白了以前原生类型只能用数组,现在集合也可以了。因为这个改进,所以现在基本上除了性能外,均推荐使用集合。

    java容器类List、ArrayList、Vector及map、HashTable、HashMap分别的区别. 
    一.List与ArrayList的区别 
          List->AbstractList->ArrayList        (1) List是一个接口,ArrayList是一个实现了List接口的具体类。        他们是父子关系,我们常用的是ArrayList,但常用List的引用去操作ArrayList              这是一个简单的面向接口编程的一种,如:List myList = new ArrayList();        (2)他们主要是用来保存对象的集合,记得是保存对象的哦,你可别传个int(类)进去          (3)要取出它里面保存的对象可以用下标,如:Object aaa = myList.get(0);              这样我们就把保存在myList里的第一个对象取出来给了   
    二.详解        
          好像List和Map都是接口,不能实例化的        以前这么写List list = new Vector();现在这么写List list = new ArrayList();        用ArrayList 代替了Vector 因为前者的性能比后者好;但是两个都是实现了List接口的        同理Map map = new HashTable();(以前)              Map map = new HashMap();(现在)         ArrayList和HashMap是异步的,Vector和HashTable是同步的,
    	所以Vector和HashTable是线程安全的,而ArrayList和HashMap并不是线程安全的。
    	因为同步需要花费机器时间,所以Vector和HashTable的执行效率要低于ArrayList和HashMap。 
      
    List接口  
    	List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。
    	用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。 
    	和下面要提到的Set不同,List允许有相同的元素。  
    	除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,
    	实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。  
    	返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,
    	允许添加,删除,设定元素,还能向前或向后遍历。  

    ArrayList类  
    ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。  
    size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。    
    每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样,ArrayList也是非同步的(unsynchronized)。  

    Map接口  
    请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。  

    HashMap类  
    HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。  

    List是接口,List特性就是有序,会确保以一定的顺序保存元素. ArrayList是它的实现类,是一个用数组实现的List. Map是接口,Map特性就是根据一个对象查找对象. 
    HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.(关于散列查找,可以参看<<数据结构>>) 

    一般情况下,如果没有必要,推荐代码只同List,Map接口打交道. 比如:List list = new ArrayList(); 
    这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要: List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类 这样,就不需要修改其它代码,这就是接口编程的优雅之处. 另外的例子就是,在类的方法中,如下声明: private void doMyAction(List list){} 
    这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数. 
    如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类

    List Set Map 是否有序等总结

    1.Collection List Set Map 区别记忆

    这些都代表了Java中的集合,这里主要从其元素是否有序,是否可重复来进行区别记忆,以便恰当地使用,当然还存在同步方面的差异,见上一篇相关文章。

     

     

    有序否

    允许元素重复否

    Collection

    List

    Set

    AbstractSet

    HashSet

    TreeSet

    是(用二叉树排序)

    Map

    AbstractMap

    使用key-value来映射和存储数据,Key必须惟一,value可以重复

    HashMap

    TreeMap

    是(用二叉树排序)

     

    List接口对Collection进行了简单的扩充,它的具体实现类常用的有ArrayList和LinkedList。你可以将任何东西放到一个List容器中,并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储,因此它的随机访问速度极快,而LinkedList的内部实现是链表,它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历,而ListIterator则继承了Iterator的思想,并提供了对List进行双向遍历的方法。 

    Set接口也是Collection的一种扩展,而与List不同的时,在Set中的对象元素不能重复,也就是说你不能把同样的东西两次放入同一个Set容器中。它的常用具体实现有HashSet和TreeSet类。HashSet能快速定位一个元素,但是你放到HashSet中的对象需要实现hashCode()方法,它使用了前面说过的哈希码的算法。而TreeSet则将放入其中的元素按序存放,这就要求你放入其中的对象是可排序的,这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的,它就应该实现Comparable接口。有时多个类具有相同的排序算法,那就不需要在每分别重复定义相同的排序算法,只要实现Comparator接口即可。集合框架中还有两个很实用的公用类:Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法,Arrays则是对一个数组进行类似的操作。 


    Map是一种把键对象和值对象进行关联的容器,而一个值对象又可以是一个Map,依次类推,这样就可形成一个多级映射。对于键对象来说,像Set一样,一个Map容器中的键对象不允许重复,这是为了保持查找结果的一致性;如果有两个键对象一样,那你想得到那个键对象所对应的值对象时就有问题了,可能你得到的并不是你想的那个值对象,结果会造成混乱,所以键的唯一性很重要,也是符合集合的性质的。当然在使用过程中,某个键所对应的值对象可能会发生变化,这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上,这不会发生任何问题(不过对你的使用却可能会造成不便,你不知道你得到的到底是那一个键所对应的值对象)。Map有两种比较常用的实现:HashMap和TreeMap。HashMap也用到了哈希码的算法,以便快速查找一个键,TreeMap则是对键按序存放,因此它便有一些扩展的方法,比如firstKey(),lastKey()等,你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单,用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。

    2.List、vector、set、map的区别与联系

    在使用Java的时候,我们都会遇到使用集合(Collection)的时候,但是Java API提供了多种集合的实现,我在使用和面试的时候频频遇到这样的“抉择” 。 :)(主要还是面试的时候)
    久而久之,也就有了一点点的心得体会,写出来以供大家讨论。
    总的说来,Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下:

    Collection<--List<--Vector
    Collection<--List<--ArrayList
    Collection<--List<--LinkedList
    Collection<--Set<--HashSet
    Collection<--Set<--HashSet<--LinkedHashSet
    Collection<--Set<--SortedSet<--TreeSet
    Vector : 基于Array的List,其实就是封装了Array所不具备的一些功能方便我们使用,它不可能走入Array的限制。性能也就不可能超越Array。所以,在可能的情况下,我们要多运用Array。另外很重要的一点就是Vector“sychronized”的,这个也是Vector和ArrayList的唯一的区别。

    ArrayList:同Vector一样是一个基于Array上的链表,但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些,但是当运行到多线程环境中时,可需要自己在管理线程的同步问题。

    LinkedList:LinkedList不同于前面两种List,它不是基于Array的,所以不受Array性能的限制。它每一个节点(Node)都包含两方面的内容:1.节点本身的数据(data);2.下一个节点的信息(nextNode)。所以当对LinkedList做添加,删除动作的时候就不用像基于Array的List一样,必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

    List总结:

    1. 所有的List中只能容纳单个不同类型的对象组成的表,而不是Key-Value键值对。例如:[ tom,1,c ];

    2. 所有的List中可以有相同的元素,例如Vector中可以有 [ tom,koo,too,koo ];

    3. 所有的List中可以有null元素,例如[ tom,null,1 ];

    4. 基于Array的List(Vector,ArrayList)适合查询,而LinkedList(链表)适合添加,删除操作。

    HashSet:虽然Set同List都实现了Collection接口,但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的,这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add(Object obj)方法的实现就可以一目了然了。

    public boolean add(Object obj)
    {
    return map.put(obj, PRESENT) == null;
    }
    这个也是为什么在Set中不能像在List中一样有重复的项的根本原因,因为HashMap的key是不能有重复的。

    LinkedHashSet:HashSet的一个子类,一个链表。

    TreeSet:SortedSet的子类,它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

    Set总结:

    1. Set实现的基础是Map(HashMap);

    2. Set中的元素是不能重复的,如果使用add(Object obj)方法添加已经存在的对象,则会覆盖前面的对象;
    3.Java基本概念:集合类 List/Set/Map... 的区别和联系

    Collection:List、Set
    Map:HashMap、HashTable

    如何在它们之间选择


    一、Array , Arrays

    Java所有“存储及随机访问一连串对象”的做法,array是最有效率的一种。

    1、
    效率高,但容量固定且无法动态改变。
    array还有一个缺点是,无法判断其中实际存有多少元素,length只是告诉我们array的容量。

    2、Java中有一个Arrays类,专门用来操作array。
    arrays中拥有一组static函数,
    equals():比较两个array是否相等。array拥有相同元素个数,且所有对应元素两两相等。
    fill():将值填入array中。
    sort():用来对array进行排序。
    binarySearch():在排好序的array中寻找元素。
    System.arraycopy():array的复制。


    二、Collection , Map

    若撰写程序时不知道究竟需要多少对象,需要在空间不足时自动扩增容量,则需要使用容器类库,array不适用。

    1、Collection 和 Map 的区别

    容器内每个为之所存储的元素个数不同。
    Collection类型者,每个位置只有一个元素。
    Map类型者,持有 key-value pair,像个小型数据库。

    2、各自旗下的子类关系

    Collection --List: 将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
    --ArrayList / LinkedList / Vector --Set : 不能含有重复的元素
    --HashSet / TreeSet
    Map
    --
    HashMap
    --HashTable
    --TreeMap

    3、其他特征

    * List,Set,Map将持有对象一律视为Object型别。
    * Collection、List、Set、Map都是接口,不能实例化。
    继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class,这些才可被实例化。
    * vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。


    三、Collections

    Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。
    相当于对Array进行类似操作的类——Arrays。
    如,Collections.max(Collection coll); 取coll中最大的元素。
    Collections.sort(List list); 对list中元素排序

    四、如何选择?

    1、容器类和Array的区别、择取
    * 容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。
    * 一旦将对象置入容器内,便损失了该对象的型别信息。

    2、
    * 在各种Lists中,最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList();
    Vector总是比ArrayList慢,所以要尽量避免使用。
    * 在各种Sets中,HashSet通常优于HashTree(插入、查找)。只有当需要产生一个经过排序的序列,才用TreeSet。
    HashTree存在的唯一理由:能够维护其内元素的排序状态。 
    * 在各种Maps中
    HashMap用于快速查找。
    * 当元素个数固定,用Array,因为Array效率是最高的。

    结论:最常用的是ArrayList,HashSet,HashMap,Array。


    注意:

    1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。
    2、Set和Collection拥有一模一样的接口。
    3、List,可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个,get(0)...。(add/get)
    4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。

    5、Map用 put(k,v) / get(k),还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。
    HashMap会利用对象的hashCode来快速找到key。
    * hashing 哈希码就是将对象的信息经过一些转变形成一个独一无二的int值,这个值存储在一个array中。
    我们都知道所有存储结构中,array查找速度是最快的。所以,可以加速查找。

    发生碰撞时,让array指向多个values。即,数组每个位置上又生成一个梿表。

    6、Map中元素,可以将key序列、value序列单独抽取出来。使用keySet()抽取key序列,将map中的所有keys生成一个Set。
    使用values()抽取value序列,将map中的所有values生成一个Collection。

    为什么一个生成Set,一个生成Collection?那是因为,key总是独一无二的,value允许重复。

    展开全文
  • 需求:根据主键id来找到对应的数组下标 原本的方法是使用for循环遍历该...2.在数据回显或有全部数据的地方把数组list变成map 该例子数据结构是[{}],所以有2个for循环 item也是[{}]结构 这里的item[j].compon
  • 数组增删 集合删除 一、数组增删 package com.test; import java.util.List; import java.util.ArrayList; import java.util.Set; import java.util.HashSet; public class ArrayBlock { ....
  • java将对象数组作为Map的key值,对数据进行增删改查 源文件Student.java import java.util.Map; import java.util.Scanner; public class Student implements Comparable<Student> { int id; String name; ...
  • controller: public R mylistBatchRemoveCustomer(@RequestParam("ids[]") Long[] customerIds,Long mylistId{ Map<String, Object> map = new HashMap<... //把数组放入Map集合,后台的数据仍是数组 ...
  • js数组方法map和filter比较

    千次阅读 2019-11-22 00:12:50
    map() 方法创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。 const newArr = arr.map((a) => { // console.log(a) return 2; }); console.log(newArr); // [2, 2, 2] (2)...
  • 使用场景: 一个后台系统中, 管理员要配置自定义字段后台要生成id和title,其他角色要使用自定义字段的表单, 添加数据, 但是每个要填写的对象的id 和title都是无法固定的,因此页面显示的ti...
  • JS-数组方法filter和map

    千次阅读 2020-01-21 16:14:15
    一、生成两个数组 var numArr = [1,8,78,115,10,80]; var tlbb = [ {userId:1,name:"乔峰",age:40,sex:1}, {userId:2,name:"段誉",age:28,sex:1}, {userId:6,name:"虚竹",age:35,sex:1}, {us...
  • 获取后端数据,拿到route字段数据格式 let pathData = [ { path : 'admin' } , { path : 'equipment' } ] ; //2.数组对象转换字段字符串数组 let pathDataArr = pathData . map ( item => item . ...
  • 数组可以存放多个同一类型数据数组也是一种数据类型,在Go中,数组是值类型 一个养鸡场有6只鸡,它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50kg。请问这六只鸡的总体重是多少?平均体重是多少? 使用传统的方法不...
  • Go 数组、切片和 map

    2019-11-30 18:25:01
    数组可以存放多个同一类型数据数组也是一种数据类型,在 Go 中,数组是值类型。 package main import "fmt" func main() { var hen [6]float64 hen[0] = 1.00 hen[1] = 1.00 hen[2] = 2.00 hen[3] = 3.00 ...
  • go基本的数据结构有数组、slice、map,高级数据结构为结构体为用户自定义类型。本片文章主要讲解三大基本数据结构。 数组 数组是包含单个类型的元素序列,但是长度固定的数据类型,一个数组声明时需要指定数据...
  • 清空数组的操作 splice清空 let arr = [1, 2, 3, 4]; console.log("test:", arr) arr.splice(0, arr.length); console.log("test:", arr) 结果...
  • 二维数组概念:一维数组中的元素又是一个一维数组。 var arr [4][6]int // [ [0 0 0 0 0 0] [0 0 0 0 0 0] [0 0 0 0 0 0] [0 0 0 0 0 0] ] arr [1][2] = 1 arr [2][3] = 2 arr [3][4] = 3 fmt.Println(arr) // ...
  • 在上篇文章中介绍了Dart的基本数据类型中的字符串 string,那么现在就继续来学习 Dart的基础语法中的数组(list)和字典(Map)。 【Flutter】苹果Mac电脑配置flutter开发环境 【Flutter】 Android Studio 安装第三方...
  • auto map_end = maplist.end(); map_end--; maplist.erase(map_end);
  • 在平时做项目的时候,使用到了redux, 如果获取服务器端的数据,例如返回一个 data = [1,2,3,4]data.map(item => item*2) , 这样使用的话如果数据正常获取到是...
  • “程序中处理数据是必不可少的一部分,而一般来说数据的出现体量都会比较大切带有一些相同点;因此在程序中如何处理一堆数据,并且这堆数据都还有着一些相同时,就是非常重要的了。最佳的解决方式就是使用集合了”01...
  • es6新增了几种数据结构:set和map。注意哦,是数据结构,不是数据类型!就好比数组,json等。一.Set它类似于数组,但是其成员的值都是唯一的,没有重复的值(甚至在Set内部,NaN和NaN是相等的)它在初始化的时候接受...
  • Set、Map数组去重

    2019-06-25 09:36:00
    https://cloud.tencent.com/developer/article/1437254 ... 深入理解:ES6中的Set和Map数据结构,Map与其它数据结构的互相转换 javascript es6 ...
  • 数组去重-Map实现

    2018-08-07 09:13:14
    问题由来 遇到一道面试题:找到数组中第一个非重复的数。 [ 1, 1, 2, 2, 3, 4, 4, 5 ]第...而更高效的方式,是使用hash Map,可将时间复杂降为O(n)。 其实这个题目可以衍生出三个类似的问题: 数组去重 找到数组中...
  • 这里主要引用es6的map方法 var array=[ { id:1, classid:255, name:'一年级' }, { id:2, classid:256, name:'二年级' }...
  • : 假若后端返回这么一个json数据格式,如下所示,我们需要拿到返回对象中的数组项,或者根据某些指定的条件,取特定的值,然后渲染到页面当中去,例如:拿name属性值 { "ret":true, "data":{ "headerTitle":"群成员", ...
  • vue中Array数组Map对象的添加与删除

    千次阅读 2020-09-23 14:18:40
    1.定义一个vue空数组与一个... mapData:{},//自定义字段提交保存数据map  dbData:[  {}  ],//数据库查询出来的自定义字段  mapKey:'age',  mapValue:29,  arrayIndex:0,  arrayValue:'中国',  }; } 2..
  • shell 数组(含"map")操作总结

    千次阅读 2019-07-27 14:10:42
    shell 数组操作总结 字符 含义 举例 # 个数相关 $#:shell的参数个数 KaTeX parse error: Expected '}', got '#' at position 2: {#̲array[@]}/{#array[*]}: 数组个数 @、* 所有元素 $@ $: shell的所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 209,559
精华内容 83,823
关键字:

数组map删除数据