JAVA基础：Arrays类

最新推荐文章于 2024-04-28 18:49:50 发布
最新推荐文章于 2024-04-28 18:49:50 发布
阅读量141 收藏
点赞数
分类专栏： java 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACBYCL/article/details/126356491
版权

一. 概述

概述

在这里插入图片描述

package Test;

import java.util.Arrays;

public class Test {
    public static void main(String[] args){
//        目标：学会使用Arrays类的常用API，并理解其原理
        int[] arr={10,2,55,23,24,100};
        System.out.println(arr);

//        1.返回数组内容的 toString(数组)
//        String rs=Arrays.toString(arr)
//        System.out.println(rs);
        System.out.println(Arrays.toString(arr));

//        2.排序的API（默认自动对数组元素进行升序排序）
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

//        3.二分搜索技术（前提数组必须排好序才支持，否则出bug）
        int index=Arrays.binarySearch(arr,55);
        System.out.println(index);

//        返回不存在元素的规律：-（应该插入的位置索引+1）
        int index2=Arrays.binarySearch(arr,22);
        System.out.println(index2);

//        注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug！！
        int[] arr2={12,36,34,25,13,24,234,100};
        System.out.println(Arrays.binarySearch(arr2,36));
    }
}

排序方法

在这里插入图片描述

package Test;


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

public class Test2 {
    public static void main(String[] args) {
//        目标：自定义数组的排序规则：Comparator比较器对象
//        1.Arrays的sort方法对于有值特性的数组是默认升序排列
        int[] ages={34,12,42,23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

//        2.需求：降序排序！（自定义比较器对象，只能支持引用类型的排序！！）
        Integer[] ages1={34,12,42,23};
//        参数一：被排序的数组  必须是引用类型的元素
//        参数二：匿名内部类对象，代表了一个比较器对象

//        如果o1大就把它排在后面
        Arrays.sort(ages1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
//                指定比较规则
                if (o1 < o2) {
                    return 1;
                }else if (o1 > o2) {
                    return -1;
                }
//                return 0;
//                return o1-o2;//默认升序
                return o2-o1;//降序

            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("------------------------");
        Student[] students = new Student[3];
        students[0] = new Student("吴磊",23,175.5);
        students[1] = new Student("吴磊",18,185.5);
        students[2] = new Student("吴磊",20,195.5);
        System.out.println(Arrays.toString(students));


//        Arrays.sort(students);//直接运行崩溃
        Arrays.sort(students,new Comparator<Student>() {
            @Override
            public int compare(Student t1,Student t2) {
//                自己指定比较规则
//                return t1.getAge()-t2.getAge();//按照年龄升序排序
//                return t2.getAge()-t1.getAge();//按照年龄降序排序
//                return Double.compart(t1.getHeight(),t2.getHeight());比较浮点型都可以这样写  升序
                return Double.compare(t2.getHeight(),t1.getHeight());//比较浮点型可以这样写  降序

            }
        });
        System.out.println(Arrays.toString(students));


    }
}

二，选择排序，二分查找

在这里插入图片描述

package Test;

import java.util.Arrays;

//目标：学会使用选择排序的方法对数组进行排序
public class Test2 {
    public static void main(String[] args) {
//        1.定义数组
        int[] arr={5,1,3,2};
//                 0 1 2 3

//        2.定义一个循环控制选择几轮：arr.length-1
        for (int i=0;i<arr.length-1;i++) {
//            i=0    j= 1  2  3
//            i=1    j= 2  3
//            j=2    j= 3
//            3.定义内部循环，控制选择几次
            for (int j=i+1;j<arr.length;j++){
//                当前位：arr[i]
//                如果有比当前位数据更小的，则交换
                if (arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

    }
}

在这里插入图片描述
**注意：**如果没有排序，那就找不出来了

package Test;

import java.util.Arrays;

//目标：理解二分搜索的原理并实现
public class Test2 {
    public static void main(String[] args) {
//        1.定义数组
        int[] arr={10,14,16,25,28,30,35,88,100};
        System.out.println(binarySearch(arr,35));


    }
    /**
     * 二分查找算法的实现
     * arr  排序的数组
     * data 要找的数组
     * 索引，如果元素不存在，直接返回-1
     */
    public static int binarySearch(int[] arr,int data){
//        1.定义左边位置   和  右边位置
        int left=0;
        int right=arr.length-1;

//        2.开始循环，折半查询
        while (left<=right){
//            取中间索引
            int middleIndex=(left+right)/2;
//            3.判断当前中间位置的元素和要找的元素的大小情况
            if (data>arr[middleIndex]){
//                往右边找，左位置更新为=中间索引+1
                left=middleIndex+1;
            }else if(data<arr[middleIndex]){
//                往左边找，右边位置=中间索引-1
                right=middleIndex-1;
            }else {
                return middleIndex;
            }
        }
        return -1;//查无此元素
    }
}

三.Lambda

概述

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

package Test;


public class Test2 {
    public static void main(String[] args) {
//        目标：学会使用Lambda的标准格式简化匿名内部类的代码形式
//        Lambda只能简化接口中只有一个抽象方法的匿名内部类形式
//        Swimming s1=new Swimming(){
//            @Override
//            public void swim(){
//                System.out.println("老师游泳贼溜");
//            }
//        };

        Swimming s1=()->{
            System.out.println("老师游泳贼溜");
        };
        go(s1);

        System.out.println("----------------------");
//        go(new Swimming(){
//            @Override
//            public void swim(){
//                System.out.println("学生游泳很开心");
//            }
//        });

        go(()->{
            System.out.println("学生游泳很开心");
        });
    }
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }

}
@FunctionalInterface//一旦加上这个注释必须是函数式接口，里面只能有一个抽象方法
interface Swimming{
    void swim();
}

Lambda实战:匿名函数

概述

在这里插入图片描述

在这里插入图片描述

package Test;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;

public class Test4 {
    public static void main(String[] args) {
        Integer[] ages1={34,12,42,23};
        /**
         * 参数一：被排序的数组   必须是引用类型的元素
         * 参数二：匿名内部类对象，代表了一个比较器对象
         */
//        1.@FunctionalInterface : 可以简化的标志
//        灰色：也可以简化
//        Arrays.sort(ages1,new Comparator<Integer>() {
//            @Override
//            public int compare(Integer a,Integer b) {
//                return b-a;//降序
//            }
//        });
        Arrays.sort(ages1,(Integer a,Integer b)-> {
                return b-a;//降序
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("----------------------------");
        JFrame win=new JFrame("登录界面");

        JButton btn=new JButton("我是一个很大的按钮");
//        btn.addActionListener(new ActionListener() {
//            @Override
//            public void actionPerformed(ActionEvent e){
//                System.out.println("有人点我，点我，点我");
//            }
//        });

//        2.有interface就可以简化，且只有一个类
        btn.addActionListener((ActionEvent e) ->{
            System.out.println("有人点我，点我，点我");
        });

        win.add(btn);
        win.setSize(400,300);
        win.setVisible(true);



    }
}

完美简化

在这里插入图片描述

package Test;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.Comparator;

public class Test4 {
    public static void main(String[] args) {
        Integer[] ages1={34,12,52,23};
//        简化案例一：
        Arrays.sort(ages1,(Integer o1,Integer o2)->{
            return o2-o1;
        });
//        极致简化
        Arrays.sort(ages1,(o1,o2)->{
            return o2-o1;
        });
//        极致简化
        Arrays.sort(ages1,(o1,o2)->o2-o1);

//        简化案列二：
        JFrame win=new JFrame("登录界面");
        JButton btn=new JButton("我是一个很大的按钮");
        btn.addActionListener((ActionEvent e)->{
            System.out.println("有人点我，点我，点我");
        } );
//        极致简化
        btn.addActionListener(( e)->{
            System.out.println("有人点我，点我，点我");
        } );
//        极致简化
        btn.addActionListener( e->{
            System.out.println("有人点我，点我，点我");
        } );
//        极致简化
        btn.addActionListener( e-> System.out.println("有人点我，点我，点我"))

    }
}

四.正则表达式

初体验

在这里插入图片描述

package Test;

import java.util.Arrays;

public class Test {
    public static void main(String[] args){
//        需求：校验qq号码，必须全部数字6-20位
        System.out.println(checkQQ("251425998"));
        System.out.println(checkQQ("251425a98"));
        System.out.println(checkQQ(null));
        System.out.println(checkQQ("2344"));

        System.out.println("----------------------");
//        正则表达式的初体验
        System.out.println(checkQQ2("251425998"));
        System.out.println(checkQQ2("251425a98"));
        System.out.println(checkQQ2(null));
        System.out.println(checkQQ2("2344"));


    }

    public static boolean checkQQ2(String qq){
        return qq!=null && qq.matches(("\\d{6,20}"));
    }
    public static boolean checkQQ(String qq){
//        1.判断qq号码的长度是否满足要求
        if (qq==null||qq.length()<6||qq.length()>20){
            return false;
        }
//        2.判断qq中是否全部是数字，不是返回false
//        251425a87
        for (int i=0;i<qq.length();i++){
//            获取每位数字
            char ch=qq.charAt(i);//charAt用来取字符串
//            判读这个字符是否不是数字，不是数字直接返回false
            if (ch<'0' || ch>'9' ){
                return false;
            }
        }
        return true;//肯定合法
    }
}

常用规则

在这里插入图片描述

package Test;

import java.util.Arrays;
//目标：全面，深入学习正则表达式的规则
public class Test {
    public static void main(String[] args){
//        public Boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true
//        只能是a  b  c
        System.out.println("a".matches("[abc]"));//true
        System.out.println("z".matches("[abc]"));//false

//        不能出现a  b  c
        System.out.println("a".matches("[^abc]"));//false
        System.out.println("z".matches("[^abc]"));//true

        System.out.println("a".matches("\\d"));//false
        System.out.println("3".matches("\\d"));//true
        System.out.println("333".matches("\\d"));//false
        System.out.println("z".matches("\\w"));//true
        System.out.println("2".matches("\\w"));//ture
        System.out.println("21".matches("\\w"));//false
        System.out.println("你".matches("\\w"));//false
        System.out.println("你".matches("\\w"));//true
        System.out.println("--------------------------------");
//        以上正则匹配只能检验单个字符

//        校验密码
//        必须是数字   字母   下划线    至少6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));
        System.out.println("244f".matches("\\w{6,}"));

//        验证码  必须是数字和字符   必须是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));
        System.out.println("23_F".matches("[a-zA-Z0-9]{4}"));
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));


    }
}

案例

在这里插入图片描述

package Test;

import java.util.Arrays;
import java.util.Scanner;

public class Test {
    public static void main(String[] args){
//        目标：检验  手机号码  邮箱  电话号码
//        checkPhone();
//        checkEmail();
        checkTel();

//        同学可以完成检验金额是否格式金额：99 0.5 99.5 019   |0.3.3

    }
    public static void checkTel(){
        Scanner sc=new Scanner(System.in);
        while(true){
            System.out.println("请您输入您的电话号码：");
            String tel=sc.next();
//            判断邮箱格式是否正确   027-3572457   0273572457
            if (tel.matches("0\\a{2,6}-?\\d{5,20}")){
                System.out.println("格式正确，注册完成");
                break;
            }else {
                System.out.println("格式有误");
            }
        }
    }
    public static void checkEmail(){
        Scanner sc=new Scanner(System.in);
        while(true){
            System.out.println("请您输入您的注册邮箱：");
            String email=sc.next();
//            判断邮箱格式是否正确   3268847878@qq.com
//            判断邮箱格式是否正确   3268847dsda87@163.com
//            判断邮箱格式是否正确   3268847dsda878@pci.com.cn
            if (email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱格式正确，注册完成");
                break;
            }else{
                System.out.println("格式有误");
            }
        }
    }
    public static void checkPhone(){
        Scanner sc=new Scanner(System.in);
        while (true){
            System.out.println("请您输入您的注册手机号码：");
            String phone=sc.next();
//            判断手机号码的格式是否正确
            if (phone.matches("1[3-9]\\d{9}")){
                System.out.println("手机号码格式正确，注册完成");
                break;
            }else {
                System.out.println("格式有误");
            }
        }
    }
}

正则表达式方法

在这里插入图片描述

package Test;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 目标：正则表达式方法的应用。
 *      public String[] split(String regx):
 *             --按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组
 *      public String replace(String regx, String newStr):
 *             --按照正则表达式匹配的内容进行替换)
 */
public class Test {
    public static void main(String[] args){
        String names="小路dhdfhdf342蓉儿43fdffdfbjdfaf过儿";
        String[] arrs=names.split("\\w+");
        for (int i=0;i<arrs.length;i++){
            System.out.println(arrs[i]);
        }
        String names2=names.replaceAll("\\w+","  ");
        System.out.println(names2);
    }
}

正则表达式爬取信息

在这里插入图片描述

package Test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 拓展：正则表达式爬取信息中的内容。（了解）
 */
public class Test {
    public static void main(String[] args){
        String rs="来黑马程序学习Java,电话020-43422424,或者联系邮箱"+
                "itcast@itcase.cn,电话18762832633，0203232323"+
                "邮箱bozai@itcast.cn,400-100-3233,4001003232";
//        需求：从上面的内容中爬取出  电话号码和邮箱
//        1.定义爬取规则，字符串形式
        String regx="(\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2})|(1[3-9]\\d{9})"+
                "|(0\\d{2,6}-?\\d{5,20})|(400-?\\d{3,9}-?\\d{3,9})";

//        2.把这个爬取规则编译成匹配对象
        Pattern pattern=Pattern.compile(regx);

//        3.得到一个内容匹配器对象
        Matcher matcher=pattern.matcher(rs);

//        4.开始找了
        while (matcher.find()){
            String rs1=matcher.group();
            System.out.println(rs1);
        }
    }
}
ACBYCL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA基础(三十九)——常用类之Arrays类
qq_37466661的博客
09-14 643
java Arrays
java基础---Arrays类使用
weixin_42996125的博客
03-11 177
Arrays类 1、数组的工具类：java.util.Arrays 2、由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays类供我们使用，从而可以对数据对象进行一些基本的操作。 3、可以查看JDK帮助文档 4、Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”，而不是“不能”） 5、Arrays类具有以下常用功能：   一、给数组赋值，通过fill方法。   二、对数组排序，通过sort方法，
Java基础Arrays类
孤夜的博客
02-22 1万+
1.Arrays类 Arrays位于java.util包下(Arrays是一个操作数组的工具类) Arrays包含各种操作数组的方法(例如排序和搜索)。该类还包含一个静态工厂，允许将数组视为列表。 Arrays类里的方法都是静态方法可以通过Arrays.方法名()直接调用 2.Arrays常用方法 (1) asList(T… a):主要用于遍历 List<String> list = Arrays.asList("a","b","c"); 该方法适用于对象型数据的数组（String、
Java Arrays类
qq_51542797的博客
12-20 1774
Java Arrays类笔记。
Java基础06(数组进阶 Arrays工具类)
最新发布
qq_52897007的博客
04-28 1164
第一种方式是通过for循环：因为数组的每个元素都可以通过索引来访问，因此，使用标准的for循环可以完成一个数组的遍历：初始条件为i=0，因为索引总是从0开始，继续循环的条件为i < ns.length，因为当i = ns.length时，i已经超出了索引范围（索引范围是0 ~ ns.length-1），每次循环后，i++实现索引递增。
Java中的Arrays类
算法与编程之美
01-18 1548
1、问题Arrays类是什么，Arrays常用方法。2、方法了解Arrays类的概念Arrays 位于java.util包下,Arrays是一个操作数组的工具类。Arrays常用方法Arrays.fill：替换数组原元素；Arrays.sort:对数组进行排序（递增）；Arrays.equal：判断两个数组是否相等；Arrays.copy0f:拷贝数组Arrays.toString:打印数组输出替...
Java中Arrays类(操作数组的工具)
weixin_62981548的博客
03-14 3350
以上就是今天所讲的Arrays类里面的一些常用方法，它可以使我们更方便的操作数组，当然还有许多种方法在Arrays类里面，有兴趣的童鞋可以去查一查。
JAVA基础知识：类、循环
JAVA-阳的博客
05-16 375
学习心得 初期学习还是比较简单的，也比较机械化，就是通过大量的代码练习，让自己有代码的感觉（类似英语的语感），这样后期才可以自己独立完成代码，告别CV大侠。我自己在学习的时候会有一些简单的作业、练习等等，然后视频要求要能默写出来的就反复的练习，直到睡觉做梦还在写代码。。。。。。。可能有点夸张，但是真的要大量大量的代码堆积。 言归正传，前期看书或者视频都会提到类、循环等等，我自己大概总结了一下前期应...
大数据必学Java基础（二十八）：Arrays工具类和数组的复制操作
07-11
的复制操作在Java中，数组的复制操作有多种方式，其中`Arrays`工具类提供了便捷的方法。本节将详细介绍如何使用`Arrays`工具类来进行数组的复制。 1. `Arrays.copyOf()` `Arrays.copyOf()`方法用于创建一个新的数组...
java：接口和抽象类练习
12-21
在Java编程语言中，抽象类和接口是两种重要的机制，它们...在给定的练习中，`GeoGraph`类将作为基础，用于描述不同几何图形的共同属性和行为。通过比较和排序，可以更好地理解和展示抽象类和接口在实际问题中的应用。
Java-Programming-Arrays-Lists-and-Structured-Data
05-18
在处理结构化数据时，Java提供了多种内置类和接口，如TreeMap、HashSet、LinkedList等，它们实现了特定的数据结构和算法。例如，HashSet用于存储不重复的元素，而TreeMap则根据键的自然顺序或自定义比较器对键值对...
java基础模拟试测试题
05-30
Java基础是每位Java开发者必须掌握的核心知识，涵盖了编程语法、面向对象编程、异常处理、集合框架、IO流、多线程、网络编程等多个方面。在这个“java基础模拟试测试题”中，我们可以预见到一系列旨在检验和提升这些...
javalib:Java库代码
05-26
`java.lang`包是所有Java程序的基础，它包含了所有其他包的默认导入类，如`Object`、`String`、`System`和`Math`等。`Object`类是所有类的父类，提供了基础的成员方法如`equals()`、`hashCode()`和`toString()`。`...
Java基础——Arrays类
qq_52519008的博客
05-08 5995
每日正能量 如果你要做一件事，不要到处宣言自己的想法，只管安安静静地去做，值不值，时间是最好的证明，自己的人生，得自己负责。 Arrays类 JDK中提供了一个专门用于操作数组的工具类，即Arrays类，位于java util 中。 用前需导包：import java.util.Arrays; 1. Arrays类常用方法 返回类型 方法 说明 String toString（array） 将数组array转换成字符串 void s...
Java数组详解3：Arrays 类（工具类）
sunyusong666的博客
03-05 655
Java数组详解3：Arrays 类（工具类）
Java-Arrays类
Ego_Ekko的博客
08-18 366
Arrays类里面包含了一系列静态方法，用于管理或操作数组。
Java中Arrays类的常用方法
热门推荐
weixin_41924879的博客
08-27 3万+
Java中 Arrays 类的常用方法 Arrays类位于 java.util 包中，主要包含了操作数组的各种方法。 import java.util.Arrays; Arrays.fill(); //填充数组 int[] arr = new int[5];//新建一个大小为5的数组 Arrays.fill(arr,4);//给所有值赋值4 String str...
Java Arrays类(Java数组常用的三个方法)
二师兄想吃肉的博客
05-16 1万+
一、Arrays类介绍 二、Arrays类中的`静态`方法 1.toString方法 2.sort方法 3.binarySearch方法 4.其它方法

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值