Java-容器

关注

原创 2023-04-01 16:28:28 292 阅读 AI 写同款· GEO 优化 ›

vivado下ECO操作-不重新综合实现修改属性并生成.bit ECO即engineer change order，即工程变更指令，可以对设计做局部小改动并只对改动部分重新布局布线并生成.bit。在一个工程动辄编译几个小时情况下，可以在调试中节省大量时间。比如我们在调试中，需要改变时钟占空比或者相位，需要改变寄存器初值等等，此时用ECO暂时改动，待验证后在重新编译无疑是最有效率的方法。实现ECO通常有两种方式，一是通过vivado界面完成，另一种方法就是tcl脚本。所有的ECO操作都可以通过tcl操作完成，有的操作用vivado界面无法完成，只能通过tcl。以下主要阅读详情

一、List

ArrayList<>（变长数组）实现

add( )：在末尾添加一个元素
clear( )：清空
size( )：返回长度
isEmpty( )：是否为空
get(i)：获取第i个元素
set(i, val)：将第i个元素设置为val

（1）add( )、size( )、get( i )

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import javax.naming.StringRefAddr;

import org.jcp.xml.dsig.internal.MacOutputStream;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         List<Integer> list = new ArrayList<>();
         
         list.add(1);
         list.add(2);
         list.add(3);
                  
         // 两种遍历方式
         //方式1：普通for循环
         for(int i = 0 ; i < list.size() ; i ++)  System.out.printf("%d ",list.get(i));
         System.out.println();
         //增强for循环
         for(int x: list)  System.out.printf("%d ",x);
    }
}

（2）clear( )

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import javax.naming.StringRefAddr;

import org.jcp.xml.dsig.internal.MacOutputStream;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         List<Integer> list = new ArrayList<>();
         
         list.add(1);
         list.add(2);
         list.add(3);
                  
         list.clear();
         
         System.out.print(list);
    }
}

（3）isEmpty( )

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         List<Integer> list = new ArrayList<>();
         
         list.add(1);
         list.add(2);
         list.add(3);
                  
         if(list.isEmpty() == true)  System.out.println("空");
         else  System.out.println("不空");
    }
}

（4）set(i, val)

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         List<Integer> list = new ArrayList<>();
         
         list.add(1);
         list.add(2);
         list.add(3);
                  
         for(int i = 0 ; i < list.size() ; i ++)  list.set(i,1);
         
         for(int x:list)  System.out.printf("%d ",x);
    }
}

LinkedList<> （双链表）实现

只需修改上面代码的其中一条语句，然后导入新的类，其他的代码和上边一模一样！！！

List<Integer> list = new LinkedList<>();

讲一下ArrayList<>和LinkedList<>的区别：

1、ArrayList 和LinkedList结构不同

可以说ArrayList和LinkedList除了是同属于集合类，其他都是不同的，因为他们本身的实现是两种不同的实现方式，ArrayList 维护的是一个动态数组，LinkedList维护的是一个双向链表，而他们之间的不同是数组与链表的特性比较；

效率不同

LinkedList添加删除快

4、查询数据

ArrayList比LinkedList快；

二、Stack<>

push()：压入元素
get（）：得到元素的值
pop()：弹出栈顶元素，并返回栈顶元素
peek()：返回栈顶元素
size()：返回长度
empty()：栈是否为空
clear()：清空

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         Stack<Integer> stk = new Stack<>();
         
         // 栈中压入元素
         stk.push(1);
         stk.push(2);
         stk.push(3);
         
         // 遍历栈
         for(int i = 0 ; i < stk.size() ; i ++)  System.out.printf("%d ",stk.get(i));
         System.out.println();
         
         // 返回栈顶元素
         System.out.println(stk.peek());
         
         // 弹出栈顶元素
         stk.pop();
         for(int i = 0 ; i < stk.size() ; i ++)  System.out.printf("%d ",stk.get(i));
         System.out.println();
         
         // 判断是否空
         if(stk.isEmpty())  System.out.println("空");
         else System.out.println("不空");
         
         // 清空栈
         stk.clear();
    }
}

三、Queue<>

add()：在队尾添加元素
remove()：删除并返回队头
isEmpty()：是否为空
size()：返回长度
peek()：返回队头
clear()：清空

1、LinkedList<>（双链表）实现队列

// size()、isEmpty()、clear()就不多哔哔了

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         Queue<Integer> q = new LinkedList<>();
         
         q.add(1);
         q.add(2);
         q.add(3);
         
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
         
         // 删除队头&&返回队头
         System.out.println(q.remove()); // 返回队头的同时把对头删除了
         
         // 返回队头
         System.out.println(q.peek());
         q.remove(); // 正常的单写，删除2
         
         //遍历一下
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
    }
}

PriorityQueue<>：优先队列实现堆

（1）小根堆（默认）

小根堆堆顶是最小值

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         PriorityQueue<Integer> q = new PriorityQueue<>();
         
         q.add(1);
         q.add(2);
         q.add(3);
         
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
         
         // 删除堆顶&&返回堆顶
         System.out.println(q.remove()); // 返回队头的同时把堆顶删除了
         
         // 返回堆顶
         System.out.println(q.peek());
         q.remove(); // 正常的单写，删除2
         
         //遍历一下
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
    }
}

（2）大根堆

加参数：

new PriorityQueue<>(Collections.reverseOrder())

小根堆堆顶是最小值

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         PriorityQueue<Integer> q = new PriorityQueue<>(Collections.reverseOrder( ));
         
         q.add(1);
         q.add(2);
         q.add(3);
         
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
         
         // 删除堆顶&&返回堆顶
         System.out.println(q.remove()); // 返回队头的同时把堆顶删除了
         
         // 返回堆顶
         System.out.println(q.peek());
         q.remove(); // 正常的单写，删除2
         
         //遍历一下
         for(int x: q)  System.out.printf("%d ",x);
         System.out.println();
    }
}

四、Map

key自动排序

put(key, value)：添加关键字和其对应的值
get(key)：返回关键字对应的值
containsKey(key)：是否包含关键字
remove(key)：删除关键字
size()：返回元素数
isEmpty()：是否为空
clear()：清空
entrySet()：获取Map中的所有对象的集合
Map.Entry<K, V>：Map中的对象类型
getKey()：获取关键字
getValue()：获取值

java.util.TreeMap<K, V>多的函数：（用于二分）
    ceilingEntry(key)：返回大于等于key的最小元素，不存在则返回null
    floorEntry(key)：返回小于等于key的最大元素，不存在则返回null

HashMap<K, V>：哈希表实现

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

import javax.naming.StringRefAddr;

import org.jcp.xml.dsig.internal.MacOutputStream;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         Map<String,Integer> m = new HashMap<>();
         
         // 添加关键字和其对应的值
         m.put("a", 0);
         m.put("b", 1);
         m.put("c", 2);
         
         // 返回关键字"a"对应的值
         System.out.println(m.get("a"));
         
         // 是否包含关键字
         if(m.containsKey("a"))  System.out.println("a存在");
         else  System.out.println("a不存在");
         
         // 删除关键字
         m.remove("a");
         for (String key : m.keySet())   System.out.println(key + "-" + m.get(key)); 
         
         //getKey()、getValue()、entrySet()和Map.Entry<K, V>的遍历，我的评价是：不如增强for循环
         for(Map.Entry<String, Integer> entry: m.entrySet())
         System.out.printf("%s %d\n",entry.getKey(),entry.getValue());
    }
}

TreeMap<K, V>：平衡树实现

package 做题;
import java.lang.reflect.Array;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.TreeMap;

import javax.naming.StringRefAddr;

public class Main 
{
    public static void main(String[] args) 
    {
         Scanner sc = new Scanner(System.in);
         final int N = 10;
        
         TreeMap<String,Integer> m = new TreeMap<>();
         
         // 添加关键字和其对应的值
         m.put("a", 0);
         m.put("b", 1);
         m.put("c", 2);
         m.put("d", 3);
         
         // 返回关键字"a"对应的值
         System.out.println(m.get("a"));
         
         // 是否包含关键字
         if(m.containsKey("a"))  System.out.println("a存在");
         else  System.out.println("a不存在");
         
         // 删除关键字
         m.remove("a");
         for (String key : m.keySet())   System.out.println(key + "-" + m.get(key)); 
         
         //getKey()、getValue()、entrySet()和Map.Entry<K, V>的遍历，我的评价是：不如增强for循环
         for(Map.Entry<String, Integer> entry: m.entrySet())
         System.out.printf("%s %d\n",entry.getKey(),entry.getValue());
         
         // 二分
         Map.Entry<String, Integer> res = m.ceilingEntry("a");
         System.out.printf("%s %d\n",res.getKey(),res.getValue());
         res = m.floorEntry("e");
         System.out.printf("%s %d\n",res.getKey(),res.getValue());
    }
}

五、set

自带去重  
关键字自动排序（用哈希表HashSet<K>和平衡树TreeSet<K>实现的都是如此）         
接口：java.util.Set<K>
实现：
- java.util.HashSet<K>：哈希表
- java.util.TreeSet<K>：平衡树
函数：
    add()：添加元素
    contains()：是否包含某个元素
    remove()：删除元素
    size()：返回元素数
    isEmpty()：是否为空
    clear()：清空
java.util.TreeSet多的函数：
    ceiling(key)：返回大于等于key的最小元素，不存在则返回null
    floor(key)：返回小于等于key的最大元素，不存在则返回null

1、测试是否带去重

import javax.persistence.criteria.CriteriaBuilder;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;



public class Main
{
    static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    static int N = (int)1e5 + 10;
    static int a[] = new int[N];
    static Set<Integer> set1 = new TreeSet<>();
    static Set<Integer> set2 = new HashSet<>();

    public static void main(String[] args ) throws IOException
    {
        int n = rd.nextInt();
        for(int i = 1 ; i <= n ; i ++)  a[i] = rd.nextInt();

        for(int i = 1 ; i <= n ; i ++)
        {
            set1.add(a[i]);
            set2.add(a[i]);
        }

        for(int x: set1)  pw.print(x + " ");
        pw.println();
        for(int x: set2)  pw.print(x + " ");
        pw.flush();
    }
}

class rd
{
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer tokenizer = new StringTokenizer("");

    static String nextLine() throws IOException  { return reader.readLine(); }

    static String next() throws IOException
    {
        while (!tokenizer.hasMoreTokens())  tokenizer = new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException  { return Integer.parseInt(next()); }

    static double nextDouble() throws IOException { return Double.parseDouble(next()); }

    static long nextLong() throws IOException  { return Long.parseLong(next());}

    static BigInteger nextBigInteger() throws IOException
    {
        BigInteger d = new BigInteger(rd.nextLine());
        return d;
    }
}

class PII
{
    int x,y;
    public PII(int x ,int y)
    {
        this.x = x;
        this.y = y;
    }
}