java进阶语法

已于 2024-07-18 16:14:28 修改
阅读量316 收藏 7
点赞数 5
分类专栏： java 文章标签： java python linux
于 2024-06-29 16:51:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44699168/article/details/140020584
版权

参考（黑马）：https://www.bilibili.com/video/BV1Cv411372m/

目录

特殊文件

Properties属性文件

在这里插入图片描述

  • Properties是一个Map集合(键值对集合)，但是我们一般不会当集合使用。
  • 核心作用:Properties是用来代表属性文件的，通过Properties可以读写属性文件里的内容。

Properties读取键值对

在这里插入图片描述

PS:

  • 如果要在控制台显示，load()方法最好接受字符流
    public static void main(String[] args) throws Exception {
        //1.创建一个Properties对象（空容器）
        Properties properties = new Properties();

        //2.开始加载属性文件中的键值对数据到properties中去
        properties.load(new FileReader("src\\SpecialFile\\users.properties"));
        System.out.println(properties);

        //3.根据键取值
        System.out.println("0:"+properties.getProperty("李笑"));

        //遍历全部键和值
        Set<String> keys = properties.stringPropertyNames();
        for(String key : keys){
            System.out.println("2:"+key+"-->"+properties.getProperty(key));
        }
    }

Properties写出键值对

在这里插入图片描述

PS：

  • store方法中的第二个参数comments仅仅只是个注释
    public static void main(String[] args) throws Exception {
        //1.创建一个Properties对象（空容器）
        Properties properties = new Properties();

        properties.setProperty("李笑","兰大");
        properties.store(new FileWriter("\"src\\\\SpecialFile\\\\users2.properties\""),"i save Properties File");


        //遍历全部键和值
        Set<String> keys = properties.stringPropertyNames();
        for(String key : keys){
            System.out.println("2:"+key+"-->"+properties.getProperty(key));
        }
    }

练习

调用Properties继承的Map方法，判断键值知否包含某一Key，并修改对象value。

    public static void main(String[] args) throws Exception {
        //1.创建一个Properties对象（空容器）
        String fileName = "data\\test_user.txt";
        Properties properties = new Properties();
        properties.load(new FileReader(fileName));

        //是Map的继承，当然包含map方法！！
        if(properties.containsKey("李笑")){
            properties.setProperty("李笑", "25");
        }

        properties.store(new FileWriter(fileName),"李笑年龄更改");
    }

XML文件

  • XML（可扩展标记语言）
  • XML 中的“<标签名>”称为一个标签或是一个元素。一般是成对出现的
  • XML中的标签名可以自己定义(可扩展)，但必须要正确的嵌套。
  • XML中只能有一个根标签。
  • XML中的标签可以有属性
    在这里插入图片描述
<?xml version="1.0" encoding="UTF-8" ?>

<!--注释：以上头声明必须放在第一行，必须有-->

<users>           <!--根标签只能有一个-->
    <user id = "1">        <!-- 子标签-->
        <name>李笑</name>
        <sex>男</sex>
        <password>minmin</password>
        <data> 2 &lt; 5 </data>
        <data2>
            <!--特殊数据区-->
            <![CDATA[
                2< 5
            ]]>
        </data2>
    </user>
    <user id = "2">        <!-- 子标签-->
        <name>笑笑</name>
        <sex>女</sex>
        <password>minmin</password>
    </user>
</users>

读取XML（Dmo4j框架）

  1. DOM4J概述
    在这里插入图片描述

  2. 常用方法

  • 拿根元素
    在这里插入图片描述
    public static void main(String[] args) throws Exception {
        //1.创建Dom4J框架提供的解析器对象
        SAXReader saxReader = new SAXReader();

        //2.使用saxReaderd对象把需要解析的XML文件读成一个Document对象
        Document document =
                saxReader.read("src\\helloworld.xml");

        //3.从文档对象中解析XML数据
        Element root = document.getRootElement();
        System.out.println(root.getName());
    }
  • 取下一级对象
    在这里插入图片描述
        //1.创建Dom4J框架提供的解析器对象
        SAXReader saxReader = new SAXReader();

        //2.使用saxReaderd对象把需要解析的XML文件读成一个Document对象
        Document document =
                saxReader.read("src\\helloworld.xml");

        //3.从文档对象中解析XML数据
        Element root = document.getRootElement();
        System.out.println(root.getName());

        //4.获取根元素下的全部一级子元素
        List<Element> elements = root.elements();
        for(Element element:elements){
            System.out.println(element.getName());
        }

        //5.获取某个子元素
        Element people = root.element("people");
        System.out.println(people.getText());

        //有很多user标签，默认获取第一个
        Element user = root.element("user");
        System.out.println(user.elementText("name"));

        //6.获取元素属性信息
        System.out.println(user.attributeValue("id"));
        Attribute id = user.attribute("id");
        System.out.println(id.getName());
        System.out.println(id.getValue());

        //获取元素全部属性
        List<Attribute> attributes = user.attributes();

        //7.获取全部文本内容
        System.out.println(user.elementText("name"));
        System.out.println(user.elementText("password"));

        Element data = user.element("data");
        System.out.println(data.getText());
        System.out.println(data.getTextTrim());  //取出文本删除欠货空格
    }

写出XML（不建议用Dmo4j框架）

  • 推荐直接把程序里的数据拼接成XML格式，然后用IO流写出去！
    在这里插入图片描述

约束XML文件的编写

  • 什么是约束XML书写：就是限制XML文件只能按照某种格式进行书写。
  • 约束文档：专门用来限制xml书写格式的文档，比如:限制标签、属性应该怎么写
    在这里插入图片描述
  • DTD约束文档
    在这里插入图片描述
  • Schema约束文档
    在这里插入图片描述

日志技术

体系结构

在这里插入图片描述

Logback框架

核心模块

在这里插入图片描述

导入方式

  • 需要自行寻找三个包
    在这里插入图片描述

PS:
对Logback日志框架的控制，都是通过其核心配置文件logback.xml来实现的，

核心配置文件logback.xml

  1. 日志输出位置、输出格式设置
  • 通常可以设置2个输出日志的位置:一个是控制台、一个是系统文件中
    在这里插入图片描述
  • 例子
    （控制台）
    在这里插入图片描述
    （系统文件）
    在这里插入图片描述
  1. 开启日志、取消日志
    在这里插入图片描述
  • 例子
    在这里插入图片描述

Logback日志级别

  • 日志级别指的是日志信息的类型，日志都会分级别，常见的日志级别如下(优先级依次升高)：
    在这里插入图片描述
  • 设置日志级别（在核心配置文件中配置）
    在这里插入图片描述

多线程

线程创建

方式一：继承Thread类

在这里插入图片描述

优缺点

  • 优点：编码简单
  • 缺点：线程类以及继承Thread，无法继承其他类，不利于功能的扩展

PS：
在这里插入图片描述

    //main()方法是由一条默认的主线程负责执行
    public static void main(String[] args) {
        //3.创建对象
        MyThread thread = new MyThread();
        //4.启动线程
        thread.start();  //main线程 thread线程

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程main输出："+ i);
        }
    }

//1.自定义子类继承Thread线程类
public class MyThread extends Thread{
    //2.必须重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程MyThread输出："+ i);
        }
    }
}

方式二：实现Runnable接口

在这里插入图片描述

优缺点

  • 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强，
  • 缺点：需要多一个Runnable对象
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程："+i);
        }
    }
}

    public static void main(String[] args) {
        Runnable target = new MyRunnable();

        //把任务对象交给一个线程对象处理！！！
        new Thread(target).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程："+i);
        }
    }
  • 匿名内部类写法
    在这里插入图片描述
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1-->："+i);
                }
            }
        };
        new Thread(target).start();

        //简化形式1：
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2-->："+i);
                }
            }
        }).start();

        //简化形式
        new Thread(()-> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3-->："+i);
                }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程-->："+i);
        }
    }

方式三：实现Callable接口

在这里插入图片描述

  • 方法
    在这里插入图片描述
  • FutureTask API
    在这里插入图片描述

优缺点

  • 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强;可以在线程执行完毕后去获取线程执行的结果
  • 缺点：编码复杂
public class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        //描述线程任务，并返回线程执行后的结果
        //需求：求1~n的和
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "1~n的和为："+sum;
    }
}

    public static void main(String[] args) throws Exception{
        Callable<String> call = new MyCallable(100);

        //未来任务对象
        //1.是一个任务对象，实现了Runnable接口
        //2.可以在线程结束后，用FutureTask的get方法拿到返回结果
        FutureTask<String> f1 = new FutureTask<>(call);

        new Thread(f1).start();

        //如果执行到这，上面线程还未执行完毕，这里代码会暂停,等待线程执行完毕
        String rs = f1.get();
        System.out.println(rs);
    }

Thread常用方法

在这里插入图片描述

  • 取线程名字
public class MyThread extends Thread{
    
    public MyThread(){}
    public MyThread(String s) {
        super(s);  //调用父类Thread的有参构造器
    }

    @Override
    public void run() {
        Thread n = Thread.currentThread();
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程"+n.getName()+"输出："+ i);
        }
    }
}

    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName("1号线程");
        t1.start();
        System.out.println(t1.getName());  //1号线程
        Thread t2 = new MyThread();
        t2.start();
        System.out.println(t2.getName());  //Thread-1

        Thread t3 = new MyThread("3号线程");
        t3.start();
        System.out.println(t3.getName());  //3号线程

        //主线程对象的名字
        //哪个线程执行它，他就会得到哪个线程的名字
        Thread n = Thread.currentThread();
        System.out.println(n.getName());   //main

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程main输出："+ i);
        }
    }

线程安全

出现原因：

  • 存在多个线程在同时执行
  • 同时访问一个共享资源
  • 存在修改该共享资源

案例 （出现安全问题）

在这里插入图片描述

  • Account类
ublic class Account {
    private double money;
    private String carID;

    public Account() {
    }

    public Account(double money, String carID) {
        this.money = money;
        this.carID = carID;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCarID() {
        return carID;
    }

    public void setCarID(String carID) {
        this.carID = carID;
    }

    //小明、小红同时来取钱
    public void drawMoney(double money) {
        //先搞清楚谁来取钱
        String name = Thread.currentThread().getName();
        if(this.money>=money){
            System.out.println(name+"来取钱"+money+"成功");
            this.money -= money;
            System.out.println(name+"取钱后,余额:"+this.money);
        }else {
            System.out.println("余额不足");
        }
    }
}
  • DrawThread类
public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    public DrawThread(Account acc) {
        this.acc = acc;
    }

    @Override
    public void run() {
        acc.drawMoney(10000);
    }
}
  • 主程序
    public static void main(String[] args) {
        //1.创建一个对象，代表两个人共享账户
        Account acc = new Account(10000, "ICBC-110");

        //2.创建两个线程分别代表两人,两种不同设置线程名字的方式
        Thread n1 = new DrawThread(acc); //小明
        n1.setName("小明");
        n1.start();

        new DrawThread(acc,"小红").start(); //小红
    }

结果：
在这里插入图片描述

线程同步

常见方案：

  • 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。
    在这里插入图片描述

方式一：同步代码块

  • 作用：把访问共享资源的核心代码给上锁，以此保证线程安全。（把响应代码块上锁）
  • 原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行
  • 注意：对于当前同时执行的线程来说，同步锁必须是同一把(同一个对象)，否则会出bug。
    在这里插入图片描述
  • 案例解决——Account类（改）

同步锁

  1. 使用字符串"lx"作为同步锁，因为" " 括起来的对象在字符串池只有一份（不好）
  2. 如果在实例方法中，使用共享资源作为锁，本案例为：this
  3. 如果在静态方法中，使用 类名.class 作为锁，本案例为Account.class（因为Accunt.class为字节码文件，只有一份）
public class Account {
    private double money;
    private String carID;

    public Account() {
    }

    public Account(double money, String carID) {
        this.money = money;
        this.carID = carID;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCarID() {
        return carID;
    }

    public void setCarID(String carID) {
        this.carID = carID;
    }
    
    public static void s_func(){   //静态方法
        synchronized (Account.class){
            
        }
    }

    //小明、小红同时来取钱
    public void drawMoney(double money) {
        //先搞清楚谁来取钱
        String name = Thread.currentThread().getName();
        //同步锁
        synchronized (this){   //共享资源作为锁
            if(this.money>=money){
                System.out.println(name+"来取钱"+money+"成功");
                this.money -= money;
                System.out.println(name+"取钱后,余额:"+this.money);
            }else {
                System.out.println("余额不足");
            }
        }
    }
}

结果：
在这里插入图片描述

方式二：同步方法

  • 作用：把访问共享资源的核心方法给上锁，以此保证线程安全。（把整个方法上锁）

  • 原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
    在这里插入图片描述

  • 底层原理：内部含有隐式锁，实例方法使用this，静态方式使用 类名.class

  • 案例解决——Account类（改）

public class Account {
    private double money;
    private String carID;

    public Account() {
    }

    public Account(double money, String carID) {
        this.money = money;
        this.carID = carID;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCarID() {
        return carID;
    }

    public void setCarID(String carID) {
        this.carID = carID;
    }


    public synchronized static void s_func(){

    }

    //小明、小红同时来取钱
    public synchronized void drawMoney(double money) {
        //先搞清楚谁来取钱
        String name = Thread.currentThread().getName();
        if(this.money>=money){
            System.out.println(name+"来取钱"+money+"成功");
            this.money -= money;
            System.out.println(name+"取钱后,余额:"+this.money);
        }else {
            System.out.println("余额不足");
        }
    }
}

同步代码块 vs 同步方法哪个好？

  • 范围上：:同步代码块锁的范围更小，同步方法锁的范围更大。锁的范围越小，性能越好。（但当今电脑性能，可以忽略不记）
  • 可读性上：同步方法更好

方式三：Lock锁

  • 是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

  • Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。
    在这里插入图片描述

  • 案例解决——Account类（改）

public class Account {
    private double money;
    private String carID;
    
	//锁对象,final修饰防止修改
    private final Lock lk = new ReentrantLock();  

    public Account() {
    }

    public Account(double money, String carID) {
        this.money = money;
        this.carID = carID;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCarID() {
        return carID;
    }

    public void setCarID(String carID) {
        this.carID = carID;
    }



    //小明、小红同时来取钱
    public void drawMoney(double money) {
        //先搞清楚谁来取钱
        String name = Thread.currentThread().getName();
        try {
            lk.lock();  //加锁
            if(this.money>=money){
                System.out.println(name+"来取钱"+money+"成功");
                this.money -= money;
                System.out.println(name+"取钱后,余额:"+this.money);
            }else {
                System.out.println("余额不足");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {             //防止中间代码出bug，没有解锁，导致别的线程无法继续执行
            lk.unlock();  //解锁
        }
    }
}

线程通信

  • 等待、唤醒方法
    在这里插入图片描述

  • 案例：三个生产者，每次生成一个包子放在桌子上，且桌子上只能由一个包子；两个消费者，每人每次只能取一个吃

主程序

public class ProduceConsumeT {
    public static void main(String[] args) {
        Desk desk = new Desk();

        //创建三个生产者线程
        new Thread(()->{
            while(true){
                desk.put();
            }
        },"厨师1").start();

        new Thread(()->{
            while(true){
                desk.put();
            }
        },"厨师2").start();

        new Thread(()->{
            while(true){
                desk.put();
            }
        },"厨师3").start();

        //创建两个消费者线程
        new Thread(()->{
            while(true){
                desk.get();
            }
        },"吃货1").start();

        new Thread(()->{
            while(true){
                desk.get();
            }
        },"吃货2").start();
    }
}

Desk类

public class Desk {
    private List<String> list = new ArrayList<>();

    public synchronized void put(){
        try {
            String name =  Thread.currentThread().getName();
            if(list.size() == 0){
                Thread.sleep(2000);
                System.out.println(name+"做了一个肉包子");
                list.add(name+"的肉包子");

                //唤醒别人,等待自己
                this.notifyAll();
                this.wait();
            }else{
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public synchronized void get(){
        String name = Thread.currentThread().getName();
        try {
            if(list.size() != 0){
                Thread.sleep(1000);
                System.out.println(name+"吃了"+list.get(0));
                list.clear();

                //唤醒别人,等待自己
                this.notifyAll();
                this.wait();
            }else{
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

线程池

概念

  • 线程池就是一个可以复用线程的技术。
    在这里插入图片描述
  • 工作原理
    在这里插入图片描述

PS：任务必须实现任务接口，成为任务对象

创建线程池

  • JDK5.0起提供了代表线程池的接口：ExecutorService
  • 如何获得线程池对象？
    在这里插入图片描述

PS：方法二见后

  • TreadPoolExecutor
    在这里插入图片描述
    public static void main(String[] args) {
        //1.创建线程池对象
        /*
        int corePoolSize,
          int maximumPoolSize,
          long keepAliveTime,
          TimeUnit unit,
          BlockingQueue<Runnable> workQueue,
          ThreadFactory threadFactory,
          RejectedExecutionHandler handle
         */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS,
                               new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                                new ThreadPoolExecutor.AbortPolicy());
    }
  • 注意事项：

任务队列是指处于等待任务的队列，被线程执行的任务不在任务队列

在这里插入图片描述

  • 新任务拒绝策略
    在这里插入图片描述

线程池处理Runnable任务

  • 方法
    在这里插入图片描述
    主程序
    public static void main(String[] args) {
        //1.创建线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS,
                               new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                                new ThreadPoolExecutor.AbortPolicy());

        //2.
        Runnable target = new MyRunnable();
        pool.execute(target);  //线程池自动创建一个新线程、自动处理整个任务，自动执行！
        pool.execute(target);  //线程池自动创建一个新线程、自动处理整个任务，自动执行！
        pool.execute(target);  //线程池自动创建一个新线程、自动处理整个任务，自动执行！
        pool.execute(target);  //复用核心线程
    }

MyRunnable类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //描述任务
        System.out.println(Thread.currentThread().getName()+"：输出666");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程池处理Callable任务

  • 方法
    在这里插入图片描述
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }

Executors工具类实现线程池

  • 是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象
  • 常用线程池：
    在这里插入图片描述

注意:这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);


        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }

线程池核心线程数配置多少？

  • 计算密集型任务：CPU核心数+1
  • IO密集型任务：CPU核心数*2

Executors使用可能存在的陷阱
在这里插入图片描述

并发、并行

线程生命周期

  • Java线程的六种状态
    在这里插入图片描述

  • 线程的6种状态转换
    在这里插入图片描述

PS:

  • sleep方法不会释放同步锁
  • wait方法会释放同步锁

网络通信

  • java.net.*包下提供了网络编程解决方案

基本通信架构

  • 基本的通信架构有2种形式:CS架构(Client客户端/Server服务端)、BS架构(Browser浏览器/Server服务端

网络通信三要素

  • 三要素：IP、端口、协议

IP（InetAddress）

在这里插入图片描述

  • InetAddress：代表IP对象
  • 常用方法：
    在这里插入图片描述
    public static void main(String[] args) throws Exception {
        //获取本机IP
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1.getHostName());  //本机名字
        System.out.println(ip1.getHostAddress());  //本机ip地址

        //获取指定IP或是域名的ip地址对象
        InetAddress ipBaidu = InetAddress.getByName("www.baidu.com");
        System.out.println(ipBaidu.getHostName());
        System.out.println(ipBaidu.getHostAddress());

        //判断主机与指定ip是否连通
        System.out.println(ipBaidu.isReachable(6000));
    }

端口

在这里插入图片描述

协议

在这里插入图片描述
UDP(User Datagram Protocol):用户数据报协议;
TCP(Transmission ControlProtocol):传输控制协议。

  • UDP
    在这里插入图片描述
  • TCP
    在这里插入图片描述

UDP通信-快速入门

  • Java提供了一个java.net.DatagramSocket类来实现UDP通信
  • DatagramSocket：
    在这里插入图片描述
  • DatagramPacket：
    在这里插入图片描述
  • 简单的通讯

在这里插入图片描述

在这里插入图片描述

客户端

public class Client {
    public static void main(String[] args) throws Exception{
        //1.创建客户端对象
        DatagramSocket socket = new DatagramSocket();

        //2.创建要发送的数据包对象
        /*
           public DatagramPacket(byte buf[], int offset, int length,
                          InetAddress address, int port)
            参数一：要发出去的数据
            参数二：发送出去的数据大小
            参数三：服务端IP地址
            参数四：服务端的端口
         */
        byte[] bytes = "我是快乐的客户端".getBytes();
        DatagramPacket packet = new DatagramPacket(bytes,bytes.length,
                                                    InetAddress.getLocalHost(),6666);

        //3.正式发送
        socket.send(packet);
        System.out.println("客户端数据发送完毕");
        socket.close();
    }
}

服务端

public class Server {
    public static void main(String[] args) throws Exception {
        System.out.println("------服务器启动------");
        //1.创建服务端对象
        DatagramSocket socket = new DatagramSocket(6666);

        //2.创建一个接受数据的数据包对象
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        //3.正式使用数据包接受数据
        socket.receive(packet);

        //4.从字节数组中，把接收的数据答应输出
        int len = packet.getLength(); //接收多少，取出多少
        String rs = new String(buffer,0,len);
        System.out.println(rs);

		System.out.println(packet.getAddress().getHostAddress()); //客户端ip地址
        System.out.println(packet.getPort());  //客户端端口

        socket.close();
    }
}

结果
在这里插入图片描述

UDP通信-多发多收

客户端

public class Client {
    public static void main(String[] args) throws Exception{
        //1.创建客户端对象
        DatagramSocket socket = new DatagramSocket();

        //2.创建要发送的数据包对象
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                socket.close();
                break;
            }
            byte[] bytes = msg.getBytes();
            DatagramPacket packet = new DatagramPacket(bytes,bytes.length,
                                                        InetAddress.getLocalHost(),6666);

            //3.正式发送
            socket.send(packet);
        }
        System.out.println("客户端关闭");
    }
}

服务端

public class Server {
    public static void main(String[] args) throws Exception {
        System.out.println("------服务器启动------");
        //1.创建服务端对象
        DatagramSocket socket = new DatagramSocket(6666);

        //2.创建一个接受数据的数据包对象
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer,buffer.length);

        while (true) {
            //3.正式使用数据包接受数据
            socket.receive(packet);

            //4.从字节数组中，把接收的数据答应输出
            int len = packet.getLength(); //接收多少，取出多少
            String rs = new String(buffer,0,len);
            System.out.println(rs);
            System.out.println("------------------------------");
        }
    }
}

结果
在这里插入图片描述

TCP通信-快速入门

java高级

爱笑的稻草人0805
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java工程师进阶学习资料
03-03
在Java工程师的进阶学习中，理解SQL语言的基本语法和高级特性至关重要，包括DML（数据操作）、DDL（数据定义）和DCL（数据控制）。此外，掌握事务处理、存储过程、索引优化、查询优化等技能，能有效提升应用程序的...
Java进阶SpringBoot视图技术共12页.pdf
11-20
【Java进阶SpringBoot视图技术】是针对Java开发者深入学习SpringBoot框架中视图处理技术的教程。SpringBoot简化了传统Spring应用的初始化和配置，使得开发更加高效。本教程共12页，旨在帮助开发者掌握SpringBoot在...
Java基础/进阶书籍
05-02
这份压缩包包含三本关于Java的重要书籍，旨在帮助读者从基础到进阶深入理解Java语言的各个方面。 首先，《Java编程思想》是一本经典的Java学习资料，作者是Bruce Eckel。这本书以深入浅出的方式阐述了面向对象编程...
Java 工程师进阶知识完全扫盲.zip
05-08
在"项目说明.zip"中，可能包含了实际项目案例或练习题，这些可以帮助你将理论知识应用于实践中，进一步巩固和提升Java进阶技能。学习过程中，不仅要掌握理论，还要通过动手实践来检验和加深理解。不断学习、实践和...
JAVA进阶架构思维导图.rar
05-13
**Java进阶与架构师思维导图** 在深入探讨Java进阶和架构师思维之前，首先需要理解Java语言的基础知识。Java是一种广泛使用的面向对象编程语言，以其平台无关性、安全性和可移植性而闻名。从Java入门到成为一名专业...
Java内存模型
最新发布
weixin_44267758的博客
07-19 342
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 879
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 728
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 935
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 176
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 515
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 601
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 536
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 525
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 785
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 378
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 220
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 269
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
【利用Selenium+autoIt实现文件上传】
凌飞安
07-16 474
当文件上传功能不能简单修改value属性的时候，你一定要看一下我这片文章。
Java进阶指南：重写与重载详解
这份资料涵盖了广泛的内容，包括了Java的关键语法和面向对象编程的核心特性。 1. **`this`与`super`**: `this`关键字在Java中用于引用当前对象，无论是用于区分实例变量和局部变量，还是在构造函数中自动调用父类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值