有效沟通问答-【官方】百战程序员_IT在线教育培训机构

会员可以在此提问，百战程序员老师有问必答

对大家有帮助的问答会被标记为“推荐”
看完课程过来浏览一下别人提的问题，会帮你学得更全面

截止目前，同学们一共提了 132359个问题

时间排序推荐排序

java.io.FileNotFoundException: F:\IdeaProjects\untitled\li (拒绝访问。)

at java.base/java.io.FileInputStream.open0(Native Method)

at java.base/java.io.FileInputStream.open(FileInputStream.java:196)

at java.base/java.io.FileInputStream.<init>(FileInputStream.java:139)

at java.base/java.io.FileInputStream.<init>(FileInputStream.java:94)

at java.base/java.io.FileReader.<init>(FileReader.java:58)

at sen.Text01.main(Text01.java:10)

为什么是目录没办法访问

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 3706楼

package com.itbaizhan;

class manTou{
    private int id;

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

//定义缓冲区 不是线程类
class SyncStack{
    //定义放馒头的容器
    private manTou m[] = new manTou[10];

    //索引
    int i;

    //放馒头
    public synchronized void push(manTou mantou){
        //判断是否满了
        while(i == m.length) {  //用while多判断几次防止当前线程没有执行而忽略
            try {
                this.wait(); //object类的方法，必须在syn调用，线程的对象锁解放，并且进入堵塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.notify();  //唤醒等待序列中的一个线程
        this.m[i] = mantou;
        i++;

    }

    //取馒头
    public synchronized manTou pop() {
        //判断是否满了
        while (i == 0) {  //用while多判断几次防止当前线程没有执行而忽略
            try {
                this.wait(); //object类的方法，必须在syn调用，线程的对象锁解放，并且进入堵塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        this.notify();  //唤醒等待序列中的一个线程
        i--;
        return m[i];

    }

}

//定义生产者线程
class shengchan extends Thread{
    private SyncStack s;

    public shengchan(SyncStack s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i = 0; i<10; i++){
            System.out.println("生产馒头" + i);
            manTou m = new manTou(); // 每次循环都创建一个新的馒头并放入stack里

            s.push(m);

        }
    }
}

class xiaofei extends Thread{
    private SyncStack s;

    public xiaofei(SyncStack s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println("取馒头" + i);
            manTou m = s.pop();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProducerThread {
    public static void main(String[] args) {
        //创建缓冲区
        SyncStack s = new SyncStack();

        //创建生产线程
        shengchan produce = new shengchan(s);
        produce.start();

        //创建消费线程
        xiaofei consumer = new xiaofei(s);
        consumer.start();

    }
}

QQ图片20230207232704.png

这里两个线程锁的都是同一个对象，那按理说应该等生产线程执行完再执行消费啊，为什么还是并发执行的？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术 3707楼

老师，我的有点问题

JAVA 全系列/第二阶段：JAVA 基础深化和提高/常用类 3708楼

package H_Socket.C_Tcp;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 聊天室，一个客户端发送消息其他的客户端也可以接收到消息
 */
//创建一个消息接收线程
class ChatReceive extends Thread{
    BufferedReader bufferedReader;
    Socket socket;
    public ChatReceive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                synchronized ("a"){
                    //把从客户端接收到的信息给缓冲区
                    ChatServer.buf = bufferedReader.readLine();
                    //唤醒发送信息的线程对象
                    "a".notifyAll();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
//创建一个消息发送线程
class ChatSend extends Thread{
    PrintWriter printWriter;
    Socket socket;
    public ChatSend(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            while (true){
                synchronized ("a"){
                    //让发送消息的线程处于等待状态
                    "a".wait();
                    //把接缓冲区的信息发送给其他的客户端
                    printWriter.println(ChatServer.buf);
                    printWriter.flush();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class ChatServer {
    //定义公共区域
    public static String buf;
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            System.out.println("监听83端口");
            serverSocket = new ServerSocket(83);
            while(true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到" + socket.getInetAddress());
                new ChatSend(socket).start();
                new ChatReceive(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

package H_Socket.C_Tcp;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 在一个程序里既是客户端也可以是服务端，根据你输入的不同而不同
 */
//发送线程
class Send extends Thread{
    private Socket socket;
    private Scanner scanner;
    public Send(Socket socket){
        this.socket = socket;
    }
    PrintWriter printWriter = null;
    @Override
    public void run() {
        try {
            printWriter = new PrintWriter(this.socket.getOutputStream());
            scanner = new Scanner(System.in);
            while (true){
                String message = scanner.nextLine();
                printWriter.println(message);
                printWriter.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (scanner != null){
                    scanner.close();
                }
                if (printWriter != null){
                    printWriter.close();
                }
            }catch (Exception e){
                printWriter.println();
            }
        }
    }
}
//接收线程
class Receive extends Thread{
    private Socket socket;
    public Receive(Socket socket){
        this.socket = socket;
    }
    BufferedReader bufferedReader = null;
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
               String string = bufferedReader.readLine();
               System.out.println("他说：" + string);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class GoodTcp {
    public static void main(String[] args) throws Exception {
        Socket socket = null;
        ServerSocket serverSocket = null;
        Scanner scanner = null;
        try {
            scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String s = scanner.nextLine();
            String[] arrays = s.split(",");
            if ("server".equals(arrays[0])){
                //启动服务端
                System.out.println("TCP服务端监听" + arrays[1] + "端口，等待连接");
                serverSocket = new ServerSocket(Integer.parseInt(arrays[1]));
                socket = serverSocket.accept();
                System.out.println("连接成功");
            }else {
                //启动客户端
                socket = new Socket(arrays[0],Integer.parseInt(arrays[1]));
                System.out.println("连接成功");
            }
            //启动发送线程
            new Send(socket).start();
            //启动接收线程
            new Receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

显示连接成功，但是不能进行相互之间的通信

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 3709楼

老师，我那个解决了，不用帮我解答了嘻嘻嘻

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 3710楼

send里面的wait锁不是锁所有拥有”abc“锁的吗，那么receive不是也是有”abc“锁吗，为啥不会被wait

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程 3711楼

public static <T> void fill(List<? super T> list, T obj) {

int size = list.size();

if (size < FILL_THRESHOLD || list instanceof RandomAccess) {

for (int i=0; i<size; i++)

list.set(i, obj);

} else {

ListIterator<? super T> itr = list.listIterator();

for (int i=0; i<size; i++) {

itr.next();

itr.set(obj);

}

我没看懂这段源码老师可以帮我解释一下么

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 3712楼

一：（1）运行是显示系统找不到文件，是什么问题，怎么处理（问题截图和原代码如下）

（2）这一阶段女老师讲的没有重点跟层次感，节奏很快，很多对于小白来说很生疏的知识点也不做解释，敲代码很快，而且用的eclise，我不熟悉，基本都是用快捷键，异常处理也是，也不解释一下怎么操作，很多新的代码编写知识也是敲得比说的快也不解释是什么怎么用，他的视频放慢一倍也看的不清不楚，求老师推荐这阶段的视频，看完他的有空在看看其他视频补完，谢谢老师！

源码如下：

;

;

;
;

{;
    {
        = ServletContext();
        <,> = .getServlet();
        <,> = .getMapping();
        = WebDom4j();
        .parse(.getDocument());<> = .getEntityList();
        <> = .getMappingList();
        (:){
            .put(.getName(),.getClazz());
        }
        (:){
            <>= .getUrlPattern();
            (:){
                .put(,.getName());
            }
        }
    }
    (url){
        (url == || url.trim().equals()) {
            ;
        }
        servlet = ;
        {
            = .getMapping().get(url);
            = .getServlet().get();
            <?> = .();
            servlet = () .newInstance();
            servlet;
        } (e) {
            e.printStackTrace();
        } (e) {
            e.printStackTrace();
        } (e) {
            e.printStackTrace();
        }
        ;
    }

    ([] args) {
        ..println(());
    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/手写服务器项目（旧） 3713楼

这个to.Array();前面的Object[] arr 是用什么快捷键出来的？

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 3714楼

看到下面的问答，有同学问，在讲使用线程池执行大量的Runnable命令时，案例中局部变量n的final为什么要加：

帖子里提到了：

匿名内部类一般定义在一个方法的内部，如果要访问该方法的参数或者方法中定义的变量，则这些参数或者变量必须使用final修饰。

虽然匿名内部类定义在方法的内部，但在编译时内部类与外部类中的方法属于同一个级别，外部类中方法的变量或参数只是方法的局部变量，这些变量或者参数的作用域只在当前方法内部有效。但是如果这些变量用final修饰，内部类就可以保存方法变量的备份，即使方法销毁也能保证内部类在访问时不会出现访问不到的错误。

匿名内部类要访问局部变量，但是函数的局部变量在执行完后会立即退出，销毁掉所有临时变量。而产生的匿名内部类可能会保留.

实际上：匿名内部类并不是直接调用的局部变量n，而是内部类将局部变量n通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。

并且JDK1.8之后匿名内部类访问方法中的局部变量不用加final修饰.

以上是关于匿名内部类中使用方法当中的变量的问题。顺便研究一下匿名内部类：

思考到了一个问题，那我们可以自己在敲代码的时候在匿名内部类里面定义匿名内部类自己的构造器吗？

第一步：研究一下，匿名内部类到底是不是执行了父类的构造器。

查资料：https://www.cnblogs.com/wzhanke/p/4779048.html

这个帖子让我们了解到，编译的时候会给匿名内部类生成自己的字节码文件（.class结尾），并且这个字节码文件当中包含外部类的引用，包含自己的构造器，也就是下面的图片代码第5行的构造器。

通过帖子对帖子中的字节码文件的解读。我们可以发现，第12行：

7: invokespecial #2; //Method Test."<init>":(I)V 这个位置应该是执行了匿名内部类父类Test的构造器。在帖子作者的案例中匿名内部类的父类是Test类。

也就是说，匿名内部类实际上是执行了父类的构造器的。

第二步：上一步已经证明了无参数构造器。那么匿名内部类可以调用父类的有参数构造器吗？也就是在创建匿名内部类对象的时候可以传参吗？

思考：我可以在下面的Inter后的小括号，（写着xxx的那个括号）里面传入参数吗？，xxx是我的参数，如下代码：

new Inter(xxx){

...方法的重写等等操作

}

是否能传取决于Inter这个父类，Inter是我们定义的匿名内部类的父类，或者是接口。

如果Inter是一个类，或者抽象类，并且这个类或者抽象类里定义了有参构造器，那么我们在写匿名内部类的时候，匿名内部类就可以传参数。（通过上面的第一步的帖子分析可推断，如果创建匿名内部类对象的时候指定了xxx的值，也就是传参了，那么编译器就会调用父类的带同参数类型的有参构造方法）

如果Inter是一个接口，接口不能定义有参及无参数构造器，所以匿名内部类的那个位置就不可以传参数。

帖子：https://blog.csdn.net/ggjjzhzz/article/details/321272

这个帖子验证了这上面说到的，传参的问题，并且给了总结：

一、由于匿名内部类没有名字，所以它没有构造函数。因为没有构造函数，所以它必须完全借用父类的构造函数来实例化，换言之：匿名内部类完全把创建对象的任务交给了父类去完成。

二、在匿名内部类里创建新的方法没有太大意义，但它可以通过覆盖父类的方法达到神奇效果，如上例所示。这是多态性的体现。

三、因为匿名内部类没有名字，所以无法进行向下的强制类型转换，持有对一个匿名内部类对象引用的变量类型一定是它的直接或间接父类类型。

所以经常在定义匿名内部类的时候会给出下面的格式：感觉好像调用的是父类的构造器。

new 父类构造器（实参列表) | 实现接口()

{

//匿名内部类的类体部分

}

第三步：回到一开始的问题：

思考：那我们可以自己在敲代码的时候在匿名内部类里面定义匿名内部类自己的构造器吗？

答案是：不可以。其实使用的时候编译器帮我们生成了构造器，但是我们自己不能写，因为匿名匿名，匿名的含义就是根本不知道这个类的名字是什么。

匿名内部类里面不可以定义自己的构造器，因为匿名内部类是要扩展或实现父类或接口，所以根本无法为其构造器命名（不能用父类名，哪有在子类里给父类写构造器的说法。而子类根本没有名，更别提用子类名做构造器了）。、因此在匿名内部中要想有构造器作用的部分要就应该是“初始化块”。

也就是说如果要初始化匿名内部类对象，可以采用构造代码块进行初始化。也就是 { }

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程和并发编程（旧） 3715楼

老师我想请问一下idea创建类的时候怎么进行视频截图上的操作，让创建的类继承另一个类

JAVA 全系列/第二阶段：JAVA 基础深化和提高/XML 技术（旧） 3716楼

为啥这一句不写也不影响结果，也都能够正常运行？

str.append("Content-Type:application/json; charset=utf-8");

JAVA 全系列/第二阶段：JAVA 基础深化和提高/手写服务器项目（旧） 3717楼

老师，请问HashMap调用put方法添加元素是 hash值和equals都相等了，是替换原有的键值对，还是直接舍弃这个添加的键值对

JAVA 全系列/第二阶段：JAVA 基础深化和提高/容器（旧） 3718楼

这个红色是什么原因

我还是将源码拷贝过来依然出现这个红色标记

JAVA 全系列/第二阶段：JAVA 基础深化和提高/XML 技术（旧） 3719楼

老师为什么把Socket socket=server.accept()放在循环里面，这个我不能理解。

然后我把这句代码放到循环外面，服务器端就出现了死循环，但是没有明白这是为什么

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 3720楼

同学您好