Java基础类库--开发支持类库

内容学习于：edu.aliyun.com


1. Arrays类

  数组排序: java.til.Arrays.sort()。 实际上Arrays类就是属于java.util 包中的一个类并且sort()方法是一个static方法，Arrays 类之中的全部方法都是static方法，所以这个类的构造方法肯定是被私有化了，在Arrays 类之中支持有如下的一些常用操作方法:

  • <mark>数组排序：public static void sort(数据类型[] a)</mark>
  • <mark>【依赖排序】二分查找：public static int binarySearch(数据类型[] a,数据类型 key)</mark>
  • 【依赖排序】数组比较：public static int compare(数据类型[] a, 数据类型[] b)
    返回三个类型：大于（1），小于（-1），等于（0）
  • 【依赖排序】数组相等判断：public static boolean equals(数据类型[] a, 数据类型[] a2)
  • 数组填充：public static void fill(数据类型[] a, 数据类型val)
  • <mark>转成字符串：public static String toString(数据类型[] a)</mark>

观察数组填充：

public class JavaAPIDemo {
    public static void main(String[] args) {
        int data [] = new int[10];
        Arrays.fill(data,3);//对数组内容进行填充处理
        System.out.println(Arrays.toString(data));
    }
}

结果：

[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]

  在Arrays类里面提供有一个最为重要的操作方法:二分查找法，主要的功能是确定要查找的数据是否存在，<mark>二分查找的核心本质在于数组必须是排序后的结果。</mark>

二分查找代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        int data [] = new int[]{1,5,7,2,3,6,0};//数组
        Arrays.sort(data);//数组默必须升序排序（默认）
        System.out.println(Arrays.binarySearch(data,3));//返回数据的索引
    }
}

结果：

3

  如果你现在的数据量本身并不大，也就只有20个数据，那么即便时间复杂度为n,那么也没有多慢，但是如果你现在的数据量非常大，大概有200个数组内容，那么这个时候就会发现循环要执行200次。所以为了提升数据的查询性能，可以借助于二分查找法进行处理。。
  <mark>传统的查找，需要依次比较，时间复杂度为n，时间复杂度为log（n），是最为理想的状态。</mark>

二分查找源码：

private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
                                     Object key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;//采用移位的计算
            @SuppressWarnings("rawtypes")
            Comparable midVal = (Comparable)a[mid];
            @SuppressWarnings("unchecked")
            int cmp = midVal.compareTo(key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

移位和整除比较：

public class JavaAPIDemo {
    public static void main(String[] args) {
        int data [] = new int[]{1,5,7,2,3,6,0,13,16,19};//数组
        Arrays.sort(data);//数组默必须升序排序（默认）[0, 1, 2, 3, 5, 6, 7, 13, 16, 19]
        int low = 0;
        int high = data.length-1;
        System.out.println((low+high)/2);//整除
        System.out.println((low+high)>>>1);//移位处理
    }
}

结果：

5
5

<mark>面试题:请编写一个二分查找法实现数组内容的查询</mark>

  在Arrays类中是有所提供的，使用的是binarySearch()，而这个查找的方式默认采用的是比较器的处理模式来完成的，那么下面可以按照同样的思路，通过循环的方式来处理，但是一旦通过循环的方式就只能够使用基本数据类型以确定大小关系了
  11 的2进制数据：00000000 00000000 00000000 00001011
  无条件向右移1位： 00000000 00000000 00000000 00000101 转为十进制是5，相当于整除除2
  使用2进制处理的最直接优势在于：速度更快，但是在大内存的情况下 ，这样的性能提升是有限的，但是所有不起眼的操作才可能造成性能的提升

简单二分查找改写代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        int data [] = new int[]{1,5,7,2,3,6,0,13,16,19};//数组
        Arrays.sort(data);//数组默必须升序排序（默认）[0, 1, 2, 3, 5, 6, 7, 13, 16, 19]
        for (int i :data){
            System.out.println(ArrayUtil.binarySearch(data,i));
        }
        
    }
}

class ArrayUtil{
    private ArrayUtil(){}

    public static int binarySearch(int data[],int key){
        int low = 0;//左边的索引
        int high = data.length-1;//右边的索引
        while (low<=high){//可能数据在边界
            int mid = (low + high)>>>1;//找到中间值
            if (data[mid]>key){//如果数据比中间的数小
                high = mid -1;//数据在左边
            }
            else if (data[mid]<key){
                low = mid+1;
            }
            else {//找到了
                return mid;
            }
        }
        return -1;//找不到
    }
}

结果：

0
1
2
3
4
5
6
7
8
9

  在实际的开发之中，这种代码你可能永远不会写到，因为如果真有此需求，直接通过现有的功能实现即可，但是笔试之中容易问到。

2. UUID类

  UUID是一种生成无重复字符串的一 种程序类，==这种程序类的主要功能是根据时间戳实现一个自动的无重复的字符串定义。==一般在获取UUID的时候往往都是随机生成一的个内容，所以可以通过如下方式获取:

  • 获取UUID对象：public static UUID randomUUID()

  • 根据字符串获取UUID内容：public static UUID fromString(String name)

    代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        UUID uid = UUID.randomUUID();
        System.out.println(uid.toString());
    }
}

结果：

ee5ab7e2-96b0-4c12-b3a0-a37c03656c6e

  <mark>在对一些文件进行自动命名处理的情况下，UUID类型非常好用。</mark>

3. Optional类

  <mark>Optional类的主要功能是进行null的相关处理</mark>，在以前进行程序开发的时候，如果为了防止程序之中现空指向异常，往往可以追加有null的验证。

传统引用传递问题代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        MessageUtil.useMessage(null);
    }
}


interface IMessage {
    String getContent();
}


class MessageImpl implements IMessage {
    @Override
    public String getContent() {
        return "www.mldn.cn";
    }
}


class MessageUtil {
    private MessageUtil() {
    }

    public static IMessage geIMessage() {
        return new MessageImpl();
    }

    public static void useMessage(IMessage msg) {
        if (!(msg == null))
            System.out.println(msg.getContent());//可能会出现null，导致空指向异常
    }
}

  在引用接收的一方往往都是被动的进行判断，所以为了解决这种被动的处理操作，在Java类中提供有一个Optional的类，这个类可以实现null 的处理操作，在这个类里面提供有如下的一些操作方法:

  • 返回空数据：public static Optional empty()
  • 获取空数据：public T get()
  • 保存数据，但是不允许出现空：public static Optional of(T value)
    • 如果为空，则抛出NullPointerException
  • 保存数据，允许为空：public static Optional ofNullable(T value)
  • 空的时候返回其他数据：public T orElse(T other)

  操作如下图所示：

修改程序代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        IMessage iMessage = MessageUtil.geIMessage().get();//获取数据
        MessageUtil.useMessage(iMessage);
    }
}


interface IMessage {
    String getContent();
}


class MessageImpl implements IMessage {
    @Override
    public String getContent() {
        return "www.mldn.cn";
    }
}


class MessageUtil {
    private MessageUtil() {
    }

    public static Optional<IMessage> geIMessage() {
        return Optional.of(new MessageImpl());//有对象
    }

    public static void useMessage(IMessage msg) {
        if (!(msg == null))
            System.out.println(msg.getContent());//可能会出现null，导致空指向异常
    }
}

结果：

www.mldn.cn

  如果说现在数据保存的内容是null,则就会在保存处出现异常，如下图所示:

  由于Optional类中允许保存有null 的内容，所以在数据获取的时候也可以进行null的处理。但是如果为null,则在使用get()获取数据的时候就会出现“Exception in thread “main” java : util . NoSuchElementException: No value present"异常信息，所以此时可以更换为orElse()方法。

空的处理：

public class JavaAPIDemo {
    public static void main(String[] args) {
        IMessage iMessage = MessageUtil.geIMessage().orElse(new MessageImpl());//获取数据
        MessageUtil.useMessage(iMessage);
    }
}

  <mark>在所有引用数据类型的操作处理之中，null 是一个重要的技术问题，所以JDK 1.8 后提供的这个新的类对于null的处理很有帮助，同时也是在日后进行项目开发之中使用次数很多的一个程序类。</mark>

4. ThreadLoad类

  在真正去了解ThreadLocal类作用的时候下面编写一个简单的程序做一个先期的分析。

代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        Message msg = new Message();//实例化消息主体对象
        msg.setInfo("www.mldn.cn");//设置消息发送内容
        Channel.setMessage(msg);//设置要发送的消息
        Channel.send();//发送消息
    }
}


class Channel {//消息发送的通道
    private static Message message;

    public static void send() {//发送消息
        System.out.println("【消息发送】" + message.getInfo());
    }

    public static void setMessage(Message message) {
        Channel.message = message;
    }
}

class Message {//要发送的消息体
    private String info;

    public void setInfo() {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

结果：

【消息发送者C消息发送】、要发送的第三个消息
【消息发送者A消息发送】、要发送的第三个消息
【消息发送者B消息发送】、要发送的第二个消息

  如图所示：

  对于当前的程序实际上采用的是一种单线程的模式来进行处理的。那么如果在多线程的状态下能否实现完全一致的操作效果呢?为此将启动三个线程进行处理。

多线程的影响代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第一个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者A").start();
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第二个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者B").start();
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第三个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者C").start();

    }
}


class Channel {//消息发送的通道
    private static Message message;

    public static void send() {//发送消息
        System.out.println("【" + Thread.currentThread().getName() + "消息发送】、" + message.getInfo());
    }

    public static void setMessage(Message message) {
        Channel.message = message;
    }
}

class Message {//要发送的消息体
    private String info;

    public void setInfo() {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

结果：

【消息发送者C消息发送】、要发送的第三个消息
【消息发送者A消息发送】、要发送的第三个消息
【消息发送者B消息发送】、要发送的第二个消息

  这个时候消息的处理产生了影响，如下图所示：
  在保持Channel (所有发送的通道)核心结构不改变的情况下，需要考虑到每个线程的独立操作问题。那么在这样的情况下就发现对于Channel类而言除了要保留有发送的消息之外，还应该多存放有一个每一一个线程的标记(当前线程)，那么这个时候就可以通过ThreadLocal类来存放数据。在ThreadLocal类里面提供有如下的操作方法:

  • 构造方法：public ThreadLocal()
  • 设置数据：public void set(T value)
  • 取出数据：public T get()
  • 删除数据：public void remove()

  如下图所示：

修改后的代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第一个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者A").start();
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第二个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者B").start();
        new Thread(() -> {
            Message msg = new Message();//实例化消息主体对象
            msg.setInfo("要发送的第三个消息");//设置消息发送内容
            Channel.setMessage(msg);//设置要发送的消息
            Channel.send();//发送消息
        }, "消息发送者C").start();

    }
}


class Channel {//消息发送的通道
    private static final ThreadLocal<Message> MESSAGE_THREAD_LOCAL = new ThreadLocal<>();

    public static void send() {//发送消息
        System.out.println("【" + Thread.currentThread().getName() + "消息发送】、" + MESSAGE_THREAD_LOCAL.get().getInfo());
    }

    public static void setMessage(Message message) {
        MESSAGE_THREAD_LOCAL.set(message);

    }
}

结果：

【消息发送者B消息发送】、要发送的第二个消息
【消息发送者C消息发送】、要发送的第三个消息
【消息发送者A消息发送】、要发送的第一个消息

  <mark>每一个线程通过ThreadLocal只允许保存一个数据。</mark>

5. 定时调度

  <mark>定时器的主要操作是进行定时任务的处理</mark>，就好比你们每天早晨起来的铃声-样。在Java中提供有定时任务函数支持，但是这种任务的处理只是实现了一种间隔触发的操作。
  如果要想实现定时的处理操作主要需要有一个定时操作的主体类，以及一个定时任务的控制。可以使用两个类实现:

  • java.util.TimerTask 类：实现定时任务处理
  • java.util.Timer类：实现任务的启动，启动的方法：
    • 任务启动：public void schedule(TimerTask task,long delay)、延迟时间为毫秒
    • 间隔触发：public void scheduleAtFixedRate(TimerTask task,long delay,long period)

实现定时任务处理代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        Timer timer = new Timer();
        //100毫秒后执行，间隔1秒执行一次
        timer.scheduleAtFixedRate(new MyTask(), 100, 1000);
    }
}


class MyTask extends TimerTask {//任务主体

    @Override
    public void run() {//多线程处理方法
        System.out.println(Thread.currentThread().getName() + "、定时任务开启，当前时间是：" + System.currentTimeMillis());
    }
}

结果：

Timer-0、定时任务开启，当前时间是：1579394654503
Timer-0、定时任务开启，当前时间是：1579394655504
Timer-0、定时任务开启，当前时间是：1579394656504
……

  如下图所示：

  <mark>这种定时是由JDK最原始的方式提供的支持，但是实际上开发之中利用此类方式进行的定时处理实现的代码会非常的复杂。</mark>

6. Base64加密工具

  正常来讲加密基本上永远都要伴随着解密，所谓的加密或者是解密往往都需要有一些所谓的规则。在JDK1.8开始提供有一组新的加密处理操作类，Base64 处理，在这个类里面有两个内部类:

  • Base64.Encoder:进行加密处理;
      加密：public byte[] encode(byte[] src)
  • Base64.Decoder:进行解密处理。
      解密：public byte[] decode(String src)

  虽然Base64可以实现加密与解密的处理，但是其由于是一个公版的算法，所以如果直接对数据进行加密往往并不安全，那么最好的做法是<mark>使用盐值操作。</mark>

解密和解密代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        String msg = "www.mldn.cn";
        String encMsg = new String(Base64.getEncoder().encode(msg.getBytes()));//加密
        System.out.println(encMsg);
        String oldMsg = new String(Base64.getDecoder().decode(encMsg));//解密
        System.out.println(oldMsg);
    }
}

结果：

d3d3Lm1sZG4uY24=
www.mldn.cn

使用盐值操作代码：

public class JavaAPIDemo {
    public static void main(String[] args) {
        String salt = "mldnjava";//盐值
        String msg = "www.mldn.cn" + "{" + salt + "}";
        String encMsg = new String(Base64.getEncoder().encode(msg.getBytes()));//加密
        System.out.println(encMsg);
        String oldMsg = new String(Base64.getDecoder().decode(encMsg));//解密
        System.out.println(oldMsg);
    }
}

结果：

d3d3Lm1sZG4uY257bWxkbmphdmF9
www.mldn.cn{mldnjava}

  即便现在有盐值实际上发现加密的效果也不是很好，<mark>最好的做法是多次加密。</mark>

复杂加密代码：

class StringUtil {
    private static final String SALT = "mldnjava";//公共盐值
    private static final int REPEAT = 5;//加密的次数

    /** * 加密处理 * * @param str 需要加密的字符串 * @return加密后的字符串 */
    public static String encode(String str) {
        String temp = str + "{" + SALT + "}";//盐值不对外公布
        byte[] data = temp.getBytes();//将字符串转换为字节
        for (int i = 0; i < REPEAT; i++) {//加密处理
            data = Base64.getEncoder().encode(data);
        }
        return new String(data);
    }

    /** * 解密处理 * @param str 需要解密的字符串 * @return 解密后去掉盐值的字符串 */

    public static String decode(String str) {
        byte[] data = str.getBytes();
        for (int i = 0; i < REPEAT; i++) {
            data = Base64.getDecoder().decode(data);
        }
        return new String(data).replaceAll("\\{\\w+\\}", "");
    }

}

public class JavaAPIDemo {
    public static void main(String[] args) {
        String str = StringUtil.encode("www.mldn.cn");
        System.out.println(str);
        System.out.println(StringUtil.decode(str));
    }
}

结果：

VjJ0U1QyRXdNSGRsU0ZKT1YwVTFhRlZ1Y0ZOTlZtUlZVMVJHVDAxcmNGb***V1F3WVZkS1dWRnRPV0ZTZWtaSVZERkZPVkJSUFQwPQ==
www.mldn.cn

<mark>最好的做法是使用2-3种加密程序，同时再找到一些完全不可解密的加密算法。</mark>

全部评论

相关推荐

11-19 15:08
中国矿业大学（北京） 后端
25届浙江二本JAVA简历：估计投500份，最多3-5个面试
注：为保证用户信息安全，姓名和学校等信息已经进行同层次变更，内容部分细节也进行了部分隐藏另外：我们出这一系列校招简历指导的原因，就是看很多学生被忽悠，没有先定位大厂、中厂还是小公司，导致没有面试机会。&nbsp;我们不放任何的广告和品牌名，完全是反馈牛客社区。大家也不要私信，现在比较忙，没空帮大家改简历。简历总体说明校招的第一法则就是必须要确定校招层次。开发岗分为大中小厂，不同的层次对学校背景、时间点、项目和考点的要求都不太一样，所以必须要确定就业的层次。&nbsp;这是一份25届某二本的计算机的JAVA简历。如果是我们的老粉丝会知道，HR第一眼要看你学的专业满不满足招聘需求，所以投递简历的时候一定要注意，先...
投递联想等公司10个岗位 > 简历中的项目经历要怎么写 你觉得哪一届的校招最难？
点赞 评论 收藏
分享
昨天 17:35
厦门大学嘉庚学院 用户运营
入职第一天的正确打开方式
入职第一天，千万别傻傻地坐在工位上发呆。虽然领导可能会说先熟悉环境，但这并不意味着你可以闲着。其实，第一天的关键在于主动出击。要有“工作的样子”，主动探索、学习和交流。最重要的是，养成写日报的习惯，每天总结和反思，并主动提交给领导。日报模板分享工作内容第一天，我通过PPT了解了公司的企业文化和考勤制度，这让我对公司的运作有了初步的认识。接着，我开始了解公司的主要产品线和目前负责项目的进度，重点是弄清楚项目的产品和定位。最后，我明确了接下来一周的主要工作内容。工作计划接下来，我计划继续深入学习公司的组织架构和业务产品信息。同时，我会详细了解公司在公众号、小红书和抖音上发布的内容，并初步确定小红书...
点赞 评论 收藏
分享
头像
11-09 17:30
门头沟学院 Java
抽象华为
TYUT太摆金星：我也是，好几个华为的社招找我了
点赞 评论 收藏
分享
11-15 17:14
暨南大学 嵌入式工程师
同学一投即中，羡慕了😭😭😭😭😭😭
牛客722552937号：新锐之星有点坑爹，特别是对男的
点赞 评论 收藏
分享
11-18 09:40
南昌航空大学 网络推广
点赞 评论 收藏
分享
点赞 收藏 评论
分享

全站热榜

正在热议
# 25届秋招总结 #
246498次浏览 2005人参与
# 学历or实习经历，哪个更重要 #
40975次浏览 298人参与
# 北方华创开奖 #
22727次浏览 257人参与
# 地方国企笔面经互助 #
2518次浏览 6人参与
# 你最想要的公司福利是？ #
39814次浏览 124人参与
# 选完offer后，你后悔学本专业吗 #
10215次浏览 75人参与
# 面试题刺客退退退 #
136998次浏览 2091人参与
# 国企/银行/研究所公司爆料 #
89673次浏览 412人参与
# 应届生被毁约被毁意向了怎么办 #
26996次浏览 238人参与
# 一觉醒来，我觉醒了超级打工人系统 #
2852次浏览 35人参与
# 机械应届生薪资要多少才合适？ #
12372次浏览 60人参与
# 查收我的offer竞争力报告 #
16631次浏览 228人参与
# 校招入职后的感受 #
156863次浏览 1960人参与
# 你觉得第一学历对求职有影响吗？ #
14866次浏览 121人参与
# 没有实习经历，还有机会进大厂吗 #
804905次浏览 13813人参与
# 我的工作日记 #
21140次浏览 270人参与
# 不给转正的实习，你还去吗 #
1516635次浏览 16964人参与
# 寒假躺平还是提前实习 #
58363次浏览 438人参与
# 总结:哪家公司面试体验感最差 #
25669次浏览 129人参与
# 秋招OC许愿 #
226416次浏览 1869人参与
# 如何写一份好简历 #
601847次浏览 8436人参与
牛客网
牛客企业服务