Java知识点总结

自定义线程池

/*ThreadPoolExecutor threadPoolExecutor =new ThreadPoolExecutor();
(核心线程数量，最大线程数量，空闲线程最大存活时间，任务队列，创建线程工厂，任务的拒绝策略)

参数一：核心线程数量     不能小于0，正式员工数量
参数二：最大线程数量     不能小于0，最大数量>=核心线程数量，餐厅最大员工数
参数三：空闲线程最大存活时间    不能小于0，临时员工多长时间被辞退
参数四：时间单位         用TimeUnit指定，辞退时间单位
参数五：任务队列         排队的客户，阻塞队列
参数六：创建线程工厂     从哪里招人
参数七：任务的拒绝策略   当排队人数过多，超出顾客拒绝服务
        */

 ThreadPoolExecutor threadPoolExecutor =new ThreadPoolExecutor(
                3,
                6,
                60,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

最大并行数：

/*
CPU密集型运算（计算）    最大并行数+1

I/O密集型运算（读取本地文件/数据库）  最大并行数*期望CPU利用率*总时间（CPU计算时间+等待时间）/CPU计算时间

*/

public static void main(String[] args) {
         //向Java虚拟机返回可用处理器的数目
        int count=Runtime.getRuntime().availableProcessors();
         System.out.println(count);

   
    }

网络编程：

初识：在网络通信协议下，不同计算机上运行的程序，进行的数据传输

常见的软件架构：CS/BS

CS:客户端服务端模式需要开发客户端

BS：浏览器服务端模式不需要开发客户端

CS：适合定制专业化的办公软件如：IDEA、网游

BS：适合移动互联网应用，可以在任何地方随时访问的系统

网络编程三要素：IP、端口号、协议

IP：设备在网络中的地址，是唯一的标识

端口号：应用程序在设备中的唯一标识

协议：数据在网络中的传输的规则，常见的协议有UDP、TCP、http、https、ftp

1.利用局域网IP解决IP不够的问题

2.127.0.0.1（永远表示本机）

3.ipconfig：查看本机IP地址

4.ping:检查网络是否联通

协议：连接和通信的规则

UDP协议：面向无连接通信协议（速度快，已丢失数据）

TCP协议：面向连接的通信协议（速度慢，数据安全）

发送数据：

public class demo01 {
    public static void main(String[] args) throws IOException {
        /*
        1.创建DatagramSocket对象（快递公司）
        细节：
        绑定端口：以后我们就是通过这个端口往外发送
        空参：所有可用的端口中随机一个进行使用
        有参：指定端口进行绑定
         */
        DatagramSocket ds=new DatagramSocket();

        //打包数据
        String str ="你好牛";
        byte[] buf=str.getBytes();
        InetAddress address=InetAddress.getByName("127.0.0.1");
        int port=1086;//端口

        DatagramPacket dp=new DatagramPacket(buf,buf.length,address,port);

        //发送数据
        ds.send(dp);

        //释放资源
        ds.close();
    }
}

   接受数据：             ​

public class demo03 {
    public static void main(String[] args) throws IOException {
                //创建DatagramSocket对象（在接受一定要绑定端口）
                DatagramSocket ds =new DatagramSocket(1086);

                //接受数据包
                byte[] buf=new byte[1024];
                DatagramPacket dp=new DatagramPacket(buf,buf.length);
                ds.receive(dp);

                //解析数据包
                byte[] buf2= dp.getData();
                int len=dp.getLength();
                InetAddress addr=dp.getAddress();
                int port=dp.getPort();

                System.out.println("接受到数据"+new String(buf2,0,len));
                System.out.println("该电脑是从"+addr+"这台电脑的"+port+"这个端口发出的");

                ds.close();

    }
}

运行结果：

TCP协议：

发送数据：（客户端）

public class demo04 {
    public static void main(String[] args) throws IOException {
        //TCP协议
        Socket socket = new Socket("127.0.0.1",1000);

        //2.可以从连接通道中获取输出流
        OutputStream os =socket.getOutputStream();

        //写出数据
        os.write("aa".getBytes());

        os.close();
        socket.close();
    }
}

接收数据：（服务端)

public class demo05 {
    public static void main(String[] args) throws IOException {
        //创建Socket对象
        ServerSocket ss =new ServerSocket(1000);

        //监听客户端的链接
        Socket socket =ss.accept();

        //从连接通道中获取输入流读取数据
        InputStream is = socket.getInputStream();
        int b;
        while((b=is.read())!=-1){
            System.out.println((char)b);
        }

        //释放
        ss.close();
        socket.close();

    }
}

运行结果：

=========================================================================

P2032 扫描

#include <iostream>
#include <algorithm>
#include<math.h>
#include <deque>

using namespace std;

/*const int N=1e4+10;*/



int main(){
    int n,k;
    cin>>n>>k;int a[n];
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    deque<int>q;
    for(int i=0;i<n;i++){
        // 删除队列中不在当前范围内的元素
        if(!q.empty()&&q.front()<i-k+1){
            q.pop_front();
        }
        // 保证队列中的元素相应的数组元素是递减的
        while(!q.empty()&&a[i]>=a[q.back()]){
            q.pop_back();
        }
        // 将当前i加入队列
        q.push_back(i);
        // 输出当前的最大值，从第 k 个元素开始输出
        if(i>=k-1)
            cout<<a[q.front()]<<"\n";
    }
    return 0;
}

if (!q.empty() && q.front() < i - k + 1)
    q.pop_front();
一个队列 q，在当前的位置 i 下进行操作。假设 i 表示当前位置，而 k 则是一个给定的大小范围。
!q.empty(): 检查队列 q 是否为空。如果队列不为空，说明着队列中至少有一个元素。
q.front() < i - k + 1: 检查队列的首个元素是否已经不在当前大小范围内（k）。也就是说，它检查队列中的首个元素是否小于当前位置 i 减去大小 k 再加 1。这个计算的结果就是当前大小范围的起始位置。
如果 q.front() 小于 i - k + 1，说明队列中的首个元素已经不在当前k范围内，需要将其从队列中删除。
如果 q.front() 大于或等于 i - k + 1，则队列中的首个元素仍然在当前k范围内，无需移除。
q.pop_front(): 在上面条件都成立的前提下（即队列的首个元素不在当前k范围内），则将队列 q 的首个元素移除（出队操作）。

P1802 5 倍经验日

#include <iostream>
#include <algorithm>
#include<math.h>
#include <deque>

using namespace std;

#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=1006;
long long f[maxn];//一定要用long long！不然只能得90分
long long a[maxn][2];//存赢和输的情况，a[i][0]代表输的，a[i][1]代表赢得
long long b[maxn];
int main(){
    int n,x1;
    scanf("%d%d",&n,&x1);
    long long x,y,z;
    for(int i=1;i<=n;i++){
        scanf("%lld%lld%lld",&x,&y,&z);
        a[i][0]=x,a[i][1]=y,b[i]=z;
    }
    for(int i=1;i<=n;i++){
        for(int j=x1;j>=0;j--){
            if(j>=b[i]){//如果有足够的药剂打赢别人，则看是输好还是赢好
                f[j]=max(f[j]+a[i][0],f[j-b[i]]+a[i][1]);
            }
            else f[j]+=a[i][0];//没有足够药剂就一个都不用直接认输，不然就浪费了药剂
        }
    }
    cout<<5*f[x1];//记得是五倍经验！
}