Java核心类库（一）——常用类库（Arrays）

最新推荐文章于 2023-06-14 07:37:40 发布
最新推荐文章于 2023-06-14 07:37:40 发布
阅读量265 收藏
点赞数
分类专栏： JavaEE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50609545/article/details/117884151
版权

Java常用类库Arrays

类Arrays包含用于操作数组的各种方法（例如排序和搜索）

  • 如果指定的数组引用为null，则此类中的方法都抛出NullPointerException ，除非另有说明

一、常用方法

1.1 toString

返回指定数组内容的字符串形式

举例
       int[] a1 = {1,2,3,4,5};
       System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
源码
	public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
其它
Modifier and TypeFieldDescription
static StringdeepToString​(Object[] a)返回指定数组的“深层内容”的字符串表示形式

1.2 Sort

排序（默认升序）

1.2.1 sort​(T[] a, int fromIndex, int toIndex)

指定区间进行排序

举例
       int[] a1 = {9,1,3,7,2,5};
       System.out.println(Arrays.toString(a1));//[9, 1, 3, 7, 2, 5]
       Arrays.sort(a1,0,3);//[0,3),对9,1,3进行排序
       System.out.println(Arrays.toString(a1));//[0[1, 3, 9, 7, 2, 5]
源码
    public static void sort(int[] a, int fromIndex, int toIndex) {
        rangeCheck(a.length, fromIndex, toIndex);
        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
    }
1.2.2 Sort(T[] a)

对整个数组进行排序

举例
       int[] a1 = {0,7,8,2,4,1};
       System.out.println(Arrays.toString(a1));//[0, 7, 8, 2, 4, 1]
       Arrays.sort(a1);
       System.out.println(Arrays.toString(a1));//[0, 1, 2, 4, 7, 8]
源码
    public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }
1.2.3 其它
Modifier and TypeFieldDescription
static voidsort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。
static voidsort​(T[] a, Comparator<? super T> c)根据指定比较器引发的顺序对指定的对象数组进行排序。
static voidparallelSort​(T[] a)将指定的数组按升序排序。
static voidparallelSort​(T[] a, int fromIndex, int toIndex)将指定的数组范围按数字升序排序。
static <T extends Comparable<? super T>>voidparallelSort​(T[] a)根据元素的natural ordering对指定的对象数组按升序排序。
static <T extends Comparable<? super T>>voidparallelSort​(T[] a, int fromIndex, int toIndex)根据元素的natural ordering ，将指定对象数组的指定范围按升序排序。
static voidparallelSort​(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp)根据指定比较器引发的顺序对指定对象数组的指定范围进行排序。
static voidparallelSort​(T[] a, Comparator<? super T> cmp)根据指定比较器引发的顺序对指定的对象数组进行排序。

1.3 copyOf

复制（常用于数组扩容）

举例
       int[] a = {1,2,3};
       System.out.println(a.length);//output：3
       a = Arrays.copyOf(a,15);
       System.out.println(a.length);//output：15
源码
  public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
        return copy;
    }
其它
Modifier and TypeFieldDescription
static T[]copyOf​(T[] original, int newLength)使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度
static <T,​U>T[]copyOf​(U[] original, int newLength, 类<? extends T[]> newType)使用空值复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度

1.4 mismatch

举例
       int[] a1 = {0,1,2,3,4,5};
       int[] a2 = {0,1,2,3,4,5};//与a1相同
       int[] a3 = {0,1,2,3,0,5};//从索引4开始与a1不同
       System.out.println(Arrays.mismatch(a1,a2));//output：-1
       System.out.println(Arrays.mismatch(a1,a3));//output：4
源码
 public static int mismatch(int[] a, int[] b) {
        int length = Math.min(a.length, b.length); // Check null array refs
        if (a == b)
            return -1;

        int i = ArraysSupport.mismatch(a, b, length);
        return (i < 0 && a.length != b.length) ? length : i;
    }
其它
Modifier and TypeFieldDescription
static intmismatch​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)查找并返回指定范围内两个 Object数组之间第一个不匹配的相对索引，否则如果未找到不匹配则返回-1。
static intmismatch​(T[] a, T[] b, Comparator<? super T> cmp)查找并返回两个 Object数组之间第一个不匹配的索引，否则如果未找到不匹配则返回-1。

1.5 binarySearch

二分查找，搜索，返回下标

1.5.1 binarySearch​(T[] a, int fromIndex, int toIndex, T key)

限定了搜索的范围[fromIndex, toIndex）

举例
  int[] a = {1,2,3,4,5};
       int x1 = Arrays.binarySearch(a,2,3,4);//在a数组下标[2,3)中查找值为4的下标
       System.out.println(x1);//output：<0的随机数
源码
	public static int binarySearch(int[] a, int fromIndex, int toIndex,int key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }
    
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
1.5.2 binarySearch​(T[] a, T key)

与上述相同，只是没有限定范围，fromIndex=0, toIndex=length

举例
       int[] a = {1,2,3,4,5};
       int x1 = Arrays.binarySearch(a,3);//在a数组中查找值为3的下标
       int x2 = Arrays.binarySearch(a,-6);//在a数组中查找值为6的下标
       System.out.println(x1);//output：2
       System.out.println(x2);//output：<0的随机数
源码
    public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
    
	private static int binarySearch0(int[] a, int fromIndex, int toIndex,int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }
1.5.3 其它
Modifier and TypeFieldDescription
static intbinarySearch​(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)使用二进制搜索算法搜索指定对象的指定数组范围
static intbinarySearch​(T[] a, T key, Comparator<? super T> c)使用二进制搜索算法在指定的数组中搜索指定的对象

1.6 equals

1.6.1 equals​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)

如果两个指定数组在指定范围内相等 ，则返回true

举例
       int[] a1 = {1,2,3,4,5};
       int[] a2 = {1,2,0,0,4,5};
       System.out.println(Arrays.equals(a1,0,2,a2,0,2));//true
       System.out.println(Arrays.equals(a1,3,5,a2,4,6));//true
源码
public static boolean equals(int[] a, int aFromIndex, int aToIndex,int[] b, int bFromIndex, int bToIndex) {
        rangeCheck(a.length, aFromIndex, aToIndex);
        rangeCheck(b.length, bFromIndex, bToIndex);

        int aLength = aToIndex - aFromIndex;
        int bLength = bToIndex - bFromIndex;
        if (aLength != bLength)
            return false;

        return ArraysSupport.mismatch(a, aFromIndex, b, bFromIndex,aLength) < 0;
    }
1.6.2 equals​(T[] a, T[] a2)

如果两个指定数组相等，则返回 true

举例
       int[] a1 = {1,2,3,4,5};
       int[] a2 = {1,2,3,4,5};
       int[] a3 = {1,2,0,4,5};
       System.out.println(Arrays.equals(a1,a2));//true
       System.out.println(Arrays.equals(a1,a3));//false
源码
 public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        return ArraysSupport.mismatch(a, a2, length) < 0;
    }
1.6.3 其它
Modifier and TypeFieldDescription
static booleandeepEquals​(Object[] a1, Object[] a2)如果两个指定的数组彼此 深度相等 ，则返回 true
static booleanequals​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)如果在指定范围内指定的两个Object数组彼此 相等 ，则返回true
static booleanequals​(T[] a, T[] a2, Comparator<? super T> cmp)如果两个指定的Objects数组彼此 相等 ，则返回 true

1.7 fills

1.7.1 fill​(T[] a, int fromIndex, int toIndex, T val)

将指定的T值分配给指定的T类型数组的指定范围的每个元素

举例
       int[] a1 = new int[10];
       Arrays.fill(a1,1,4,8);
       char[] a2 = new char[10];
       Arrays.fill(a2,0,3,'s');
       System.out.println(Arrays.toString(a1));//[0, 8, 8, 8, 0, 0, 0, 0, 0, 0]
       System.out.println(Arrays.toString(a2));//[s, s, s,  ,  ,  ,  ,  ,  ,  ]
源码
    public static void fill(char[] a, int fromIndex, int toIndex, char val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }
1.7.2 fill​(T[] a, T val)

将指定的T值分配给指定的T类型数组的每个元素

举例
       int[] a1 = new int[10];
       Arrays.fill(a1,8);
       char[] a2 = new char[10];
       Arrays.fill(a2,'s');
       System.out.println(Arrays.toString(a1));//[8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
       System.out.println(Arrays.toString(a2));//[s, s, s, s, s, s, s, s, s, s]
源码
	public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }

二、其他方法

Modifier and TypeFieldDescription
static ListasList​(T… a)返回由指定数组支持的固定大小的列表。
static intcompare​(T[] a, T[] b)字典顺序比较两个T阵列
static intcompare​(T[] a, int aFromIndex, int aToIndex,T[] b, int bFromIndex, int bToIndex)在指定范围内按字典顺序比较两个T阵列
static <T extends Comparable<? super T>>intcompare​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)在指定范围内按字典顺序比较两个 Object阵列。
static intcompare​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp)在指定范围内按字典顺序比较两个 Object阵列。
static <T extends Comparable<? super T>>intcompare​(T[] a, T[] b)按 Object顺序比较两个 Object阵列，在可比元素中。
static intcompare​(T[] a, T[] b, Comparator<? super T> cmp)使用指定的比较器按字典顺序比较两个 Object阵列
static intcompareUnsigned​(T[] a, T[] b)byte字典顺序比较两个T阵列，数字处理元素为无符号
static intcompareUnsigned​(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)在指定范围内按字典顺序比较两个 T阵列，将元素数字处理为无符号
static T[]copyOfRange​(T[] original, int from, int to)将指定数组的指定范围复制到新数组中
static T[]copyOfRange​(T[] original, int from, int to)将指定数组的指定范围复制到新数组中
static <T,​U>T[]copyOfRange​(U[] original, int from, int to, 类<? extends T[]> newType)将指定数组的指定范围复制到新数组中
static inthashCode​(T[] a)根据指定数组的内容返回哈希码
static intdeepHashCode​(Object[] a)返回基于指定数组的“深层内容”的哈希码
static voidparallelPrefix​(T[] array, int fromIndex, int toIndex,TBinaryOperator op)对于给定的数组子范围执行parallelPrefix(T[], TBinaryOperator)
static voidparallelPrefix​(dT[] array, TBinaryOperator op)使用提供的函数并行地累积给定数组的每个元素
static voidparallelPrefix​(T[] array, int fromIndex, int toIndex, BinaryOperator op)对于给定的数组子范围执行 parallelPrefix(Object[], BinaryOperator)
static voidparallelPrefix​(T[] array, BinaryOperator op)使用提供的函数并行地累积给定数组的每个元素
static voidparallelSetAll​(double[] array, IntToDoubleFunction generator)使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
static voidparallelSetAll​(int[] array, IntUnaryOperator generator)使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
static voidparallelSetAll​(long[] array, IntToLongFunction generator)使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
static voidparallelSetAll​(T[] array, IntFunction<? extends T> generator)使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
static voidsetAll​(double[] array, IntToDoubleFunction generator)使用提供的生成器函数设置指定数组的所有元素以计算每个元素
static voidsetAll​(int[] array, IntUnaryOperator generator)使用提供的生成器函数设置指定数组的所有元素以计算每个元素
static voidsetAll​(long[] array, IntToLongFunction generator)使用提供的生成器函数设置指定数组的所有元素以计算每个元素
static voidsetAll​(T[] array, IntFunction<? extends T> generator)使用提供的生成器函数设置指定数组的所有元素以计算每个元素
staticSpliterator.OfDouble spliterator​(double[] array)返回覆盖所有指定数组的Spliterator.OfDouble
staticSpliterator.OfDouble spliterator​(double[] array, int startInclusive, int endExclusive)返回覆盖指定数组的指定范围的Spliterator.OfDouble
staticSpliterator.OfInt spliterator​(int[] array)返回覆盖所有指定数组的Spliterator.OfInt
staticSpliterator.OfInt spliterator​(int[] array, int startInclusive, int endExclusive)返回覆盖指定数组的指定范围的Spliterator.OfInt
staticSpliterator.OfLong spliterator​(long[] array)返回覆盖所有指定数组的Spliterator.OfLong
staticSpliterator.OfLong spliterator​(long[] array, int startInclusive, int endExclusive)返回覆盖指定数组的指定范围的Spliterator.OfLong
static Spliteratorspliterator​(T[] array)返回覆盖所有指定数组的Spliterator
static Spliteratorspliterator​(T[] array, int startInclusive, int endExclusive)返回覆盖指定数组的指定范围的Spliterator
static DoubleStreamstream​(double[] array)返回以指定数组作为源的顺序DoubleStream
static DoubleStreamstream​(double[] array, int startInclusive, int endExclusive)返回指定数组的指定范围作为其源的顺序DoubleStream
static IntStreamstream​(int[] array)返回以指定数组作为源的顺序IntStream
static IntStreamstream​(int[] array, int startInclusive, int endExclusive)返回指定数组的指定范围作为其源的顺序IntStream
static LongStreamstream​(long[] array)返回以指定数组作为源的顺序LongStream
static LongStreamstream​(long[] array, int startInclusive, int endExclusive)返回指定数组的指定范围作为其源的顺序LongStream
static Streamstream​(T[] array)返回以指定数组作为源的顺序Stream
static Streamstream​(T[] array, int startInclusive, int endExclusive)返回指定数组的指定范围作为其源的顺序Stream
Selcouther
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java常用代码整理
07-27
2. **面向对象编程**：Java是纯面向对象的语言，其三大特性——封装、继承和多态，是理解Java核心的关键。封装通过访问修饰符来保护数据，继承使得子类可以扩展父类的功能，多态则提供了灵活性，使得一个接口可以有...
Java开发详解.zip
09-02
031112_【第11章：Java常用类库】_Arrays笔记.pdf 031113_【第11章：Java常用类库】_比较器（Comparable、Comparator）笔记.pdf 031114_【第11章：Java常用类库】_观察者设计模式笔记.pdf 031115_【第11章：Java常用...
Java核心类库（—）
最新发布
suhfui的博客
06-14 304
元素的key调用hashcode方法获得对应的哈希码值，根据哈希算法计算该元素对应的索引位置，若该索引位置无元素则直接放入，若有元素则比较二者key的哈希码值，若哈希码值不同则将该元素放入后面，若哈希值也相同则再调用equals方法进行比较，若相同则修改value值，不相同放后面。我们可以向集合中存入各种类型的对象，这是因为我们在存入集合对象时，将其识别为Object类型的对象，当我们取出该对象时，也需要将其强转来获得元素的实际类型，这就有可能触发强转类型异常，所以我们引入了泛型的概念。
Java核心类库之（常用API、字符串类、集合类、泛型）
努力让自己发光，对的人才能迎着光而来
07-15 2万+
Java核心类库之（常用API、字符串类、集合类、泛型）
Java常用类库
刘程云的博客
11-30 1516
Java语言已经有许多非常成熟的开源基础类库，封装了日常开发中的各种常用操作，如：对象判空，字符串编码，本地缓存等等。 可以直接在项目中引入对应类库使用即可，或者参与完善相应类库的方法。
string转map集合_Java9系列第5篇集合类的增强
weixin_39621044的博客
12-15 132
我计划在后续的一段时间内，写一系列关于java 9的文章，虽然java 9 不像Java 8或者Java 11那样的核心java版本，但是还是有很多的特性值得关注。期待您能关注我，我将把java 9 写成一系列的文章，大概十篇左右，本文是第5篇。这是真的：java接口中可以定义private 方法资源自动关闭语法的优化-java9系列让一个Jar包在多个JDK版本下面运行Java9响应式...
alg.rar_alg.rar_java算法
09-23
描述中提到的"Java算法库——查找和排序"，揭示了这个库的重点在于提供查找和排序这两种基础但至关重要的算法。查找算法帮助我们在数据集中快速定位特定元素，如二分查找、哈希查找等；排序算法则用于组织数据，例如...
Java API 1.8.zip 中文+英文 0积分
04-16
这个压缩包提供的两个CHM文件——"jdk api 1.8_google.CHM"和"Java Platform SE 8.chm"——都是Java 8的API文档，为开发者提供了详细的语言特性和类库参考。 首先，让我们深入了解一下Java API 1.8中的主要变化和...
java案例
03-14
Java是一种广泛使用的面向对象的编程语言，以其跨平台、高性能和丰富的类库而著名。本案例将探讨基于Java 8（具体版本为jdk1.8.0_40）的编程实践，该版本引入了许多重要特性，如lambda表达式、流API和方法引用来增强...
Java 类库 大全
04-13
这个对于学习Java的人们来说非常的重要，极为重要，因为在学习一门面向对象的语言时，学习其语法只是最基本的，要进一步自己编写程序就得了解Java的类库，这样可以省去在编程中带来的很多麻烦问题，是进一步学习Java的必经之路，希望大家好好去研究....
Java核心类库
Android系统优化
10-11 4200
Java核心类库 2|01. 常用的类 2|11.1 常用的包与功能描述 java.lang 核心包，jvm自动导入。包含System，String......类。 java.util 工具包，包含大量工具类与集合类，如Scanner，Random，List等。 java.io 输入输出包，关于读写文件相关的类，FileInputStream，FileOutputStream等。 java.net 网络包，提供大量网络编程相关类，ServerSocket，Socket等。 java.sql
第十一章《Java实战常用类》第8节：Arrays类
穆哥学堂--Java学习园地
11-29 164
Arrays类位于java.util包，它是一个数组工具类，可以帮助程序员完成一些对数组常见的操作。这些常见的操作包括对数组元素排序，从数组中查找特定的元素、比较两个数组元素是不是相同，对数组进行复制等。
Java开发人员必知必会的20种常用类库和API
热门推荐
java、c++、机器学习方向King
01-31 3万+
一个有经验的Java开发人员特征之一就是善于使用已有的轮子来造车。《Effective Java》的作者Joshua Bloch曾经说过：“建议使用现有的API来开发，而不是重复造轮子”。在本文中,我将分享一些Java开发人员应该熟悉的最有用的和必要的库和API。顺便说一句，这里不包括框架，如Spring和Hibernate因为他们非常有名,都有特定的功能。 本文总结了日志、JSON解析、单
Java核心类库——笔记重点
chenxi0905的博客
09-09 366
异常机制和File类异常机制和File类异常机制 异常机制和File类 异常机制 基本概念 异常就是"不正常"的含义，在Java语言中主要指程序执行中发生的不正常情况。 java.lang.Throwable类是Java语言中错误(Error)和异常(Exception)的超类。 其中Error类主要用于描述Java虚拟机无法解决的严重错误，通常无法编码解决，如：JVM挂掉了等。 Exception类主要用于描述因编程错误或偶然外在因素导致的轻微错误，通常可以编码解决，如：0作为除数等。 异常的分类
23.Arrays类
qq_39393387的博客
09-20 181
Arrays类 数组的工具类java.util.Arrays。 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。 Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能")。 具有以下常用功能： 给数组赋值：通过 fill 方法。 对数组排序：通过 sort 方法,按升序。 比较数组：通过 equals 方法比较数组中元素值是否相等
如何使数组内的数字不相同_如何比较2个数组相等以及如何检出不匹配项
weixin_39638305的博客
12-03 479
当我空闲的时候，我会密切地观察读者群里的一举一动，不放过他们的任何一个问题，帮助他们成长虽然不是我应尽的义务，但我的确喜欢和他们交流的感觉，毕竟能帮一个是一个。也许我的一个小小的举动，就能够他们跨越成长过程中的一大步——请给我一次骄傲的机会嘛。有一次，我在“石器时代”群里发现了 1 个有意思的提问：“如何比较 2 个数组相等以及如何检出不匹配项？”严格意义上讲，这是 2 个问题，其一是比较数组是否...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Selcouther

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值