精华内容
下载资源
问答
  • 自定义数组
    2021-04-26 11:34:28

    /*

    * 二维数组自定义排序函数

    * uasort($arr,function_name)

    *

    **/

    $arr = array(

    array('a'=>1,'b'=>'c'),

    array('a'=>4,'b'=>'a'),

    array('a'=>5,'b'=>'g'),

    array('a'=>7,'b'=>'f'),

    array('a'=>6,'b'=>'e')

    );

    function compare_arr($x,$y){

    if($x['b']

    return -1;

    }else if($x['b']>$y['b']){

    return 1;

    }else{

    return 0;

    }

    }

    uasort($arr,'compare_arr');

    foreach($arr as $a){

    echo $a['a'].'=>'.$a['b'].'
    ';

    }

    手册里的自定义排序类:

    class multiSort

    {

    var $key; //key in your array

    //排序函数 参数依次是 数组 待排列索引 排序类型

    function run ($myarray, $key_to_sort, $type_of_sort = '')

    {

    $this->key = $key_to_sort;

    if ($type_of_sort == 'desc')

    uasort($myarray, array($this, 'myreverse_compare'));

    else

    uasort($myarray, array($this, 'mycompare'));

    return $myarray;

    }

    //正序

    function mycompare($x, $y)

    {

    if ( $x[$this->key] == $y[$this->key] )

    return 0;

    else if ( $x[$this->key] < $y[$this->key] )

    return -1;

    else

    return 1;

    }

    //逆序

    function myreverse_compare($x, $y)

    {

    if ( $x[$this->key] == $y[$this->key] )

    return 0;

    else if ( $x[$this->key] > $y[$this->key] )

    return -1;

    else

    return 1;

    }

    }

    更多相关内容
  • java 创建自定义数组

    2020-09-02 01:43:52
    本篇文章是关于java 如何自己创建自定义数组,这里给大家一个小实例,希望能帮助有所需要的同学
  • 本文实例讲述了JavaScript自定义数组排序方法。分享给大家供大家参考。具体分析如下: Array中有自带的排序功能,这个使用起来比较方便,我们有一点必须清楚,就是排序的依据,如果sort不传入参数的话,那就是按照...
  • Java自定义数组

    千次阅读 2021-02-12 10:40:33
    前言今天有点无聊,写了一个自定义数组,里边主要实现很多js中数组的方法,例如:排序、数组连接、删除、剪切。算是加深对java的一些基础操作的印象。代码/*** @Auther dbc* @Date 2020/9/5 22:03* 自定义数组,数组...

    前言

    今天有点无聊,写了一个自定义数组,里边主要实现很多js中数组的方法,例如:排序、数组连接、删除、剪切。算是加深对java的一些基础操作的印象。

    代码/**

    * @Auther dbc

    * @Date 2020/9/5 22:03

    * 自定义数组,数组元素为Object类

    * 构造方法:

    * MyArrayList() 初始化数组,长度为0

    * MyArrayList(int size) 创建长度为size的数组

    * MyArrayList(Object... objects) 初始化即加入一些元素

    * 主要方法:

    * String join() 方法用于根据分隔符把数组中的所有元素放入一个字符串,默认分隔符为","逗号.

    * String join(String separator) example: 元素为0,1,2,3的数组 使用join("-")得到:0-1-2-3

    * String toString() 得到数组字符串形式

    * boolean add(int index,Object o) 在指定索引后增加元素

    * void add(Object... objects) 在数组末尾添加元素

    * Object pop() 删除并返回数组最后一个元素

    * MyArrayList splice(int index,int length) 在原数组从索引index开始剪切length长度个元素,返回剪切后的新的数组

    * MyArrayList update(int index,Object o) 修改指定索引的元素

    * Object shift() 删除并返回数组的第一个元素

    * void unShift(Object... objects) 在数组开头添加元素

    * MyArrayList slice(int start,int end) 方法可从已有的数组中返回选定的元素

    * void sortAsc() 对数组进行升序排序(选择排序) 前提:数组元素均为Integer、Double、Float中的一种

    * void sortDesc() 对数组进行降序排序(冒泡排序) 前提:数组元素均为Integer、Double、Float中的一种

    * MyArrayList concat(MyArrayList... allList) 方法用于连接两个或多个数组(该方法不会改变现有的数组)

    * void reverse() 颠倒数组中的元素

    * Object charAt(int index) 获取索引index处的元素

    * int indexOf(Object o,int startIndex) 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1

    * int lastIndexOf(Object o,int startIndex) 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1

    *

    */

    public class MyArrayList {

    private Object[] elementData;//元素

    private int size;//数组长度

    private static final float DEFAULT_EXPAND_FACTOR = 0.75f;//扩容因子

    private static final float DEFAULT_NARROW_FACTOR = 0.5f;//缩小容量的因子

    private static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量

    private static String joinSeparator =","; //join方法默认的分隔符

    /**

    * 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1

    * @param o

    * @param startIndex

    * @return

    */

    public int lastIndexOf(Object o,int startIndex){

    if(startIndex<0) startIndex=0;

    if(startIndex>=size) startIndex=size-1;

    for(int i=startIndex;i>=0;i--){

    if(elementData[i].equals(o)) return i;

    }

    return -1;

    }

    /**

    * 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1

    * @param o

    * @param startIndex

    * @return

    */

    public int indexOf(Object o,int startIndex){

    if(startIndex<0) startIndex=0;

    if(startIndex>=size) startIndex=size-1;

    for(int i=startIndex;i

    if(elementData[i].equals(o)) return i;

    }

    return -1;

    }

    /**

    * 颠倒数组中的元素

    */

    public void reverse(){

    Object o;

    for(int i=0;i

    o=elementData[i];

    elementData[i] = elementData[size-i-1];

    elementData[size-i-1] =o;

    }

    }

    /**

    * 连接多个数组

    * @param allList

    * @return

    */

    public MyArrayList concat(MyArrayList... allList){

    MyArrayList concatData =new MyArrayList(this.getElementData());

    for (MyArrayList myArrayList:allList) {

    concatData.add(myArrayList.getElementData());

    }

    return concatData;

    }

    /**

    * 对数组进行升序排序

    */

    public void sortAsc(){

    if(!isAllNumArray()) return;

    Object o;

    //选择排序

    for(int i=0;i

    int min = i;//最小数的索引

    for(int j=i+1;j

    if(Double.parseDouble(elementData[i].toString())>Double.parseDouble(elementData[j].toString())){

    min = j;

    }

    }

    if(min ==i) continue;

    o = elementData[i];

    elementData[i]=elementData[min];

    elementData[min] = o;

    }

    }

    /**

    * 对数组进行降序排序

    */

    public void sortDesc(){

    if(!isAllNumArray()) return;

    Object o;

    //冒泡排序

    for(int i=0;i

    for(int j=i+1;j

    if(Double.parseDouble(elementData[i].toString())

    o=elementData[i];

    elementData[i]=elementData[j];

    elementData[j]=o;

    }

    }

    }

    }

    /**

    * 方法可从已有的数组中返回选定的元素

    * @param start

    * @param end

    * @return

    */

    public MyArrayList slice(int start,int end){

    if(start<0) return new MyArrayList();

    if(end>=size) end=size-1;

    Object[] sliceData =new Object[end-start+1];

    for(int i=start;i<=end;i++){

    sliceData[i-start]=elementData[i];

    }

    return new MyArrayList(sliceData);

    }

    /**

    * 在数组开头添加元素

    * @param objects

    */

    public void unShift(Object... objects){

    int len =objects.length;

    ensureCapacity(len);

    for(int i=size+len-1;i>=len;i--){

    elementData[i]=elementData[i-len];

    }

    for (int i=0;i

    elementData[i]=objects[i];

    }

    size+=len;

    }

    /**

    * 删除并返回数组的第一个元素

    * @return

    */

    public Object shift(){

    if(size<=0) return null;

    Object o = elementData[0];

    for(int i=0;i

    elementData[i]=elementData[i+1];

    }

    size--;

    return o;

    }

    /**

    * 修改指定位置的元素

    * @param index

    * @param o

    * @return

    */

    public MyArrayList update(int index,Object o){

    if(index<0 || index>=size) return this;

    this.elementData[index]=o;

    return this;

    }

    /**

    * 删除元素,并返回被删除的元素数组

    * @param index 从index索引开始删除

    * @param length 删除的长度。若删除超过数组下标,默认从索引index一直删除到数组的最后一个元素。

    * @return

    */

    public MyArrayList splice(int index,int length){

    if(index<0 || index>size-1) return new MyArrayList();

    if(length<=0) return new MyArrayList();

    if(index+length>size) length =size-index;

    Object[] removeList =new Object[length];

    //开始删除

    for(int i=0;i

    removeList[i] =elementData[index+i];

    if(i+length

    elementData[index+i] =elementData[index+length+i];

    }else {

    elementData[index+i]=null;

    }

    }

    for(int i=index+length;i

    if(i+length>=elementData.length) break;

    elementData[i] = elementData[i+length];

    }

    size-=length;

    return new MyArrayList(removeList);

    }

    /**

    * 删除并返回数组的最后一个元素

    */

    public Object pop(){

    if(size<=0) return null;

    Object removeEle=elementData[size-1];

    elementData[--size]=null;

    return removeEle;

    }

    /**

    * 增加元素 方式二:指定下标的后面添加

    * @param o 新元素

    * @param index 索引

    */

    public boolean add(int index,Object o){

    if(index<0 || index>=size) return false;

    ensureCapacity(1);//检测容量

    for(int i=size;i>index+1;i--){

    elementData[i] =elementData[i-1];

    }

    elementData[index+1]=o;

    size++;

    return true;

    }

    /**

    * 增加元素 方式一:末尾添加

    * js中的push()方法

    */

    public void add(Object... objects){

    //检测容量

    ensureCapacity(objects.length);

    //末尾增加

    for(int i=0;i

    elementData[size++] =objects[i];

    }

    }

    /**

    * 获取数组长度

    *

    */

    public int getSize(){

    return this.size;

    }

    /**

    * toString

    */

    public String toString(){

    StringBuffer sb =new StringBuffer("[");

    for(int i=0;i

    sb.append(elementData[i]);

    sb.append(",");

    }

    String str;

    if(size>0){

    str = sb.substring(0, sb.length() - 1);

    str+="]";

    }else{

    sb.append("]");

    str =sb.toString();

    }

    return str;

    }

    /**

    * join() 方法用于把数组中的所有元素放入一个字符串

    * 元素是通过指定的分隔符进行分隔的

    * 使用默认的方法

    */

    public String join(){

    StringBuffer sb =new StringBuffer();

    for(int i=0;i

    sb.append(elementData[i]);

    sb.append(joinSeparator);

    }

    if(size==0) return "";

    return sb.substring(0, sb.length() - 1);

    }

    /**

    * join() 方法用于把数组中的所有元素放入一个字符串

    * 元素是通过指定的分隔符进行分隔的

    * 使用默认的方法

    */

    public String join(String separator){

    StringBuffer sb =new StringBuffer();

    for(int i=0;i

    sb.append(elementData[i]);

    sb.append(separator);

    }

    if(size==0) return "";

    return sb.substring(0, sb.length() - 1);

    }

    /**

    * @param addNum 此次添加的数目

    * 检测数组容量与实际元素个数是否达到扩容标准,若达到则扩容,否则不管

    */

    private void ensureCapacity(int addNum){

    //容量*扩容因子>size && 容量*缩容因子

    if(size+addNum

    && size+addNum

    //达到扩容要求,计算新的容量

    int capacity = (int)((size+addNum)/DEFAULT_EXPAND_FACTOR);

    //大于最大容量,不管了只有

    if(capacity>MAXIMUM_CAPACITY) capacity =MAXIMUM_CAPACITY;

    elementData= Arrays.copyOf(elementData,capacity);

    }

    /**

    * 获取所有数组元素

    * @return

    */

    public Object[] getElementData(){

    return Arrays.copyOf(this.elementData,size);

    }

    /**

    * 获取数组某个元素

    * @return

    */

    public Object charAt(int index){

    if(index<0 || index>=size) return null;

    return this.elementData[index];

    }

    /**

    * 判断数组元素是否都是数字

    * @return

    */

    private boolean isAllNumArray(){

    for(int i=0;i

    if(elementData[i] instanceof Integer || elementData[i] instanceof Float

    || elementData[i] instanceof Double) {

    }

    else return false;

    }

    return true;

    }

    public MyArrayList(){

    this.size =0;

    this.elementData =new Object[0];

    }

    /**

    * 定义长度为size的空数组

    * @param size

    */

    public MyArrayList(int size){

    if(size<0) size=0;//确保不为负数

    this.elementData =new Object[size];

    this.size=0;

    }

    /**

    * 初始化数组,并初始化数组内容

    * @param objects

    */

    public MyArrayList(Object... objects){

    this.size=objects.length;

    elementData=Arrays.copyOf(objects,size);

    ensureCapacity(1);//扩容

    }

    }

    展开全文
  • 本文实例讲述了PHP实现的自定义数组排序函数与排序类。分享给大家供大家参考,具体如下: /* * 二维数组自定义排序函数 * uasort($arr,function_name) * **/ $arr = array( array('a'=>1,'b'=>'c'), array('a'=>4...
  • C++自定义数组

    2022-04-14 10:24:48
    #pragma once #include<iostream> using namespace std; template<class T> class myarray{ public: myarray<T>& operator=(const myarray& arr); T& operator[](int a) { ......

    #pragma once
    #include<iostream>
    using namespace std;

    template<class T>
    class myarray{
    public:
        myarray<T>& operator=(const myarray& arr);
        T& operator[](int a) {
            return this->address[a];
        }
        T* address;
        int size;
        myarray(int size) {
            if (this->address != NULL) {
                delete []this->address;
                this->address = NULL;
            }
            this->size = size;
            this->address = new T[size];
    }
        myarray(myarray &arr) {
            if (this->address != NULL) {
                delete[]this->address;
                this->address = NULL;
            }
            this->size =arr. size;
            this->address = new T[this->size];
            for (int i = 0; i < this->size; i++) {
                this->address[i] = arr.address[i];
            }
        }
        
        ~myarray() {
            if (this->address != NULL) {
        delete[]this->address;
        this->address = NULL;        }
        this->size = 0;

            
        }
        
    };
    template<class T>
    myarray<T>& myarray<T>::operator=(const myarray<T>& arr) {
        if (this->address != NULL) {
            delete[]this->address;
            this->address = NULL;
        }
        this->size = arr.size;
        this->address = new T[this->size];
        for (int i = 0; i < this->size; i++) {
            this->address[i] = arr.address[i];
        }
        return *this;
    }

    分文件编写

    #include<iostream>
    using namespace std;
    #include"myarray.hpp"
    int main() {
        myarray <int>arr(5);
        for (int i = 0; i < 5; i++) {
            arr.address[i] = i + 1;
        }
        for (int i = 0; i < 5; i++) {
        
                cout << arr.address[i];
                cout << "    " << typeid(arr.address[i]).name();
                cout << "    " << &arr.address[i] << endl;
            }
        myarray <int>arr2(3);
    arr2=arr;
        for (int i = 0; i < 5; i++) {
            cout << arr2[i];
            cout <<"    "<< typeid(arr2[i]).name();
            cout << "    " <<& arr2[i] << endl;
        }
        return 0;
    }

    展开全文
  • 自定义数组如何快速排序: 工作过程中可能会遇到,sql查出来的数据排序需要再次处理,下面是一个自己封装的一个数组二处理的方法,一起学习下。 来直接上代码: 代码如下(示例): /** * 自定义数据排序 * @...

    自定义数组如何快速排序:

    工作过程中可能会遇到,sql查出来的数据排序需要再次处理,下面是一个自己封装的一个数组二处理的方法,一起学习下。


    来直接上代码:

    代码如下(示例):

    /**
         * 自定义数据排序
         * @param array $array
         * @param string $key
         * @param $where
         * @return array
         */
        public function customDataSorting($array =[],$key='',$where){
            $result = [];
            foreach ($array as $k => $v){
                $values[$k] = $v[$key] ? $v[$key] : "";
            }
            switch ($where){
                case 'desc':
                    arsort($values);
                    break;
                case 'asc':
                    asort($values);
                    break;
            }
            unset($k,$v);
            $key = 0;
            foreach ($values as $k => $v){
                $result[$key] = $array[$k];
                $key = $key + 1;
    //            $result[$k] = $array[$k];
            }
            return $result;
        }
        $arr =  [
    	    {
    	        "id":"1",
    	        "sort":"1",
    	        "sort_new":"2",
    	    },
    	    {
    	        "id":"2",
    	        "sort":"2",
    	        "sort_new":"1",
    	    }
    	]
    	$new_arr = $this->customDataSorting($arr,'sort_new','asc');
    	var_dump($new_arr);
    

    总结

    这个封装的方法可以处理一般上面例子的数组,比较方便,直接拿过去就可以用。

    展开全文
  • Java自定义数组排序

    2022-06-07 17:02:39
    Java自定义数组排序
  • 一、自定义forEach Array.prototype.myForEach = function(callback) { for(let i=0;i<this.length;i++){ callback(this[i],i,this) } } const arr1=[1,2,3] arr1.myForEach((item, index,data)=>{ ...
  • Javascript自定义数组删除方法remove()</title> [removed] Array.prototype.remove=function(dx){ if(isNaN(dx)||dx>this.length){return false;} for(var i=0,n=0;i<this.length;i++){ if(this[i]!=this...
  • 而本文主要给大家介绍了关于Js利用prototype自定义数组方法的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧。 题目 如何实现下列代码: [1,2,3,4,5].duplicator(); // [1,2,3,4,5,1,...
  • 创建自定义数组 [ ] 消息类型以及使用 以自定义的消息类型 Distance.msg 为基础,再次定义消息类型 distance.msg 以及使用 以自定义的消息类型Distance.msg 为基础,再次定义数组 [ ] 消息类型Sj.msg (尚未解决...
  • table: 表示定义可变长度的一维数组,如果要定义固定长度的数据就要使用varray,比如定义一个长度为10的数组 type dateArray is varray(10) of varchar2(10); varchar2(10): 表示数组是字符串类型的,且长度不超过10 ...
  • 自定义数组去重方法

    2020-08-10 11:06:54
    为数组原型添加一个自定义去重的方法 // 为数组添加一个自定义去重方法myDistinct ... // 这里的this就是你使用的数组 (arr、arr1) for(var i=0;i<this.length;i++){ var cur=this[i]; if(obj[cu
  • 文件.wxml <view class="section"> <view class="section__...自定义普通选择器</view> <picker bindchange="bindPickerChangeCity" mode="selector" value="{{cityArray.name}}" range-key="...
  • 连接现场实时数,代替岗位工眼睛判断一段趋势是上升还是下降,进而进行下一步操作,比如转炉下副枪的时机,岗位工通过观察CO2、CO的趋势进行下副枪...输入:实时值、数组大小 输出:y=kx+b、斜率k、截距b、相关系数r^2
  • 需求描述: 通过使用 C++ 中类模板的特性,实现一个能够存储任意类型的数组。可以通过在尾部追加的方式在数组中完成数据传入,且可以通过尾部操作删除数组最后一个元素。完整代码如下: #include<iostream> #...
  • 自定义数组

    千次阅读 2019-07-06 21:46:37
    在学习c++的过程中,我们经常使用到数组,那怎么去定义一个类去实现数组的功能呢? 我们先列除一些经常对数组进行的一些操作, 1、 创建一个指定容量的数组 2、 用已有的数组初始化另一个数组 3、 用已有的...
  • 存储过程之自定义数组类型

    千次阅读 2021-01-19 07:54:49
    SQL> create or replace type myvarray_list as varray(10) of varchar2(50);2 /类型已创建。SQL> create or replace procedure show_list(2 p_varlist in myvarray_list3 )4 is5 str varchar2(50);...
  • JS 自定义数组方法

    2019-02-15 10:35:48
    //判断数组是否有重复项 Array.prototype.isItemRepeat = function(){ return /(\x0f[^\x0f]+)\x0f[\s\S]*\1/.test(&amp;amp;quot;\x0f&amp;amp;quot;+ this.join(&amp;amp;quot;\x0f\x0f&amp;...
  • 自定义数组的工具类----Java 求最大值 求最小值 求总和 求平均值 数组排序 数组反转 数组遍历 数组复制 查找元素 自定义工具类代码: package com.array.project; /** * @author: LYM * @description 自定义...
  • 主要目的:解决ArrayList 类不能改变大小的问题,主要实现数组列表动态调整大小。1、数组类型如何选择?由于我们不清楚数组中具体存入什么类型的数据, 我们可以声明一个对象Object [ ] ,这样,数组列表就可以存储...
  • 可以对内置数据类型以及自定义数据类型的数据进行存储 将数组中的数据存储到堆区 构造函数中可以传入数组的容量 提供对应的拷贝构造函数以及operator=防止浅拷贝问题 提供尾插法和尾删法对数组中的数据进行增加和...
  • 自定义数组

    千次阅读 2018-12-25 22:33:44
    通过学习自定义数组,了解数组的数据结构。 package algorithm; public class Array&lt;E&gt; { private E[] data; private int size;//数组的实际大小 /** * 无参的构造函数,默认初始容量 */ ...
  • 第二种: asort() 对数组进行排序并保持索引关系 arsort() 对数组进行逆向排序并保持索引关系 自定义数组 $data = [ ['id'=>1,'title'=>'华为','price'=>6999], ['id'=>2,'title'=>'苹果','price'=>1999], ['id'=>3...
  • C语言自定义数组函数

    千次阅读 2021-05-31 10:27:48
    自定义数组函数 strcmp #include<stdio.h> int main() { int mystrcmp(char a[], char b[]); char str1[] = "123", str2[] = "1234"; int z; z = mystrcmp(str1, str2); printf("%d\n", z); return...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 678,317
精华内容 271,326
关键字:

自定义数组

友情链接: fpga_spi.rar