精华内容
下载资源
问答
  • PHP数组元素的顺序和逆序排列
    2021-04-17 02:26:22

    对一个数组的元素排序是很常见的编程任务,比如顺序、逆序,还有排序是否保持元素的键值对问题,下面开始研究下这些问题。

    sort()函数

    sort()函数对数组进行排序,各元素按值由低到高的顺序排列。其形式如下:

    1

    void sort (array array[,int sort_flags])

    sort()函数不返回排序后的数组。相反,它只是“就地”对数组排序,不论结果如何都不返回任何值。sort_flags参数可选,将根据这个参数指定的值修改该函数的默认行为。

    SORT_NUMBERIC,按数值排序。对整数或浮点数排序时很有用。

    SORT_REGULAR,按照相应的ASCll值对元素排序。例如,这意味着B在a的前面。在网上很快就能查到很多ASCII表,所以这里就不再列出了。

    SORT_STRING,按接近于人所认知的正确顺序对元素排序。有关的更多信息请本节后面介绍的natsort()。

    下面来看一个例子。假设希望由低到高对考试成绩进行排序:

    1

    $grades =array(42,57,98,100,13,43,78,12);

    2

    sort($grades);

    3

    print_r($grades);

    值得注意到一点是,使用这个函数后,数组元素的键/值关联不再保持。看看下面的例子:

    1

    $fruits =array("apple" =>"red","banana" =>"yellow","pear" =>"orange");

    2

    sort($fruits);

    3

    4

    echo '

    ';

    5

    print_r($fruits);

    6

    echo '

    ';

    程序运行结果:

    1

    Array

    2

    (

    3

    [0] => orange

    4

    [1] => red

    5

    [2] => yellow

    6

    )

    保持键/值对的排序函数asort()

    assort()函数与sort()函数相同,以升序对数组排序,只不过它将保持键/值得关联。其形式如下:

    1

    void asort(array array[,integer sort_flags])

    还是使用上面的例子:

    1

    $fruits =array("apple" =>"red","banana" =>"yellow","pear" =>"orange");

    2

    asort($fruits);

    3

    print_r($fruits);

    程序运行输出:

    1

    Array

    2

    (

    3

    [pear] => orange

    4

    [apple] => red

    5

    [banana] => yellow

    6

    )

    如果使用可选的sort_flags参数,具体的排序行为将由这个值确定,可以参考sort()排序的部分。

    逆序排序函数rsort()

    rsort()函数与sort()函数相同,只不过它以相反的顺序(降序)对数组进行元素排序。其形式如下:

    1

    void rsort(array array[,integer sort_flags])

    1

    $fruits =array(42,57,98,100,13,43,78,12);

    2

    rsort($fruits);

    3

    print_r($fruits);

    同样,这个函数也不能保持数组的键值对关系。

    保持键/值对的逆序排序函数arsort()

    与asort()一样,arsort()会保持键/值得关联。但是,它以降序对数组进行排序,其形式如下:

    1

    void arsort(array array[,integer sort_flags])

    实例程序如下:

    1

    $fruits =array("apple" =>"red","banana" =>"yellow","pear" =>"orange");

    2

    arsort($fruits);

    3

    print_r($fruits);

    程序运行结果为:

    1

    Array

    2

    (

    3

    [banana] => yellow

    4

    [apple] => red

    5

    [pear] => orange

    6

    )

    以上是常用的排序函数,当然还有其它排序函数,后面会继续介绍。

    更多相关内容
  • PH常用函数汇总

    千次阅读 2018-10-15 17:04:00
    * array_chunk() 把一个数组分割为新的数组块 * array_column() 返回输入数组中某个单一列的值 * array_combine() 通过合并两个数组来创建一个新数组 * array_count_values() 用于统计数组中所有值出现的次数...
    <?php
    /**
     *  array_change_key_case() 把数组中所有键更改为小写或大写
     *  array_chunk() 把一个数组分割为新的数组块
     *  array_column() 返回输入数组中某个单一列的值
     *  array_combine() 通过合并两个数组来创建一个新数组
     *  array_count_values() 用于统计数组中所有值出现的次数
     *  array_diff() 比较数组,返回差集(只比较键值)
     *  array_diff_assoc() 比较数组,返回差集(比较键名和键值)
     *  array_diff_key() 比较数组,返回差集(只比较键名)
     *  array_fill() 用给定的键值填充数组
     *  array_fill_keys() 用指定键名的给定键值填充数组
     *  array_filter() 用回调函数过滤数组中的元素
     *  array_flip() 交换数组中的键和值
     *  array_intersect() 比较数组,返回交集(只比较键值)
     *  array_intersect_assoc() 比较数组,返回交集(比较键名和键值)
     *  array_intersect_key() 比较数组,返回交集(只比较键名)
     *  array_key_exists() 检查指定的键名是否存在于数组中
     *  array_keys() 返回数组中所有的键名
     *  array_map() 把数组中的每个值发送到用户自定义函数,返回新的值
     *  array_merge() 把一个或多个数组合并为一个数组
     *  array_merge_recursive() 递归地合并一个或多个数组
     *  array_multisort() 对多个数组或多维数组进行排序
     *  array_pad() 用值将数组填补到指定长度
     *  array_pop() 删除数组的最后一个元素(出栈)
     *  array_product() 计算数组中所有值的乘积
     *  array_push() 将一个或多个元素插入数组的末尾(入栈)
     *  array_rand() 返回数组中一个或多个随机的键
     *  array_reduce() 通过使用用户自定义函数,以字符串返回数组
     *  array_replace() 使用后面数组的值替换第一个数组的值
     *  array_replace_recursive() 递归地使用后面数组的值替换第一个数组的值
     *  array_reverse() 以相反的顺序返回数组
     *  array_search() 搜索数组中给定的值并返回键名
     *  array_shift() 删除数组中首个元素,并返回被删除元素的值
     *  array_slice() 返回数组中被选定的部分
     *  array_splice() 删除并替换数组中指定的元素
     *  array_sum() 返回数组中值的和
     *  array_udiff() 比较数组,返回差集(只比较值,使用一个用户自定义的键名比较函数)
     *  array_udiff_assoc() 比较数组,返回差集(比较键和值,使用内建函数比较键名,使用用户自定义函数比较键值)
     *  array_udiff_uassoc() 比较数组,返回差集(比较键和值,使用两个用户自定义的键名比较函数)
     *  array_uintersect() 比较数组,返回交集(只比较值,使用一个用户自定义的键名比较函数)
     *  array_uintersect_assoc() 比较数组,返回交集(比较键和值,使用内建函数比较键名,使用用户自定义函数比较键值)
     *  array_uintersect_uassoc() 比较数组,返回交集(比较键和值,使用两个用户自定义的键名比较函数)
     *  array_unique() 删除数组中的重复值
     *  array_unshift() 在数组开头插入一个或多个元素
     *  array_values() 返回数组中所有的值
     *  array_walk() 对数组中的每个成员应用用户函数
     *  array_walk_recursive() 对数组中的每个成员递归地应用用户函数
     *  arsort() 对关联数组按照键值进行降序排序
     *  asort() 对关联数组按照键值进行升序排序
     *  compact() 创建包含变量名和它们的值的数组
     *  count() 返回数组中元素的数目
     *  current() 返回数组中的当前元素
     *  each() 返回数组中当前的键/值对
     *  end() 将数组的内部指针指向最后一个元素
     *  extract() 从数组中将变量导入到当前的符号表
     *  in_array() 检查数组中是否存在指定的值
     *  key() 从关联数组中取得键名
     *  krsort() 对数组按照键名逆向排序
     *  ksort() 对数组按照键名排序
     *  list() 把数组中的值赋给一些变量
     *  natcasesort() 用“自然排序”算法对数组进行不区分大小写字母的排序
     *  natsort() 用“自然排序”算法对数组排序
     *  next() 将数组中的内部指针向前移动一位
     *  pos()current() 的别名
     *  prev() 将数组的内部指针倒回一位
     *  range() 创建包含指定范围单元的数组
     *  reset() 将数组的内部指针指向第一个元素
     *  rsort() 对数组逆向排序
     *  shuffle() 将数组打乱
     *  sizeof()    count() 的别名
     *  sort() 对数组排序
     */
    // array_change_key_case() 把数组中所有键更改为小写或大写(CASE_UPPER),默认为小写(CASE_LOWER)
    $age=array("Bill"=>"Bill","Steve"=>"56","Mark"=>"31");
    // print_r(array_change_key_case($age,CASE_UPPER));
    
    // array_chunk($arr,$num) 把一个数组分割为新的数组块,一般用于一维数组,分割时重置键,针对二维及以上数组,不存在递归分割
    $cars = array(array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
    		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
    		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45),
    		array('0'=>45,'1'=>45,'2'=>45,'3'=>45,'4'=>45)
    	);
    $cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
    // print_r(array_chunk($cars,2));
    
    // array_column($arr,'column','index_key') 返回数组中某一个单列的值
    $arr = array(
        'dasd' =>array(
            'id' => 5698,
            'first_name' => 'Bill',
            'last_name' => 'Gates',
        ),
        'dassadasdasd' =>array(
            'id' => 4767,
            'first_name' => 'Steve',
            'last_name' => 'Jobs',
        ),
        'ddasdasdasasd' =>array(
            'id' => 3809,
            'first_name' => 'Mark',
            'last_name' => 'Zuckerberg',
        )
    );
    // 返回$arr中last_name的值并形成一个新数组
    // print_r(array_column($arr,'last_name')); Array ( [0] => Gates [1] => Jobs [2] => Zuckerberg )
    
    
    // 返回$arr中last_name的值并形成一个以id为键的新数组
    // print_r(array_column($arr,'last_name','id')); Array ( [5698] => Gates [4767] => Jobs [3809] => Zuckerberg )
    
    // 第二个参数为null时,返回原数组,重置数组键
    // print_r(array_column($arr,null));
    /*Array
    (
        [0] => Array
            (
                [id] => 5698
                [first_name] => Bill
                [last_name] => Gates
            )
    
        [1] => Array
            (
                [id] => 4767
                [first_name] => Steve
                [last_name] => Jobs
            )
    
        [2] => Array
            (
                [id] => 3809
                [first_name] => Mark
                [last_name] => Zuckerberg
            )
    )*/
    // 第二个参数为null时,返回原数组,可配合第三个参数来重置数组键
    // print_r(array_column($arr,null,'first_name'));
    /*Array
    (
        [Bill] => Array
            (
                [id] => 5698
                [first_name] => Bill
                [last_name] => Gates
            )
    
        [Steve] => Array
            (
                [id] => 4767
                [first_name] => Steve
                [last_name] => Jobs
            )
    
        [Mark] => Array
            (
                [id] => 3809
                [first_name] => Mark
                [last_name] => Zuckerberg
            )
    
    )
    */
    
    // array_combine($arr1,$arr2)   
    // 合并两个数组来创建一个新的数组,第一个数组为键,第二个数组为值 若数组个数不同,返回false
    $fname=array("Bill","Steve","Mark");
    $age=array("60","56","31");
    
    $c=array_combine($fname,$age);
    // print_r($c);                         // Array ( [Bill] => 60 [Steve] => 56 [Mark] => 31 )
    
    // array_count_values($arr) 对数组中所有的值进行计数
    $a=array("A","Cat","Dog","A","Dog");
    // print_r(array_count_values($a));     // Array ( [A] => 2 [Cat] => 1 [Dog] => 2 ) 
    
    // array_diff($arr1,$arr2[,$arr3]) 返回两个或以上数组的差集数组(其他数组与第一数组进行仅有值的比较)
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("e"=>"red","f"=>"black","g"=>"purple");
    $a3=array("a"=>"red","b"=>"black","h"=>"yellow");
    
    // 比较a1与a2,返回a1中与a2不匹配的部分,结果不包括a2中的键值
    // print_r(array_diff($a1,$a2));        // Array ( [b] => green [c] => blue [d] => yellow ) 
    // 比较a1,a2与a3,返回a1中与a2,a3同时不匹配的部分,结果不包括a2,a3中的键值
    // print_r(array_diff($a1,$a2,$a3));    // Array ( [b] => green [c] => blue )
    
    
    // array_diff_assoc($a1,$a2,$a3...) 比较2个或以上数组的键与值并返回差集
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("e"=>"red","f"=>"green","g"=>"blue");
    
    // 条件:当键与值同时匹配
    // print_r(array_diff_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue [d] => yellow )
    
    
    // array_diff_key($a1,$a2,$a3...) 比较两个或以上的数组的键,并返回差集
    $a1=array("a"=>"red","b"=>"green","c"=>"blue");
    $a2=array("a"=>"red","c"=>"blue","d"=>"pink");
    
    // print_r(array_diff_key($a1,$a2));   // Array ( [b] => green )
    
    $a1=array("red","green","blue","yellow");
    $a2=array("red","green","blue");
    
    // print_r(array_diff_key($a1,$a2));   // Array ( [3] => yellow )
    $a1=array("a"=>"red","b"=>"green","c"=>"blue");
    $a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
    $a3=array("f"=>"green","c"=>"purple","g"=>"red");
    
    // print_r(array_diff_key($a1,$a2,$a3)); // Array ( [a] => red [b] => green )
    
    
    // array_fill(start_index, num, value) 從start_index索引開始,填充num條值為value形成新數組
    // print_r(array_fill(5,3,'value'));   // Array ( [5] => value [6] => value [7] => value )
    
    
    // array_fill_keys(keys, value) 用指定鍵、值填充數組
    $keys=array("a","b","c","d");
    // print_r(array_fill_keys($keys,'blue')); // Array ( [a] => blue [b] => blue [c] => blue [d] => blue )
    
    // array_filter($array[,'myfunction']) 使用自定义函数过滤数组中的元素,数组键名保持不变。若无自定义函数,则取出数组中为空、null的值
    $a = [1,2,3,4,5,6,7,8,9,10];
    // print_r(array_filter($a,function($a){ if($a > 5) { return $a; } }));
    
    // array_flip(arr)  反转数组的键值,如果同一值出现了多次,则最后一个键名将作为它的值,所有其他的键名都将丢失。 如果原数组中的值的数据类型不是字符串或整数,函数将报错。
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    // print_r(array_flip($a1));    // Array ( [red] => a [green] => b [blue] => c [yellow] => d )
    
    
    // array_intersect(array1, array2) 比较两个或以上的数组的值,并返回交集
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("e"=>"red","f"=>"green","g"=>"blue");
    // print_r(array_intersect($a1, $a2));    // Array ( [a] => red [b] => green [c] => blue )
    
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("e"=>"red","f"=>"black","g"=>"purple");
    $a3=array("a"=>"red","b"=>"black","h"=>"yellow");
    // print_r(array_intersect($a1,$a2,$a3)); // Array ( [a] => red )
    
    // array_intersect_assoc(array1, array2)  比较两个或以上的数组的键、值,并返回交集
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("a"=>"red","b"=>"green","c"=>"blue");
    // print_r(array_intersect_assoc($a1,$a2)); // Array ( [a] => red [b] => green [c] => blue )
    
    // array_intersect_key($a1,$a2,$a3) 比较两个或以上的数组的键,并返回交集
    $a1=array("a"=>"red","b"=>"green","c"=>"blue");
    $a2=array("a"=>"red","c"=>"blue","d"=>"pink");
    // print_r(array_intersect_key($a1,$a2));
    /*Array
    (
        [a] => red
        [c] => blue
    )
    */
    
    // array_key_exists(key, array) 检查键是否存在于数组中,区分大小写
    $a=array("Volvo"=>"XC90","BMW"=>"X5");
    /*if (array_key_exists('Volvo',$a)) {
        echo '键存在';
    }else{
        echo '键不存在';
    }*/
    
    /*$a=array("Volvo","BMW");
    if (array_key_exists(0,$a))
    {
        echo "键存在!";
    }
    else
    {
        echo "键不存在!";
    }*/
    
    // array_keys(array,value,strict) 返回包含数组中所有键的一个新数组
    $a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
    // print_r(array_keys($a));
    /*Array
    (
        [0] => Volvo
        [1] => BMW
        [2] => Toyota
    )*/
    
    // 如果提供了第二个参数,则只返回键值为该值的键名,不存在返回空数组
    // print_r(array_keys($a,'Highlander'));
    /*Array
    (
        [0] => Toyota
    )
    */
    // 如果 strict 参数指定为 true,则 PHP 会使用全等比较 (===) 来严格检查键值的数据类型,默认false
    $a=array(10,20,30,"10");
    // print_r(array_keys($a,"10",false));
    /*Array
    (
        [0] => 0
        [1] => 3
    )
    */
    $a=array(10,20,30,"10");
    // print_r(array_keys($a,"10",true));
    /*Array
    (
        [0] => 3
    )
    */
    
    // array_map('function',arr) 函数将用户自定义函数作用到数组中的每个值上,并返回用户自定义函数作用后的带有新值的数组
    // 回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致
    $arr = ['20180000001/3.55','20180000044/3.55','20180005501/3.55','20144000001/3.55'];
    // print_r(array_map(function($v){ return substr($v,0,11); },$arr));
    /*Array
    (
        [0] => 20180000001
        [1] => 20180000044
        [2] => 20180005501
        [3] => 20144000001
    )
    */
    $a1=array("Horse","Dog","Cat");
    $a2=array("Cow","Dog","Rat");
    // print_r(array_map(function($k,$v){ if($k === $v){ return 'same'; }else{ return 'diff'; } },$a1,$a2));
    /*Array
    (
        [0] => diff
        [1] => same
        [2] => diff
    )
    */
    
    // print_r(array_map(function($v){ return strtoupper($v); }, $a1));
    /*Array
    (
        [0] => HORSE
        [1] => DOG
        [2] => CAT
    )
    */
    // print_r(array_map(null,$a1,$a2)); 函数名赋值为null时,返回包含a1,a2的数组
    
    // array_merge(array1,array2) 将两个数组或多个数组合并为一个数组
    // 如果元素有相同的键,则最后的元素会覆盖其他元素
    $a1=array("red","green");
    $a2=array("blue","yellow");
    // print_r(array_merge($a1,$a2));
    /*Array
    (
        [0] => red
        [1] => green
        [2] => blue
        [3] => yellow
    )
    */
    // 如果仅向函数输入一个数组,且键名是整数,将返回带有整数键名的新数组,键名以0开始进行重新索引
    $a=array(3=>"red",4=>"green");
    // print_r(array_merge($a));
    /*Array
    (
        [0] => red
        [1] => green
    )
    */
    
    // array_merge_recursive(array1,array2) 把一个或多个数组合并为一个数组
    // 该函数与 array_merge() 函数的区别在于处理两个或更多个数组元素有相同的键名时,array_merge_recursive() 不会进行键名覆盖,而是将多个相同键名的值递归组成一个数组。
    $a1=array("a"=>"red","b"=>"green");
    $a2=array("c"=>"blue","b"=>"yellow");
    // print_r(array_merge_recursive($a1,$a2));
    /*Array
    (
        [a] => red
        [b] => Array
            (
                [0] => green
                [1] => yellow
            )
    
        [c] => blue
    )
    */
    // 如果仅向 array_merge_recursive() 函数输入一个数组,结果与 array_merge() 相同,函数将返回带有整数键名的新数组,键名以 0 开始进行重新索引
    
    // array_multisort(arr) 函数返回排序数组,输入一个或多个数组,函数先对第一个数组进行排序,接着是其他数组,如果两个或多个值相同,它将对下一个数组进行排序
    // 字符串键名将被保留,但是数字键名将被重新索引,从 0 开始,并以 1 递增
    $a=array("Dog","Cat","Horse","Bear","Zebra");
    array_multisort($a);
    // print_r($a);
    /*Array
    (
        [0] => Bear
        [1] => Cat
        [2] => Dog
        [3] => Horse
        [4] => Zebra
    )
    */
    
    // array_multisort(array1,sorting order,sorting type,array2,array3...)
    /**
     * array1        必需,规定数组
     * sorting order 可选,规定排列顺序,SORT_ASC 默认,升序(A-Z);SORT_DESC 降序(Z-A)
     * sorting type  可选,规定排序类型
     *               SORT_REGULAR - 默认,把每一项按常规顺序排列(Standard ASCII,不改变类型)
     *               SORT_NUMERIC - 把每一项作为数字来处理。
     *               SORT_STRING - 把每一项作为字符串来处理。
     *               SORT_LOCALE_STRING - 把每一项作为字符串来处理,基于当前区域设置(可通过 setlocale() 进行更改)。
     *               SORT_NATURAL - 把每一项作为字符串来处理,使用类似 natsort() 的自然排序。
     *               SORT_FLAG_CASE - 可以结合(按位或)SORT_STRING 或 SORT_NATURAL 对字符串进行排序,不区分大小写
     * 
     */
    // 合并两个数组,并按数字降序排列
    $a1=array(1,30,15,7,25);
    $a2=array(4,30,20,41,66);
    $num=array_merge($a1,$a2);
    array_multisort($num,SORT_DESC,SORT_NUMERIC);
    // print_r($num);
    
    // 多维数组的排序
    $arr = array(
        array('name'=>'lisi','order'=>1),
        array('name'=>'zhangsan','order'=>11),
        array('name'=>'wangwu','order'=>111),
    );
    $arr1 = array_map(create_function('$n', 'return $n["order"];'), $arr);
    array_multisort($arr1,SORT_DESC,$arr );
    // print_r($arr);
    /*Array
    (
        [0] => Array
            (
                [name] => wangwu
                [order] => 13
            )
    
        [1] => Array
            (
                [name] => lisi
                [order] => 12
            )
    
        [2] => Array
            (
                [name] => zhangsan
                [order] => 4
            )
    )
    */
    
    // array_pad(array,size,value) 向array中插入值为value直至array数组个数为size
    $a=array("red","green");
    // print_r(array_pad($a,5,"blue"));
    /* Array
    (
        [0] => red
        [1] => green
        [2] => blue
        [3] => blue
        [4] => blue
    )
    */
    // size设置为负数,函数会在原始数组之前插入新的元素,小于原始数组的长度,函数不会删除任何元素
    // print_r(array_pad($a,-5,"blue"));
    /*Array
    (
        [0] => blue
        [1] => blue
        [2] => blue
        [3] => red
        [4] => green
    )
    */
    
    // array_pop(array) 删除数组中的最后一个元素
    $a=array("red","green","blue");
    array_pop($a);  // 返回数组的最后一个值,如果数组是空的,或者非数组,将返回 NULL
    // print_r($a);
    /*Array
    (
        [0] => red
        [1] => green
    )
    */
    
    // array_product(array) 计算并返回数组的乘积
    $a=array(5,5,2,10);
    // echo(array_product($a));    //500
    
    // array_push(array, var) 向第一个参数的数组尾部添加一个或多个元素,然后返回新数组的长度
    $a=array("red","green");
    // 如果用 array_push() 来给数组增加一个单元,还不如用 $array[] =,因为这样没有调用函数的额外负担
    $a[] = '';
    // print_r($a);
    /*Array
    (
        [0] => red
        [1] => green
        [2] => 
    )*/
    
    array_push($a,"blue","yellow");
    // print_r($a);
    /*Array
    (
        [0] => red
        [1] => green
        [2] => 
        [3] => blue
        [4] => yellow
    )*/
    // 即使数组中有字符串键名,添加的元素也始终是数字键
    $a=array("a"=>"red","b"=>"green");
    array_push($a,"blue","yellow");
    // print_r($a);
    // Array ( [a] => red [b] => green [0] => blue [1] => yellow ) 
    
    // array_rand(arr,num);
    $a=array("red","green","blue","yellow","brown");
    $random_keys=array_rand($a,3);
    // print_r($random_keys);
    /*Array ([0] => 0 [1] => 2 [2] => 3 )
    Array ([0] => 0 [1] => 1 [2] => 3 )
    Array ([0] => 1 [1] => 2 [2] => 4 )*/
    
    // ** array_reduce(arr, function,initial) 向用户自定义函数发送数组中的值,并返回一个字符串
    function myfunction($v1,$v2)
    {
        // $v1 上次的值     $v2 本次的值
        return $v1 . "-" . $v2;
    }
    $a=array("Dog","Cat","Horse");
    // print_r(array_reduce($a,"myfunction"));                             //-Dog-Cat-Horse
    
    // initial 规定发送到函数的初始值
    $a=array("Dog","Cat","Horse");
    // print_r(array_reduce($a,"myfunction",5));                           //5-Dog-Cat-Horse
    
    
    $a=array(10,15,20);
    // print_r(array_sum($a));                                             // 45
    // print_r(array_reduce($a,function($v1,$v2){ return $v1+$v2; },5));   // 50
    // print_r(array_reduce($a,function($v1,$v2){ return $v1*$v2; },5));   // 15000
    // print_r(array_product($a));                                         // 3000
    
    // 2种方法:返回array('id'=>name)
    $user = array(
        0 => array(
            'id' => 1,
            'name' => '张三',
            'email' => 'zhangsan@sina.com',
        ),
        1 => array(
            'id' => 2,
            'name' => '李四',
            'email' => 'lisi@163.com',
        ),
        2 => array(
            'id' => 5,
            'name' => '王五',
            'email' => '10000@qq.com',
        )
    );
    
    foreach($user as $k=>$v){
         $name2[$v['id']] = $v['name'];
    }
    // print_r($name2);
    /*Array
    (
        [1] => 张三
        [2] => 李四
        [5] => 王五
    )
    */
    
    // print_r(array_reduce($user,function($v,$w){ $v[$w['id']] = $w['name'];return $v; }));
    /*Array
    (
        [1] => 张三
        [2] => 李四
        [5] => 王五
    )*/
    
    // 将id作为键,重组数组
    // print_r(array_column($user,null,'id'));
    /*Array
    (
        [1] => Array
            (
                [id] => 1
                [name] => 张三
                [email] => zhangsan@sina.com
            )
        [2] => Array
            (
                [id] => 2
                [name] => 李四
                [email] => lisi@163.com
            )
        [5] => Array
            (
                [id] => 5
                [name] => 王五
                [email] => 10000@qq.com
            )
    )
    */
    
    // array_replace(array, array1) 使用第二个数组的值替换第一个数组的值
    $a1=array("red","green");
    $a2=array("blue","yellow");
    // print_r(array_replace($a1,$a2));
    /*Array
    (
        [0] => blue
        [1] => yellow
    )*/
    
    // 如果一个键存在于 array1 中同时也存在于 array2 中,第一个数组的值将被第二个数组中的值替换、新增
    $a1=array("a"=>"red","b"=>"green");
    $a2=array("a"=>"orange","burgundy");
    // print_r(array_replace($a1,$a2));
    /*Array
    (
        [a] => orange
        [b] => green
        [0] => burgundy
    )
    */
    
    // 如果一个键存在于第二个数组 array2,但是不存在于第一个数组 array1,则会在第一个数组 array1 中创建这个元素
    $a1=array("a"=>"red","green");
    $a2=array("a"=>"orange","b"=>"burgundy");
    // print_r(array_replace($a1,$a2));
    /*Array
    (
        [a] => orange
        [0] => green
        [b] => burgundy
    )
    */
    
    // 使用三个数组 - 最后一个数组($a3)会覆盖之前的数组($a1 和 $a2)
    $a1=array("red","green");
    $a2=array("blue","yellow");
    $a3=array("orange","burgundy");
    // print_r(array_replace($a1,$a2,$a3));
    /*Array
    (
        [0] => orange
        [1] => burgundy
    )
    */
    
    // 使用数值键 - 如果一个键存在于第二个数组中但不在第一个数组中
    $a1=array("red","green","blue","yellow");
    $a2=array(0=>"orange",3=>"burgundy");
    // print_r(array_replace($a1,$a2));
    /*Array
    (
        [0] => orange
        [1] => green
        [2] => blue
        [3] => burgundy
    )
    */
    
    // array_replace_recursive(a1,a2) 递归地使用a2的值替换$a1的值
    $a1=array("a"=>array("red"),"b"=>array("green","blue"),);
    $a2=array("a"=>array("yellow"),"b"=>array("black"));
    // print_r(array_replace_recursive($a1,$a2));
    /*Array
    (
        [a] => Array
            (
                [0] => yellow
            )
    
        [b] => Array
            (
                [0] => black
                [1] => blue
            )
    
    )*/
    
    $a1=array("a"=>array("red"),"b"=>array("green","blue"));
    $a2=array("a"=>array("yellow"),"b"=>array("black"));
    $a3=array("a"=>array("orange"),"b"=>array("burgundy"));
    // print_r(array_replace_recursive($a1,$a2,$a3));
    /*Array
    (
        [a] => Array
            (
                [0] => orange
            )
    
        [b] => Array
            (
                [0] => burgundy
                [1] => blue
            )
    
    )
    */
    
    // array_replace() 与 array_replace_recursive() 的差别
    $a1=array("a"=>array("red"),"b"=>array("green","blue"),);
    $a2=array("a"=>array("yellow"),"b"=>array("black"));
    
    $result=array_replace_recursive($a1,$a2);
    // print_r($result);
    /*Array
    (
        [a] => Array
            (
                [0] => yellow
            )
    
        [b] => Array
            (
                [0] => black
                [1] => blue
            )
    
    )
    */
    $result=array_replace($a1,$a2);
    // print_r($result); // Array ( [a] => Array ( [0] => yellow ) [b] => Array ( [0] => black ) )  
    
    // array_reverse(array1) 以相反的元素顺序返回数组
    $a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
    // print_r(array_reverse($a)); //  Array ( [c] => Toyota [b] => BMW [a] => Volvo )
    
    
    $a=array("Volvo","XC90",array("BMW","Toyota"));
    // print_r($a);
    // Array ( [0] => Volvo [1] => XC90 [2] => Array ( [0] => BMW [1] => Toyota ) )
    $reverse=array_reverse($a);
    // print_r($reverse);
    // Array ([0] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [2] => Volvo )
    
    $preserve=array_reverse($a,true);
    // 第二个参数为true,保留原始键名
    // print_r($preserve);
    // Array ([2] => Array ([0] => BMW [1] => Toyota ) [1] => XC90 [0] => Volvo )
    
    // array_search(needle, arr, strict) 函数在数组中搜索某个键值,并返回对应的键名
    $a=array("a"=>"5","b"=>5,"c"=>"5");
    // echo array_search(5,$a);        // a
    // echo array_search(5,$a,true);   // b
    
    // array_shift(arr) 函数删除数组中第一个元素,并返回被删除元素的值
    $a=array("a"=>"red","b"=>"green","c"=>"blue");
    // echo array_shift($a);   // red
    // print_r ($a);           // Array ( [b] => green [c] => blue ) 
    
    // array_slice(array,start,length,preserve)   在数组中根据条件取出一段值,并返回
    /**
     * array     必需,规定数组
     * start     必需,数值,规定取出元素的开始位置, 0 = 第一个元素
     *           如果该值设置为正数,则从前往后开始取
     *           如果该值设置为负数,则从后向前取 start 绝对值, -2 意味着从数组的倒数第二个元素开始
     *           
     * length    可选,数值,规定被返回数组的长度
     *           如果该值设置为整数,则返回该数量的元素
     *           如果该值设置为负数,则函数将在数组末端length远的地方终止取出
     *           如果该值未设置,则返回从 start 参数设置的位置开始直到数组末端的所有元素
     *           
     * preserve  可选,规定函数是保留键名还是重置键名,可能的值:
     *           true  -   保留键名
     *           false -   默认,重置键名
     * return    返回数组中的选定部分
     */
    $a=array("red","green","blue","yellow","brown");
    // print_r(array_slice($a,2));          //Array ([0] => blue [1] => yellow [2] => brown )
    
    // print_r(array_slice($a,1,2));        // Array ([0] => green [1] => blue )
    
    // print_r(array_slice($a,-2,1));       //Array ([0] => yellow )
    
    // print_r(array_slice($a,1,2,true));   // Array ([1] => green [2] => blue )
    
    // 如果数组有字符串键,所返回的数组将保留键名
    $a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"brown");
    // print_r(array_slice($a,1,2));        // Array ([b] => green [c] => blue )
    
    $a=array("0"=>"red","1"=>"green","2"=>"blue","3"=>"yellow","4"=>"brown");
    // print_r(array_slice($a,1,2));        //Array ([0] => green [1] => blue )
    
    // array_splice(array,start,length,array) 从数组中移除元素,并用新元素取代它
    /**
     * array    必需,规定数组
     * start    必需,数值,规定删除元素的开始位置
     *          0 = 第一个元素
     *          如果该值设置为正数,则从数组中该值指定的偏移量开始移除
     *          如果该值设置为负数,则从数组末端倒数该值指定的偏移量开始移除
     *          -2 意味着从数组的倒数第二个元素开始
     * length   可选,数值,规定被移除的元素个数,也是被返回数组的长度
     *          如果该值设置为正数,则移除该数量的元素
     *          如果该值设置为负数,则移除从 start 到数组末端倒数 length 为止中间所有的元素
     *          如果该值未设置,则移除从 start 参数设置的位置开始直到数组末端的所有元素
     * array    可选,规定带有要插入原始数组中元素的数组
     *          如果只有一个元素,则可以设置为字符串,不需要设置为数组
     * return   返回由被提取元素组成的数组
     */
    
    // 返回由被提取元素组成的数组
    $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
    $a2=array("a"=>"purple","b"=>"orange");
    // print_r(array_splice($a1,0,2,$a2)); // Array ([a] => red [b] => green )
    array_splice($a1,0,2,$a2);
    // print_r($a1); // Array ([0] => purple [1] => orange [c] => blue [d] => yellow )
    array_splice($a1,1,0,$a2);
    // print_r($a1); 
    // Array ([a] => red [0] => purple [1] => orange [b] => green [c] => blue [d] => yellow )
    
    // array_sum($arr) // 返回数组中所有值的和
    
    // array_unique($a1)    删除数组中的重复值。
    $a=array("a"=>"red","b"=>"green","c"=>"red");
    // print_r(array_unique($a));   // Array ([a] => red [b] => green )
    
    // array_unshift(array, var)   将var插入到array开头
    array_unshift($a, 'blue');
    // print_r($a);                 // Array ([0] => blue [a] => red [b] => green [c] => red )
    
    // array_values(arr)    返回数组的所有值
    $a=array("Name"=>"Bill","Age"=>"60","Country"=>"USA");
    // print_r(array_values($a));   // Array ([0] => Bill [1] => 60 [2] => USA )
    
    // array_walk(array,myfunction,userdata...) 对数组中的每个元素应用用户自定义函数
    
    $a=array("a"=>"red","b"=>"green","c"=>"blue");
    // array_walk($a,function($v,$k){ echo "The key $k has the value $v \n"; });
    /*The key a has the value red 
    The key b has the value green 
    The key c has the value blue*/
    
    // 设置一个参数
    // array_walk($a,function($v,$k,$p){ echo "$k $p $v \n"; },'has the value');
    /*a has the value red 
    b has the value green 
    c has the value blue 
    */
    
    // 更改一个数组元素的值(请注意 &$value)
    array_walk($a,function(&$v){ $v='555'; });
    // print_r($a);         Array ([a] => 555 [b] => 555 [c] => 555 )
    
    // array_walk_recursive(input, funcname) 对数组中的每个元素应用用户自定义函数
    function myfunctions($value,$key)
    {
    echo "键 $key 的值是 $value 。\n";
    }
    $a1=array("a"=>"red","b"=>"green");
    $a2=array($a1,"1"=>"blue","2"=>"yellow");
    // array_walk_recursive($a2,"myfunctions");
    /*键 a 的值是 red 。
    键 b 的值是 green 。
    键 1 的值是 blue 。
    键 2 的值是 yellow 。
    */
    
    $age=array("Steve"=>"56","Bill"=>"60","Mark"=>"31");
    sort($age);     // 按照值对关联数组进行升序排序,不保持索引关系
    // print_r($age);  Array ([0] => 31 [1] => 56 [2] => 60 )
    
    asort($age);    // 按照值对关联数组进行升序排序,保持索引关系
    // print_r($age);   Array ([Mark] => 31 [Steve] => 56 [Bill] => 60 )
    
    rsort($age);    // 按照值对关联数组进行降序排序,不保持索引关系
    // print_r($age);  Array ([0] => 60 [1] => 56 [2] => 31 )
    
    arsort($age);   // 按照值对关联数组进行降序排序,保持索引关系
    // print_r($age);Array ([Bill] => 60 [Steve] => 56 [Mark] => 31 )
    
    ksort($age);    // 按照键对关联数组进行升序排序,保持索引关系
    // print_r($age);  Array ([Bill] => 60 [Mark] => 31 [Steve] => 56 )
    
    krsort($age);   // 按照键对关联数组进行降序排序,保持索引关系
    // print_r($age);  Array ([Steve] => 56 [Mark] => 31 [Bill] => 60 )
    
    // compact(var1,var2...)    创建一个包含变量名和它们的值的数组
    $firstname = "Bill";
    $lastname = "Gates";
    $age = "60";
    $result = compact("firstname", "lastname", "age");
    
    // print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )
    
    // 使用不匹配变量的字符串,以及一个变量名数组:
    $name = array("firstname", "lastname");
    $result = compact($name, "location", "age");
    
    // print_r($result);Array ([firstname] => Bill [lastname] => Gates [age] => 60 )
    
    // count(array,mode)       // 返回数组中元素的数目,mode为1时计算多维数组中的所有元素
    $cars=array("Volvo","BMW","Toyota");
    // echo count($cars);   //3
    
    $people = array("Bill", "Steve", "Mark", "David");
    
    // echo current($people) . "\n";    // 当前元素是 Bill
    // echo next($people) . "\n";       // Bill 的下一个元素是 Steve
    // echo current($people) . "\n";    // 现在当前元素是 Steve
    // echo prev($people) . "\n";       // Steve 的上一个元素是 Bill
    // echo end($people) . "\n";        // 最后一个元素是 David
    // echo prev($people) . "\n";       // David 之前的元素是 Mark
    // echo current($people) . "\n";    // 目前的当前元素是 Mark
    // echo reset($people) . "\n";      // 把内部指针移动到数组的首个元素,即 Bill
    // echo next($people) . "\n";       // Bill 的下一个元素是 Steve
    
    // print_r (each($people)); // 返回当前元素的键名和键值(目前是 Steve),并向前移动内部指针
    
    $a = "Original";
    $my_array = array("a" => "Cat", "b" => "Dog", "c" => "Horse");
    
    extract($my_array, EXTR_PREFIX_SAME, "dup");
    
    // echo "\$a = $a; \$b = $b; \$c = $c; \$dup_a = $dup_a \n";
    
    // in_array(search,array,type) 搜索数组中是否存在指定的值
    /*search 必需,规定要在数组搜索的值
    array 必需,规定要搜索的数组
    type 可选,如果设置该参数为 true,则检查搜索的数据与数组的值的类型是否相同*/
    
    // list()  将数组中的值赋给一些变量
    $my_array = array("Dog","Cat","Horse");
    
    list($a, $b, $c) = $my_array;
    // echo "I have several animals, a $a, a $b and a $c.";
    // I have several animals, a Dog, a Cat and a Horse.
    list($a, , $c) = $my_array;
    // echo "我在这里只用了 $a 和 $c 变量。";
    // 我在这里只用了 Dog 和 Horse 变量。
    
    
    // natcasesort() 函数用"自然排序"算法对数组进行排序,键值保留它们原始的键名
    $temp_files = array("temp15.txt","Temp10.txt", "temp1.txt","Temp22.txt","temp2.txt");
    
    natsort($temp_files);
    // echo "自然排序:"; print_r($temp_files); echo "\n";
    // 自然排序:Array ([1] => Temp10.txt [3] => Temp22.txt [2] => temp1.txt [4] => temp2.txt [0] => temp15.txt )
    
    natcasesort($temp_files);
    // echo "不区分大小写的自然排序:"; print_r($temp_files);echo "\n";
    // 不区分大小写的自然排序:Array ([2] => temp1.txt [4] => temp2.txt [1] => Temp10.txt [0] => temp15.txt [3] => Temp22.txt )
    
    // range(low,high,step)    返回包含从 low 到 high , step步长的元素的数组
    $letter = range("a","d");
    // print_r ($letter);  Array ([0] => a [1] => b [2] => c [3] => d )
    $number = range(1,50,10);
    // print_r ($number);  Array ([0] => 1 [1] => 11 [2] => 21 [3] => 31 [4] => 41 )
    
    // shuffle() 把数组中的元素按随机顺序重新排列
    $my_array = array("red","green","blue","yellow","purple");
    
    shuffle($my_array);
    // print_r($my_array); Array ([0] => yellow [1] => purple [2] => red [3] => green [4] => blue )
    
    $my_array = array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"purple");
    shuffle($my_array);
    // print_r($my_array); Array ([0] => yellow [1] => red [2] => blue [3] => purple [4] => green )
    
    // sizeof()    count() 的别名
    
    
    // 重置数组键的几种方法:
    array_column($arr,null);
    
    // 配合first_name的值重置数组键
    array_column($arr,null,'first_name');
    
    // 键名是整数,重置数组键
    array_merge($arr);
    array_merge_recursive($arr);
    
    
    展开全文
  • 数组深化

    2019-02-22 14:45:54
    多维数组 二维数组的定义 二维数组就是存储一维数组(内存地址/引用)的数组 public class TestArray { public static void main(String[] args) { //数组可以存储基本数据类型和引用数据类型 int [] ...

    多维数组

    二维数组的定义

    二维数组就是存储一维数组(内存地址/引用)的数组

    public class TestArray {
    	public static void main(String[] args) {
    		//数组可以存储基本数据类型和引用数据类型
    		int [] arrA = {11,22,33,44}; //一维数组,应用数据类型
    		/**数据类型 [] 数组名 = new 数据类型[长度]*/
    		System.out.println(arrA);//[I@7852e922
    		//二维数组:存储一维数组的数组
    		int [] [] arrB = new int[3][];
    		//使用二维数组去存储一维数组
    		arrB[0] = arrA;//引用
    		System.out.println(arrB);//[[I@4e25154f
    	}
    }
    

    在这里插入图片描述

    二维数组的初始化

    package com.java.array;
    
    public class TestArray2 {
    	public static void main(String[] args) {
    		//二维数组不是规则的矩阵
    		int [] intA[] = {{1,2},{2,3,4},{3,4,5,6}};
    		System.out.println(intA);
    		
    		//声明一个二维数组,用于存储3个一维数组,每一个一维数组存多少个数组,不知道
    		int [][] intB = new int[3][];
    		intB[0] = new int[3];
    		intB[1] = new int[] {1,2,3,4};
    		intB[2] = new int[2];
    		System.out.println(intB);
    		
    		//声明一个二维数组,同时创建出一维数组,每个一维数组的长度均相同
    		//声明三个一维数组,每个一维数组的长度为4
    		int []intC[] = new int[3][4];
    		System.out.println(intC);
    	}
    }
    
    

    二维数组的遍历

    package com.java.array;
    
    public class TestArray3 {
    	public static void main(String[] args) {
    		//二维数组
    		int [] intA[] = {{1,2},{2,3,4},{3,4,5,6}};
    		//普通for循环
    		for(int i=0;i<intA.length;i++) {
    			for(int j=0;j<intA[i].length;j++) {
    				System.out.print(intA[i][j]+"\t");
    			}
    			System.out.println();
    		}
    		//加强for循环
    		for(int[] arr:intA) { //int[]:二维数组中元素的类型,arr迭代变量,intA二维数组的名称
    			for(int i:arr) {	//int:一维数组中元素的类型,i:迭代变量,arr,一维数组的名称
    				System.out.print(i+"\t");
    			}
    			System.out.println();
    		}
    		//普通与加强for循环的混搭
    		for(int[] arr:intA) {
    			for(int i = 0;i<arr.length;i++) {
    				System.out.print(arr[i]+"\t");
    			}
    			System.out.println();
    		}
    		for(int i=0;i<intA.length;i++) {
    			for(int j:intA[i]) {
    				System.out.print(j+"\t");
    			}
    			System.out.println();
    		}
    	}
    }
    
    

    多维数组

    二维数组是存储一维数组的数组
    三维数组,存储二维数组的数组
    四维数组,存储三维数组的数组

    对象数组存储表格数据

    在这里插入图片描述

    public class TestArray {
    	public static void main(String[] args) {
    		Person[] pers = new Person[3];
    		Person p1 = new Person("张三", 19, "男");
    		pers[0] = p1;
    		pers[1] = new Person("李四", 20, "女");
    		pers[2] = new Person("王五",28,"男");
    		for(int i = 0;i<pers.length;i++) {
    			System.out.println(pers[i]);
    		}			
    	}
    }	
    

    在这里插入图片描述

    3.数组的拷贝

    3.1地址的拷贝

    public class TestArrayCopy {
    	public static void main(String[] args) {
    		int[] arrA = {11,22,33,44};
    		int[] arrB = new int[5];
    		System.out.println("拷贝之前arrA的地址="+arrA);
    		System.out.println("拷贝之前arrB的地址="+arrB);
    		
    		arrB = arrA;
    		System.out.println("拷贝之后arrA的地址="+arrA);
    		System.out.println("拷贝之后arrB的地址="+arrB);
    	}	
    }
    

    在这里插入图片描述

    3.2值的拷贝

    public class TestArrayCopy2 {
    	public static void main(String[] args) {
    		int[] arrA = {11,22,33,44};
    		int[] arrB = new int[5];
    		
    		int length = Math.min(arrA.length, arrB.length);
    		for(int i=0;i<length;i++) {
    			arrB[i]=arrA[i];
    		}
    		for(int i:arrB) {
    			System.out.println(i);
    		}
    	}
    }
    

    3.3 System类中的arraycopy方法

    public class TestArrayCopy3 {
    	public static void main(String[] args) {
    		int[] arrA = {11,22,33,44};
    		int[] arrB = new int[5];
    		
    		System.arraycopy(arrA, 0, arrB, 0, 4);
    		for(int i:arrB) {
    			System.out.println(i);
    		}
    	}
    }
    

    4.java.util.Arrays工具类的使用

    4.1Arrays类中的常用方法

    1. toSting()打印数组
    2. equals()比较两个数组是否相同
    3. copyOf()复制指定的数组(效率低,开辟空间)
    4. fill()填充
    5. sort()数组排序 升序排序(排序的对象具备比较大小的能力)‘’
      对象数组的排序 (需要编写比较的规则)
    import java.util.Arrays;
    
    public class TestArraysMethod {
    	public static void main(String[] args) {
    		//创建了一个一维数组
    		int[] arrA = {11,22,33,44,55};
    		int[] arrB = {11,22,33,44,55};
    		//Arrays.toString(数组名),快速的遍历数组元素
    		System.out.println(Arrays.toString(arrA));
    		System.out.println("arrA==arrB:"+(arrA==arrB));//false
    		//两个数组以相同的顺序包含相同的元素
    		System.out.println(Arrays.equals(arrA, arrB));//true
    		//Arrays.equals与Object中的equals方法有什么不同?
    		System.out.println(arrA.equals(arrB));//false
    		
    		//copyof()
    		int[] arrC = new int[5];
    		System.out.println("前"+arrC);
    		
    		arrC = Arrays.copyOf(arrA, 10);//重新开辟空间
    		System.out.println("后"+arrC);
    		System.out.println(Arrays.toString(arrC));
    		
    		//填充
    		Arrays.fill(arrC, 99);
    		System.out.println(Arrays.toString(arrC));
    		
    		int[] arrD = {5,4,3,2,1};
    		//对arrA数组进行排序--->升序
    		Arrays.sort(arrD);
    		System.out.println(Arrays.toString(arrD));
    		
    		Person[] pers = new Person[3];
    		pers[0] = new Person("marry",20,"女");
    		pers[1] = new Person("jack",22,"男");
    		pers[2] = new Person("rose",19,"女");
    		Arrays.sort(pers);
    		for(Person i:pers) {
    			System.out.println(i);
    		}
    	}
    }	
    class Person implements Comparable<Person>{
    	private String name;
    	private int age;
    	private String gender;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getGender() {
    		return gender;
    	}
    	public void setGender(String gender) {
    		this.gender = gender;
    	}
    	public Person(String name, int age, String gender) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.gender = gender;
    	}
    	public Person() {
    		super();
    	}
    	@Override
    	public String toString() {
    		return name + "\t" + age + "\t" +gender;
    	}
    	@Override
    	public int compareTo(Person o) {
    		// TODO Auto-generated method stub
    		return this.age-o.age;
    	}
    	
    }
    

    冒泡排序的基础算法

    1. 如有一个数列有 N(5)个元素,则至多需要 N-1(4)趟循环才 能保证数列有序
    2. 每一趟循环都从数列的第一个元素开始比较,依次比较相 邻的两个元素,比较到数列的最后
    3. 如果前一个元素大于后一个元素,则使用第三变量交换
      在这里插入图片描述
    public class TestBubble {
    	public static void main(String[] args) {
    		int[] arr = {75,87,56,45,49};
    		System.out.println(Arrays.toString(arr));
    		for(int i = 0;i<arr.length-1;i++) { //比较的轮数
    			for(int j = 0;j<arr.length-1;j++) {	//每轮比较的次数
    				if(arr[j]>arr[j+1]) {
    					int temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    				
    			}
    		}
    		System.out.println(Arrays.toString(arr));
    	}
    }
    

    冒泡排序的优化算法

    public class TestBubble {
    	public static void main(String[] args) {
    		int[] arr = {75,87,56,45,49};
    		
    		int temp;
    		boolean flag;
    		int count = 0;
    		
    		for(int i=0;i<arr.length-1;i++) {
    			flag = true;
    			count++;
    			for(int j=0;j<arr.length-1-i;j++) {
    				if(arr[j]>arr[j+1]) {
    					temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    					flag = false;
    				}
    			}
    			if(flag) {
    				break;
    			}
    		}
    		System.out.println("总共用了"+count+"轮");
    		System.out.println(Arrays.toString(arr));
    	}
    }
    

    折半查找算法

    在这里插入图片描述
    在这里插入图片描述

    import java.util.Arrays;
    
    public class TestBinarySearch {
    	public static void main(String[] args) {
    		int[] arr = {5,13,19,21,37,56,64,75,80,88,92};
    		System.out.println(Arrays.binarySearch(arr, 21));//找到,返回索引
    		System.out.println(Arrays.binarySearch(arr, 85));//找不到,-插入点-1
    		System.out.println(TestBinarySearch.binary(arr, 21));
    		System.out.println(TestBinarySearch.binary(arr, 85));
    		
    	}
    	public static int binary(int[] arr,int key){
    		int low = 0;
    		int high = arr.length;
    		int mid = (low+high)>>>1;
    		while(low<high) {
    			mid = (low+high)>>>1;
    			if(arr[mid]>key) {
    				high=mid-1;
    			}else if(arr[mid]<key) {
    				low=mid+1;
    			}else {
    				return mid;
    			}
    		}
    		return -low-1;
    	}
    }
    
    展开全文
  • 文章目录二维数组二维数组的创建与访问数组方法位移元素数组排序 二维数组 二维数组是内部元素为数组的数组,二维数组常用于当数据有一定的数据逻辑时,比如表示矩阵或者创建表格的时候。 二维数组的创建与访问 创建...

    二维数组

    二维数组是内部元素为数组的数组,二维数组常用于当数据有一定的数据逻辑时,比如表示矩阵或者创建表格的时候。

    二维数组的创建与访问

    • 创建

    二维数组的创建与普通数组的创建并没有太大区别,只不过是将内部的元素替换成中括号包括的另一个未命名数组。或者将已创建好的数组赋值给二维数组。

    示例:

    var fruits = [["1", "Banana"], ["2", "Orange"]];
    var element = ["3", "Apple"];
    fruits[2] = element;
    
    • 访问

    二维数组的访问方式也和普通数组没有太大区别,但是需要注意如果只输入一个下标的话访问的只会是二维数组中存的数组,需要用两个下标来访问二维数组中某数组的具体元素。

    示例:

    fruits[0] // ["1", "Banana"]
    fruits[0][1] // "Banana"
    
    • 遍历

    二维数组的遍历需要使用双重循环来实现,一层循环用于遍历二维数组中储存的数组,一层循环用于遍历二维数组中所存数组的具体元素。

    示例:

    for(var i in fruits){
    	for(var j in fruits[i]){
    		console.log(fruits[i][j]);
    	}
    }
    
    • 添加

    二维数组同样可以使用数组中提供的各种方法,比如pop()和push()等方法(具体使用方法见上期)

    示例:

    var arr = [["1","Banana"],["2","Orange"]]
    var element = ["3","Apple"]
    arr.push(element)
    

    数组方法

    JS数组真正的力量隐藏在数组方法之中。这里主要介绍元素位移和数组排序两种。

    位移元素

    • shift()
      删除首个数组元素并返回被删除的元素,同时把所有其他元素“位移”到更低的索引

    示例:

    var fruits = ["Banana", "Orange", "Apple", "Mango"];  
    var x = fruits.shift();
    //fruits的值是[“Orange”, “Apple” , “Mango”]; x的值是"Banana"
    
    • unshift()
      向数组的开头添加一个或更多元素并返回新的长度,同时把所有其他元素“位移”到更高的索引

    示例:

    var fruits = ["Orange", "Apple", "Mango"];  
    var x = fruits.unshift("Banana");
    //fruits的值是[“Banana”, “Orange”, “Apple” , “Mango”]; x的值是4
    

    数组排序

    JS的数组排序方法有很多种,除了使用系统自带的排序方法之外,还可以用户自己定义排序规则。

    • reverse()
      点到数组中元素的顺序,并返回数组。

    示例:

    var fruits = ["Banana", "Orange", "Apple", "Mango"];  
    var x = fruits.reverse();
    //x和fruits的值均为[“Mango”, “Apple”, “Orange”, “Banana”]
    
    • sort() 对数组的元素进行排序,并返回数组

    示例:

    var fruits = ["Banana", "Orange", "Apple", "Mango"];  
    var x = fruits.sort();
    //x和fruits的值均为[“Apple”, “Banana”, “Mango” , “Orange”]
    

    sort()排序的规则如下:
    对字符串排序,从左至右逐字比较(ASCII码顺序)

    如[“a”, “A”, “1”], 按ASCII码顺序排列后为[“1”, “A”, “a”]。(数字>大写字母>小写字母)

    如[“ab”, “ac”, “abc”], 排序后为[“ab”, “abc”, “ac”]。
    (第一位相同比较第二位,b>c,因此ab和abc在ac之前;再比较ab与abc, ab没有第三位,因此排在abc之前)

    对字符串形式的数字,排序规则不变,如[“10”, “5”, “18” , “50”], 排序后为[“10”, “18”, “5”, “50”]

    如需要对字符串形式的数字进行排序,采用以下两种方式

    统一格式,补足位数,如[“10”, “5”, “18” , “50”]中, 将“5”写为“05”

    转换为数字,使用特殊方法对数字排序

    • 自定义排序(数字)
      自定义函数定义排序方法,在使用的时候嵌套进sort()中,该比较函数的名字可为任意,也可直接在sort()内写匿名函数作为参数

    示例:

    function sortby(a, b) {  
        return a - b //升序
    }  
    var arr = [10,5,8,50];
    arr.sort(sortby)  //[5,8,10,50]
    
    function sortby(a, b) {  
        return b - a //降序
    }  
    var arr = [10,5,8,50];
    arr.sort(sortby)  //[50,10,8,5]
    
    arr.sort(function (a, b) {  
        return a - b 
    }) 
    
    • 自定义排序(多维数组)
      需要对多维数组中的值进行排序时,可借助比较函数sortby,根据比较函数的返回值为正或为负决定排列顺序。

    示例:

    var arr = [["Alice", "95"], ["Bob", "80"], ["Cart", "100"]];
    function sortby(a,b){
        return a[1]-b[1]
    }
    arr.sort(sortby)
    
    展开全文
  • 数组是对大量数据进行有效组织和管理的手段之一,通过数组的强大功能,可以对大量性质相同的数据进行存储、排序、插入及删除等操作,从而可以有效地提高程序开发效率及改善程序的编写方式。 数组:是一组有序成员...
  • JS数组(Array)应用大全!!!

    万次阅读 2018-07-18 20:01:31
    【书山有路勤为径,学海无涯苦作舟】 ...一、生成数组 1、使用Array构造函数: var arr = new Array(10); //创建一个包含10项的数组 2、使用数组字面量表示法: var arr1 = [10]; // console.log(arr) ...
  • php 二维数组排序

    2017-08-11 15:55:19
    例如像下面的数组: 代码如下: $users = array( array('name' => 'tom', 'age' => 20) , array('name' => 'anny', 'age' => 18) , array('name' => 'jack', 'age' => 22) ); 希望能按照age从小...
  • JS数组(Arry)应用大全

    千次阅读 2018-09-13 18:06:46
    一、生成数组 1、使用Array构造函数: var arr = new Array(10); //创建一个包含10项的数组 2、使用数组字面量表示法: var arr1 = [10]; // console.log(arr) //[] // console.log(arr1) //[10] 二、数组方法...
  • js数组方法

    2019-09-27 16:58:00
    JavaScript中创建数组有两种方式 (一)使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组var arr2 = new Array(20); // 创建一个包含20项的数组var arr3 = new Array("lily","lucy","Tom"); // ...
  • 数组

    2014-07-16 19:09:28
    第八章 数组 1.C语言中数组的下标都是从0开始,数组名代表数组的首地址; 2.定义数组时,不能使用变量定义数组的大小,而只能用整型常量; 3.一维数组的定义格式:类型 数组名[元素个数];  二维数组的定义格式:类型...
  • 分享一个php数组排序的例子,介绍了和php,有关的知识、技巧、经验,和一些php源码等。 class='pingjiaF' frameborder='0' src='...对数组排序 usort() 函数使用用户自定义的函数对数组排序。 */ funct
  • 题集链接 目录:OPA Ultra-QuickSort题目大意思路代码B Stars题目大意思路代码C Mobile phones题目大意思路代码D Cows题目大意思路代码E Get Many Persimmon Trees题目大意思路代码F Matrix...感谢ph和zsl两位大佬的指
  • 我们需要将一个数组内的元素顺序进行打乱,达到随机排序的目的。首先想到的是 Math.random() 方法结合数组的 sort() 方法。 Math.random() 结合 sort() 方法 Math.random() 方法用于产生一个介于 0 和 1 之间的...
  • 【PHP学习】数组

    2015-07-20 09:55:08
    多维数组书上这块只是略微提了下,我这里再补充下: 二维数组标准例子$families = array ( "Griffin"=>array ( "Peter", "Lois", "Megan" ), "Quagmire"=>array ( "Glenn" ), "Brown"=>array ( "Cleveland", ...
  • (4) TreeMap:TreeMap实现SortedMap接口,能够把它保存的记录根据键排序,默认是按键值的升序排序,也可以指定排序的比较器,当用Iterator遍历TreeMap时,得到的记录是排过序的。如果使用排序的映射,建议使用...
  • 我们要如何存储这个堆了,显然我们需要一个数组,然后通过写算法实现这个堆的顺序存储。 这里主要说一下堆的升序与降序,以及初始化,插入删除吧。 堆其实理解起来相比二叉树的链式存储要容易很多,堆升序时候...
  • 9.1 数组的分类 在PHP中,更具数组提供下标的不同方式,将数组分为索引数组(indexed)和关联数组(associative)两种。索引数组的索引值是整数,而关联数组是以字符串作为索引值。 9.2 数组的定义 9.2.1 直接赋值的...
  • YTU 2436: C++ 习题 输出日期时间--友元类2016年02月23 - 2436: C++ 习题 输出日期时间--友元类时间限制: 1 Sec 内存限制: 128 ...对象数组输入与输出)2017年06月06 - 题目描述建立一个对象数组,内放n(n<10)个学...
  • jdk1.7中底层是由数组(也有叫做“位桶”的)+链表实现;jdk1.8中底层是由数组+链表/红黑树实现 可以存储null键和null值,线程不安全。在HashMap中,null可以作为键,这样的键只有一个,但可以有一个或多个键所对应...
  • 排序链表 给你链表的头结点 head ,请将其按 升序 排列并返回 排序后的链表 。 输入:head = [4,2,1,3] 输出:[1,2,3,4] 归并排序:1.快慢指针找到中点2.递归调用sort()继续分成两半3.分到最底层的时候开始两两合并...
  • HashMap在Jdk1.7和1.8中的实现

    千次阅读 2019-11-21 18:01:30
    当Map中元素总数超过Entry数组的75%,触发扩容操作,为了减少链表长度,元素需分配更均匀 1.7中是 先扩容后插入 新值的,1.8中是 先插值再扩容 为什么说HashMap是线程不安全的? 在接近临界点时,若此时两个...
  • 我当时提出的解决方案是:将生成的随机数(数组的随机下标)放在一个数组中,每次对新生成的随机数首先判断是否已经存在,如果不存在就加入这个数组,如果存在就重新生成随机数,直到这个数组中的元素个数到达一个...
  • js sort 二维数组排序用法

    千次阅读 2012-06-26 10:43:10
    最近在搞js 排序的问题,因为数据库排序太耗资源,如果能转移到客户端去排序...我们知道在js中默认提供了sort函数,但是这个函数默认是按照数组内容的ascii码升序进行排列的,如果我们要对二维数组排序要如何做呢?在ph
  • Dart语法篇之基础语法(一)

    千次阅读 2019-10-24 23:49:33
    print(url.indexOf("ph")); //获取指定字符的索引位置, 类似Java和Kotlin print(url.contains("http")); //字符串是否包含指定字符, 类似Java和Kotlin print(url.trim()); //去除字符串的首尾空格, 类似Java和...
  • oracle学习文档 笔记 全面 深刻 详细 通俗易懂 doc word格式 清晰 第一章 Oracle入门 一、 数据库概述 数据库(Database)是按照数据结构来组织、存储和管理数据的仓库,它产生于距今五十年前。...
  • } 定义结构体数组 sturct 结构体名 {成员列表} 数组名【数组长度】; struct Person { char name[20]; int count; }leader[3]; 结构体类型 数组名【数组长度】; struct Person leader[3]; 定义结构体数组 【例9.3】...
  • 初学C语言之-指针

    2020-12-11 14:06:06
    } } average函数中形参stu是一个整型指针,实参传递的是数组名score,数组名是一个地址常量,stu接收实参数组元素的地址后,就指向了score数组的存储空间,在average函数中,通过指针stu来逐个访问数组元素,实现...
  • 面试高频题

    2021-03-16 20:58:20
    //归并函数 void merge(int *R, int low, int mid,int high) { //需要定义一个额外的数组,临时存放归并的结果 int maxSize = high - low + 1; int temp[7];//这里的大小是原数组的大小 for(int k=0;k;k++) ...
  • sql 开发 取中位数

    2022-03-23 16:48:36
    分析:1).Cast(ph_score AS DECIMAL(5, 2)) sp //格式转换不用解释 Row_number() OVER ( PARTITION BY dept_name ORDER BY ph_score ASC, e_id ASC) AS RowAsc //根据dept_name分组,按照ph_score 升序排序,RowAsc...
  • PH值越接近7越好;细菌总数越少越好;植物营养物量介于10-20之间最佳,超过20或低于10均不好。 (1)原始矩阵正向化 1.1 常见的四种指标 原始矩阵正向化就是将所有的指标类型统一转化为极大型指标 1.2 指标转换方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 442
精华内容 176
关键字:

ph 数组升序