结对编程（JAVA实现）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了结对编程（JAVA实现），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含20408字，纯文字阅读大概需要30分钟。

内容图文

一、github地址：https://github.com/Jasminejiamei/pairProgramming

二、PSP表格

三、效能分析

　　由于之前采用单线程执行，在文件IO流的处理上花费了不少的时间，包括代码上的执行存在部分冗余，代码上可以提高利用率。打开了线程池以后，多线程执行，大大提高了执行速度，在代码逻辑改进优化后，对大量生成题目的效果十分显著，由30s时间完成优化到2s： 

四、设计过程

（一）流程图

视图设计过程：

生成题目设计过程：

判断对错设计过程：

（二）项目目录：

分包思路：

1）视图层：view 包含主页面与两个功能页面

2）实体类：po  包含题目存放类Deposit、ChildDeposit，分数处理类

3）逻辑处理层：service  处理题目生成等的逻辑、处理题目判错的逻辑

4）工具类：util 包含文件的读写功能

（三）总体实现思路

　　程序运行，进入主页面，点击选择进入相应功能页面（生成题目or判断对错），如果为生成题目，用户需要输入相关参数（题目数量、数的大小范围），视图层获取输入的数据，传入至逻辑层中进行处理，先判断输入是否有误，有误则终止程序，无误则调用题目生成的方法CreateAth；如果为判断对错，用户需要选择相应的文件（Exersises.txt和Answers.txt）,视图层获取输入的数据，传入到逻辑层进行处理，判断输入无误后，调用题目盘错的方法Judge。

　　题目生成的思路：题目要求生成的算术运算符少于3个，先随机生成一个运算符的个数，传入到CreateAth方法中，先生成一个根结点即算术运算符，然后随机生成在左右子树小于总运算符个数的运算符个数，同时生成运算符，当生成运算符个数为0，则生成叶子结点即运算操作数，左右子树也是重复上述过程。把生成的算式放在一个动态数组里面，每当生成一个算式，就去检查里面是否包含这个算式，如果重复就去掉，达到查重的目的。

　　判断对错的思路：使用readfile读取Exersises.txt文件内容，使用正则表达式分割开题目的序号和算式，算式是中缀表达式的表示方式，通过build方法把算式改为前缀表达式，如：1 + (( 2 + 3)* 4 ) – 5，转换成前缀则为- + 1 * + 2 3 4 5，计算其答案，读取Answers.txt的内容，使用正则表达式分割开题目的序号和答案，根据两个文件的序号，对比答案是否相同，如果相同则记录对的题目的数量，和题目序号，写出到Correction.txt文件。

（四）细节实现思路

1）如何保证基本的数值运算，确定参数的范围？

　　自然数的数值之间的运算可简单实现，但是自然数、真分数、带分数之间的运算之间的格式需要自己设计的，并且题目要求“如果存在形如e1÷ e2的子表达式，那么其结果应是真分数”，经过讨论之后，决定把所有数据统一当成分数来处理，整数的分母则为1，在运算的过程中把分子与分母独立出来分别操作加减乘除运算，到最后再进行约分等化简处理。

2）怎么生成算式并且查重?

　　生成的算式要求不能产生负数、生成的题目不能重复，且即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目，经过讨论，决定使用二叉树来实现，由于二叉树的运算次序是孩子结点的运算次序要优先于根结点的，所以使用非叶子节点存放运算符，叶子结点存放数值，可以解决前后符号之间的优先级别关系，解决括号的添加问题，当父母结点的算术符优先级高于右孩子结点的算术运算符时，左右都要加括号，当相等时，则右孩子树要加括号；出现了负数时，交换左右子树即可；此外，解决了查重的复杂度问题，开始的方案想采用遍历的方式来达到查重，现只需要判断两棵树是否相同即可。

五、程序关键代码

从页面获取到数据，进行处理:

package service;

import java.util.HashMap;
import java.util.Map;

public class EntryJudge{
    public boolean Entry(String[] args){
        //向主页面返回的运行成功与否的标志
        boolean tag = false;
        //判断用户输入是否正确
        if(args.length == 0 || args.length % 2 != 0)  {
            tag = false;
            return tag;
        }
        //取出参数
        Map<String, String> params = checkParams(args);
        //执行相应处理
        CreateAth opera = new CreateAth(params);
        Judge check =  new Judge(params);
        if(params.containsKey("-e")&&params.containsKey("-a")){
            check.Judge();
            tag = true;
            return tag;
        } else if(params.containsKey("-n") || params.containsKey("-r") || params.containsKey("-d")) {
            opera.createAth();
            tag = true;
            return tag;
        }
        return tag;
    }
    private Map<String, String> checkParams(String[] args) {
        Map<String, String> params = new HashMap<>();
        for (int i = 0; i < args.length; i = i + 2) {
            params.put(args[i], args[i+1]);
        }
        return params;
    }
}

题目生成逻辑处理：

题目判错处理：判断答案的正确性，并记录下来正确题目与错误题目序号，打印到Grade.txt

package service;

import po.Fraction;
import util.FileUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 答案判错类
 */
public class Judge{
    private int trueNum;  //正确数目
    private int wrongNum;    //错误数目
    private String exerciseFileName;  // 题目文件名
    private String answerFileName;  // 答案文件名

    public Judge(Map<String, String> params) {
        for (String str : params.keySet()) {
            if (str.equals("-e")) {
                exerciseFileName = params.get(str);
            } else if (str.equals("-a")) {
                answerFileName = params.get(str);
            }
        }
    }
    /**
     * 判断错误 ，并把错误写入文件
     */
    public void Judge() {
        long start = System.currentTimeMillis();
        List<String> correctNums = new ArrayList<>();
        List<String> wrongNums = new ArrayList<>();
        FileUtil.readFile((exercise, answer) -> {
            String[] strs1 = exercise.split("\\."); //匹配每一行
            String[] strs2 = answer.split("\\.");
            if (strs1[0].equals(strs2[0])) {
                CreateAth exes = new CreateAth(false);
                exes.build(strs1[1].trim());  //去掉两端的空格后，将后缀表达式生成树变成前缀的，
                if (exes.getResult().equals(new Fraction(strs2[1].trim()))) {   //答案两边都相等，继续执行下面的
                    correctNums.add(strs1[0]);
                    trueNum++;
                } else {
                    wrongNums.add(strs1[0]);
                    wrongNum++;
                }
            }
        }, exerciseFileName, answerFileName);
        FileUtil.writeFile(printResult(correctNums, wrongNums), "Correction.txt");
        long end = System.currentTimeMillis();
        System.out.println("题目答案对错统计存在当前目录下的Correction.txt文件下，耗时为：" + (end - start) + "ms");
    }

    private String printResult(List<String> correctNums, List<String> wrongNums) {
        StringBuilder builder = new StringBuilder();
        builder.append("Correct: ").append(trueNum).append(" (");
        for (int i = 0; i < correctNums.size(); i++) {
            if (i == correctNums.size() - 1) {
                builder.append(correctNums.get(i));
                break;
            }
            builder.append(correctNums.get(i)).append(", ");
        }
        builder.append(")").append("\n");
        builder.append("Wrong: ").append(wrongNum).append(" (");
        for (int i = 0; i < wrongNums.size(); i++) {
            if (i == wrongNums.size() - 1) {
                builder.append(wrongNums.get(i));
                break;
            }
            builder.append(wrongNums.get(i)).append(", ");
        }
        builder.append(")").append("\n");
        return builder.toString();
    }
}

分数处理类：把所有随机生成的数都当成是分数处理，同时在些定义分数的四则运算方法

package po;

/**
 * 1. 把所有随机生成的数都当成是分数处理（解决了自然整数，分数，带分数之间的差异）
 * 2. 定义了分数的四则运算类
 */
public class Fraction{

    private int mol; //分子
    private int den;  //分母

    /**
     * 处理随机生成的数值（约分等）,组合分数对象
     */
    public Fraction(int mol, int den) {
        this.mol = mol;
        this.den = den;
        if (den <= 0) {
            throw new RuntimeException("分数分母不能为0");
        }
        //否则就进行约分
        int mod = 1;
        int max = den > mol ? den : mol;
        for (int i = 1; i <= max; i++) {
            if (mol % i == 0 && den % i == 0) {
                mod = i;
            }
        }
        this.mol = mol / mod;
        this.den = den / mod;
    }

    /**
     * 处理随机生成的数值,这个用于分解分数对象(仅在判错中使用)
     */
    public Fraction(String str) {
        int a = str.indexOf("'");
        int b = str.indexOf("/");
        if (a != -1) {
            //取出数组，转换类型
            int c = Integer.valueOf(str.substring(0, a));
            den = Integer.valueOf(str.substring(b + 1));
            mol = c * den + Integer.valueOf(str.substring(a + 1, b));
        } else if (b != -1) {
            String[] sirs = str.split("/");
            mol = Integer.valueOf(sirs[0]);
            den = Integer.valueOf(sirs[1]);
        } else {
            mol = Integer.valueOf(str);
            den = 1;
        }
    }/**
     * 定义加减乘除类,返回值类型(全都当成分数处理)，由于要返回这个类的内容，所以方法前要加类名
     */
    public Fraction add(Fraction fraction) {
        return new Fraction(this.mol * fraction.den + this.den * fraction.mol, this.den * fraction.den);
    }

    public Fraction subtract(Fraction fraction) {
        return new Fraction(this.mol * fraction.den - this.den * fraction.mol, this.den * fraction.den);
    }

    public Fraction multiply(Fraction fraction) {
        return new Fraction(this.mol * fraction.mol, this.den * fraction.den);
    }

    public Fraction divide(Fraction fraction) {
        return new Fraction(this.mol * fraction.den, this.den * fraction.mol);
    }

}

题目实现存放类以及其子类：

package po;

import java.util.Objects;
/**
 * 用于存放题目的类，用二叉树的形式
 */
public class Deposit{

    private Deposit left;
    private Deposit right;
    private Fraction value; //用于二叉树结点的是符号与运算结果数值的之间的变化

    public Deposit(Fraction value, Deposit left, Deposit right){
        this.value = value;
        this.left = left;
        this.right = right;
    }

    /**
     * 取结点数据
     */
    public Fraction getValue() {
        return value;
    }
    public Deposit getRight(){
        return right;
    }
    public Deposit getLeft(){
        return left;
    }

    /**
     * 设置结点数据
     */
    public Deposit(Fraction value){
        this.value = value;
    }
    public void setLeft(Deposit left){
        this.left = left;
    }
    public void setRight(Deposit right){
        this.right = right ;
    }
    public void setValue(Fraction value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value.toString();
    }

    /**
     * 用于查重，判断二棵树是否相同
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Deposit)) return false;
        Deposit node = (Deposit) o;
        return Objects.equals(value, node.value) &&
                Objects.equals(left, node.left) &&
                Objects.equals(right, node.right);
    }
}

—————————————————————————————————————分割线——————————————————————————————————————————————

package po;

/**
 * 用于记录符号结点，与Deposit类是一样的道理
 */
public class ChildDeposit extends Deposit{

    private String symbol;

    public ChildDeposit(String symbol, Deposit left, Deposit right){
        super(null, left, right);
        this.symbol = symbol;
    }

    public String getSymbol() {
        return symbol;
    }

    @Override
    public String toString() {
        return " " + symbol + " ";
    }

    /**
     * 用于查重
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ChildDeposit)) return false;
        ChildDeposit that = (ChildDeposit) o;

        boolean flag = this.symbol != null && symbol.equals(that.symbol);
        if(!flag) return false;

        boolean left = this.getLeft() != null && getLeft().equals(that.getLeft());
        boolean right = this.getRight() != null && getRight().equals(that.getRight());
        //左右子树相同
        if(left && right) {
            return true;
        }
        if(left ^ right) {
            return false;
        }
        //如果是加法或乘法由于满足交换律所以要判断
        if(this.symbol.equals("+") || this.symbol.equals("x")) {
            left = this.getLeft() != null && getLeft().equals(that.getRight());
            right = this.getRight() != null && getRight().equals(that.getLeft());
        }
        return left && right;
    }
}

文件读写工具类：处理文件的写入与读出

package util;

import java.io.*;

public class FileUtil{
    /**
     * 写入文件中
     */
    public static void writeFile(String content, String fileName) {
        File file = new File(fileName);
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))){
            if(!file.exists()){
                file.createNewFile();
            }
            bw.write(content);
            bw.flush();
        } catch (IOException e) {
            System.out.println("文件操作失败...");
        }
    }
    /**
     * 读文件内容
     * @param callBack 回调接口，分别处理每一行
     * @param exerciseFileName 题目文件
     * @param answerFileName 答案文件
     */
    public static void readFile(ReaderCallBack callBack, String exerciseFileName, String answerFileName) {
        File exerciseFile = new File(exerciseFileName);
        File answerFile = new File(answerFileName);
        if(!exerciseFile.exists() || !answerFile.exists()) {
            System.out.println("文件不存在！");
            return;
        }
        try (BufferedReader br1 = new BufferedReader(new FileReader(exerciseFileName));
             BufferedReader br2 = new BufferedReader(new FileReader(answerFileName))) {
            String line1, line2;
            while ((line1 = br1.readLine()) != null && (line2 = br2.readLine()) != null) {
                callBack.deal(line1, line2);
            }
        } catch (IOException e) {
            System.out.println("读取文件失败！");
        }
    }

    public interface ReaderCallBack {
        void deal(String exercise, String answer) throws IOException;
    }
}

图形界面：

MainView ：主页面，用户在两种操作中选一进行

package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MainView {
    public static void main(String[] args) {
        new MainJFrame();
    }
}
class MainJFrame extends JFrame {
    /**
     *   程序主界面
     */
    private static final long serialVersionUID = 1;
    //定义全局变量

    private JLabel title;
    private JButton generate,judge;

    private JLabel result;
    private JPanel down = new JPanel();

    //创建一个容器
    Container ct;

    MainJFrame(){

        ct=this.getContentPane();
        this.setLayout(null);//设置容器为空布局，绝对定位

        //标题
        title= new JLabel("四则运算题目生成程序");
        title.setFont(new Font("微软雅黑",Font.BOLD, 30));
        title.setBounds(140, 40, 340, 100);

        //生成
        generate = new JButton("生成题目");
        generate.setBounds(120, 220, 140, 40);
        generate.addActionListener(new generateListener());
        //判错
        judge = new JButton("判断对错");
        judge.setBounds(300, 220, 140, 40);
        judge.addActionListener(new judgeListenner());
//添加组件

        ct.add(title);
        ct.add(generate);
        ct.add(judge);
        ct.add(down);
        this.setTitle("MyApp");
        this.setSize(600, 450);// 设置窗口大小
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setVisible(true);//显示窗口
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //关闭窗口 当点击窗口的关闭按钮时退出程序（没有这一句，程序不会退出）
    }


    class generateListener implements ActionListener {
        //监听生成按钮点击事件
        public void actionPerformed(ActionEvent e) {

            new GenerateView();
        }

    }
    class judgeListenner implements ActionListener{
        //监听判错按钮点击事件
        public void actionPerformed(ActionEvent e) {
            new JudgeView();

        }
    }
}

GenerateView：用户输入参数范围、生成题目的页面

package view;

import service.EntryJudge;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GenerateView extends JFrame {


    private JLabel title,result;
    private JButton confirm;
    private JLabel subjectNum,intArea,denArea;
    private JTextField subjectNumField,intAreaField,denAreaField;
    private JPanel down = new JPanel();


    public GenerateView() {
        //创建一个容器
        Container ct;
        ct=this.getContentPane();
//        this.setLayout(null);//设置容器为空布局，绝对定位

        this.setSize(600, 450);//基本设置
        this.setLocationRelativeTo(null);
        this.setLayout(null);
        title = new JLabel("生成题目");
        title.setFont(new Font("微软雅黑",Font.BOLD, 20));
        title.setBounds(200,20,280,60);
        //生成题目数
        subjectNum = new JLabel("请输入生成题目数：");
        subjectNum.setFont(new Font("微软雅黑",Font.BOLD, 16));
        subjectNum.setBounds(70,100,160,50);
        subjectNumField = new JTextField (10);
        subjectNumField.setBounds(260,100,260,40);
        //整数范围
        intArea = new JLabel("请输入整数范围：");
        intArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        intArea.setBounds(70,150,160,50);
        intAreaField = new JTextField (20);
        intAreaField.setBounds(260,150,260,40);
        //分母范围
        denArea = new JLabel("请输入分数分母的范围：");
        denArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        denArea.setBounds(70,200,180,50);
        denAreaField = new JTextField (20);
        denAreaField.setBounds(260,200,260,40);
        confirm = new JButton("确定");
        confirm.setBounds(250,270, 60, 50);
        confirm.addActionListener(new ConfirmActionListener());
        //设置底部panel
        down.setBounds(130, 330, 280, 50);
        //设置底部panel背景透明
        down.setBackground(null);
        down.setOpaque(false);
        result= new JLabel();
        result.setFont(new Font("微软雅黑",Font.BOLD, 18));
        //添加组件
        down.add(result);
        ct.add(title);
        ct.add(subjectNum);
        ct.add(subjectNumField);
        ct.add(intArea);
        ct.add(intAreaField);
        ct.add(denArea);
        ct.add(denAreaField);
        ct.add(confirm);
        ct.add(down);

        this.setVisible(true);//显示窗口
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  //关闭窗口
    }
    class ConfirmActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            String args1 = subjectNumField.getText();
            String args2 = intAreaField.getText();
            String args3 = denAreaField.getText();

            String [] args  = new String[]{"-n",args1,"-r",args2,"-d",args3};
            EntryJudge ej = new EntryJudge();
            boolean res = ej.Entry(args);
            //获取命令执行结果
            if(res == true) {
                result.setText("结果：生成题目成功" );

            } else{
                result.setText("结果：生成题目失败" );

            }
        }
    }
}

JudegeView：用户选择文件，是判断对错的页面

package view;

import service.EntryJudge;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class JudgeView extends JFrame {


    private JLabel title,result;
    private JButton confirm;
    private JLabel subjectNum,intArea,file1,file2;
    private JButton btn1,btn2;
    private JPanel down = new JPanel();


    public JudgeView() {
        //创建一个容器
        Container ct;
        ct=this.getContentPane();

        this.setSize(600, 450);//基本设置
        this.setLocationRelativeTo(null);
        this.setLayout(null);
        title = new JLabel("判断对错");
        title.setFont(new Font("微软雅黑",Font.BOLD, 20));
        title.setBounds(200,20,280,60);
        //生成题目数
        subjectNum = new JLabel("请选择题目文件：");
        subjectNum.setFont(new Font("微软雅黑",Font.BOLD, 16));
        subjectNum.setBounds(70,100,160,50);
        btn1 = new JButton ("选择文件");
        btn1.setBounds(240,100,120,40);
        btn1.addActionListener(new ChooseFile1ActionListener());
        file1 = new JLabel();
        file1.setFont(new Font("微软雅黑",Font.BOLD, 14));
        file1.setBounds(390,100,130,50);
        //整数范围
        intArea = new JLabel("请输入答案文件：");
        intArea.setFont(new Font("微软雅黑",Font.BOLD, 16));
        intArea.setBounds(70,150,160,50);
        btn2 = new JButton ("选择文件");
        btn2.setBounds(240,150,120,40);
        btn2.addActionListener(new ChooseFile2ActionListener());

        file2 = new JLabel();
        file2.setFont(new Font("微软雅黑",Font.BOLD, 14));
        file2.setBounds(390,150,130,50);

        confirm = new JButton("确定");
        confirm.setBounds(250,270, 60, 50);
        confirm.addActionListener(new ConfirmActionListener());
        //设置底部panel
        down.setBounds(130, 330, 280, 50);
        //设置底部panel背景透明
        down.setBackground(null);
        down.setOpaque(false);
        result= new JLabel();
        result.setFont(new Font("微软雅黑",Font.BOLD, 18));
        //添加组件
        down.add(result);
        ct.add(title);
        ct.add(subjectNum);
        ct.add(btn1);
        ct.add(file1);
        ct.add(intArea);
        ct.add(btn2);
        ct.add(file2);

        ct.add(confirm);
        ct.add(down);

        this.setVisible(true);//显示窗口
        this.setLocationRelativeTo(null);//基本设置  把窗口位置设置到屏幕中心
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  //关闭窗口
    }
    class ChooseFile1ActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            JFileChooser chooser = new JFileChooser();             //设置选择器
            chooser.setMultiSelectionEnabled(true);             //设为多选
            int returnVal = chooser.showDialog(new JLabel(),"选择");
            String filename = chooser.getSelectedFile().getName();      //获取绝对路径

            file1.setText(filename);

        }
    }
    class ChooseFile2ActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {

            JFileChooser chooser2 = new JFileChooser();             //设置选择器
            chooser2.setMultiSelectionEnabled(true);             //设为多选
            int returnVal = chooser2.showDialog(new JLabel(),"选择");

            String filename = chooser2.getSelectedFile().getName();      //获取绝对路径

            file2.setText(filename);
        }
    }
    class ConfirmActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {
            //获取结果
            String [] args = new String[]{"-e", "Exercises.txt","-a","Answers.txt"};
            EntryJudge ej = new EntryJudge();
            boolean res = ej.Entry(args);
            //获取命令执行结果
            if(res == true) {
                result.setText("结果：生成题目成功" );

            } else{
                result.setText("结果：生成题目失败" );

            }
        }
    }
}

六、测试测试结果

程序运行，成功打开图形界面：

点击生成题目：

测试题目生成是否成功：

输入相关参数，点击确定 ,生成题目成功：

 查看Exersises.txt，成功生成题目：

 查看Answers.txt，答案：

测试判错程序：

改错二道题的答案：

打开判错的图形界面：

选择算式文件：

选择答案文件：

选择文件后：

点击确定，查看统计文件Grade.txt:

生成一万道算式：

详细的github地址：

算式生成文件：https://github.com/Jasminejiamei/pairProgramming/blob/master/Exercises.txt

答案生成文件：https://github.com/Jasminejiamei/pairProgramming/blob/master/Answers.txt

部分截图：

七、项目小结

      此次的结对编程，我们均涉及了代码的设计、编写以及测试。讨论项目的基本构思对我负责的前期编码十分重要，从基础数值的定义和生成，再到采用二叉树存放算式，最后一步步完成项目，通过两个人的讨论，使得项目的整体思路变得清晰。在后期的编码中我的伙伴对我的编程方式提出了更有条理性的建议，最终在小改动下让整个项目的代码变得更为整洁与条理。

     多讨论交流意见对编程的帮助很大，在判错功能中，从开始的没有头绪，到讨论出来通过应用一个栈的实例：中缀表达式转前缀表达式，解决了判错的问题；开始项目生成大数量题目的速度很慢，在小伙伴丰富的编程经验下，指出了关于多线程运行程序的方式，并且通过优化一些代码，大大提高了效率。

项目成员：黄思扬（3117004657）、刘嘉媚（3217004685）

内容总结

以上是互联网集市为您收集整理的结对编程（JAVA实现）全部内容，希望文章能够帮你解决结对编程（JAVA实现）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端