Arrays---工具类

数组Array

概念:

  • 数组Array是用于储存多个相同类型数据的集合。
  • 想要获取数组中的元素值,可以通过元素的下标来获取,下标是从0开始的。

创建数组

  • 动态初始化:

int[ ] a = new int[5];

在这里插入图片描述

  • 静态初始化:

1:int[ ] a ={1,2,3,4,5,6,7,8};

2:int[ ] a =new int[ ]{1,2,3,4,5};

二维数组

存放数组的数组,也就是说数组里存的还是数组的数据形式。

在这里插入图片描述

int[ ][ ] deepArray = new int[ ][ ]{{1, 3},{2, 4}};

工具类—Arrays

  • 此静态类专门用来操作array ,提供搜索、排序、复制等静态方法。
    在这里插入图片描述

数组转字符串

  • Arrays.toString()
int[] array = new int[]{1, 2, 3};
out.println(Arrays.toString(array)); //[1, 2, 3]
  • deepToString()
    如果是一维数组,toString方法可以很好的适用。但遇到多维数组时,需要使用deepToString把数组完全转成字符串。
int[][] deepArray = new int[][]{{1, 3},{2, 4}};
out.println(Arrays.toString(deepArray)); //[[I@1540e19d, [I@677327b6]
out.println(Arrays.deepToString(deepArray)); //[[1, 3], [2, 4]]

填充数组

  • Arrays.fill()
array = new int[5];
Arrays.fill(array, 2);
out.println(Arrays.toString(array)); //[2, 2, 2, 2, 2]

array = new int[5];
Arrays.fill(array, 1, 4, 2); //部分填充
out.println(Arrays.toString(array));//[0, 2, 2, 2, 0]

数组元素排序

  • Arrays.sort()
array = new int[]{3, 10, 4, 0, 2};
Arrays.sort(array);
out.println(Arrays.toString(array)); //[0, 2, 3, 4, 10]

array = new int[]{3, 10, 4, 0, 2};
Arrays.parallelSort(array); //和sort相比是这个是并行的
out.println(Arrays.toString(array)); //[0, 2, 3, 4, 10]

array = new int[]{3, 10, 4, 0, 2};
Arrays.sort(array, 0, 4); //部分排序
out.println(Arrays.toString(array)); //[0, 3, 4, 10, 2]

数组的比较

  • Arrays.equals(array, array2))
array = new int[]{1, 2, 3};
int[] array2 = new int[]{1, 2, 3};
out.println(Arrays.equals(array, array2)); //true
  • Arrays.deepEquals(deepArray1, deepArray2)
    和toString方法一样,equals方法遇到多维数组时也会出现问题。
int[][] deepArray1 = new int[][]{{1, 3},{2, 4}};
int[][] deepArray2 = new int[][]{{1, 3},{2, 4}};
out.println(Arrays.equals(deepArray1, deepArray2)); //false
out.println(Arrays.deepEquals(deepArray1, deepArray2)); //true
  1. deepEquals用于判定两个指定数组彼此是否深层相等,此方法适用于任意深度的嵌套数组。
  2. equals用于判定两个数组是否相等,如果两个数组以相同顺序包含相同元素,则返回true。
  3. 如果两个数组使用equals返回true,则使用deepEquals必定也返回true,也就是说在比较的两个数组均为一维数组的前提下,equals和deepEquals的比较结果没有差别。

数组复制

  • Arrays.copyOf(array, n);
array = new int[]{3, 10, 4, 0, 2};
int[] arrayCopy = Arrays.copyOf(array, 3);
out.println(Arrays.toString(arrayCopy)); //[3, 10, 4]

arrayCopy = Arrays.copyOf(array, 7);
out.println(Arrays.toString(arrayCopy)); //[3, 10, 4, 0, 2, 0, 0], 多出的长度补0

arrayCopy = Arrays.copyOfRange(array, 1, 4);
out.println(Arrays.toString(arrayCopy)); //[10, 4, 0]

数组转List

  • Arrays.asList(array)
int array = new int[]{3, 10, 4, 0, 2};
out.println(Arrays.asList(array).contains(3)); //false

Integer arr[] = new Integer[]{3, 10, 4, 0, 2};
out.println(Arrays.asList(arr).contains(3)); //true

这里是比较有意思的地方,实际上拆开来看是这样的

int array = new int[]{3, 10, 4, 0, 2};
List<int[]> ints = Arrays.asList(array);

Integer arr[] = new Integer[]{3, 10, 4, 0, 2};
List integers= Arrays.asList(arr);

  • 原始数据类型int的数组调用asList之后得到的List只有一个元素,这个元素就是元素类型的数组。
  • 封装类Integer数组调用asList是把数组中每个元素加到了List中。

二分查找返回下标

  • Arrays.binarySearch(array, n)
array = new int[]{0, 3, 4, 10, 20};
out.println(Arrays.binarySearch(array, 10)); //3, array必须是排序的,否则得到的是错误的结果
out.println(Arrays.binarySearch(array, 6)); //-4, 找不到的值,从-1开始,6如果存在下标是3, 所以返回-4
out.println(Arrays.binarySearch(array, 2, 5, 10)); //3, 返回的还是全局的下标值。

对数组元素采用指定的方法计算

array = new int[]{3, 10, 4, 0, 2};
Arrays.parallelPrefix(array, (x,y)->(x+y)); //[3, 13, 17, 17, 19]
out.println(Arrays.toString(array));

array = new int[]{3, 10, 4, 0, 2};
Arrays.parallelSetAll(array, (x)->(x*x)); //[0, 1, 4, 9, 16]
out.println(Arrays.toString(array));

Arrays.setAll(array, (x)->(x%3));
out.println(Arrays.toString(array)); //[0, 1, 2, 0, 1], 与parallelSetAll相比只是不并行

自定义排序规则

String[] names = {"tom", "alice", "fred"};
Arrays.sort(names);
out.println(Arrays.toString(names));

假如想根据字符串的长度而不是根据字典顺序对字符串排序,但是String类我们是无法修改的。上面的代码对String数组进行排序,只能按照字典顺序对String数组进行排序。

Arrays.sort方法和Collections.sort方法都提供了一个可以接收Comparator实例作为第二个参数的版本。

要按照长度比较字符串,定义一个实现Comparator的类。

public class LengthComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length();
    }
    public static void main(String[] args){
        String[] names = {"tom", "alice", "fred"};
        Arrays.sort(names, new LengthComparator());
        out.println(Arrays.toString(names));
    }
}

lambda表达式

String[] names = {"tom", "alice", "fred"};
Comparator<String> comp = (first, second) -> first.length() - second.length();
Arrays.sort(names, comp);

或者更加简单点

String[] names = {"tom", "alice", "fred"};
Arrays.sort(names, (first, second) -> first.length() - second.length());
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值