JavaSE基础:Arrays工具类

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量93 收藏 1
点赞数
文章标签： java
原文链接：https://juejin.im/post/5a6ade5c518825733e60acb8
版权

Java工具类: Arrays

Arrays类是数组的操作类,定义在java.util包中,主要功能是实现数组元素的查找/数组内容的充填/排序等功能

1.排序数组的sort方法

重点:对数组元素进行排序操作,默认由小到大排序.

该方法的参数不仅可以是基础数据类型的数组，也可以是对象引用的数组。同时还可以指定数组中需要排序的元素的索引范围。

当对对象进行排序时，数组中的所有元素都必须实现 Comparable 接口。(就当你没有看到,哈哈)

即数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）

(1) 数字排序

排序规则:由小到大排序

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest01 {
    public static void main(String[] args) {
        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(2) 字符串排序

排序规则:先大写后小写

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest02 {
    public static void main(String[] args) {
        String[] a = {"a","A","b","B"};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(3) 字符串严格排序

排序规则:严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest03 {
    public static void main(String[] args) {
        String[] a = {"a","C","b","D"};
        Arrays.sort(a,String.CASE_INSENSITIVE_ORDER);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(4) 反向排序

排序规则:先小写后大写

字符串反向

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest04 {
    public static void main(String[] args) {
        String[] a = {"a","A","b","B"};
        Arrays.sort(a, Collections.reverseOrder());//Collections 集合类中的工具类
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

数字排序,要使用包装类

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest05 {
    public static void main(String[] args) {
        //不能使用基本数据类型
        Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, Collections.reverseOrder());
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

这个里面我们使用了Collections工具类,如果想自己完成规则的定义,那么就需要使用比较器接口Comparable(简单了解即可)

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysTest05_1 {
    public static void main(String[] args) {
        //不能使用基本数据类型
        Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, new IntegerComparator());
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}

/**
 * Comparator是一个接口
 * 所以这里我们自己定义的类IntegerComparator要implents该接口
 * 而不是extends Comparator
 *
 */
class IntegerComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        //如果o1小于o2，我们就返回正值，如果n1大于n2我们就返回负值，
        //这样颠倒一下，就可以实现反向排序了
        if(o1 < o2) {
            return 1;
        }else if(o1 > o2) {
            return -1;
        }else {
            return 0;
        }
    }
}
复制代码

(5) 忽略大小写反向排序

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest04 {
    public static void main(String[] args) {
        String[] a = {"a","C","b","D"};
        Arrays.sort(a, Collections.reverseOrder());
        Collections.reverse(Arrays.asList(a));//先忽略吧
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(6) 区间排序-了解

Arrays.sort(int[] a, int fromIndex, int toIndex)
复制代码

这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序！

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest07 {
    public static void main(String[] args) {
        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, 0, 3);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + " ");
        }
    }
}
//运行结果为: 7 8 9 2 3 4 1 0 6 5 
复制代码

Java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，

其实，数组排序功能，在java的api里面早已实现，我们没有必要去重复制造轮子。

如果你是应届生,还是需要学习各种排序的,参考网址:http://geek.csdn.net/news/detail/113928

JDK8强大了排序功能:parallelSort
parallelSort是java8中新出的一种排序API，
这是一种并行排序，Arrays.parallelSort使用了Java7的Fork/Join框架使排序任务可以在线程池中的多个线程中进行，
Fork/Join实现了一种任务窃取算法，一个闲置的线程可以窃取其他线程的闲置任务进行处理
发现数据量越大，parallelSort的优势就越明显。
复制代码

2.查找数组的binarySearch方法

public static int binarySearch(T[] a, T key)
复制代码

使用二分搜索法来搜索指定类型数组，以获得指定的值。

[重点]必须在进行此调用之前对数组进行排序（通过 sort() 方法）。

如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

返回值说明:

1、如果找到关键字，则返回值为关键字在数组中的位置索引，且索引从0开始

2、如果没有找到关键字，返回值为负的插入点值，所谓插入点值就是第一个比关键字大的元素在数组中的位置索引，而且这个位置索引从1开始 (-(插入点)),如果数组中的所有元素都小于指定的键，则为(-a.length-1)。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest08 {
    public static void main(String[] args) {

        int[] b = new int[]{4, 25, 10, 95, 06, 21};
        System.out.println("原数组为：");
        for (int dim1 : b) {
            System.out.print("" + dim1 + " ");
        }
        //一定要先排序
        Arrays.sort(b);
        System.out.println("排序后为：");
        for (int x : b) {
            System.out.print(x + " ");
        }
        System.out.println();
        int index = Arrays.binarySearch(b, 2);
        System.out.println("关键字2的返回值为：" + index);

        index = Arrays.binarySearch(b, 20);
        System.out.println("关键字20的返回值为：" + index);

        index = Arrays.binarySearch(b, 30);
        System.out.println("关键字30的返回值为：" + index);

        index = Arrays.binarySearch(b, 100);
        System.out.println("关键字100的返回值为：" + index);

        index = Arrays.binarySearch(b, 10);
        System.out.println("关键字10的返回值为：" + index);


    }
}
复制代码
结果分析如下:
原数组为：
4 25 10 95 6 21 
排序后为：
4 6 10 21 25 95 
关键字2的返回值为：-1 
关键字2并没有在数组中，而且2比数组中的任何一个元素都小，所以其插入点的值应为元素4的位置也就是1(没有找到关键字从1开始）

关键字20的返回值为：-4
关键字20也不在数组中，数组中第一个比20大的数是21，所以20的插入点值为4（没用找到关键字从索引从1开始）

关键字30的返回值为：-6
关键字30也不在数组中，数组中第一个比30大的数是95，所以30的插入点值为6（没用找到关键字从索引从1开始）

关键字100的返回值为：-7 
关键字100也不在数组中，而且100比数组中所有的元素都大，此时插入点值为length+1 为7（没有找到关键字索引从1开始）

关键字10的返回值为：2
关键字10在数组中，所以返回其在数组中的索引为2（找到关键字索引从0开始）
复制代码

3.充填数组的fill()方法

用指定的值来填充数组，可以指定需要填充的索引范围。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest09 {
    public static void main(String[] args) {

        Integer[] a = new Integer[5];
        Arrays.fill(a, 2);
        System.out.println("当前数组容器："+Arrays.toString(a));
        Arrays.fill(a, 5);
        // 数字3覆盖并填满了整个Array容器
        System.out.println("当前数组容器："+Arrays.toString(a));
        // 填充的开始位
        Integer startIndex = 1;
        // 填充的结束位
        Integer endIndex = 3;
        Arrays.fill(a, startIndex, endIndex, 8);
        System.out.println("当前数组容器："+Arrays.toString(a));

    }
}
/*
当前数组容器：[2, 2, 2, 2, 2]
当前数组容器：[5, 5, 5, 5, 5]
当前数组容器：[5, 8, 8, 5, 5]
*/
复制代码

4.比较两个数组的equals方法

如果两个指定类型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。

equals方法适用于一维数组，多维数组则使用deepEquals()，用法同equals。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest10 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2={5,6,9,3,2,4};
        int[] array3={6,5,9,3,2,4};
        boolean flag1=Arrays.equals(array1,array2); // true
        boolean flag2=Arrays.equals(array1,array3); // false

        //直接使用equals方法会是什么结果呢?
        boolean flag3 = array1.equals(array2); //堆内存地址不一样 false  array1==array2


        System.out.println(flag1+" "+flag2+" "+flag3);

    }
}
复制代码

5.数组转字符串toString()方法

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

字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。

相邻元素用字符 ", "（逗号加空格）分隔。

这些元素通过 String.valueOf(short) 转换为字符串。如果 a 为 null，则返回 "null"。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest11 {
    public static void main(String[] args) {
        String[] array01 = new String[3];
        System.out.println(array01);
        System.out.println(Arrays.toString(array01));
        
        String[] array02 = {"悟空","八戒","唐僧"};
        System.out.println(array02);
        System.out.println(Arrays.toString(array02));

    }
}
复制代码

6.克隆数组的copyOf方法

如果你想扩大数组容量又不想改变它的内容的时候可以使用这个方法

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest13 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        System.out.println("array1的数组长度:"+array1.length);

        int[] array2 = Arrays.copyOf(array1,array1.length+1);//根据实际情况扩容
        System.out.println("array2的数组长度:"+array2.length);

        array2[0]=100;

        System.out.println("array1:"+Arrays.toString(array1));
        System.out.println("array2:"+Arrays.toString(array2));
        
    }
}
/**
array1的数组长度:6
array2的数组长度:7
array1:[5, 6, 9, 3, 2, 4]
array2:[100, 6, 9, 3, 2, 4, 0]
*/
复制代码

array1 和 array2 是两个不相干的数组

7.克隆数组的copyOfRange方法

copyOfRange(int []original,int from,int to)
复制代码

original为原始的int型数组，from为开始角标值，to为终止角标值。（其中包括from角标，不包括to角标。即处于[from,to)状态）

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest14 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2 = Arrays.copyOfRange(array1,1,5);
        System.out.println("array2的数组长度:"+array2.length);

        System.out.println("array2:"+Arrays.toString(array2));

    }
}
// 运行结果: array2的数组长度:4
// array2:[6, 9, 3, 2]
复制代码

这个方法比循环遍历复制数组效率要高。

8.数组转列表asList方法

返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同Collection.toArray()一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        System.out.println("list的长度:"+list.size());
    }
}
// list的长度:6

复制代码

避免使用基本数据类型数组转换为列表

对上述的代码改造一下,改为基本数据类型的数组

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        System.out.println("list的长度:"+list.size());
        System.out.println(list);
    }
}
/**
list的长度:1
[[I@4554617c]
*/
复制代码

程序的运行结果并没有像我们预期的那样是 6 而是逆天的 1，这是什么情况？

从这个运行结果我们可以充分证明 list 里面的元素就是 int 数组。

转换为列表后不能添加元素

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        list.add(99);//添加元素
    }
}
复制代码
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at com.shxt.demo03.ArraysTest15.main(ArraysTest15.java:10)
复制代码

如果想给列表添加数据,需要重新构造列表

package com.shxt.demo03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        //再次转换
        List tempList = new ArrayList(list);
        tempList.add(666);
        //可以添加
        System.out.println(tempList);
    }
}
复制代码

9.数组的哈希码hashCode

基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的同类 型数组 a 和 b，也可以说 Arrays.hashCode(a) ==Arrays.hashCode(b)。

此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的实例的序列。如果 a 为 null，则此方法返回 0。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest12 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2={5,6,9,3,2,4};
        int[] array3={6,5,9,3,2,4};

        System.out.println(Arrays.hashCode(array1));
        System.out.println(Arrays.hashCode(array2));
        System.out.println(Arrays.hashCode(array3));

        System.out.println("---------------------");
        //所有的都不一样
        System.out.println(array1.hashCode());
        System.out.println(array2.hashCode());
        System.out.println(array3.hashCode());

    }
}
/*
1036461630
1036461630
1064167260
---------------------
1163157884
1956725890
356573597
*/
复制代码
weixin_33901926
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面向对象和工具类
06-26
此外，Java还提供了一些其他的工具类，例如Arrays和System类。Arrays类提供了一些有用的数组操作方法，例如sort()和toString()方法。System类提供了一些系统相关的方法，例如currentTimeMillis()方法，可以获取当前...
javase基础练习代码
05-02
5. **字符串处理**：String类是Java中处理文本的重要工具。学习如何创建、操作字符串，使用indexOf、substring、concat、replace等方法。 6. **异常处理**：Java通过异常处理来捕获运行时错误。学会使用try-catch-...
javaSE基础23之Arrays类
px239203的博客
03-19 130
1，toString()方法 返回指定数组内容的字符串表示形式2，sort()方法 对指定的类型数组按数字升序进行排序3，binarySearch()方法 使用二分搜索法来搜索指定类型数组，以获得指定的值4，fill()方法 将指定类型值分配给指定类型数组的每个元素 public class TestArrays {    public static void main(String args[]...
java form array_Java中数组操作 java.util.Arrays 类常用方法的使用
weixin_36431157的博客
02-16 190
任何一门编程语言，数组都是最重要和常用的数据结构之一，但不同的语言对数组的构造与处理是不尽相同的。Java中提供了java.util.Arrays 类能方便地操作数组，并且它提供的所有方法都是静态的。下面介绍一下Arrays类最常用的几个方法。1. 数组排序Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。2. 数组转换为字符串Arrays提供了一个toString方法...
java Arrays 小结
范范123的博客
05-18 166
Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率 关键字 简介 copyOfRange 数组复制 toString 转换为字符串 sort 排序 binarySearch 搜索 equals 判断是否相同 fill 填充 数组复制 与使用Sys...
java.util.Arrays类常用方法
qq_27139689的博客
06-17 578
Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。 步骤1:数组复制步骤2:转换为字符串步骤3:排序步骤4:搜索步骤5:判断是否相同步骤6:填充步骤7:练习-二维数组排序步骤8:答案-二维数组排序 步骤1:数组复制 与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。 不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。 copyOfRange 只需...
java自定义数组排序_集合（一）-Java中Arrays.sort()自定义数组的升序和降序排序...
weixin_33321522的博客
02-21 291
默认升序package peng;import java.util.Arrays;public class Testexample {public static void main(String[] args) {int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};Arrays.sort(a);for(int arr:a) {System.out.print(arr ...
黑马程序员Javase笔记
01-18
首先，DOS命令是操作系统中的基础工具，对于Java开发者来说，了解如何在命令行环境下操作至关重要。常见的DOS命令包括`cd`用于切换目录，`dir`或`ls`列出目录内容，`mkdir`创建新目录，以及`java`和`javac`命令来...
JavaSE基础入门视频教程33天之（17） part2
09-09
这个33天的视频教程系列，特别是第17部分，主要聚焦在Java的常用API上，包括Math类、System类以及Arrays工具类的应用。这些知识点对于任何初学者来说都是必须掌握的，因为它们在实际编程中非常常见。 首先，Math类...
JavaSE.docx
08-12
工具类 * Arrays 类的使用 * System 类的使用 * Math 类的使用 集合 * 集合的概念和分类 * ArrayList 和 LinkedList 的使用 * HashSet 和 TreeSet 的使用 文件与流 * 文件的读写操作 * 输入输出流的使用 * 文件...
Java基础案例教程 第五章JavaAPI———【任务5-2】字符串排序程序设计
wangpailiulanqi8的博客
06-20 1206
一、运行结果： 二、实现思路： 1、把字符串转为字符数组 String[] arr_str = str.split(" "); 2、把string数组转为int数组 // string ---> int arr_int[i] = Integer.parseInt(arr_str[i]); 3、对int数组进行排序 Arrays.sort(arr_in...
字符串数字排序Arrays.sort() Comparator的用法
Baple的专栏
03-05 4207
package test; import java.util.Arrays; import java.util.Comparator; public class Arraysort {  public static void main(String[] args) {   String s = "100,10,1,0,15,20";   String[] strArr = s.spli
Arrays结合Comparator用法小结
看风起云落的博客
05-30 1064
1.二维数组按照列排序： import java.util.Arrays; import java.util.Comparator; /** * 二维数组排序示例 * @author YY2924 2014/11/28 * @version 1.0 */ public class leetcode { public static void main(String[] args...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 566
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 836
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
解决分布式环境下session共享问题
shenxiaomo1688的博客
07-06 995
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 234
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 680
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
JavaSE基础（标识符+关键字+字面量+数据类型+类型转换+修饰符+代码块+方法重载+this关键字等）
06-21
此外，JavaSE基础还包括继承、方法重写、抽象类、接口、异常和I/O流等。继承是一种实现代码复用和类之间关系的机制，通过继承可以派生出子类并继承父类的属性和方法。方法重写是子类对父类的方法进行重新定义，以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值