java-Arrays

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量1.3k 收藏 7
点赞数 10
文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74886498/article/details/138067497
版权

一、Arrays的概述

Arrays是操作数组的工具类

二、Arrays的常用方法

Arrays的常用方法基本上都被static静态修饰，因此在使用这些方法时，可以直接通过类名调用

1.toString

语法：Arrays.toString(数组)

用于将数组的元素转换为一个字符串，元素之间用逗号分隔，所有元素用[]包括。

注意：Arrays 类的 toString 方法来拼接或获取任何类型数组的字符串表示，包括基本数据类型数组和对象数组。对于对象数组，如果对象本身重写了 toString 方法，那么这些方法的实现将被用于生成字符串表示。

该方法可以用来展示数组的元素（因为如果直接输出数组名 则输出的是数组的地址）

import java.util.Arrays;

public class test1 {
    public static void main(String[] args) {
        // 1.Arrays.toString(数组) 将数组变成字符串
        int [] arr1=new int[]{1,2,3};
        String s1=Arrays.toString(arr1);
        System.out.println(s1);// [1, 2, 3]

        char [] arr2=new char[]{'a','b','c'};
        String s2=Arrays.toString(arr2);
        System.out.println(s2);// [a, b, c]

        String [] arr3=new String[]{"aaa","bbb","ccc"};
        String s3=Arrays.toString(arr3);
        System.out.println(s3);// [aaa, bbb, ccc]
        
        // Student类重写了toString方法 它的输出是"Student{name = " + name + ", age = " + age + "}"
        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr4=new Student[]{student1,student2,student3};
        String s4=Arrays.toString(arr4);
        System.out.println(s4);// [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}]

    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

2.binarySearch

语法：Arrays.binarySearch(数组，元素)；

返回查找元素的索引 前提是传入的数组必须是升序的

注意：

如果该元素存在 则返回他在数组中的索引值 

如果该元素不存在 则返回 -插入值-1

插入值是根据从小到大的顺序 该元素如果在数组中存在 它的索引值

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.binarySearch(数组,元素) 返回元素在数组中的索引
        int [] arr1=new int[]{1,2,3,4,5,6,7,8,9,10};
        int index1=Arrays.binarySearch(arr1,4);
        int index2=Arrays.binarySearch(arr1,10);
        int index3=Arrays.binarySearch(arr1,-1);
        System.out.println(index1);// 3  元素值为4在数组中的索引为3
        System.out.println(index2);// 9  元素值为10在数组中的索引为9
        System.out.println(index3);// -11 元素值在数组中不存在的索引为-插入值-1
        // 元素-1如果在数组(已经按照升序排列)存在 那么它的位置应该在0索引处 这就是它的插入值 再减一 得到它的索引
    }
}

3.copyOf

语法：Arrays.copyOf(老数组，新数组的长度)；

如果新数组的长度小于老数组的长度 则会部分拷贝（从左往右拷贝）

如果新数组的长度等于老数组的长度 则会完全拷贝

如果新数组的长度大于老数组的长度 不仅会完全拷贝 而且多余的部分通过该数组元素数据类型的默认值来填充

组合数据类型的默认值为null

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOf(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        int [] arr1=Arrays.copyOf(arr,2);
        int [] arr2=Arrays.copyOf(arr,4);
        int [] arr3=Arrays.copyOf(arr,8);
        // 如果直接输出数组名 则结果是数组的地址
        // 如果想要输出数组的元素 则可以通过Arrays.toString()
        System.out.println(arr1);// [I@4eec7777
        System.out.println(arr2);// [I@3b07d329
        System.out.println(arr3);// [I@41629346
        System.out.println(Arrays.toString(arr1));// [7, 8]
        System.out.println(Arrays.toString(arr2));// [7, 8, 9, 10]
        System.out.println(Arrays.toString(arr3));// [7, 8, 9, 10, 0, 0, 0, 0]

        String [] arr_1=new String[]{"AAA","BBB","CCC"};
        String [] arr4=Arrays.copyOf(arr_1,2);
        String [] arr5=Arrays.copyOf(arr_1,3);
        String [] arr6=Arrays.copyOf(arr_1,5);

        System.out.println(Arrays.toString(arr4));// [AAA, BBB]
        System.out.println(Arrays.toString(arr5));// [AAA, BBB, CCC]
        System.out.println(Arrays.toString(arr6));// [AAA, BBB, CCC, null, null]

        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr7=new Student[]{student1,student2,student3};
        Student [] arr8=Arrays.copyOf(arr7,4);
        System.out.println(Arrays.toString(arr8));
        // [Student{name = zhangsan, age = 20}, Student{name = lisi, age = 17}, Student{name = wangwu, age = 18}, null]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

4.copyOfRange

语法：Arrays.copyOfRange(开始索引，结束索引)；

从开始索引拷贝到结束索引，包括开始索引，但是不包括结束索引

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.copyOfRange(数组,长度)
        int [] arr=new int[]{7,8,9,10};
        // 从索引0拷贝到索引3 不包括索引3
        int [] arr1=Arrays.copyOfRange(arr,0,3);
        System.out.println(Arrays.toString(arr1));// [7, 8, 9]

        String [] arr_1=new String[]{"AAA","BBB","CCC","DDD"};
        // 从索引1拷贝到索引3 不包括索引3
        String [] arr2=Arrays.copyOfRange(arr_1,1,3);
        System.out.println(Arrays.toString(arr2));// [BBB, CCC]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr_1_1=new Student[]{student1,student2,student3};
        // 从索引0拷贝到索引1 不包括索引1
        Student [] arr3=Arrays.copyOfRange(arr_1_1,0,1);
        System.out.println(Arrays.toString(arr3));
        // [Student{name = zhangsan, age = 20}]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

5.fill

语法：Arrays.fill(数组，新数据)；

用新数据填充数组的每一个元素，注意：是直接在原数组中进行覆盖

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.fill(数组,新数据)
        int [] arr=new int[]{7,8,9,10};
        Arrays.fill(arr,100);
        System.out.println(Arrays.toString(arr));// [100, 100, 100, 100]

        String [] arr1=new String[]{"AAA","BBB","CCC","DDD"};
        Arrays.fill(arr1,"ppp");
        System.out.println(Arrays.toString(arr1));// [ppp, ppp, ppp, ppp]


        Student student1=new Student("zhangsan",20);
        Student student2=new Student("lisi",17);
        Student student3=new Student("wangwu",18);
        Student [] arr2=new Student[]{student1,student2,student3};
        Arrays.fill(arr2,student3);
        System.out.println(Arrays.toString(arr2));
        // [Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}, Student{name = wangwu, age = 18}]
    }
}
class Student{
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

6.sort

语法1：Arrays.sort(数组)；

对数组进行排序 默认是升序排序 注意：是直接在原数组中进行排序

补充：字符串之间的比较是基于它们每个字符的Unicode值进行的。

import java.util.Arrays;

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组)
        int [] arr=new int[]{100,20,89,1,-10,65};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]

        String [] arr1=new String[]{"i","like","pen","and"};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));// [and, i, like, pen]
        
    }
}

语法2：Arrays.sort(数组，排序规则)；

Arrays.sort(数组, (o1,o2)->o2-o1); 

是降序排序 其中o1,o2可以换成任何变量名

总结：如果是(o1,o2)->o2-o1则是降序  如果是(o1,o2)->o1-o2则是升序 

根据排序规则对数组进行排序  只能给引用数据类型排序 如果要给基本数据类型排序 则需要将基本数据类型转化为对应的包装类

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

public class test2 {
    public static void main(String[] args) {
        // 1.Arrays.sort(数组,排序规则)
        Integer [] arr=new Integer[]{100,20,89,1,-10,65};
        /*
           这个降序是通过Comparator接口实现的 方法的参数是接口
           当我们要调用方法时 需要传入该接口的实现类
           Comparator接口的compare方法:
           该方法是用来排序的 需要传入两个参数 Integer o1 Integer o2
           规定数组的0索引为有序序列 0索引以后为无序序列
           o1表示从无序序列中遍历得到的每一个元素
           o2表示从有序序列的元素
           返回值为正 表示当前插入的元素小于有序序列的元素 放在后面
           返回值为负 表示当前插入的元素大于有序序列的元素 放在前面
        */
        // 未通过lamdba表达式简化
        Arrays.sort(arr,new Comparator<Integer>(){
            @Override
            public int compare(Integer o1,Integer o2){
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));// [100, 89, 65, 20, 1, -10]
        
        // 通过lamdba表达式简化
        Arrays.sort(arr, (o1,o2)->o2-o1);
        System.out.println(Arrays.toString(arr));// [-10, 1, 20, 65, 89, 100]
    }
}

新野一.
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java-----Arrays工具类】
qq_45071131的博客
09-30 1059
Arrays Arrays是Java中的一个工具类，类中的方法均为static修饰，所以可以直接使用Arrays.xxx来调用，Arrays类处于java.util包下，使用时需导入java.util.Arrays一 String toString(type[] a)二 二分查询int binarySearch(type[] a,type key)三二分查询int binarySearch(type[] a,int fromlndex,int tolndex,type四 type[] copyOf
Java-Arrays工具类的常见方法总结
2401_82742105的博客
02-22 1833
在Java中，提供了一个专门用于操作数组的工具类，即Arrays类，该类提供了一些方法对数组进行排序，打印，复制等操作。下面是一些该工具类方法总结。
Java---Arrays类的常用方法
gaoqiandr的博客
11-16 1691
对于Java中数组的一些操作快捷方法，比如查元素，转换字符串，拷贝数组之类的，简单详细。
Java-Arrays.sort()方法的比较器
qq_25046827的博客
10-04 1586
Arrays.sort()有以下重载（此处只展示两种）： Arrays.sort(Object[] a); Arrays.sort(T[] a, Comparator<? super T> c); Arrays.sort(Object[] a) 此方法看似没有要求我们实现比较器，对于基本数据类型，String类型确实如此，因为这些类型中已经自带了compareTo()方法 然而对于我们自定义的类型，则需要让该类实现Comparable接口，重写其中的compareTo()函数 否则虽然编译时
Java-Arrays类-fill()方法详解
zzl8888888的博客
12-04 908
** Java-Arrays类-fill()方法详解 ** fill()方法使用参考 声明举例： public static void fill(int[] a, form, to, int var) 参数： a–数组 form–替换开始位置（包括） to–替换结束位置（不包括） var–要替换的值 代码示例： ```java public class Test { public static void main(String[] args) { int
Java-Arrays.asList 报 java.lang.UnsupportedOperationException
weixin_45203607的博客
03-14 542
调用Arrays.asList()生产的List的add、remove方法时报异常，这是由Arrays.asList() 返回的是 Arrays的内部类ArrayList， 而不是java.util.ArrayList。Arrays的内部类ArrayList和java.util.ArrayList都是继承AbstractList，remove、add等方法，而且这些方法都没有进行重写，java.util.ArrayList重写了这些方法而Arrays的内部类ArrayList没有重写，所以会抛出异常。
Java工具类系列--Arrays的用法
IT利刃出鞘的博客
10-29 1291
原文网址： 简介 本文用示例介绍Java中的Arrays的常用方法。 Arrays用来操作数组，比如：拷贝数组、转换为list、填充等。 asList 数组/多个类都可以 package org.example.a; import java.util.Arrays; import java.util.List; public class Demo { public static void main(String[] args) throws Clas...
Java基础-Arrays排序
趁年轻，多尝试
03-09 971
Arrays.sort()针对对象数组和字符串数组中元素长度进行排序
Java-arrays.copyOf()方法
qq_37020594的博客
08-13 917
Arrays的copyOf()方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。copyOf的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原来数组的长度，则保留数组默认值。 package extracurricular; import java.util.Arrays; public class CopyOf { public s...
Java8-Arrays.sort
weixin_42454225的博客
05-31 849
Java8-Arrays.sort Arrays.sort是我们常用来排序数组的方法，不止如此，其实Collections.sort方法中也是直接拿到集合中的元素数组作为入参直接调用Arrays.sort方法的。 所以作为JDK中的常驻API，底层中对排序的各个场景是做了对应的优化算法的，使Arrays.sort在默认使用的前置下，有着最高的性能功率。 Sort 由于Java泛型、多数据类型的原因，sort方法在Arrays类中有多重重载场景。 下面我们以两部分，基本类型数组、对象类型数组，进行源码跟踪。
当时oajava源码-Java-Arrays:Java数组
06-06
java源码Java数组 如何在 Java 中初始化数组 Code Snippet: //initialize primitive one dimensional array int[] arrInt = new int[5]; //initialize Object one dimensional array String[] strArr; //...
java-quiz-arrays
05-12
要测试此代码，请签出并运行以下命令gradle fatJar java -jar build / libs / array-finder-all-1.0-SNAPSHOT.jar 1,2,3,4 2,3其中1,2,3,4和2,3是样本输入数组
Java Methods-Arrays.ppt
09-05
Java Methods-Arrays.ppt
Java-Programming-Arrays-Lists-and-Structured-Data
05-18
在Java编程中，数组、列表和结构化数据是核心概念，它们构成了程序处理和存储信息的基础框架。让我们深入探讨这些主题。 首先，数组是Java中最基本的数据结构之一，它允许我们存储固定数量相同类型的元素。数组可以...
exercicio-sobre-arrays-curso-de-java-completo-professor-Nelio-Alves
03-21
库索德Java大学教授内里奥·阿尔维斯（NélioAlves） Exercício光纤阵列： 退休金和退休金，退休金和退休金0至9。 （N pode ser de 1 a 10）。塞古达（Em seguida），注册女登记员（bem como qual dos quartos ele...
配置Java开发环境
Broken_x的博客
07-10 1585
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 541
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
elk部署springboot
Chihirozy的博客
07-11 404
elk部署springboot。
java当中Arrays
03-08
在Java中，Arrays是一个用于操作数组的工具类。它提供了一系列静态方法，用于对数组进行排序、搜索、填充等操作。以下是Arrays类的一些常用方法： 1. sort()：对数组进行排序。可以使用该方法对基本类型数组和对象数组进行排序。 2. binarySearch()：在已排序的数组中使用二分查找算法来搜索指定元素。同样适用于基本类型数组和对象数组。 3. fill()：将指定值填充到数组的每个元素中。 4. equals()：比较两个数组是否相等。 5. toString()：将数组转换为字符串形式。 除了上述方法，Arrays类还提供了其他一些方法，用于操作数组。需要注意的是，Arrays类中的方法都是静态方法，可以直接通过类名调用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值