Java作业之容器篇

已于 2022-08-06 09:39:29 修改
阅读量278 收藏
点赞数
分类专栏： Java 文章标签： java servlet 开发语言
于 2022-08-05 12:31:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56423338/article/details/126174964
版权

第一天

1.设计一个动态数组

 import java.util.Arrays;
public class MyArr {
    private int[] data;
    //表示当前数组中已经存储的元素个数
    private int size;

    //通过构造方法，传入一个长度为length的整形数组
    //data数组初始化，产生一个新的数组对象
    public MyArr(int length) {
        this.data = new int[length];
    }

    //在数组末尾添加一个值为val的元素
    public void add(int val) {
        data[size]= val;
        size ++;
        //判断数组是否已满，是否需要扩容
        if (size == data.length){
            grow();
        }
    }
    //在数组的index索引位置添加一个值为val的元素
    public void add(int index ,int val) {
        //首先要判断索引位置是否合法
        if (index < 0 || index > size) {
            //错误输出
            System.err.println("索引非法，请重新输入");
        }
        int ret = data[index];
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = val;
        size++;
        if (size == data.length) {
            grow();
        }
    }
    //查询  查询当前动态数组中第一个值为val的元素索引
    public int getByValue(int val){
        for (int i = 0; i < size; i++) {
            if (data[i] == val){
                return i;
            }
        }
        //循环走完，还未找到val，说明数组中不存在
        return -1;
    }
    //查询 查询当前动态数组中是否包含值为val的元素
    public boolean contains(int val){
        return getByValue(val) != -1;

    }

    //查询当前动态数组中索引为index的元素值
    public int get(int index){
        if(index < 0 || index >= size){
            System.err.println("索引非法，请重新输入");
            return -1;
        }
        return data[index];
    }

    //修改 修改index位置的元素为新的值newval，返回修改前的值
    public int set(int index, int newval) {
        if(index < 0 || index >= size){
            System.err.println("索引非法，请重新输入");
            return -1;
        }
        int ret = data[index];
        data[index] = newval;
        return ret;
    }

    //修改 修改第一个值oldVal 的值，更改为新的值 newVal ，返回是否修改成功
    public boolean setVal(int oldVal, int newVal){
        //利用写好的getByValue方法，判断oldVal是否存在
        int index = getByValue(oldVal);
        if (index != -1){
            data[index] = newVal;
            return true;
        }
        return false;
    }

    //删除  删除索引为index 对应的元素， 返回删除前的元素
    public int remove (int index){
        if(index < 0 ||index >= size){
            System.err.println("索引非法，请重新输入");
            return -1;
        }
        int ret = data[index];
        for (int i = index; i < size-1 ; i++) {
            data[i] = data[i+1];
        }
        size--;
        return ret ;
    }

    //删除  删除数组的头元素
    public int removeFirst(){
        return remove(0);
    }

    //删除 删除数组的尾元素
    public int removeLast(){
        return remove(size-1);
    }

    //删除  删除第一个值为val的元素，返回是否删除成功
    public boolean removeByValOnce(int val) {
        for (int i = 0; i < size; i++) {
            if (data[i] == val){
                remove(i);
                return true;
            }

        }
        return false;
    }

    //删除  删除数组中所有值为val的元素
    public void removeAllVal(int val){
        for (int i = 0; i < size; i++) {
            //内层循环也要保证索引的合法性
            while (i < size && data[i] == val){
                remove(i);
            }

        }

    }

    //扩容方法是私有的，因为对程序的使用者来说，根本不知道MyArr类中有一个数组
    //数组的扩容方法对外部也是不可见的
    private void grow() {
        this.data = Arrays.copyOf(data,data.length*2);
    }

    public String toString(){
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if(i != size-1){
                ret += ", ";
            }
        }
        ret += "]";
        return ret;
    }
}

测试

public class TestMyArr {
    public static void main(String[] args) {
        MyArr arr=new MyArr(3);
        System.out.println("扩容前数组长度为："+arr.data.length);
        arr.add(1);
        arr.add(2);
        arr.add(2);
        arr.add(3);//添加元素
        System.out.println(arr);
        arr.remove(0);//根据下标删除
        System.out.println(arr);
        arr.removeAllVal(2);//删除所有为2的数
        System.out.println(arr);
        System.out.println("扩容后数组长度为："+arr.data.length);
    }
}

结果为：

扩容前数组长度为：3
[1, 2, 2, 3]
[2, 2, 3]
[3]
扩容后数组长度为：6

2.设计一个栈

package Howe;

import java.util.Arrays;
public class Stack {

    private Object[] data;
    private int size;
    private int capacity;

    public Stack() {
        // 默认创建一个10容量的栈
        this.capacity = 10;
        data = new Object[this.capacity];
    }

    public Stack(int capacity) {
        this.capacity = capacity;
        data = new Object[this.capacity];
    }

    //进栈一个元素
    public void push(Object e){
        // 先判断栈是否已经满了
        if (this.isFull()) {
            // 扩容
            // 扩容的规则是原有容量的1.5倍
            int length = this.capacity + (this.capacity >>> 1);
            this.resize(length);
        } else {
            this.data[size++] = e;
        }
    }

    // 判断是否存满
    private boolean isFull() {
        return this.capacity == this.size;
    }

    // 扩容或缩容容器的大小
    private void resize(int len){
        this.data = Arrays.copyOf(this.data, len);
        this.capacity = len;
    }

    // 判断栈是否为空
    public boolean isEmpty(){
        return this.size == 0;
    }

    // 出栈一个元素
    public Object pop(){
        if (this.isEmpty()) {
            throw new RuntimeException("对不起，栈中已经没有元素了");
        }
        return this.data[--this.size];
    }

    // 查看栈顶元素
    public Object peek(){
        return this.data[this.size - 1];
    }

    // 获取栈中元素的个数
    public int size(){
        return this.size;
    }

    // 清空栈
    public void clear(){
        this.size = 0;
    }

    // 返回栈的字符串形式
    public String toString(){
        return Arrays.toString(Arrays.copyOf(this.data, this.size));
    }

    // 对比两个栈是否相等
    @Override
    public boolean equals(Object o)	{
        Stack s = (Stack) o;
        if (this.size != s.size()) {
            return false;
        }
        for (int i = 0; i < s.size() ; i++) {
            if (data[i] != s.data[i]) {
                return false;
            }
        }
        return true;
    }
}

测试类

package Howe;

public class TestStack {
    public static void main(String[] args) {
        Stack stack = new Stack();
        System.out.println(stack.isEmpty());
        stack.push("王");//添加
        stack.push("帅");//添加
        stack.push("哥");//添加
        System.out.println(stack);
        System.out.println("现有元素为："+stack.size());//现有元素
        System.out.println(stack.isEmpty());//看是否存满
        System.out.println("栈顶元素为："+stack.peek());//查看栈顶元素
    }
}

结果为：

true
[王, 帅, 哥]
现有元素为：3
false
栈顶元素为：哥

3.设计一个队列

package Howe;

public class Queue {

    private Stack stackA;
    private Stack stackB;

    //创建默认的队列对象
    public Queue(){
        this.stackA = new Stack();
        this.stackB = new Stack();
    }
    //进队一个元素
    public void offer(int e){
        this.stackA.push(e);
    }
    //出队一个元素
    public int poll(){
        remove();
        return (int) stackB.pop();
    }

    private void remove() {
        if (this.stackB.size() == 0){
            while (this.stackA.size() != 0){
                this.stackB.push(this.stackA.pop());
            }
        }
    }
    //查看队首元素
    public int element(){
        remove();
        return (int) this.stackB.peek();
    }
    //获取队列中元素的个数
    public int size(){
        remove();
        return this.stackB.size();
    }
    //判断队列是否为空
    public boolean isEmpty(){
        remove();
        return  this.stackB.size() == 0 && this.stackA.size() == 0;
    }
    //清空队列
    public void clear(){
        this.stackA.clear();
        this.stackB.clear();
    }
    //返回队列的字符串形式
    public String toString(){
        return this.stackB.toString();
    }
    //对比两个队列是否相等
    @Override
    public boolean equals(Object o) {
        Queue queue = (Queue) o;
        if (this.size() != queue.size()) {
            return false;
        }
        if (this.stackA.equals(queue.stackA) && this.stackB.equals(queue.stackB)){
            return true;
        }else {
            return false;
        }
    }
}

测试：

package Howe;

public class QueueTest {
    public static void main(String[] args) {
                Queue queue = new Queue();
                System.out.println("队列是否为空："+queue.isEmpty());
                queue.offer(1);
                queue.offer(2);
                queue.offer(3);
                System.out.println("出队的元素为："+queue.poll());
                System.out.println("队首元素为："+queue.element());
                System.out.println("返回字符串形式为："+queue.toString());
                Queue queue1 = new Queue();
                queue1.offer(456);
                queue1.offer(789);
                System.out.println(queue.equals(queue1));
            }
        }

结果为：

队列是否为空：true
出队的元素为：1
队首元素为：2
返回字符串形式为：[3, 2]
false

4.设计一个双向链表

public class LinkedList {
    private Node first;
    private Node last;
    private int size;

    public LinkedList() {
    }

    public void add(Object obj) {
        // 向尾部添加一个新的节点
        Node newNode = new Node();
        newNode.value = obj;
        // 判断是否是第一次添加
        if (first == null) {
            this.first = newNode;
            this.last = newNode;
        } else {
            newNode.prev = last;
            last.next = newNode;
            last = newNode;
        }
        this.size++;
    }

    public Object get(int index) {
        if (index >= this.size || index < 0) {
            throw new RuntimeException("对不起，不存在这个下标");
        }
        Node temp = first;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp.value;
    }

    class Node {
        Node prev;
        Node next;
        Object value;

        public Node() {
        }

        public Node(Node prev, Object value, Node next) {
            this.prev = prev;
            this.next = next;
            this.value = value;
        }
    }
}

测试

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList();
        linkedList.add(123);
        linkedList.add(456);
        linkedList.add(789);
        System.out.println(linkedList.get(0));
        System.out.println(linkedList.get(1));
    }
}

结果为：

123
456

第二天

作业：

    某个人进入如下一个棋盘中，要求从左上角开始走，
    最后从右下角出来（要求只能前进，不能后退），
    其中，有些点标志为1，表示该点为无法通过的点，
    问题：共有多少种走法？

    0   0   0   0   1   0   0   0   

    0   0   0   0   0   0   1   0

    1   0   0   0   1   0   0   0

    0   0   0   0   0   0   0   0

    0   0   0   1   0   0   0   0

public class Howe {
    public static void main(String[] args) {
        int[][] list = {
                {0, 0, 0, 0, 1, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 1, 0},
                {1, 0, 0, 0, 1, 0, 0, 0},
                {0, 0, 0, 0, 1, 0, 0, 0},
                {0, 0, 0, 1, 0, 0, 0, 0},
        };
        System.out.println("共有" +  theOne(list) + "种走法");
    }

    public static int theOne(int[][] arr) {
        if (arr[0][0]==1) return 0;
        int m = arr.length, n = arr[0].length;
        int[][] dw = new int[m][n];
        for (int i = 0; i < m && arr[i][0] == 0; i++){
            dw[i][0] = 1;
        }
        for (int i = 0; i < n && arr[0][i] == 0; i++){
            dw[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (arr[i][j] == 0){
                    dw[i][j] = dw[i - 1][j] + dw[i][j - 1];
                }
            }
        }
        return dw[m - 1][n - 1];
    }
}

结果为：

一共有24种走法

容器入门篇：
        自定义容器

Java的容器主要分为2个大类，即Collection和Map。Collection代表着集合，类似数组，只保存一个数字。而Map则是映射，保留键值对两个值。

List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
Set (注重独一无二的性质)：存储的元素是无序的、不可重复的。
Queue (实现排队功能的叫号机):按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。
Map (用 key 来搜索的专家) :使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，“x” 代表 key，“y” 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

java集合

集合的继承关系
    |-- Collection
        |-- List        // 线性表
        |-- Set            // 哈希表
        |-- Queue        // 队|-- Map            // 键值对，映射


注意：容器中，不能保存基本数据类型！！！
    如果一定要使用基本数据类型，则需要使用它们的包装类

注意：删除基本数据类型，需要手动装箱
    否则，int默认是下标，而不是数据本书

ArrayList源码解析：
    1、Vector默认的容量是10；
    2、Vector是线程安全的容器，操作方法都加了同步锁
    3、ArrayList是非线程安全的容器

    4、ArrayList根据调用不同的构造函数，初始化容器不同
        如果使用无参的构造，默认容量是0，节约内存，
            一旦添加元素，会发生第一次扩容，默认容量为10；

        如果有参的构造，则传递为多少，默认就是多少。

    ArrayList alist = new ArrayList();    // 默认容量0
    ArrayList alist = new ArrayList(8);    // 默认容量8

注意：  如果在开发过程中，数据大小基本确定，建议使用有参的构造函数，减少频繁扩容，提高性能当然如果不能确定的话，可以使用无参的构造。

南孚程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java棋盘问题
weixin_50837529的博客
08-06 324
代码】Java棋盘问题。
Java中容器的练习
张子又
01-10 917
1.使用List和Map存放多个图书信息，遍历并输出。其中商品属性：编号，名称，单价，出版社；使用商品编号作为Map中的key。 public class Book { public int id; public String name; public double price; public String press; public Book() { super(); } pu...
11、容器作业
友培的博客
12-10 783
容器作业 一、填空题 1.Java集合框架提供了一套性能优良、使用方便的接口和类，包括Collection和Map两大类，它们都位于__java.util___ 包中 2.队列和堆栈有些相似，不同之处在于 栈是先进后出，队列是先进先出 。 3. 链表 结构是一种由多个节点组成的线性数据结构，并且每个节点包含有数据以及指向下一个节点的引用。 4.LinkedList________是一种集合类，它 采用链表作为存储结构，便于删除和添加元素，但是按照索引查
java从小白开始的练习（四，数组）
weixin_47514459的博客
07-14 399
请输入10位同学的java成绩，1、求平均成绩，最高成绩、最低成绩？2、对10的成绩按照从低到高的顺序排列 1,取平均值，最大值最小值。 import java.util.Scanner; public class Test { public static void main(String[] args) { int arr[]=new int[10]; Scanner sc = new Scanner(System.in); //输入成绩 .
python15
zzh164672917的博客
11-21 780
作业1： 棋盘问题进行升级： 某个人进入如下一个棋盘中，要求从左上角开始走，最后从右下角出来（要求只能前进，不能后退）， 该棋盘中存在了障碍物（数字1），遇到障碍物，棋盘无法正常通过 作业2： 有一对兔子，从出生后的第3个月起，每个月都生一对兔子， 小兔子长到第3个月后每个月又生一对兔子， 假如兔子不死，问第n个月第兔子对数为多少 作业3： 假设用户每次上楼梯只能上一个台阶或者两个台阶，请写一个函数，判断用户到第n台阶共有多少种走法 作业4： 找出10000以内能被5或6整除，但不能被两者同时整除的数（函
java在线作业3：容器
weixin_45047913的博客
06-03 289
一 用HashMap模拟一个网上购物车。要求：从键盘输入n本书的名称、单价、购买数量，将这些信息存入一个HashMap，然后将该HashMap作为参数调用方法getSum（HashMap books），该方法用于计算书的总价并返回。【说明：键盘输入可使用Scanner类】 ...
Java课堂作业
weixin_43921948的博客
12-03 1256
3.代码填空. 键盘输入Scanner 下列Java应用程序是用户从键盘输入个人信息，然后程序将个人信息输出。 请按程序实现要求，将下面程序的【代码】替换为Java程序代码。 文件Main.java import java.util.Scanner; public class Main { public static void main(String args[]) { Sc...
初识Java_课后补充作业
08-17
【Java初识篇】 在Java的世界里，初学者往往会面临许多挑战，但“初识Java_课后补充作业”正是为了帮助这些新手们提供必要的学习支持。这份资料旨在加深对Java编程语言的理解，提高学习效率，使初学者能更快地掌握...
JAVA课程作业时间同步服务器.doc
06-10
【Java UDP 时间同步服务器】是本篇作业的主题，主要任务是使用Java的UDP网络编程技术构建一个时间服务器，客户端通过发送UDP数据报来获取服务器的当前时间。在设计上，服务器端包含实时时间显示、传输历史记录以及...
hadoop Java API
06-30
本篇将深入探讨Hadoop Java API的相关知识点，包括Hadoop的核心组件、API的使用、数据存储与处理以及常见问题解决。 首先，Hadoop由两个主要组件构成：HDFS（Hadoop Distributed File System）和MapReduce。HDFS是...
面试-Java一些常见面试题+题解之操作系统-OperatingSystem.zip
03-03
本篇将详细探讨操作系统与Java面试中的常见问题，帮助求职者更好地准备面试。 一、内存管理 1. 垃圾回收（Garbage Collection, GC）：Java的自动内存管理机制，了解不同垃圾收集器如Serial、Parallel、CMS、G1、...
2021年春石油华东《程序设计(Java)》在线作业（三）参考答案.docx
10-22
这篇文档是2021年春季石油华东大学《程序设计(Java)》在线作业第三部分的参考答案。这里我们将深入探讨其中涉及的一些Java编程概念。 1. **继承关系**：特快订单类和订单类之间的关系是继承关系（C）。在Java中，一...
2021-11-07--Three
妖仙的博客
11-07 120
第七天： 作业1：有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币 [10, 8, 5, 3, 27, 99] 代码如下： num=int(input(“请输入硬币数”)) def yibi(n): d={1:1,2:2} if n in d.keys(): return d[n] else: return yibi(n-1)+yibi(n-2) print(yibi(num)) 结果： 请输入硬币数12 233 作业2：如果两个素数之差为2,这样的两个素数就叫作"孪生数",找出100以内的所有
Java学习之容器（3）---作业
Arthur_____的博客
03-07 359
题目如下： 实现List和Map数据的转换。具体要求如下： 【功能1】：定义方法public void listToMap( ){ }将List中Student元素封装到Map中 1) 使用构造方法Student(int id,String name,int age,String sex )创建多个学生信息并加入List; 2) 遍历List，输出每个Student信息;...
Python 练习题三
Remancy0429的博客
03-29 678
问题：共有多少种走法？
Java常用容器基础操作汇总
starhyacinth的博客
02-10 686
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Java数组编程练习题(面试题)
weixin_51612062的博客
07-19 5675
Java数组编程练习题(面试题)，设计一些算法和面试题。1. 输入10位同学的java成绩：(1)求平均成绩，最高成绩、最低成绩；(2)对10的成绩按照从低到高的顺序排列（选做）。2. 给定一个数组，判断某个元素是否在该数组中。3. 给定一个数组，大小为10，输入十个同学的成绩，求这些成绩的总分数；某一天转入2个新同学，请再次求12个同学的平均成绩（尝试着使用扩容的形式做）。4. 有一堆硬币，每次只能拿一个或者两个，求最少多少次可以拿完硬币等题...
LeetCode062
牢骚太盛防肠断，风物长宜放眼量
07-16 195
某个人进入如下一个棋盘中，要求从左上角开始走， 最后从右下角出来（要求只能前进，不能后退）， 问题：共有多少种走法？ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 package com.xiaoz.homework; import java.util.Arrays; import java.util.Iterator; /*作业2： 某个人进入如下一个棋盘中，要求从左上角开始走，
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 442
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
Java容器集合（equals 和 hashCode+基础数据结构+ArrayList+Vector和LinkedList）
06-21
Java容器集合主要包括ArrayList、Vector和LinkedList这三种基础数据结构。在Java中，equals和hashCode是两个非常重要的方法，用于确定对象是否相等以及在散列操作中的具体位置。 首先，让我们来看看equals方法。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南孚程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值