JAVASE15

最新推荐文章于 2024-04-22 15:04:22 发布
最新推荐文章于 2024-04-22 15:04:22 发布
阅读量185 收藏
点赞数
分类专栏： java 后端 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnjss/article/details/115638488
版权

JAVASE15

一、TreeMap

TreeSet底层就是由TreeMap维护的

底层结构: 红黑树
特点: 有序(默认升序排序),存放存储与内部真实存储顺序是不一致的

注意: 以后什么功能|结构能够实现排序的,想到比较器:指定比较规则

去重排序: 根据key实现去重与排序
key中存放的数据的类型->1)实现内部比较器 2)实现外部比较器

我们先写一User类

public class User implements Comparable<User>{
    private String username;
    private int password;

    public User() {
    }

    public User(String username, int password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Person{" +
                "username='" + username + '\'' +
                ", password=" + password +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return password == user.password &&
                Objects.equals(username, user.username);
    }

    @Override
    public int hashCode() {
        return Objects.hash(username, password);
    }

    //内部比较方式
    @Override
    public int compareTo(User o) {
        return this.getUsername().compareTo(o.getUsername());
    }
}

然后开始存储

public class TreeMapDemo01 {
    public static void main(String[] args) {
        //默认根据User类的内部比较器提供的比较方式进行比较排序
        //TreeMap<User,String> map = new TreeMap<>();

        //指定使用某种外部比较规则
        TreeMap<User,String> map = new TreeMap<>((o1, o2) -> o1.getPassword()-o2.getPassword());

        //map.put(null,null);  //treemap中存储键值对key不能为null

        //存储数据,在存储的时候才会比较,排序
        map.put(new User("阿浪",111),"新浪");
        map.put(new User("阿汤",122),"腾讯");
        map.put(new User("阿哥",133),"斗鱼");
        map.put(new User("阿笙",144),"拼多多");
        map.put(new User("阿烨",144),"点淘app");

        System.out.println(map);
    }
}

二、Properties

Properties为Hashtable的子类，要求键与值只能为字符串 ，不能为null，常与配置文件(与外界交互的信息) 即内存与存储介质(文件、数据库、网络、服务器内存等)交互

​ properties根式作为配置文件的格式存在,键值对 都是字符串,简单
​ 程序从properties文件中读取数据:
​ void load(InputStream inStream) 从输入字节流中读取属性列表（键和元素对）。

.properties文件

userName=庄周
passWord=12345678

public class PropertiesDemo02 {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();

        //通过properties对象从配置文件中读取数据
        //指定从哪一个文件,通过哪个流加载
        pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

        System.out.println(pro.getProperty("userName"));
        System.out.println(pro.getProperty("passWord"));
    }
}

注意：这里如果我们的userName输入的是中文，我们需要设置好编码格式不然在java中输出的就是类似于乱码的存在。

三、Collections

Collections 与 Collection 之间的区别:
Collection 集合体系的上层接口
Collections 操作集合数据的工具类 , 与 Array很像

查找的方法查找特定对象
使用前提: 升序排序

HashMap线程不安全问题:
1.Hashtable类型,线程安全的HashMap
Hashtable是同步的。 如果不需要线程安全实现，建议使用HashMap代替Hashtable 。 如果需要线程安全的高度并发实现，则建议使用ConcurrentHashMap代替Hashtable 。
2.Collections -> static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全）映射。
3.juc包(高级并发编程包) - > ConcurrentHashMap 线程安全的哈希表—>推荐,安全性好效率高

public class CollectionsDemo01 {
    public static void main(String[] args) {
        //sort
        //List<Integer> list = List.of(5,1,2,6,4,3);
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(5);
        list.add(1);
        list.add(4);
        list.add(2);

        System.out.println(list);
        //升序
        Collections.sort(list);

        System.out.println(list);

        List<User> list2 = new ArrayList<>();
        list2.add(new User("", 19));
        list2.add(new User("", 18));
        list2.add(new User("", 20));

        Collections.sort(list2, (o1, o2) -> o2.getPassword() - o1.getPassword());

        System.out.println(list2);

        // void shuffle(List) //对List容器内的元素进行随机排列
        // Collections.shuffle(list);

        System.out.println(list);

        //reverse
        //Collections.reverse(list);
        System.out.println(list);

        //void fill(List, Object)
        //Collections.fill(list,111);
        System.out.println(list);

        System.out.println(Collections.binarySearch(list, 6));//-插入点-1
    }
}

四、Thread

线程（英语：thread）是操作系统**能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

​ 多线程优点: 资源利用率更好;程序设计在某些情况下更简单；程序响应更快

进程与线程的区别

区别进程线程
根本区别作为资源分配的单位调度和执行的单位
开销每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的的开销线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程由独立运行栈和程序计数器（PC），线程切换的开销小
所处环境在操作系统中能同时运行多个任务（程序）在同一应用程序中有多个顺序流通时执行
分配内存系统在运行的时候会为每个进程分配不同的内存区域线程间共享进程的所有资源，每个线程只有自己的堆栈和局部变量，线程有CPU独立调度执行，在多CPU环境下就允许多个线程同时运行
包含关系没有线程的进程可以看做单线程，如果一个进程拥有多个线程，则执行过程不是一条线的，而是多余线（线程）共同完成的线程是进程的一部分，所以线程有的时候会被称为是轻量级进程或轻权进程

创建线程+开启线程:
1.继承Thread,重写run() + start()
2.实现Runnable,重写run()方法,方法的内部定义线程体 + start()
接口: 可以多实现,类只能单继承
可以资源共享

第一种方法

public class ThreadDemo01 extends Thread{
    public static void main(String[] args) {
        //创建线程
        ThreadDemo01 th = new ThreadDemo01();
        //开启线程
        th.start();
        //th.run(); 方法的调用

        //主线程
        for(int i=1;i<=20;i++){
            System.out.println("一边讲课");

            /*休息10ms*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /*
        定义线程体代码
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边喝水");

            /*休息10ms*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

第二种方法

实现Runnable接口,重写run()方法 + start() 开启线程
接口可以多实现
可以实现资源共享

public class ThreadDemo02 implements Runnable{
    public static void main(String[] args) {
        //线程的创建
        ThreadDemo02 th = new ThreadDemo02();
        Thread thread = new Thread(th);

        //开启
        thread.start();

        new Thread(new ThreadDemo02()).start();


        for(int i=0;i<=50;i++){
            System.out.println("一边说话...");
        }
    }

    /*
        线程体
     */
    @Override
    public void run() {
        for(int i=0;i<=50;i++){
            System.out.println("一边吃饭...");
        }
    }
}

这里我们可以使用内部类来简化代码

public class ThreadDemo03 {

    //内部类
    static class Inner1 implements Runnable{

        @Override
        public void run() {
            for(int i=0;i<=50;i++){
                System.out.println("一边打游戏...");
            }
        }
    }

    static class Inner2 extends Thread{

        @Override
        public void run() {
            for(int i=0;i<=50;i++){
                System.out.println("一边打上厕所...");
            }
        }
    }

    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=50;i++){
                    System.out.println("一边陪女朋友...");
                }
            }
        }).start();

        //lambda
        new Thread(()->{
            for(int i=0;i<=50;i++){
                System.out.println("一边陪直播...");
            }
        }).start();

        //线程开启
        new Thread(new Inner1()).start();

        new Inner2().start();
    }
}

这里我们写一个经典的例子

/*
    龟兔赛跑
        参赛者跑满一百步结束
        乌龟 : 一直跑不休息
        兔子 : 每20步休息2ms
        如果一旦有人赢了游戏就结束
 */
public class ThreadDemo04 {
    public static void main(String[] args) {
        Match match = new Match();

        new Thread(match,"乌龟").start();
        new Thread(match,"兔子").start();
    }
}

//比赛
class Match implements Runnable{
    //结束标识
    private String winner;  //记录赢的人的名字


    @Override
    public void run() {
        //i作为步数
        for(int i=1;i<=100;i++){
            //是否为兔子
            System.out.println(Thread.currentThread().getName()+"正在跑第"+i+"步");
            if("兔子".equals(Thread.currentThread().getName()) && i%20==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //结束判断
            if(checkOver(i)){
                break;
            }
        }

    }

    //结束的条件判定  返回值: true结束   false不结束
    public boolean  checkOver(int steps){
        boolean flag = false;
        //有人赢了
        if(winner != null){
            return true;
        }
        //自己赢了
        if(steps==100){
            winner = Thread.currentThread().getName();
            return true;
        }
        return false;
    }
}

第三种开启线程的方法（了解即可）

Callable 接口 call() ,定义线程体
优点:
可以抛出异常,可以定义返回值

public class ThreadDemo05 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Match2 match = new Match2();

        //通过线程池 固定大小线程池2个  static ExecutorService newFixedThreadPool(int nThreads)
        //1.创建执行服务
        ExecutorService server = Executors.newFixedThreadPool(2);
        //2.提交任务  <T> Future<T> submit(Callable<T> task) 提交值返回任务以执行并返回表示任务的挂起结果的Future。
        Future<Integer> f1 = server.submit(match);
        Future<Integer> f2 = server.submit(match);

        //3.获取结果
        //Integer result1 = f1.get();
        //Integer result2 = f2.get();

        //System.out.println(result1);
        //System.out.println(result2);

        //4.结束服务
        server.shutdown();

    }
}

//比赛
class Match2 implements Callable<Integer> {
    //结束标识
    private String winner;  //记录赢的人的名字


    /*
        可以抛出异常
     */
    @Override
    public Integer call() throws InterruptedException {
        //i作为步数
        for(int i=1;i<=100;i++){
            //是否为兔子
            System.out.println(Thread.currentThread().getName()+"正在跑第"+i+"步");
            if("兔子".equals(Thread.currentThread().getName()) && i%20==0){
               Thread.sleep(20);
            }
            //结束判断
            if(checkOver(i)){
                return i;
            }
        }
        return null;
    }

    //结束的条件判定  返回值: true结束   false不结束
    public boolean  checkOver(int steps){
        boolean flag = false;
        //有人赢了
        if(winner != null){
            return true;
        }
        //自己赢了
        if(steps==100){
            winner = Thread.currentThread().getName();
            return true;
        }
        return false;
    }
}
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
JavaSE上机练习15.zip
04-20
【JavaSE上机练习15.zip】是一个包含Java标准版（Java Standard Edition，简称JavaSE）编程实践的压缩包，由原创作者田超凡创作。这个练习可能涉及到Java语言的基础知识，面向对象编程，以及GUI（图形用户界面）的...
javase阶段15个实战项目代码
09-21
15个javase小项目的源代码，可以用来做实训练习，也可以用来巩固java阶段性学习成果
JavaSE 15(String 习题）
weixin_45333967的博客
08-06 329
前言： 字符串String在java编程中也是很重要的一个知识点，所以在老师带领下做过的习题我准备整理在这里，一边自己的复习与巩固。 1. 1.思路及步骤： 2.编程代码及运行结果： 总结： 运用了面向对象的思想做这道题，需要构造函数。 2. 1.思路及步骤： 2.编程代码及运行结果： 总结：比较两个字符串，其实字符串本质就是字符数组，也可以比较各个位置的各个元素 3. 1.思路...
Java SE 15 新增特性
Practitioner
08-21 222
如果没有一个密封的类，编译器就不能合理地确定所有可能的子类都被我们的 if-else 语句所覆盖。隐藏类的目标是允许在运行时创建不能被发现的类。像这样的类通常有一个很短的生命周期，因此，隐藏类被设计成在加载和卸载时都很高效。instanceof 类型匹配功能在 Java SE 14 中进行了预览，Java SE 15 旨在继续其预览状态，没有新的增强功能。请注意，当前版本的 Java 确实允许创建类似于隐藏类的匿名类。这种有限的、详尽的层次结构是使用密封类的一大好处。然而，默认的垃圾收集器仍然是 G1。
JAVASE-15-动态代理
苍煜
06-26 552
Table of Contents 1：基于JDK的动态代理 1.1：创建接口 1.2：创建实现类 1.3：创建InvocationHandler方法执行器 和生成代理类 1.4：编写代理类实际的调用。 1.5：或者使用内部类来标识InvocationHandler处理器； 2：基于CGLIB的动态代理 2.1：引入jar包 2.2：被代理类 2.3：代理了实现MethodInterceptor接口 2.4：测试： 2.5：CGLIB原理 目前java动态代理的实现分为两种 1.
JavaSE(十五)——注解
吃饭了吗
12-09 826
1. 概述 不是程序本身，但可以对程序作出解释，可以被其他程序（比如：编译器）读取。 格式：@注释名（参数值） 使用范围：可以附加在package、class、method、field等上面。 2. 内置注解 @Override: 只适用于修饰方法，表示一个方法声明打算重写超类中另一个方法声明。 @Deprecated: 用于修饰方法、属性、类，表示不鼓励使用这样的元素。 @Suppress...
JavaSE全套学习PPT15
12-07
JavaSE阶段的全套学习以及练习PPT,学习者可以按顺序,从上到下,学习,资料详细,无遗漏,包含对应练习.和项目.
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
Java javase15
kkh01421的博客
08-27 227
一、网络编程 （一）软件结构 C/S结构：全称为Client/Server结构，是指客户端和服务器结构。常见的有QQ、迅雷等。 B/S结构：全称为Browser/Server结构，是指浏览器和服务器结构。常见的有谷歌、火狐等等。 网络编程：就是在一定的协议下实现两台计算机的通信的程序。 （二）网络通信协议 网络通信协议：通过计算机网络使多台计算机实现连接位于同一个网络中的计算机在进行连接和通信时需要遵守的一定规则。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据传输的格式、传输的速率和步骤
JavaSE 15
cystart的博客
02-04 139
abstract关键字的使用: 1.abstract:抽象的 2.abstract可以用来修饰的结构：类、方法 3. abstract修饰类：抽象类 ①此类不能实例化 ② 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程） ③开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 4. abstract修饰方法：抽象方法 ①抽象方法只有方法的声明，没有方法体 ②包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。 ③若子类重写了父类中的所有的抽象方法后，此子
JavaSE第15篇：集合之Collection集合上篇
【01编程】的博客
08-06 804
目录第一章：对象数组第二章：认识集合1.1-集合概述（了解）1.2-Java中的集合框架（了解）1.3-Collection集合通用方法（记忆）第三章：遍历集合3.1-Iterator方式遍历（记忆）3.2-增强for方式遍历（记忆）第四章：数据结构4.1-概述（了解）4.2-数据结构-栈（了解）4.3-数据结构-队列（了解）4.4-数据结构-数组（了解）4.5-数据结构-链表（了解）第五章：List集合5.1-概述（了解）5.2-List集合常用方法（记忆）第六章：ArrayList集合6.1-概述（了解
javase_15(File类的应用)
weixin_30914981的博客
08-11 81
File类:用来将文件或者文件夹封装成对象方便对文件或者文件夹的操作File对象可以作为参数传递给一个流.递归:函数自己调用自己应用场景:当某一个功能需要重复调用..1.遍历一个文件,并且让让这个文件写入到一个文本里面,(需要树状的排序) 1 package com.javami.kudy.CodeAM; 2 import java.io.BufferedWriter; ...
Java SE基础知识（15）
TuZiBuQing的博客
08-20 664
一、概述 在JAVA中，用Thread类代表线程，所有线程对象，都必须是Thread类或者Thread类子类的实例。每个线程的任务就是执行一段顺序执行的代码，JAVA使用线程执行体来容纳这段代码。所以，我们创建线程时，主要是根据实际需求，编写放入线程执行体的代码。 二、三种创建方式 2.1 第一种，通过继承Thread类创建线程类 通过继承Thread类来创建并启动多线程的步骤如下： 1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把r
Java SE(15) 变量1
wqh101121的博客
12-23 161
定义
JavaSE-15-常用对象StringBuffer StringBuilder
oDianZi1234567的博客
05-02 279
StringBuffer 与String 区别 1.StringBuffer 就是字符串缓冲区， 2.StringBuffer可变长度。String 长度不可变。 3. 可以存储不同类型数据。最终转换成字符串 ，初始容量默认16个字符。 4.可以对字符串 插入insert 追加 append ,修改replace。删除delete,查找indexOf (增删改查) package stringb...
JavaSE学习15（多线程）
weixin_44643735的博客
11-10 139
1.实现多线程 1.1 进程 进程是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 是进程中的单个顺序控制流，是一条执行路径 单线程： 一个进程如果只有一条执行路径，则称为单线程程序 多线程： 一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 方式1： 定义一个类MyThread继承Thread类 ...
JavaSE-15笔记【注解（+2024新）】
最新发布
weixin_45041745的博客
04-22 868
什么是注解？①注解是JDK1.5才引入的。②注解可以标注在 类上，属性上，方法上 等。③注解可以做到在不改变代码逻辑的前提下在代码中嵌入补充信息。注解与注释注释：给程序员看的，编译器编译时会忽略注释。注解：给编译器看的，或给其它程序看的，程序根据有没有这个注解来决定不同的处理方式。注解的重要性框架实现原理：框架 = 反射 + 注解 + 设计模式。使用@interface来定义注解。默认情况下注解可以出现在类上、方法上、属性上、构造方法上、方法参数上等…。
JavaSE 15 Math 数学工具类
Niiuu的博客
02-09 216
第二十章 Math 数学工具类 20.1 概述 java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算的相关操作。 20.2 绝对值 public static double abs(double num) 20.3 向上取整（向正方向） public static double ceil(double num) 20.3 向下取整 public sta...
Java OOP与JavaSE实战考试重点
15. 创建线程有两种方式：一是实现`Runnable`接口并创建`Thread`对象，二是直接继承`Thread`类。 以上是Java OOP和JavaSE的一些基础概念，这些知识对于理解和编写Java程序至关重要。通过学习和实践这些内容，开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值