java编程基础总结——19.自定义容器

最新推荐文章于 2022-08-14 22:37:02 发布
最新推荐文章于 2022-08-14 22:37:02 发布
阅读量223 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58679504/article/details/126177518
版权

线性表：       
 *      栈
 *      队列
 *      数组
 *      链表

 

一、栈

         LIFO：后进先出
         FILO：先进后出

实现代码：

package com.openlab.collection;

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){
//		Object[] arr = new Object[len];
//		for (int i = 0; i < data.length; i++) {
//			arr[i] = data[i];
//		}
//		this.data = arr;
//      上面的代码等价于下面的

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

二、队列

        FIFO：先进先出
        LILO：后进后出

实现：

方法1：和栈类似，只需改变出队代码

方法2：利用两个栈来实现队列

1：

package com.openlab.collection;

import java.util.Arrays;

public class Queue {

	private Object[] data;
	private int size;
	private int capacity;
	
	public Queue() {
		// 默认创建一个10容量的队列
		this.capacity = 10;
		data = new Object[this.capacity];
	}
	
	public Queue(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("对不起，队列中已经没有元素了");
		}
		this.size--;
		Object temp = this.data[0];
		System.arraycopy(data, 1, this.data, 0, data.length - 1);
		return temp;
	}	
	
	// 查看队列顶元素
	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)	{
		Queue s = (Queue) 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;
	}
}

2：

package com.openlab.collection;

public class Queue2 {
	
	private Stack stackA;					
	private Stack stackB;		

	public Queue2() {
		stackA = new Stack();
		stackB = new Stack();
	}
	
	// 进队一个元素
	public void offer(Object e){
		this.stackA.push(e);
	}	
	
	// 出队一个元素
	public Object poll(){
		remove();
		return stackB.pop();
	}

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

三、数组

 数组是相同类型元素的集合，用一段连续的空间来存放数组的内容。

package com.openlab.collection;


import java.util.Arrays;

/**
 *  动态数组
 *
 */
public class ArrayList {
	
	private Object[] objs;
	private int size;
	private int capacity;
	
	public ArrayList() {
		this.capacity = 10;
		this.objs = new Object[this.capacity];
	}
	
	public ArrayList(int capacity) {
		this.capacity = capacity;
		this.objs = new Object[this.capacity];
	}
	
	public void add(Object obj) {
		if (this.isFull()) {
			// 扩容
			this.grow();
		}
		this.objs[size++] = obj;
	}

	private void grow() {
		// 1.5 倍
		int newCapaCity = this.capacity + (this.capacity >>> 1);
		System.out.println("扩容开始，容量由"+ this.capacity +"变为："+ newCapaCity);
		this.objs = Arrays.copyOf(this.objs, newCapaCity);
		this.capacity = newCapaCity;
		System.out.println("扩容成功");
	}

	private boolean isFull() {
		return this.size == this.capacity;
	}
	
	public void add(int index, Object obj) {
		if (this.isFull()) {
			this.grow();
		}
		for (int i = size; i > index ; i--) {
			this.objs[i] = this.objs[i - 1];
		}
		this.objs[index] = obj;
		this.size++;
	}

	public void remove(int index) {
		for (int i = index; i < this.size - 1; i++) {
			this.objs[index] = this.objs[index+1];
		}
		this.size--;
	}
	
	public void update(int index, Object obj) {
		this.objs[index] = obj;
	}

	public Object load(Object Object) {
		
		return null;
	}

	public Object get(int index) {
		if (index < size) {
			return null;
		}
		return this.objs[index];
	}

	public Object[] list() {
		return Arrays.copyOf(this.objs, size);
	}

	public void clear() {
		this.size = 0;
	}

	public String toString() {
		return "ObjectMangerImpl [objs=" + Arrays.toString(objs) + ", size=" + size + ", capacity=" + capacity + "]";
	}
	
	public int size() {
		return this.size;
	}
	
}

四、 链表

双向循环链表：

package p3.链式结构;

import p1.接口.Dequeue;
import p1.接口.List;
import p1.接口.Stack;

import java.util.Comparator;
import java.util.Iterator;

//双向循环链表
public class LinkedList<E> implements List<E>, Dequeue<E>, Stack<E> {

    private class Node {
        E data;
        Node pre;//直接前驱
        Node next;//直接后继

        public Node() {
            this(null, null, null);
        }

        public Node(E data) {
            this(data, null, null);
        }

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

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

    private Node head;
    private Node tail;
    private int size;

    public LinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedList(E[] arr) {
        if (arr == null) {
            throw new IllegalArgumentException("arr can not be null");
        }
        for (E e : arr) {
            add(e);//默认在表尾添加
        }
    }

    @Override
    public void add(E element) {
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index out of range");
        }
        Node n = new Node(element);
        if (size == 0) {//刚开始链表为空的，来个新节点对象，直接head ,tail 指向新节点
            head = n;
            tail = n;
            tail.next = head;//节点的下一跳 尾的下一跳指头               体现循环
            head.pre = tail;//节点的上一跳（前驱）  头的下一跳应该是尾
        } else if (index == 0) {//要插入的角标在第一个
            //先把当前（头）上一跳给 新节点的上一跳（指的尾） 新节点的下一跳指向当前的head  当前头的上一跳指新节点   head更新为新节点   尾的下一跳更新为当前的head
            n.pre = head.pre;
            n.next = head;
            head.pre = n;
            head = n;
            tail.next = head;
        } else if (index == size) {//在表尾
            //从右向左读 ：先把当前尾的下一跳给新节点的下一跳（或者说从左向右读 新节点的下一跳指向尾的下一跳）   尾的下一跳指向新节点 新节点的上一跳指向当前尾  尾更新为新节点 头的上一跳重新指向尾
            n.next = tail.next;
            n.pre = tail;
            tail.next = n;
            tail = n;
            head.pre = tail;
        } else {//中间
            Node p, q;//要插入节点位置的前驱 后继（也是要插入的位置）   p q
            if (index <= size / 2) {//链表偏左的地方添加
                p = head;
                for (int i = 0; i < index - 1; i++) {//如在i=2位置添加元素 需要找到其前驱，i=0 i<2-1=1 0-1 移动一次 刚好到i=1的位置 即为 i=2的前驱
                    p = p.next;
                }
                q = p.next;
                // p的下一跳指向新节点  新节点的上一跳指向p             q的上一跳指向新节点 新节点的下一跳指向q
                p.next = n;
                n.pre = p;
                q.pre = n;
                n.next = q;
            } else {//链表偏右的地方添加
                p = tail;//从尾部找起   此时q是p的前驱
                for (int i = size - 1; i > index; i--) {//如在index=4的位置添加元素 size=6 i=size-1=5,i>index 移一个 i--=4 4
                    p = p.pre;
                }
                q = p.pre;
                //q的下一跳指向新节点 新节点的上一跳指向q   p的上一跳指向新节点  新节点的下一跳指向p
                q.next = n;
                n.pre = q;
                n.next = p;
                p.pre = n;
            }
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexof(element);
        if (index != -1) {//！=-1 即存在  根据角标删除即可
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret = null;
        Node node;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            ret = head.data;//保存值
            node = head.next;//node作辅助用  找到新的头节点
            head.next = null;//先断head和node的联系
            node.pre = head.pre;//head的上一跳给node的上一跳
            head.pre = null;//head的上一跳还存在 指向着尾 将它清空，不再指向任何
            head = node;//head重新指向node
            tail.next = head;//尾的下一跳指向头
        } else if (index == size - 1) {
            ret = tail.data;
            node = tail.pre;//先找到新的尾节点  node
            tail.pre = null;//tail上一跳置空
            node.next = tail.next;//tail的下一跳给node的下一跳（让node指向头）
            tail.next = null;//tail下一跳置空
            tail = node;//tail指向新的尾节点
            head.pre = tail;//头的上一跳重新更新为当前的尾节点
        } else {
            Node p, q, r;//要删除节点的前驱   要删除节点    要删除节点的后继
            if (index <= size / 2) {
                p = head;
                for (int i = 0; i < index - 1; i++) {
                    p = p.next;
                }
                q = p.next;
                r = q.next;
                ret = q.data;
                p.next = r;//p的下一跳指向r
                r.pre = p;//r的上一跳指向p
                q.next = null;//q上下置空
                q.pre = null;
            } else {
                p = tail;
                for (int i = size - 1; i > index + 1; i++) {//如在index=4的位置删除元素 i=size-1=6 i>index+1=5 移一个 i++=6 不移
                    p = p.pre;
                }
                q = p.pre;
                r = q.pre;
                ret = q.data;
                r.next = p;
                p.pre = r;
                q.next = null;
                q.pre = null;
            }
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        if (index == 0) {
            return head.data;
        } else if (index == size - 1) {
            return tail.data;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexof(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
            p = p.next;
            index++;
            if (p == head) {
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexof(element) != 0;
    }


    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }



    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }

        if (size == 0 || size == 1) {
            return;
        }
        //插入排序来做
        for (Node nodeA = head.next; nodeA != head; nodeA = nodeA.next) {
            E e = nodeA.data;
            Node nodeB;
            Node nodeC;
            for (nodeB = nodeA, nodeC = nodeB.pre; nodeC != tail && c.compare(nodeC.data, e) > 0; nodeB = nodeB.pre, nodeC = nodeC.pre) {//或者判断的条件为nodeB!=head 都表示结束
                nodeB.data = nodeC.data;
            }
            nodeB.data = e;
        }
    }

    @Override
    public List<E> sublist(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("0<=fromIndex<=toIndex<size");
        }
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        LinkedList<E> list = new LinkedList<>();
        while (true) {//从A开始移，先放再移  ，直到B
            list.add(p.data);//到B时，先把nodeB加进去，判断是NodeB就跳出
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                } else {
                    sb.append(',');
                    sb.append(' ');
                    p = p.next;
                }
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedListIterator();
    }

    class LinkedListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true;//是否在第一圈

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }
    //双端队列的方法
    @Override
    public void addFirst(E element) {
        add(0, element);
    }

    @Override
    public void addLast(E element) {
        add(size, element);
    }

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E removeLast() {
        return remove(size-1);
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size-1);
    }

    //栈的方法
    @Override
    public void push(E element) {
        addLast(element);
    }

    @Override
    public E pop() {
        return removeLast();
    }

    @Override
    public E peek() {
        return getLast();
    }

    //队列的方法
    @Override
    public void offer(E element) {
        addLast(element);
    }

    @Override
    public E poll() {
        return removeFirst();
    }

    @Override
    public E element() {
        return getFirst();
    }

}

m0_58679504
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java开发详解.zip
09-02
031901_【第19章：Java网络编程】_IP（Internet Protocol）与InetAddress笔记.pdf 031902_【第19章：Java网络编程】_URL与URLConnection笔记.pdf 031903_【第19章：Java网络编程】_URLEncoder与URLDecoder笔记.pdf ...
教你用 Java 写一个自己的 Tomcat 容器，涨姿势了。。
Java技术栈，分享最主流的Java技术
08-24 287
点击关注公众号，Java干货及时送达当我们开始接触到SpringBoot项目的时候，我们特别惊讶，为什么没有了tomcat服务器，web项目还能跑起来。为什么只用了一个main方法就能讲一...
Java自定义容器
qq_52566242的博客
08-05 554
Java自定义容器
Java自定义实现四种线性容器
学废了的阿串的博客
08-14 176
使用Java自定义实现四种基本的线性容器，Java自定义实现栈、Java自定义实现队列、Java自定义实现动态数组、Java自定义实现链表。
Java 容器简介
codeboys的专栏
07-12 2028
Java 容器简介，Java 容器类型
java容器应用实例_JAVA容器
weixin_36054993的博客
02-16 335
JAVA容器一、容器体系结构java.util二、迭代器Iterator迭代器是一种设计模式，可以遍历并选择序列中的对象，而开发人员并不需要了解该序列的底层结构。迭代器通常被称为”轻量级”对象，因为创建它的代价小。JAVA的Iterator功能比较简单，并且只能单向移动。相对Iterator而言，for()循环遍历的速度较快点。而Iterator则比较通用，且序列的内部状态都由Iterator维护...
Java开发技术大全 电子版
04-10
第2章Java语言基础19 2.1Java语言的特点19 2.2Java程序的构成21 2.3数据类 型23 2.3.1基本数据类型23 2.3.2常量25 2.3.3变量26 2.3.4整型数据27 .2.3.5浮点型数据29 2.3.6字符型数据30 2.3.7布尔型数据32 ...
精通qt4编程（源代码）
03-17
\第19章 脚本——QtScript 459 \19.1 执行ECMAScript脚本 459 \19.2 QtScript中的信号和槽 460 \19.3 使用JavaScript操作Qt对象 463 \19.4 基于Prototype的继承 467 \19.5 小结 467 \第20章 国际化 468 \20.1 ...
精通Qt4编程(第二版)源代码
01-19
\第19章 脚本——QtScript 459 \19.1 执行ECMAScript脚本 459 \19.2 QtScript中的信号和槽 460 \19.3 使用JavaScript操作Qt对象 463 \19.4 基于Prototype的继承 467 \19.5 小结 467 \第20章 国际化 468 \20.1...
javaSE代码实例
06-21
第2章　基本数据类型——构建Java 大厦的基础　12 2.1　源代码注释　12 2.1.1　单行注释　12 2.1.2　区域注释　12 2.1.3　文档注释　13 2.2　基本数据类型　14 2.2.1　整型　15 2.2.2　浮点型　17 2.2.3　char型　17...
自定义IOC容器
02-18
自己动手实现IOC容器的demo，帮助理解和学习spring IOC容器的基本原理和实现，适合学过或者用过spring的java玩家
java 容器实现_java 容器类的实现
weixin_30231327的博客
02-16 337
/*1. 它能支持字符串数据类型的存储与操作。也即把容器看成一个集合，集合内的元素是整数。2. 容器的大小可以任意设置。因为数组一旦定义长度，不能更改，可以通过一个计数器变量count标识数组的大小。1)在初始化一个容器时指定包含元素的个数。2)使用“直接插入排序”对容器内数组进行升序排列。3)使用“冒泡排序”对容器内数组进行升序排列。4)使用“快速排序”对容器内数组进行升序排列。5)通过给定元素...
java之自定义容器
weixin_45433052的博客
07-26 609
基于数组方式 public class IntArray { Object[] data; int size; IntArray(int length){ //自定义储存大小 data=new Object[length]; } IntArray(){ //调用有参的构造方法，默认储存大小 this(5); } //添加元素 public...
Java数据结构（3）- 数组
热门推荐
何忆清风
01-26 8万+
1、容器 容器：什么是容器，容器是一种基础工具。泛指任何可以用于容纳其它物品的工具，可以部分或完全封闭，被用于容纳、储存、运输物品。物体可以被放置在容器中，而容器则可以保护内容物。通俗一点讲，就是用来装东西的，可以存放物体。而再java’语言当中什么是容器，容器就是用来装数据的，存储数据的容器。 2、数组 何为数组，从字面上来理解，就是一组数字，一组数据。数组作为一种基本容器，可以在jvm虚...
java自定义容器排序的两种方法
shirenfeigui的专栏
09-04 2万+
首先说一下排序的返回值的含义。对于参与比较的两个Object，o1和o2，如果函数的返回值为正值，把o1排在o2后面；返回值为负值，把o1排在o2前面。如果返回值是0，按照容器之前的顺序排列。在compareTo中，this相当于o1,传入的Object相当于o2 第一种方法：对于要排序的类实现Comparable接口 package sort; import java.util.Arr
JavaSE基础(100) 自定义容器类(存储任意数据类型和数据个数)
郑清
08-30 2439
自定义容器类：可以存储任意数据类型和数据个数 /** * 自定义容器类：可以存储任意数据类型和个数 * @author 郑清 */ public class MyArrayDemo { public static void main(String[] args) { MyArray myArray = new MyArray(); myArray.add("这是第"); m...
java 定义容器,java 自定义一个容器类
weixin_36478866的博客
03-11 249
public class ArrayList {public int index = 0;Object[] objects = new Object[2];public void add(Object o) {//当index超出最初定义数组的长度时，自动扩容if(index == objects.length){System.out.println("extend...................
深入理解Java中的容器
什么最重要？算法！！
07-27 6万+
1、容器的概念 在Java当中，如果有一个类专门用来存放其它类的对象，这个类就叫做容器，或者就叫做集合，集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体 2、容器与数组的关系 之所以需要容器： 1、数组的长度难以扩充 2、数组中数据的类型必须相同 容器与数组的区别与联系： 1、容器不是数组，不能通过下标的方式访问容器中的元素 2、数组的所有功能通过Arraylist容器
Java自定义容器类设计
f2315895270的博客
07-23 486
我的网站：欢迎大家访问 设计一个容器类，可以添加任意多及任意类型的数据，打印容器对象的时候可以将所有数据打印出来 示例代码： package Test; import java.util.Arrays; import com.sun.org.apache.bcel.internal.generic.NEW; import sun.security.util.Length; public c...
AndroidStudio——java.lang.UnsatisfiedLinkError错误
最新发布
06-07
这个错误通常是由于缺少本地库（native library）文件或者本地库文件不可用所导致的。你可以尝试以下几种解决方案： 1. 确定本地库文件是否存在或者是否在正确的位置。如果本地库文件不存在或者位置错误，可以使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值