首页 > 编程语言 >阶段一：Java基础进阶期末题型

阶段一：Java基础进阶期末题型

时间：2024-06-22 12:31:07浏览次数：29  
标签：题型 Java 进阶 System import println new public out

目录

前言

第一题

第二题

第三题

第四题

第五题

第六题

前言

java基础进阶结课期末题

第一题

需求

  • 某小型商城系统的订单信息在素材下的orders.xml文件中，现在要求把xm!中的订单信息，封装成一个一个的订单对象，将订单对象保存到ArrayList集合中。

具体功能点要求

  • 1)定义订单类Order，创建ArrayList集合，用于存储订单Order对象
  • 2)请使用Stream流找出今天之前的订单，并遍历输出。
  • 3)请使用Stream流找出集合中价格最贵的订流单，把这个订单的详细信息打印出来
  • 4)请使用Stream流遍历集合中的每个订单，要求按照价格降序输出每个订单的详情

Order.class

package com.itheima.demo1;

import java.time.LocalDateTime;

public class Order {
    private int id;
    private String name;
    private LocalDateTime time;
    private double price;

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", time=" + time +
                ", price=" + price +
                '}' ;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public LocalDateTime getTime() {
        return time;
    }

    public void setTime(LocalDateTime time) {
        this.time = time;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Order() {
    }

    public Order(int id, String name, LocalDateTime time, double price) {
        this.id = id;
        this.name = name;
        this.time = time;
        this.price = price;
    }
}

Test1.class

package com.itheima.demo1;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;

/*
*1)定义订单类Order，创 建ArrayList集合，用于存储订单Order对象 （解析XML 4分，封装成对象2分）
2）请使用Stream流找出今天之前的订单，并遍历输出。（3分）
3) 请使用Stream流找出集合中价格最贵的订流单，把这个订单的详细信息打印出来。（3分）
4) 请使用Stream流遍历集合中的每个订单，要求按照价格降序输出每个订单的详情。（3分）
*
* */
public class Test1 {
    public static void main(String[] args) throws Exception {
        //1、定义一个List集合存储全部订单对象
        List<Order> orders = new ArrayList<>();

        //2、导入dom4j框架
        SAXReader saxReader = new SAXReader();

        //3、读取xml文件成为一个Document对象,获取文件路径，直接可以在电脑上项目跑通，无需在修改路径
        Document document = saxReader.read(Test1.class.getResourceAsStream("/orders.xml"));

        //4、提取根元素
        Element root = document.getRootElement();

        //5、提取一级子元素（order订单元素）
        List<Element> orderEles = root.elements();

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //6、遍历每个订单元素
        for (Element orderEle : orderEles) {
            // 7、每个订单元素是一个订单对象。
            Order order = new Order();
            order.setId((Integer.valueOf(orderEle.attributeValue("id"))));
            order.setName(orderEle.elementText("name"));
            order.setTime(LocalDateTime.parse(orderEle.elementText("time"), dtf));
            order.setPrice(Double.valueOf(orderEle.elementText("double")));
            //8、把订单对象存入到集合中去
            orders.add(order);
        }
        System.out.println("订单内容如下：");
        for (Order order : orders) {
            System.out.println(order);
        }

        //请使用Stream流找出今天之前的订单，并遍历输出
        System.out.println("今天之前的订单如下");
        orders.stream().filter(o -> o.getTime().isBefore(LocalDateTime.now())).forEach(System.out::println);

        //请使用Stream流找出集合中价格最贵的订流单，把这个订单的详细信息打印出来。
        Order order = orders.stream().max((o1, o2) -> Double.compare(o1.getPrice(), o2.getPrice())).get();
        System.out.println("价格最贵的订流单如下：");
        System.out.println(order);

        //请使用Stream流遍历集合中的每个订单，要求按照价格降序输出每个订单的详情
        System.out.println("价格降序输出每个订单如下：");
        orders.stream().sorted((o1,o2)->Double.compare(o2.getPrice(),o1.getPrice())).forEach(System.out::println);

    }


}

orders.xml 

<?xml version="1.0" encoding="UTF-8" ?>
<orders>
    <order id="1">
        <name>Java入门</name>
        <time>2023-11-11 09:23:11</time>
        <double>45.4</double>
    </order>

    <order id="2">
        <name>黑枸杞</name>
        <time>2023-11-21 13:33:23</time>
        <double>28.9</double>
    </order>

    <order id="3">
        <name>决明子</name>
        <time>2023-03-21 09:30:00</time>
        <double>36.5</double>
    </order>

    <order id="4">
        <name>菊花</name>
        <time>2023-05-11 19:30:00</time>
        <double>16.5</double>
    </order>
</orders>

第二题

需求

  • 某个班级组织团建活动，班长给出了几个去处给大家选择，分别是 “农家乐” , "轰趴"，“野外拓展”，“健身房”，本次活动每个学生是可以多选的。

现在有如下5名学生选择了如下去处。

  • 张全蛋儿  农家乐,野外拓展
  • 李二狗子  轰趴,野外拓展,健身房
  • 翠花     野外拓展，
  • 小帅     轰趴，健身房
  • 有容     农家乐

具体的功能点如下：

  • 请找出每个去处想去的人数是多少，并输出投票最多的去处是哪个。
  • 请找出哪些人没有选择投票最多的去处，输出他们的名字。
  • 比如：小帅，有容没有选择野外拓展。

Test2.class

package com.itheima.demo2;
/*
    * 张全蛋儿  农家乐,野外拓展
    李二狗子  轰趴,野外拓展,健身房
    翠花     野外拓展，
    小帅     轰趴，健身房
    有容     农家乐
* */

import java.util.*;
import java.util.stream.Collectors;

public class Test2 {
    public static void main(String[] args) {
        //1、拿数据到程序中来,用对象封装，用Map集合封装
        Map<String, List<String>> selects = new HashMap<>();
        List<String> data1 = new ArrayList<>();
        Collections.addAll(data1, "农家乐", "野外拓展");
        selects.put("张全蛋儿", data1);

        List<String> data2 = new ArrayList<>();
        Collections.addAll(data2, "轰趴", "野外拓展", "健身房");
        selects.put("李二狗子", data2);

        List<String> data3 = new ArrayList<>();
        Collections.addAll(data3, "野外拓展");
        selects.put("翠花", data3);

        List<String> data4 = new ArrayList<>();
        Collections.addAll(data4, "轰趴", "健身房");
        selects.put("小帅", data4);

        List<String> data5 = new ArrayList<>();
        Collections.addAll(data5, "农家乐");
        selects.put("有容", data5);

        System.out.println(selects);

        //2、找出每个去处选择的人数，输出人数最多的地方是哪些
        Map<String, Integer> infos = new HashMap<>();
        selects.forEach((name, datas) -> {
            for (String data : datas) {
                infos.put(data, infos.containsKey(data) ? infos.get(data) + 1 : 1);
            }
        });
        System.out.println("每个去处的人数是：");
        System.out.println(infos);

        //3、输出去处最多的地方
        System.out.println("选择人最多的去处是:");
        Map.Entry<String, Integer> entry = infos.entrySet().stream().max((e1, e2) -> (e1.getValue() - e2.getValue())).get();
        List<String> names = infos.entrySet().stream().filter(e -> e.getValue() == entry.getValue()).map(e -> entry.getKey()).collect(Collectors.toList());
        System.out.println(names);


        //4、哪些人没有选择去处最多的地方
        System.out.println("如下是没有人去处最多的地方：");
        selects.entrySet().stream().filter(e -> {
            boolean flag = true;//没有包含
            for (String s : e.getValue()) {
                if (names.contains(s)) {
                    flag = false;
                    break;
                }
            }
            return flag;
        }).forEach(e -> System.out.println(e.getKey()));
    }
}

第三题

需求

  • 教学管理系统的菜单信息如下（图1所示），菜单的详细数据存储在给的素材文件“系统菜单.txt”中。  

具体要实现的功能点如下所示

  • 从系统菜单.txt中读取这些菜单信息，将这些菜单信息在控制台展示成图1的样子（必须确保展示的顺序是正确的）
  • 将正确的菜单顺序，写出到一个新文件"系统菜单2.txt"中保存起来，详细格式如下

Test3.class

package com.itheima.demo3;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test3 {
    public static void main(String[] args) {

        try (
                PrintStream ps = new PrintStream("javasepro-test-final\\src\\系统菜单2.txt");
                //1、使用流读取文件中的全部数据
                BufferedReader br = new BufferedReader(new FileReader("javasepro-test-final\\src\\系统菜单.txt"));
        ) {

            // 2、按照行读取
            List<String> menus = new ArrayList<>();
            String line;
            while ((line = br.readLine()) != null) {
                menus.add(line);
            }
            // 3、对菜单进行排序。
            Collections.sort(menus);

            //4、遍历集合
            for (String menu : menus) {
                String[] menusAndName = menu.split("-");
                System.out.println(menusAndName[0].length() == 4 ? menusAndName[1] : "\t" + menusAndName[1]);
            }

            //5、写出菜单到文件中去
            for (String menu : menus) {
                ps.println(menu);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

系统菜单.txt

00010001-班级学员管理
00030001-就业班管理
00030002-就业学员管理
0001-班级管理
00020001-班级每日反馈
00020002-班级入学测评
00010002-班级学员就业管理
0003-就业业务管理
00020003-班级讲师评分
00020004-班级授课视频
0002-教学业务管理
00020005-班级作息时间设置
00030003-学员面试记录

第四题

需求

  • 红包雨游戏，某企业有100名员工，员工的工号依次是1, 2，3, 4，..到100。现在公司举办了年会活动，活动中有一个红包雨环节，要求共计发出200个红包雨。其中小红包在[1 - 30] 元之间，总占比为80%，大红包[31-100]元，总占比为20%。

具体的功能点如下

  • 系统模拟上述要求产生200个红包。
  • 模拟100个员工抢红包雨，需要输出哪个员工抢到哪个红包的过程，活动结束时需要提示活动结束。
  • 活动结束后，请1对100名员工按照所抢红包的总金额进行降序排序展示，例如：3号员工抢红包总计：293元、1号员工抢红包总计250元，....

PeopleThread.class

package com.itheima.demo4;

import java.util.List;
import java.util.Random;

public class PeopleThread extends Thread {
    private List<Integer> redEnvelops;
    private int totalRedEnvelop;

    public int getTotalRedEnvelop() {
        return totalRedEnvelop;
    }

    public void setTotalRedEnvelop(int totalRedEnvelop) {
        this.totalRedEnvelop = totalRedEnvelop;
    }

    public PeopleThread(List<Integer> redEnvelop, String name) {
        super(name);
        this.redEnvelops = redEnvelop;
    }

    private Random r = new Random();

    @Override
    public void run() {
        //100个线程来抢
        while (true) {
            String name = Thread.currentThread().getName();
            synchronized (redEnvelops) {
                if (redEnvelops.size() == 0) {
                    break;
                }

                //取红包给当前这个人
                int redEnvelop = redEnvelops.remove(r.nextInt(redEnvelops.size()));
                System.out.println(name+"抢到了："+redEnvelop);
                totalRedEnvelop += redEnvelop;
                try {
                    Thread.sleep(60);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

Test4.class

package com.itheima.demo4;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/*
* **需求**

- 红包雨游戏，某企业有100名员工，员工的工号依次是1, 2，3, 4，..到100。
* 现在公司举办了年会活动，活动中有一个红包雨环节，要求共计发出200个红包雨。其中小红包在[1 - 30]  元之间，总占比为80%，大红包[31-100]元，总占比为20%。

 **具体的功能点如下**

1、系统模拟上述要求产生200个红包。

2、模拟100个员工抢红包雨，需要输出哪个员工抢到哪个红包的过程，活动结束时需要提示活动结束。

3、活动结束后，请1对100名员工按照所抢红包的总金额进行降序排序展示，**
*
* 例如：3号员工抢红包总计：293元、1号员工抢红包总计250元，....**
* */
public class Test4 {
    public static void main(String[] args) throws Exception {
        //1、拿红包进来
        List<Integer> redEnvelop = getRedEnvelop();
        Collections.shuffle(redEnvelop);
        System.out.println(redEnvelop);

        //2、创建100个员工
        List<PeopleThread> peopleThreads = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            PeopleThread peopleThread = new PeopleThread(redEnvelop, i + "号");
            peopleThreads.add(peopleThread);
            peopleThread.start();
        }

        //3、统计谁抢的最多、降序排名。
        for (PeopleThread peopleThread : peopleThreads) {
            peopleThread.join();
        }
        System.out.println("活动结束。。。。。。。。");

        peopleThreads.stream().sorted((p1, p2) -> p2.getTotalRedEnvelop() - p1.getTotalRedEnvelop()).forEach(p -> {
            System.out.println(p.getName()+"抢红包总计："+p.getTotalRedEnvelop());
        });
    }

    public static List<Integer> getRedEnvelop() {
        //1、拿红包进来
        List<Integer> redEnvelop = new ArrayList<>();
        Random r = new Random();
        //2、按照权重随机红包
        for (int i = 0; i < 160; i++) {
            redEnvelop.add((r.nextInt(30) + 1));
        }
        for (int i = 0; i < 40; i++) {
            redEnvelop.add((r.nextInt(70) + 31));
        }
        return redEnvelop;
    }
}

第五题

需求

  • 在实际开发中，很多系统都要完成用户登录和注册功能，但需要注意的是，用户注册的登录名和密码必须是发送给服务端进行保存的，并且注册的登录名是不能重复的，同时登录也是需要到服务端进行认证的。

功能点具体要求

  • 开发一个客户端，具备注册，和登录功能，除非用户输入exit，否则不退出这个界面。
  • 注册功能要求：可以发送登录名和密码给服务端，服务端要响应是否注册成功的结果给客户端。如果注册没有问题，服务端需要将用户注册的登录名和密码保存到文件中去。（注：是什么文件，可自行确定）
  • 登录功能要求：用户输入登录名和密码，需要发送给服务端，服务端认证后需要把登录的结果发送给客户端接收。

Client.class

package com.itheima.demo5;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    private Socket socket;
    private Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        try {
            // 1、创建客户端对象
            Client client = new Client();
            client.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void start() throws Exception {
        socket = new Socket("127.0.0.1", 8119);
        System.out.println("连接服务端成功~~~~~~~~");
        // 1、开发界面。
        // 2、提示功能
        while (true) {
            System.out.println("请您输入操作命令：");
            System.out.println("1、注册");
            System.out.println("2、登录");
            System.out.println("请选择：");
            String command = sc.next();
            switch (command) {
                case "1":
                    // 注册
                    register();
                    break;
                case "2":
                    // 登录'
                    login();
                    break;
                case "exit":
                    System.out.println("退出系统！");
                    socket.close();
                    break;
            }
        }
    }

    private void register() throws Exception {
        System.out.println("==============注册==================");
        System.out.println("请您输入注册信息：");
        // 1、提示用户输入登录名和密码
        System.out.println("登录名称：");
        String loginName = sc.next();

        System.out.println("登录密码");
        String passWord = sc.next();

        // 2、发送登录名和密码给服务端保存
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeInt(1); // 注册
        dos.writeUTF(loginName);
        dos.writeUTF(passWord);
        dos.flush();

        // 3、马上接收服务端响应。
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        System.out.println(dis.readUTF());
    }

    private void login() throws Exception {
        System.out.println("==============登录==================");
        System.out.println("请您输入登录信息：");
        System.out.println("登录名称：");
        String loginName = sc.next();

        System.out.println("登录密码");
        String passWord = sc.next();

        // 2、发送登录名和密码给服务端保存
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeInt(2); // 登录
        dos.writeUTF(loginName);
        dos.writeUTF(passWord);
        dos.flush();

        // 3、马上接收服务端响应。
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        System.out.println(dis.readUTF());
    }

}

Server.class

package com.itheima.demo5;

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static final String USER_FILE_PATH = "javasepro-test-final\\src\\users.properties";

    public static void main(String[] args) {
        try {
            // 1、注册端口：
            ServerSocket serverSocket = new ServerSocket(8119);
            while (true) {
                // 2、开始接收客户端的管道连接
                Socket socket = serverSocket.accept();
                // 3、分配一个独立的线程来处理客户端的socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ServerReaderThread.class

package com.itheima.demo5;

import java.io.*;
import java.net.Socket;
import java.util.Properties;

public class ServerReaderThread extends Thread {
    private Socket socket;
    public ServerReaderThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        // 处理的信息：注册 登录。
        try {
            // 1、得到输入流
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            while (true) {
                // 2、读消息类型
                int type = dis.readInt();
                // 3、区别消息，不同处理
                switch (type) {
                    case 1:
                        // 注册
                        register();
                        break;
                    case 2:
                        // 登录
                        login();
                }
            }
        } catch (Exception e) {
            // 离线逻辑
            System.out.println("有人离线了~~");
        }
    }

    private void register() throws Exception {
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        String loginName = dis.readUTF();
        String passWord = dis.readUTF();

        // 开始做判断，登录名是否重复的问题。
        String result = "注册成功";
        if(exist(loginName)) {
            result = "注册失败，您注册的登录名称已被占用！";
        }else {
            // 保存登录名和密码
            Properties properties = new Properties();
            properties.setProperty(loginName, passWord);
            properties.store(new FileWriter(Server.USER_FILE_PATH, true), "");
        }

        // 响应结果回去
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(result);
        dos.flush();
    }

    private void login() throws Exception {
        DataInputStream dis = new DataInputStream(socket.getInputStream());
        String loginName = dis.readUTF();
        String passWord = dis.readUTF();

        String result = "登录成功";
        File file = new File(Server.USER_FILE_PATH);
        if(file.exists()){
            // 提取全部的登录名，看是否存在当前这个登录名
            Properties properties = new Properties();
            properties.load(new FileReader(file));
            // 校验登录名：根据登录名获取密码
            String OKpwd = properties.getProperty(loginName);
            if(OKpwd == null) {
                result = "登录名称错误";
            }else {
                // 比较密码
                if(!OKpwd.equals(passWord)){
                    result = "密码错误！";
                }
            }
            // 校验密码
        }else {
            result = "当前无任何用户信息，无法登录！";
        }

        // 响应result即可
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(result);
        dos.flush();
    }

    public boolean exist(String loginName) throws Exception {
        File file = new File(Server.USER_FILE_PATH);
        if(file.exists()){
            // 提取全部的登录名，看是否存在当前这个登录名
            Properties properties = new Properties();
            properties.load(new FileReader(file));
            if(properties.containsKey(loginName)) {
                return true;
            }
        }
        return false;
    }
}

第六题

需求

  • 在素材demo6包下，有生成链表的代码，目前Test类中已经为您创建了两个链表，分别是链表 head1 -> 2 → 4 → 1，链表head2 → 4→ 1 → 3 。

具体功能点如下

  • 在MyLinkedList类中，开发一个sort方法，支持对链表进行升序排序，写完后需要分别测试对这两个链表排序，并分别遍历输出。
  • 在MyLinkedList类中，开发一个mergeSort方法，支持将这两个升序排序的链表，再次合并成一个新链表，要求新链表中的节点仍然是递增排序的。

示例1：

  • 输入：head1 -> 2 → 4 → 1, head2 → 4 → 1 → 3 返回：head3 -> 1->1->2->3->4->4

MyLinkedList.class 

package com.itheima.demo6;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyLinkedList<E extends Comparable> {
    // 封装一个链表
    Node<E> head = null;

    /**
     * 定义了一个私有的内部类，作为链表的结点。
     */
    public static class Node<E> {
        E data;
        Node<E> next;

        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }

    public Node<E> add(E e) {
        if (head == null) {
            head = new Node(e, null);
        } else {
            // 往后面插入结点。（尾插法）
            Node<E> temp = head;
            // 让temp走到尾部结点
            while (temp.next != null) {
                temp = temp.next;
            }
            // 把当前结点创建出来，加入到尾部结点
            temp.next = new Node(e, null);
        }
        return head;
    }

    public Node<E> sorted() {
        if (head == null) {
            return head;
        }

        List<E> number = new ArrayList<>();
        Node<E> temp = head;
        while (temp != null) {
            number.add(temp.data);
            temp = temp.next;
        }

        Collections.sort(number);

        Node<E> temp2 = head;
        for (E e : number) {
            temp2.data = e;
            temp2 = temp2.next;
        }
        return head;
    }

    public void forEach(Node<E> head) {
        if (head == null) {
            System.out.println(head);
            return;
        }
        Node<E> temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    public Node<E> mergeSort(Node<E> head2) {
        // head =  1 2 3
        // head2 = 1 3 4
        if (head == null && head2 == null) {
            return null;
        }

        if (head == null && head2 != null) {
            return head2;
        }

        if (head != null && head2 == null) {
            return head;
        }

     /*   if(head != null && head2 != null){
            Node<E> temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            // 尾部了。
            temp.next = head2;
            sorted();
        }*/

        if (head != null && head2 != null) {
            // head =  1     2  2
            //                      temp1
            // head2 = 1      3  4 5 6 6 8 9
            //                temp2
            // newHead 1  1  2  2
            Node<E> newHead = new Node<>(null, null); // 新链表
            Node<E> newTemp = newHead;
            Node<E> temp1 = head;
            Node<E> temp2 = head2;
            while (temp1 != null && temp2 != null) {
                if (temp1.data.compareTo(temp2.data) == -1) {
                    newHead.next = temp1;
                    temp1 = temp1.next;
                } else {
                    newHead.next = temp2;
                    temp2 = temp2.next;
                }
                newHead = newHead.next;
            }

            if (temp1 == null) {
                newHead.next = temp2;
            }

            if (temp2 == null) {
                newHead.next = temp1;
            }
            head = newTemp.next;
        }
        return head;
    }
}

Test.class 

package com.itheima.demo6;

public class Test {
    public static void main(String[] args) {
        // 第一个链表：
        MyLinkedList<Integer> list1 = new MyLinkedList<>();
        list1.add(2);
        list1.add(4);
        list1.add(1);
        // 第一个链表的头结点：head1
        MyLinkedList.Node<Integer> head1 = list1.head;

        // 第二个链表：
        MyLinkedList<Integer> list2 = new MyLinkedList<>();
        list2.add(4);
        list2.add(1);
        list2.add(3);
        list2.add(2);
        list2.add(8);
        list2.add(9);
        // 第二个链表的头结点：head1
        MyLinkedList.Node<Integer> head2 = list2.head;

        // 功能1：在MyLinkedList类中，开发一个sort方法，对两个链表分别排序，并分别遍历输出
        MyLinkedList.Node<Integer> first1 = list1.sorted();
        MyLinkedList.Node<Integer> first2 = list2.sorted();
        list1.forEach(first1);
        list2.forEach(first2);

        // 功能2：在MyLinkedList类中，开发一个mergeSort方法，支持将这两个升序排序的链表，合并成一个新链表，要求新链表中的节点仍然是递增排序的。
        // ，然后对新链表遍历输出
        MyLinkedList.Node<Integer> allFirstHead = list1.mergeSort(first2);
        list1.forEach(allFirstHead);


    }
}

标签：题型,Java,进阶,System,import,println,new,public,out
From： https://blog.csdn.net/m0_60041624/article/details/139721447

相关文章

  • JAVA 医院管理住院系统
    本系统采用的是自顶向下的分层模块设计方法，由于医院住院管理系统分为：医生信息管理、病人信息管理、病床信息管理、收费信息管理、统计分析和系统管理等功能，我们在设计过程中按其功能把它分成不同的模块。医院管理住院系统的主模块如图所示：图5-1程序流程图1.2 系统登录......
  • java基础知识面试准备 第三天
    &和&&的区别        &和&&都是Java中的逻辑运算符，用于判断两个布尔表达式的逻辑关系(&和&&的优先级不同，&&的优先级比&高)，它们的区别如下：1.&是逻辑与运算符，它的两个操作数都会被求值，只有当两个操作数都为true时，结果才为true；即使第一个操作数为false，第二个操作数也会......
  • 【C#进阶】高级面向对象特性_2024-06-22
    一、概念1.高级面向对象特性面向对象编程（OOP）是一种编程范式，它使用“对象”来设计软件。这些对象可以包含数据和行为。高级面向对象特性包括：封装：把数据和操作这些数据的代码打包在一起，不让外部直接访问数据，而是通过方法来操作。继承：允许新创建的类（子类）继承现有类（父类）的属性和......
  • 【C#进阶】高级数据结构和算法_2024-06-22
    当我们深入到编程的世界，我们会发现，掌握高级数据结构和算法就像是拥有了一套高级工具箱，它们能帮助我们更高效、更优雅地解决问题。今天，我们就来一探究竟，看看这些高级工具是如何工作的。首先，让我们来谈谈高级数据结构。数据结构就像是我们用来存放东西的容器，高级数据结构就是一些......
  • 深入了解Java异常处理
    在Java编程中，异常处理是一个至关重要的概念。通过正确地处理异常，程序员可以编写出健壮且易于维护的代码，提升程序的可靠性。本文将详细介绍Java的异常处理机制，包括异常的分类、捕获和处理异常的语法、常见的异常类型以及自定义异常的实现。一、什么是异常异常是程序运行过......
  • Java中的构造器详解
    在Java中，构造器（也称构造方法）是一种特殊的方法，用于初始化对象的状态。当创建对象时，构造器会被自动调用。以下是关于Java中构造器的详细解释：命名规则：构造器的名称必须与类名完全相同。构造器没有返回值类型，连void也没有。用途：初始化对象的属性（实例变量）。执行一些必要的操作，......
  • JavaScript基础部分知识点总结(Part5)
    注册事件（绑定事件）1.注册事件概述给元素添加事件，称为注册事件或者绑定事件。注册事件有两种方式：传统方式和方法监听注册方式传统注册方式：利用on开头的事件onclick<buttonοnclick=“alert('hi~')”></button>btn.onclick=function(){}特点：注册事件的唯一性同一个元素同......
  • 基于JAVA个人博客系统设计（论文）
    目录1引言11.1课题背景11.2国内研究情况11.3国外研究情况21.4课题研究目标及意义22相关框架和技术简介32.1semanticUI框架32.2SpringMVC框架32.3MyBatis框架32.4Spring框架32.5wangEditor插件42.6Vue框架42.7MySQL数据库42.8Tomc......
  • Android14之java层：增加系统API(二百二十)
    简介：CSDN博客专家，专注Android/Linux系统，分享多mic语音方案、音视频、编解码等技术，与大家一起成长！优质专栏：Audio工程师进阶系列【原创干货持续更新中……】......
  • java集合使用中的注意事项
    集合判断是否为空判断所有集合内部的元素是否为空，使用 isEmpty() 方法，而不是 size()==0 的方式这是因为isEmpty()方法的可读性更好，并且时间复杂度为O(1)。绝大部分我们使用的集合的size()方法的时间复杂度也是O(1)，不过，也有很多复杂度不是O(1)的，比如java.util.c......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99