Java基础 - 代码练习

第一题:集合的运用(幸存者)

public class demo1 {
    public static void main(String[] args) {
        ArrayList<Integer> array = new ArrayList<>();  //一百个囚犯存放在array集合中
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            OUT:
            while (true) {
                int n = r.nextInt(200)+1;  //生成随机数1-200
                //用for循环对比有没有重复比较复杂
//                for (int j = 0; j < i; j++) {
//                    if(n==array.get(j)){  //随机数重复
//                        continue OUT;
//                    }
//                }
                if(array.contains(n)){  //随机数重复
                    continue OUT;
                }
                //说明没有重复的
                array.add(n);
                break OUT;
            }
        }
        System.out.println(array);

        ArrayList<Integer> arr = new ArrayList<>(); //保存一百个囚犯第一次的存放位置
        arr.addAll(array);
        System.out.println(arr);

        //题中要求位置从1开始计数,现在我们的位置是从0开始,所以后续计算要+1
        while(array.size()>1){
            for (int i = array.size()-1; i>=0; i--) {
                if((i+1)%2==1){  //奇数位置
                    array.remove(i);
                }
            }
            System.out.println(array);
        }

        System.out.println("幸存者编号:" + array.get(0));
        System.out.print("幸存者第一次所占的位置(从1开始算):");
        System.out.print(arr.indexOf(array.get(0)) + 1);
    }
}

第二题:基础编程能力

//User
public class User {
    private Long id; //用户id
    private String name; //用户名
    private String gender; //用户性别
    private LocalDate birthday; //用户生日

    public User() {
    }

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

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    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;
    }

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

//demo2
public class demo2 {
    public static void main(String[] args) {
        //创建一个ArrayList集合
        List<User> users = 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[] strs = userStrs.split("#"); //用#号把每个用户的数据先拆分开
        //System.out.println(Arrays.toString(strs)); //[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]

        for (int i = 0; i < strs.length; i++) {
            String s = strs[i];
            String[] str2 = s.split(":");  //用:号把每个用户的个人数据(id 姓名 性别 生日)拆分开
            //str2[0]代表id  str2[1]代表姓名  str2[2]代表性别  str2[3]代表生日

            long id = Long.parseLong(str2[0]); //把用户id从String型转换成long型
            //long id = Long.valueOf(str2[0]); //把用户id从String型转换成long型

            //把生日转换成从字符串转换成LocalDate
            LocalDate birth = LocalDate.parse(str2[3]);
//            String[] time = str2[3].split("-"); //time[0]代表年 time[1]代表月 time[2]代表日
//            int year = Integer.parseInt(time[0]);
//            int month = Integer.parseInt(time[1]);
//            int day = Integer.parseInt(time[2]);
//            LocalDate birth = LocalDate.of(year,month,day);

            User user = new User(id,str2[1],str2[2],birth);
            users.add(user);
        }

        System.out.println(users);

        System.out.println("============================================");

        //遍历List<User>集合,统计每个名字出现的次数
        Map<String,Integer> map = new HashMap<>();
        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            if(map.containsKey(user.getName())){ //如果用户的名字在map的键中存在
                map.put(user.getName(),map.get(user.getName())+1);
            }else{ //如果用户的名字在map的键中第一次出现
                map.put(user.getName(),1);
            }
        }
        //System.out.println(map);
        map.forEach((k,v) -> System.out.println(k+":"+v+"次"));
    }
}

第三题:JDK8新时间的应用

public class demo3 {
    public static void main(String[] args) {
        LocalDate ld = LocalDate.of(2022,2,3); //记录首次休息日
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您查询月份(XXXX-X):");
            String s = sc.next();
            if(!s.matches("\\d{4}-\\d{1,2}")){
                System.out.println("您输入的时间格式不正确,请重新输入");
                continue;
            }else {
                String[] str = s.split("-");
                int year = Integer.parseInt(str[0]); //查询的年份
                int month = Integer.parseInt(str[1]); //查询的月份呢
                if(month > 12 || month < 1){ //查询的月份不是1-12之间
                    System.out.println("请输入正确的月份(1-12)~~~");
                }else if (year < 2022 || (year == 22 && month <= 2)) {  //查询月份不在2022年2月之后
                    System.out.println("请输入2022年2月之后的月份~~~");
                } else { //查询月份在2022年2月之后 且 月份符合规范(1-12)
                    int days = dayNum(year, month); //该月有几天
                    //打印该月的上班情况
                    for (int i = 1; i < days; i++) {
                        LocalDate date = LocalDate.of(year, month, i);
                        //判断该日是否是休息日
                        Long next = date.toEpochDay() - ld.toEpochDay();  //获取相差天数
                        if (next % 3 == 0) {
                            System.out.print(date + "[休息]");
                            //判断休息日是否是周末(周六 周日)
                            if(date.getDayOfWeek() == DayOfWeek.SATURDAY){
                                System.out.print("[周六] ");
                            }else if(date.getDayOfWeek() == DayOfWeek.SUNDAY){
                                System.out.println("[周日] ");
                            }else{
                                System.out.print(" ");
                            }
                        } else if (next % 3 == 1 || next % 3 == 2) {
                            System.out.print(date + " ");
                        }
                    }
                    break;
                }
            }
        }
    }

    public static int dayNum(int year, int month) {
        int num = 0;
        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                num = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                num = 30;
                break;
            case 2:
                if((year%4==0 && year%100!=0) || (year%400==0)){
                    //闰年
                    num = 29;
                }else{
                    num = 28;
                }
                break;
            default:
                System.out.println("月份有误");
                break;
        }
        return num;
    }
}

第四题:手写ArrayList集合

//MyArrayList
public class MyArrayList<E> {
    private Object[] arr = new Object[10];
    private int count = 0; //记录数组中现存有几个数据
    private double gene = 0.8; //激活因子

    //往集合中添加数据(返回值是boolean类型)
    public boolean add(E e){
        arr[count] = e;
        count++;
        if(count >= arr.length * gene){
            Object[] arr1 = Arrays.copyOf(arr,arr.length * 2); //如果数组中的数据个数等于或超过数组最大范围的80%,则扩容两倍
            arr = arr1;
        }
        //System.out.println(Arrays.toString(arr));
        //但是由于用户只是当成集合,应该设计成看不到最后扩容的null值位
        //比如用户存入第一个数据11,用户希望返回的是[11],不是[11,null,null…]
//        Object[] rs = Arrays.copyOf(arr,count);
//        System.out.println(Arrays.toString(rs));

        return true;
    }

    //根据索引查询指定元素
    public E get(int index) {
        //但是由于用户只是当成集合,应该设计成看不到最后扩容的null值位
        //比如用户存入第一个数据11,用户希望返回的是[11],不是[11,null,null…]
        //因此用户输入超过他自己存入个数的索引值,就产生了越界
        if(index >= count || index < 0){ //索引值越界
            throw new ArrayOutException("您输入的索引越界");
        }else{
            return (E) arr[index];
        }
    }

    //根据索引删除指定元素(返回值是被删除的元素)
    public E remove(int index){
        if(index >= count || index < 0) { //索引值越界
            throw new ArrayOutException("您输入的索引越界");
        }else{
            E e = (E) arr[index]; //记录被删除元素
            //删除的元素是最后一个元素
            if(index == arr.length-1){  //由于扩容机制,所以不会删除的元素永远不会是数组的最后一个
                arr[index] = null;
                return e;
            }
            //删除的元素不是最后一个元素,需要进行移位(后面的数前移)
            for (int i = index + 1; i < arr.length; i++) {
                if(i != arr.length-1){
                    arr[i-1] = arr[i];
                }else{
                    arr[i] = null;   //由于扩容机制,永远都没有存满,最后一位永远是null,因此最后一个数的前移不会导致最后一位多出来一个重复的数
                }
            }
            //System.out.println(Arrays.toString(arr));
            count--; //数组元素个数-1
            //但是由于用户只是当成集合,应该设计成看不到最后扩容的null值位
            //比如用户存入第一个数据11,用户希望返回的是[11],不是[11,null,null…]
//            Object[] rs = Arrays.copyOf(arr,count);
//            System.out.println(Arrays.toString(rs));

            return e;
        }
    }

    //返回集合大小
    public int size(){
        return count;
    }

    //遍历集合
    public void forEach1(){
        for (int i = 0; i < count; i++) {
            System.out.print(arr[i]+ " ");
        }
        System.out.println();
    }

    //遍历集合(可以用Lambda表达式)
    public void forEach(MyConsumer<E> action){
        Objects.requireNonNull(action);
        for (int i = 0; i < count; i++) {
            action.accept((E) arr[i]);
        }
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < count; i++) {
            E e = (E) arr[i];
            sb.append(e).append(i==count-1?"":", "); //判断该元素是否是最后一个数据,是否需要加,
        }
        sb.append("]");
        return sb.toString();
    }
}

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

//ArrayOutException
public class ArrayOutException extends RuntimeException{
    public ArrayOutException(){

    }
    public ArrayOutException(String message){
        super(message);
    }
}

//demo4
public class demo4 {
    public static void main(String[] args) {
        MyArrayList<Integer> arr = new MyArrayList<>();
        arr.add(11);
        arr.add(22);
        arr.add(33);
        arr.add(44);
        arr.add(55);
        arr.add(66);
        arr.add(77);
        arr.add(88);
        arr.add(99);

        System.out.println(arr); //[11, 22, 33, 44, 55, 66, 77, 88, 99]
        System.out.println(arr.size()); //集合大小 9

        System.out.println(arr.get(8)); //索引8是99
        //System.out.println(arr.get(11)); //您输入的索引越界
        //System.out.println(arr.get(-1)); //您输入的索引越界

        System.out.println(arr.remove(7)); //返回被删除的元素88

        System.out.println(arr.size()); //集合大小 8

        arr.forEach1(); //11 22 33 44 55 66 77 99

        arr.forEach((Integer integer) -> System.out.print(integer + " ")); //11 22 33 44 55 66 77 99
    }
}

第五题:二分查找的应用

public class demo5 {
    public static void main(String[] args) {
        int[] nums = {};
        int target = 0;
        int[] rs = isExist(nums,target);
        System.out.println(Arrays.toString(rs));
    }

    //查找目标值对应的最左边的位置
    public static int getLeftIndex(int[] nums, int target){
        int rs = -1; //数据不存在为-1
        //二分查找
        int left = 0;
        int right = nums.length-1;
        while (left<=right){
            int middle = (left + right) / 2;
            if(nums[middle]==target){
                rs = middle; //先临时存放第一次找到目标值的位置
                //二分查找该元素的 左边 是否还存在目标值
                right = middle - 1;
            }else if(nums[middle] < target){
                left = middle + 1;
            }else if(nums[middle] > target){
                right = middle - 1;
            }
        }
        return rs;
    }

    //查找目标值对应的最右边的位置
    public static int getRightIndex(int[] nums, int target){
        int rs = -1; //数据不存在为-1
        //二分查找
        int left = 0;
        int right = nums.length-1;
        while (left<=right){
            int middle = (left + right) / 2;
            if(nums[middle]==target){
                rs = middle; //先临时存放第一次找到目标值的位置
                //二分查找该元素的 右边 是否还存在目标值
                left = middle + 1;
            }else if(nums[middle] < target){
                left = middle + 1;
            }else if(nums[middle] > target){
                right = middle - 1;
            }
        }
        return rs;
    }

    //复杂度O(log2n)
    public static int[] isExist(int[] nums, int target) {
        int[] rs = {-1,-1}; //记录返回值
        if(nums == null ||nums.length == 0){ //如果 数组不存在 或 数组为空
            return rs;
        }
        //数组不为空
        rs[0] = getLeftIndex(nums,target);
        rs[1] = getRightIndex(nums,target);
        return rs;
    }

    //复杂度O(n)
    public static int[] isExist1(int[] nums, int target) {
        int[] rs = new int[2];
        int count = 0; //记录第几次找到该数字
        for (int i = 0; i < nums.length; i++) {
            if(nums[i] == target && count == 0){ //第一次找到该数字
                rs[0] = i;
                count++;
            }else if(nums[i] == target && count != 0){ //不是第一次找到该数字
                rs[1] = i;
                count++;
            }
        }
        if(count == 0){ //说明未找到
            rs[0] = -1;
            rs[1] = -1;
        }
        return rs;
    }
}

第六题:手写链表、反转链表

//MyLinkedList
public class MyLinkedList<E> {
    private int size;
    /**
     * 定义了一个私有的内部类,作为链表的结点
     */
    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(){
        Node<E> head = null;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入当前结点的数据值(exit为结束):");
            String data = sc.next();
            if(data.equals("exit")){ //如果输入的是exit则结束
                break;
            }
            //输入不是exit
            if(head==null){ //第一次创建结点
                head = new Node(data,null);
                size++;
            }else{
                //已存在头结点,往后插入结点(尾插法)
                Node<E> temp = head;
                //让temp走到尾部
                while(temp.next != null){
                    temp = temp.next;
                }
                //把当前结点值创建出来,加入尾部
                temp.next = new Node(data,null);
                size++;
            }
        }
        return head; //返回链表是返回链表的头结点
    }

    public Node<E> reverse(Node<E> head,int left,int right){
        if(head == null || left < 1 || left > size || right < 1 || right > size || left >= right){
            return head;
        }
        //反转
        //先找到左结点的位置
        //从左结点遍历到右结点,然后把数据存到集合中
        Node<E> first = head; //遍历结点标识
        Node<E> mark = null; //记录左结点
        List<E> data = new ArrayList<>();
        int index = 0;
        while(first != null){
            index++;
            if(index == left){
                mark = first;
            }
            if(index>=left && index<=right){
                data.add(first.data);
            }
            if(index == right){
                break;
            }
            first = first.next;
        }
        
        //倒序遍历集合
        for (int i = data.size()-1; i >= 0; i--) {
            E e = data.get(i);
            mark.data = e;
            mark = mark.next;
        }
        
        return head;
    }

    public void forEach(Node<E> head){
        if(head == null){
            System.out.println(head);
            return;
        }

        while(head != null){
            System.out.print(head.data+" ");
            head = head.next;
        }
        System.out.println();
    }

}

//demo6
public class demo6 {
    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        MyLinkedList.Node<String> head = list.add();
        list.forEach(head);
        MyLinkedList.Node<String> head2 = list.reverse(head,2,5);
        list.forEach(head2);
    }
}

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

yolov9文献阅读记录

本文记录了yolov9文献的阅读过程&#xff0c;对主要内容进行摘选翻译&#xff0c;帮助理解原理和应用&#xff0c;包括摘要、主要贡献、网络结构、主要模块&#xff0c;问题描述和试验对比等内容。 文献摘要前言摘选主要贡献相关工作可逆性结构辅助监督 问题描述信息瓶颈原理可…

windows上配置Redis主从加哨兵模式实现缓存高可用

一、哨兵模式 哨兵&#xff08;sentinel&#xff09;是Redis的高可用性(High Availability)的解决方案&#xff1a;由一个或多个sentinel实例组成sentinel集群可以监视一个或多个主服务器和多个从服务器。当主服务器进入下线状态时&#xff0c;sentinel可以将该主服务器下的某…

Appium如何自动判断浏览器驱动

问题&#xff1a;有的测试机chrome是这个版本&#xff0c;有的是另一个版本&#xff0c;怎么能让自动判断去跑呢&#xff1f;&#xff1f; 解决办法&#xff1a;使用appium的chromedriverExecutableDir和chromedriverChromeMappingFile 切忌使用chromedriverExecutableDir和c…

vue处理后端返回的日志

vue处理后端返回的日志&#xff0c;并保持日志内容最新&#xff08;滚动到最新内容&#xff09; 1、后端返回的日志格式如下所示&#xff0c;该如何处理成正常的文本换行 2、在获取日志的接口中做如下处理&#xff0c;把返回的/n替换成换行标签&#xff0c;并根据任务状态判断…

Python构建高效可扩展的Web应用程序库之aiohttp使用详解

概要 在Python异步编程领域中,aiohttp库以其强大的功能成为构建高效可扩展的Web应用程序的重要工具。它利用asyncio提供异步HTTP客户端和服务器功能,使其成为处理并发请求和优化性能的理想选择。在本全面指南中,将深入探讨aiohttp库,包括安装方法、特性、基本和高级功能、…

突破校园网限速:使用 iKuai 多拨分流负载均衡 + Clash 代理(内网带宽限制通用)

文章目录 1. 简介2. iKuai 部署2.1 安装 VMware2.2 安装 iKuai(1) 下载固件(2) 安装 iKuai 虚拟机(3) 配置 iKuai 虚拟机(4) 配置 iKuai(5) 配置多拨分流 2.3 测试速度 3. Clash 部署3.1 准备工作(1) 配置磁盘分区(2) 安装 Docker(3) 安装 Clash(4) 设置代理 1. 简介 由于博主…

DETR【Transformer+目标检测】

End-to-End Object Detection with Transformers 2024 NVIDIA GTC&#xff0c;发布了地表最强的GPU B200&#xff0c;同时&#xff0c;黄仁勋对谈《Attention is All You Need》论文其中的7位作者&#xff0c;座谈的目的无非就是诉说&#xff0c;Transformer才是今天人工智能成…

vtk,ITK,DICOM3.0

(14 封私信 / 80 条消息) VTK ITK OPENCV&#xff0c;从图像处理的角度来说&#xff0c;哪种用的人多&#xff1f; - 知乎 (zhihu.com) 医学领域&#xff1a;通常要求使用ITK和VTK。 ITK做底层处理算法。 VTK做可视化显示。 ITK:Insight Segment and Regestration Toolkit …

链表之单链表

上一篇博客我们学习了线性表中的顺序表&#xff0c;这一篇博客让我们继续往下了解线性表的链表&#xff0c;链表分为好几种结构&#xff0c;活不多说&#xff0c;让我们开始学习吧&#xff01; 目录 1.链表 2.链表的结构 3.单链表的实现 1.链表 1.概念&#xff1a;它是一种物…

【QT入门】 自定义标题栏界面qss美化+按钮功能实现

往期回顾&#xff1a; 【QT入门】 鼠标按下和移动事件实现无边框窗口拖动-CSDN博客【QT入门】 设计实现无边框窗口拉伸的公用类-CSDN博客【QT入门】对无边框窗口自定义标题栏并实现拖动和拉伸效果-CSDN博客 【QT入门】 自定义标题栏界面qss美化按钮功能实现 一、最终效果 二、…

Linux简单介绍

Linux简单介绍 编译器VMware虚拟机Ubuntu——LinuxOS为什么使用LinuxOS&#xff1f; 目录结构Windows目录结构Linux操作系统home是不是家目录&#xff1f; Linux常用命令终端命令行提示符与权限切换命令tab 作用&#xff1a;自动补全上下箭头pwd命令ls命令mkdir命令touch命令rm…

Vue 大文件切片上传实现指南包会,含【并发上传切片,断点续传,服务器合并切片,计算文件MD5,上传进度显示,秒传】等功能

Vue 大文件切片上传实现指南 背景 在Web开发中&#xff0c;文件上传是一个常见的功能需求&#xff0c;尤其是当涉及到大文件上传时&#xff0c;为了提高上传的稳定性和效率&#xff0c;文件切片上传技术便显得尤为重要。通过将大文件切分成多个小块&#xff08;切片&#xff0…

小程序滑动删除组件+全选批量删除组件+附源码

小程序滑动删除组件全选批量删除组件附源码 说明 使用 uni-app、uview 组件开发&#xff0c;全端&#xff08;微信小程序、QQ小程序、抖音小程序等等&#xff09; 支持滑动删除组件、支持左滑删除、长按进入批量删除、全选删除、长按弹窗删除、 组件式开发&#xff0c;文章…

LabVIEW太赫兹波扫描成像系统

LabVIEW太赫兹波扫描成像系统 随着科技的不断发展&#xff0c;太赫兹波成像技术因其非电离性、高穿透性和高分辨率等特点&#xff0c;在生物医学、材料质量无损检测以及公共安全等领域得到了广泛的应用。然而&#xff0c;在实际操作中&#xff0c;封闭性较高的信号采集软件限制…

Leetcode 674. 最长连续递增序列

心路历程&#xff1a; 这道题和递增子序列的一样&#xff0c;由于题目中要求连续&#xff0c;实际上会让状态转移更加简单&#xff0c;因为候选的动作集合相当于更小了。 状态&#xff1a;nums的区间[0, i]&#xff0c;第i个元素和第i-1个元素的大小关系 动作&#xff1a;是否…

Vue3_2024_7天【回顾上篇watch常见的后两种场景】___续

Vue3中监听多条数据的两种使用 1.watch【使用上一章写法&#xff0c;监听两个属性&#xff0c;然后执行相应操作…】 2.watchEffect【相对于使用watch&#xff0c;watchEffect默认页面初始加载&#xff0c;有点类似加配置&#xff1a;立即执行 immediate】 代码&#xff1a; …

无熟人难办事?--迪米特法则

1.1 第一天上班 第一天上班&#xff0c;电脑安装工作但是安装的同事小张刚巧有事要忙&#xff0c;主管有事也出去了&#xff0c;没有人搭理。小张快下班的时候才回来&#xff0c;开始帮我装系统&#xff0c;加域&#xff0c;设置密码等。 1.2 无熟人难办事 管理上出了问题&a…

文献阅读:将条形码神经解剖学与空间转录分析相结合,可以识别投射神经元相关基因

文献介绍 「文献题目」 Integrating barcoded neuroanatomy with spatial transcriptional profiling enables identification of gene correlates of projections 「研究团队」 Anthony M. Zador&#xff08;美国冷泉港实验室&#xff09; 「发表时间」 2021-05-10 「发表期…

Rust---复合数据类型之枚举、数组

目录 枚举的使用Option 枚举数组的使用输出结果 枚举&#xff08;Enum&#xff09;&#xff1a;表示一个类型可以有多个不同的取值。枚举类型可以包含不同的变体&#xff08;variants&#xff09;&#xff0c;每个变体可以有不同的数据类型。 枚举的使用 enum Direction {Up,…

[QOpenGLWidget+QMouseEvent]实时绘制长方形

复现moho-打卡第1天 - 20240402 1.1--QOpenGLWidget中显示长方形 实现方法&#xff1a;顶点着色器中给定长方形的四个顶点数据&#xff0c;代码如下&#xff1a; // 顶点位置 GLfloat vertics[1][4][3] { {{mousePressPosX,mousePressPosY,0.0},{mousePressPosX,mouseMoveP…