进阶JAVA篇- Java 综合基本语法实践（习题一）

news2024/11/24 20:44:35

                         路漫漫其修远兮，吾将上下而求索。—— 屈原

目录

        第一道题：集合的灵活运用

        第二道题：基础编程能力

        第三道题： 手写 ArrayList 集合（模拟实现 ArrayList 核心API）

        第四道题：二分查找的应用

        第五道题：手写单链表（模拟实现 LinkedList 集合的核心API）

        第一道题：集合的灵活运用

题目如下：

对题目进行分析：

      可以根据囚犯的编号、所占的位置信息，可以封装成一个囚犯类，接着就是遍历 100 个人的信息了，推荐可以用 for 来遍历。这里要注意的是不能重复出现相同的编号，这里可以单独构造一个方法，去除重复的编号。对于删除奇数位置上的数据，那么新 new 一个集合来接收占位为偶数的元素就好了。这题不算难，可以根据题目自己试着敲一敲。

 具体代码如下：（答案肯定是不唯一的，答案对了，还有逻辑清晰即可）

先定义了囚犯类：

public class People {
    private int number;
    private int location;

    public People(int number, int location) {
        this.number = number;
        this.location = location;
    }

    public People() {
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public int getLocation() {
        return location;
    }

    public void setLocation(int location) {
        this.location = location;
    }

    @Override
    public String toString() {
        return "People{" +
                "number=" + number +
                ", location=" + location +
                '}';
    }
}
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Text {
    private  static List<People> peopleLists = new ArrayList<>();
    public static void main(String[] args) {

        Random random = new Random();
        for (int i = 1; i <= 100 ; i++) {
            //先判断取到的数是否重复了
            int number = random.nextInt(200)+1;
            if (isRepeat(number)){
                i--;
                continue;
            }else{
                People people = new People(number,i);
                peopleLists.add(people);
            }
        }
        System.out.println("原先的排位：");
        System.out.println(peopleLists);

        //除去在位在奇数位置的人，直到剩最后一位。
        //1,2,3,4,5,6,7,8
        //0,1,2,3,4,5,6,7
        //可以看出来就是要保留集合中的奇数位

        while (peopleLists.size() > 1){
            List<People> temp = new ArrayList<>();
            for (int i = 1; i < peopleLists.size(); i+=2) {
                temp.add(peopleLists.get(i));
            }
            peopleLists = temp;
        }
        System.out.println("后来的排位：");
        System.out.println(peopleLists.get(0));

    }
    private static boolean isRepeat(int number){
        for (int i = 0; i < peopleLists.size(); i++) {
            if (peopleLists.get(i).getNumber() == number) {
                return true;
            }
        }
        return false;
    }
}

        第二道题：基础编程能力

 题目如下：

对题目进行分析：

      先定义出来 User 实体类，这里难点在于将 userStrs 变量进行拆分为一个个字符串，这里就可以使用 split() 方法了，用数组来接收，先拆分 "#",再用数组接收 ":"的字符串，就拆调用两次 split() 方法即可，接着就是对数据的类型处理了，其中两个难点就是字符串 id 转变为 long 类型，就直接用 Long.valueof() 方法就行了，还有一个是转变 LocalDay birthday ，用 LocalDay.parse() 来解析字符串。再有就是封装到 Map 集合中，对原来的 list 集合遍历，再需要用到的是 containsKey() 方法来判断是否重复存在了，最后可以将数据放到 map 集合中了。

具体代码如下：（答案肯定是不唯一的，答案对了，还有逻辑清晰即可）

import java.time.LocalDate;

public class User {
    private Long id;
    private String gender;
    private LocalDate birthday;
    private String name;

    public User() {
    }

    public User(Long id, String gender, LocalDate birthday, String name) {
        this.id = id;
        this.gender = gender;
        this.birthday = birthday;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public void setBirthday(LocalDate birthday) {
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", gender='" + gender + '\'' +
                ", birthday=" + birthday +
                ", name='" + name + '\'' +
                '}';
    }
}

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Text {
    public static void main(String[] args) {
        List<User> userLists = new ArrayList<>();

        String userStrs = "10001:张三:男:1990-01-01#" +
                "10002:李四:女:1989-01-09#" +
                "10003:王五:男:1999-09-09#" +
                "10004:刘备:男:1899-01-01#" +
                "10005:孙悟空:男:1900-01-01#" +
                "10006:张三:女:1999-01-01#" +
                "10007:刘备:女:1999-01-01#" +
                "10008:张三:女:2003-07-01#" +
                "10009:猪八戒:男:1900-01-01#";

        String[] userInformation = userStrs.split("#");
        for (int i = 0; i < userInformation.length; i++) {
            String[] userSpilt = userInformation[i].split(":");
            String idString = userSpilt[0];
            long id = Long.valueOf(idString);
            String name = userSpilt[1];
            String gender = userSpilt[2];
            String birthdayString = userSpilt[3];
            LocalDate birthday = LocalDate.parse(birthdayString);
            User user = new User(id,gender,birthday,name);
            userLists.add(user);
        }
        System.out.println(userLists);

        //遍历集合中的每个名字出现的次数
        Map<String,Integer> map = new HashMap<>();
        for (User userList : userLists) {
            if (map.containsKey(userList.getName())){
                map.put(userList.getName(),map.get(userList.getName())+1);
            }else {
                map.put(userList.getName(),1);
            }
        }
        //遍历打印map集合
        map.forEach((k,v)-> System.out.println(k+" : "+v));
    }
}

        第三道题： 手写 ArrayList 集合（模拟实现 ArrayList 核心API）

题目如下：

对题目进行分析：

       ArrayList 添加第一个元素时集合默认的大小为数组空间为 10 ，每当等于或者超过相关的值，就会扩容为原来的1.5倍，一直往后下去。重点在于一开始类中应该得设置一个 size = 0 ，这个成员变量很重要，即是代表了元素的个数，还可以是指向下一个应该添加元素的位置。

具体代码如下：（答案肯定是不唯一的，答案对了，还有逻辑清晰即可）

public interface MyConsumer<E> {
    void accept(E e);
}
import java.util.Arrays;
public class MyArrayList <E>{
    private int defaultLength = 10;
    private Object[] arr = new Object[defaultLength];
    private int size = 0;

    public MyArrayList() {
    }
    //添加数据
    public boolean add(E e){
        //先判断arr数组是否要扩容
        if (isExpansion()){
            //已经扩容成功
            System.out.println("已经扩容了");

        }
        arr[size++] = e;
        return true;
    }
    //查询数据
    public E get(int index){
        if(index >= size || index < 0){
            throw new RuntimeException();
        }
        else {
            return (E)arr[index];
        }
    }
    //删除数据
    public E remove(int index) {
        if (index >= size || index < 0) {
            throw new RuntimeException();
        } else {
            E retainData = (E) arr[index];
            if (index != size - 1) {
                //1,2,3,4,5,6
                //0,1,2,3,4,5
                //int remainder = size - index - 1;
                for (int i = index; i < size - 1; i++) {
                    arr[i] = arr[i + 1];
                }
            }
            size--;
            return retainData;
        }
    }
    //获取集合大小size
    public int size(){
        return size;
    }
    //开发一个forEach方法
    public void forEach(MyConsumer myConsumer){
        for (int i = 0; i < size; i++) {
            myConsumer.accept(arr[i]);
        }
    }
    private boolean isExpansion(){
        if (size >= defaultLength){
            defaultLength = (int) (defaultLength * (1.5));
            Object[] temp = new Object[defaultLength];
            for (int i = 0; i < size; i++) {
                temp[i] = arr[i];
            }
            arr = temp;
            return true;
        }else {
            return false;
        }
    }

    @Override
    public String toString() {
        Object[] temp = new Object[size];
        for (int i = 0; i < size; i++) {
            temp[i] = arr[i];
        }
        return Arrays.toString(temp);
    }
}
public class Text {
    public static void main(String[] args) {
        MyArrayList<String> myArrayList = new MyArrayList<>();
        myArrayList.add("1");
        myArrayList.add("2");
        myArrayList.add("3");
        myArrayList.add("4");
        myArrayList.add("5");
        myArrayList.add("6");
        myArrayList.add("7");
        myArrayList.add("8");
        myArrayList.add("9");
        myArrayList.add("10");
        myArrayList.add("11");
        myArrayList.add("13");
        myArrayList.add("13");
        myArrayList.add("19");
        myArrayList.add("13");
        myArrayList.add("18");

        System.out.println(myArrayList);

        System.out.println("------------------");
        System.out.println(myArrayList.get(2));
        System.out.println("------------------");
        System.out.println(myArrayList.remove(3));
        System.out.println("删除的结果："+myArrayList);
        System.out.println(myArrayList.size());
        System.out.println("---------遍历---------");
        myArrayList.forEach(System.out::println);
    }
}

        第四道题：二分查找的应用

题目如下：

对题目进行分析：

        这里注明了必须是确保程序的时间复杂度是 O(log2n)，很显然就是要使用二分法来进行查找元素，用二分法来寻找目标元素的开始位置还有结束位置，那就可以用分别使用二分法来寻找开始位置还有结束位置，注意的是，若数组中不存在目标元素的话，就要返回-1。

具体代码如下：（答案肯定是不唯一的，答案对了，还有逻辑清晰即可）

import java.util.Arrays;
public class BinaryLookup {
    public static void main(String[] args) {
        int[] arr = {7,7,7,8,8,8,10};
        int target = 9;
        int[] a = lookupRightAndLeft(arr,target);
        System.out.println(Arrays.toString(a));
    }
    public static int lookupLeft(int[] arr, int target){
        int left = 0;
        int right = arr.length-1;
        int isLeft = - 1;
        while (left <= right){
            int index = (left+right)/2;
            if ( arr[index] == target){
                isLeft = index;
                right = index - 1;
            } else if (arr[index] > target) {
                right = index - 1;
            }else {
                left = index + 1;
            }
        }
        return isLeft;
    }
    public static int lookupRight(int[] arr, int target){
        int left = 0;
        int right = arr.length-1;
        int isRight = - 1;
        while (left <= right){
            int index = (left+right)/2;
            if ( arr[index] == target){
                isRight = index;
                left = index + 1;
            } else if (arr[index] > target) {
                right = index - 1;
            }else {
                left = index + 1;
            }
        }
        return isRight;
    }
    public static int[] lookupRightAndLeft(int[] arr,int target){
        int[] returnArr = new int[2];
        int isLeft = lookupLeft(arr,target);
        int isRight = lookupRight(arr,target);
        returnArr[0] = isLeft;
        returnArr[1] = isRight;
        return returnArr;
    }
}

        第五道题：手写单链表（模拟实现 LinkedList 集合的核心API）

题目如下：

对题目进行分析：

        由于官方的 LinkedList 集合使用了内部类来实现的，所以为了保持一致，我们也使用内部类来模拟实现，单链表需要一个个节点来组成，因此，定义一个内部类来封装节点，节点无非就是数据还有该类型对象的引用，需要注意的是，这里需要设置泛型类，我感觉用以上的题目给的信息来实现 LinkedList 集合与原 LinkedList 集合差别会很大而且很乱，所以我做了一些改进。

 具体代码如下：（答案肯定是不唯一的，答案对了，还有逻辑清晰即可）

public interface MyConsumer<E> {
    void accept(E e);
}
public class MyLinkedList<E> {

    private int size = 0;
    private NodeCode hand;
    class NodeCode{
        E data;
        NodeCode nextNodeCode;

        public  NodeCode(E data, NodeCode nextNodeCode) {
            this.data = data;
            this.nextNodeCode = nextNodeCode;
        }
    }
    public NodeCode add(E e){
            if (hand == null){
                hand = new NodeCode(e,null);
            }else {
                NodeCode temp = hand;
                while (temp.nextNodeCode != null){
                    temp = temp.nextNodeCode;
                }
                temp.nextNodeCode = new NodeCode(e,null);
            }
        size++;
        return hand;
    }
    public void forEach(MyConsumer<E> myConsumer){
        NodeCode first = hand;
        while ( first!=null ){
            myConsumer.accept(first.data);
            first = first.nextNodeCode;
        }
    }
    public void reverse(int left,int right){
        NodeCode first = hand;
        int count = 1;
        NodeCode tempLeft = null;
        Object[] arr = new Object[right-left + 1];
        while (count <= right){
            if (count == left){
                tempLeft = first;
            }
            if (count >= left ) {
                arr[count-left] = first.data;
            }
            first = first.nextNodeCode;
            count++;
           /* if (count == right){
                arr[count-left] = first.data;
            }*/
        }
        for (int i = arr.length - 1; i >= 0; i--) {
            tempLeft.data = (E) arr[i];
            tempLeft = tempLeft.nextNodeCode;
        }
    }
}
public class Text {
    public static void main(String[] args) {

        MyLinkedList<Integer> myLinkedList = new MyLinkedList<>();
        myLinkedList.add(1);
        myLinkedList.add(2);
        myLinkedList.add(3);
        myLinkedList.add(4);
        myLinkedList.add(5);
        myLinkedList.add(6);
        myLinkedList.reverse(2,5);

        myLinkedList.forEach(new MyConsumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

/*        MyLinkedList<String> myLinkedList = new MyLinkedList<>();
        myLinkedList.add("1");
        myLinkedList.add("2");
        myLinkedList.add("3");
        myLinkedList.add("4");
        myLinkedList.add("5");
        myLinkedList.add("5");
        myLinkedList.add("6");
        myLinkedList.add("6");
        myLinkedList.forEach(System.out::println);*/


/*        System.out.println("-----------------");
        LinkedList<String> list = new LinkedList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("5");
        list.add("6");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
    }
}

        若可以完成大部分题目，很高心衷心地祝贺你，你的编程能力是极高的！！！

        想要进一步了解更多的相关 Java 知识，可以点击以下链接：小扳_-CSDN博客

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1144800.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

设置Oracle数据库默认为spfle启动，并且设置数据库SGA大小和PGA大小

设置Oracle数据库默认为spfle启动，并且设置数据库SGA大小和PGA大小

本次目标&#xff1a;设置数据库默认为spfle启动&#xff0c;并且数据库SGA大小为2G&#xff0c;PGA大小为200M 1、环境检查 Oracle 9i以后启动的时候默认使用的初始化文件是spfile&#xff0c;但是为了万一还是进行查看一下 首先&#xff0c;确认您的数据库当前是否使用pfi…
阅读更多...
事件循环的学习、执行上文、this、执行栈和任务队列

事件循环的学习、执行上文、this、执行栈和任务队列

事件循环 对于js运行中的任务&#xff0c;js有一套处理收集&#xff0c;排队&#xff0c;执行的特殊机制&#xff0c;我们称之为事件循环(Even Loop). &#x1f355;js一大特点就是单线程&#xff0c;同一个时间只能做一件事。为了协调事件、用户交互、脚本、UI渲染和网络处理…
阅读更多...
FPGA_状态机工作原理

FPGA_状态机工作原理

FPGA_状态机介绍和工作原理 状态机工作原理Mealy 状态机模型Moore 状态机模型状态机描述方式代码格式 总结 状态机工作原理 状态机全称是有限状态机&#xff08;Finite State Machine、FSM&#xff09;&#xff0c;是表示有限个状态以及在这些状态之间的转移和动作等行为的数学…
阅读更多...
2023年正版win10/win11系统安装教学（纯净版）

2023年正版win10/win11系统安装教学（纯净版）

第一步&#xff1a;准备一个8G容量以上的U盘。 注意&#xff0c;在制作系统盘时会格式化U盘&#xff0c;所以最好准备个空U盘&#xff0c;防止资料丢失。 第二步&#xff1a;制作系统盘。 安装win10 进入windows官网 官网win10下载地址&#xff1a;https://www.microsoft.c…
阅读更多...
【精选】VMware部署ESXI6.5 vCenter Server详解

【精选】VMware部署ESXI6.5 vCenter Server详解

VMware部署ESXI6.5 vCenter Server 一、ESXi主机介绍1、虚拟机的好处2、为什么要使用虚拟机 二、虚拟化服务器概述1、VSphere物理架构2、体系架构3、VMware vSphere 组件 三、ESXi安装环境1、安装步骤2、使用VMware新建ESXi主机3、初始环境安装 四、创建虚拟机五、安装部署VMwa…
阅读更多...
kr 第三阶段（五）32 位逆向

kr 第三阶段（五）32 位逆向

如何寻找 main 函数 对于低版本的 VC 编译器&#xff08;VC 6.0&#xff09;&#xff0c;main 函数在 PE 入口点 mainCRTStartup 函数中是倒数第 3 个函数调用&#xff0c;且参数个数为 3 个&#xff08;wmain 函数为 4 个参数&#xff09;。 对于高版本的 VC 编译器 程序入口…
阅读更多...
DTI-ALPS处理笔记

DTI-ALPS处理笔记

DTI-ALPS处理笔记 前言： 前段时间刚好学习了一下DTI-ALPS处理（diffusion tensor image analysis along the perivascular space ），记录一下，以便后续学习。ALPS是2017年发表在《Japanese Journal of Radiology》的一篇文章首次提出的 (文章地址)，主要用于无创评估脑内淋…
阅读更多...
锐捷Smartweb管理系统 默认开启Guest账户漏洞

锐捷Smartweb管理系统 默认开启Guest账户漏洞

通过弱口令进行登录 guest/guest 文笔生疏&#xff0c;措辞浅薄&#xff0c;望各位大佬不吝赐教&#xff0c;万分感谢。 免责声明&#xff1a;由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c; 文章…
阅读更多...
ce从初阶到大牛（两台主机免密登录）

ce从初阶到大牛（两台主机免密登录）

一、配置ssh远程连接 实现两台linux主机之间通过公钥验证能够互相实现免密登陆 1.确认服务程序是否安装 rpm -qa | grep ssh 2.是否启动 ps -aux | grep ssh 3.生成非对称公钥 ssh-keygen -t rsa 4.公钥发送到客户端 cd /root/.ssh/ ssh-copy-id root192.168.170.134 因为…
阅读更多...
Apollo 快速上手指南：打造自动驾驶解决方案

Apollo 快速上手指南：打造自动驾驶解决方案

快速上手 概述云端体验登录云端仿真环境 打开DreamView播放离线数据包PNC Monitor 内置的数据监视器cyber_monitor 实时通道信息视图福利活动 主页传送门&#xff1a;&#x1f4c0; 传送 概述 Apollo 开放平台是一个开放的、完整的、安全的平台&#xff0c;将帮助汽车行业及自…
阅读更多...
搭建帮助中心系统的关键注意事项

搭建帮助中心系统的关键注意事项

帮助中心系统是现代企业不可或缺的一部分。它们提供了一个集中管理和发布信息的平台&#xff0c;使企业能够向客户提供准确、及时且易于访问的帮助文档和知识库。在搭建帮助中心系统之前&#xff0c;务必要仔细考虑这些关键注意事项。 | 选择合适的帮助中心系统软件 考虑功能…
阅读更多...
​Vue2响应式原理

​Vue2响应式原理

目录 初始化 initProps()&#xff1a;父组件传的 props 列表&#xff0c;proxy() 把属性代理到当前实例上 vm._props.xx 变成 vm.xx initData()&#xff1a;判断data和props、methods是否重名&#xff0c;proxy() 把属性代理到当前实例上 this.xx observe()&#xff1a;给…
阅读更多...
OpenCV学习（五）——图像基本操作（访问图像像素值、图像属性、感兴趣区域ROI和图像边框）

OpenCV学习（五）——图像基本操作（访问图像像素值、图像属性、感兴趣区域ROI和图像边框）

图像基本操作 5. 图像基本操作5.1 访问像素值并修改5.2 访问图像属性5.2 图像感兴趣区域ROI5.3 拆分和合并图像通道5.4 为图像设置边框&#xff08;填充&#xff09; 5. 图像基本操作 访问像素值并修改访问图像属性设置感兴趣区域&#xff08;ROI&#xff09;分割和合并图像 …
阅读更多...
洛谷 B2033 A*B问题 C++代码

洛谷 B2033 A*B问题 C++代码

目录 题目描述 AC Code 题目描述 AC Code #include<bits/stdc.h> using namespace std; int main() {long long a,b;cin>>a>>b;cout<<a*b<<endl;return 0; }
阅读更多...
刷爆指针笔试题

刷爆指针笔试题

第一题 int main() { int a[5] { 1, 2, 3, 4, 5 }; int *ptr (int *)(&a 1); printf( "%d,%d", *(a 1), *(ptr - 1)); return 0; } //程序的结果是什么&#xff1f; 先自己思考一下&#xff0c;然后再看解析哦 【解析】 &a表示整个数组的地…
阅读更多...
LeetCode——哈希表（Java）

LeetCode——哈希表（Java）

哈希表 简介242. 有效的字母异位词349. 两个数组的交集202. 快乐数 简介 记录一下自己刷题的历程以及代码&#xff0c;会尽量把在本地测试包含main函数的完整代码贴上&#xff0c;以及一些注释掉的输出语句。写题过程中参考了 代码随想录。会附上一些个人的思路&#xff0c;如…
阅读更多...
LCD屏硬件调光的几种方式

LCD屏硬件调光的几种方式

一 前言 最近新开的项目用到了LCD屏&#xff0c;关于LCD屏的调光&#xff0c;主板硬件主要用到了偏压IC与背光IC。关于偏压IC,我们后期再聊&#xff0c;今天主要聊一聊背光IC&#xff0c;以及它的调光方式。 二 LED电路设计 在聊背光IC前&#xff0c;首先要对LCD屏的电压电流…
阅读更多...
C++学习day--24 推箱子游戏图像化开发

C++学习day--24 推箱子游戏图像化开发

环境要求&#xff1a; 1、VS2015以上 2、成功安装并配置图形库 项目注意事项&#xff1a;代码复制好以后&#xff0c;把下面的字符集改为多字节字符集 第 1 节 项目需求 实现一款推箱子游戏&#xff0c;效果如下图所示 , 具体规则&#xff1a; 1. 箱子只能推动而不能拉动…
阅读更多...
X86 SMAP(Supervisor Mode Access Prevention)机制引入的一个问题分析

X86 SMAP(Supervisor Mode Access Prevention)机制引入的一个问题分析

在Linux系统中&#xff0c;当涉及到用户态和内核态数据拷贝的时候&#xff0c;如果不考虑建立kernel space和user space的共享映射实现的零拷贝情况&#xff0c;一般是调用copy_from_user/copy_to_user/put_user/get_user几组宏来实现的。在早些时候&#xff0c;对于用户态指针…
阅读更多...
STM32F4X SDIO(一) SD卡介绍

STM32F4X SDIO(一) SD卡介绍

STM32F4X SDIO&#xff08;一&#xff09; SD卡介绍 SD卡分类外观分类容量分类传输速度分类 在之前的章节中&#xff0c;讲过有关嵌入式的存储设备&#xff0c;有用I2C驱动的EEPROM、SPI驱动的FLASH和MCU内部的FLASH&#xff0c;这类存储设备的优点是操作简单&#xff0c;但是缺…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023