Java集合进阶

最新推荐文章于 2025-05-31 22:32:21 发布
置顶 最新推荐文章于 2025-05-31 22:32:21 发布
阅读量784 收藏 5
点赞数 9
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2501_90959181/article/details/148148042
版权

集合体系结构

在这里插入图片描述
在这里插入图片描述

Collection

在这里插入图片描述
迭代器对象的演示代码：

package kl003;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class demo2 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        //获取迭代器对象
        Iterator<String> it = coll.iterator();;
        //利用循环遍历集合中的每一个元素
        while (it.hasNext()){
            //获取指针并移动指针
            String str = it.next();
            System.out.println(str);
        }
        //上面循环结束的时候指针已经指向没有元素的位置
        //迭代器遍历完集合后，指针不会复位
        //如果还想遍历第二次就必须获取新的迭代器对象
        //循环中只能调用一次next方法
        //迭代器对象遍历的时候不能使用集合对象的方法修改和删除
        //如果要删除，可以用迭代器的方法删除

    }
}

迭代器的总结：
在这里插入图片描述
增强for遍历
在这里插入图片描述
增强for的细节：
在这里插入图片描述
增强for循环的演示代码

package kl003;

import java.util.ArrayList;
import java.util.Collection;

public class demo3 {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        //利用增强for遍历集合
        //注意点：s是一个第三方变量，代表集合中的每一个数据
        for (String s : coll) {
            System.out.println(s);
        }
    }
}

运行结果：
aaa
bbb
ccc
ddd
Lambda表达式遍历
在这里插入图片描述
Collection总结
在这里插入图片描述
Collection包含了list
在这里插入图片描述
和Collection一样同为接口类
list的演示代码

package kl003;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
    public static void main(String[] args) {
        //创建一个集合
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //插入指定元素
        //细节：原来索引的元素会一次往后移动
        list.add(1,"kkk");
        //删除指定元素，并返回被删除的元素
        //细节：原来索引的元素会依次往前移动
        String remove = list.remove(1);
        System.out.println(remove);
        //set方法修改集合索引的指定元素，返回被修改的元素
        String result = list.set(0,"QQQ");
        //get方法获取指定索引的元素
        String s = list.get(1);
        System.out.println(s);
        //打印集合
        System.out.println(list);
    }
}


package kl003;

import java.util.ArrayList;
import java.util.List;

public class ListRemoveDemo1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //删除元素
        //list.remove(1);这是为自动装箱，优先调用实参一致的方法
        //手动装箱

        Integer i = Integer.valueOf(1);
        list.remove(i);
        System.out.println(list);

    }
}

list集合的遍历方式
在这里插入图片描述
list的五种遍历方式的演示代码

package kl003;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.Consumer;

public class ListDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println("迭代器遍历");
        //迭代器遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //增强for循环遍历
        System.out.println("增强for循环遍历");
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("Lambda表达式遍历");
        //Lambda表达式遍历
        list.forEach(string->System.out.println(string));
        //普通遍历
        System.out.println("普通遍历");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        //列表迭代器
        System.out.println("列表迭代器遍历");
        ListIterator<String> it2 = list.listIterator();
        while (it2.hasNext()){
            String s = it2.next();
            if ("bbb".equals(s)){
                //添加元素
                it2.add("qqq");
            }
        }
        System.out.println(list);
    }
}

五种遍历方式的对比
在这里插入图片描述
在这里插入图片描述
数据结构：
扩展的分块查找：
不同的业务场景采用不同的数据结构
在这里插入图片描述
常见的数据结构：
在这里插入图片描述
数据结构（栈）
在这里插入图片描述
数据进出入栈
在这里插入图片描述
在这里插入图片描述
数据结构（队列）
在这里插入图片描述
队列和栈的总结
在这里插入图片描述
数组
在这里插入图片描述

数组的弊端：
在这里插入图片描述
在这里插入图片描述
查询块，增删慢的模型
链表
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
单向链表和双向链表
在这里插入图片描述
对上述数据结构模型的总结
在这里插入图片描述
ArrayList集合底层原理
在这里插入图片描述
一次添加一个元素
一次添加一堆元素
在这里插入图片描述
在这里插入图片描述
linkedlist集合
在这里插入图片描述
泛型
在这里插入图片描述
泛型代码演示

package kl002;

import java.sql.Array;
import java.util.ArrayList;
import java.util.Iterator;

public class GengericsDemo1 {
    public static void main(String[] args) {
        //没有泛型的时候，集合如何存储数据
        //创建集合对象
        //获取数据的时候，无法获取特有行为
        ArrayList<String> list = new ArrayList();
        //添加数据
        //list.add(123);
        list.add("aaa");
        //list.add(new Student());
        //遍历集合获取集合里面的每一个数据
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
    }
}

泛型的细节：
在这里插入图片描述
Arraylist泛型演示代码

package kl002;

import java.util.Arrays;

public class MyArrayList<E> {
    Object[] obj = new Object[10];
    int size;
    //E代表不确定类型，e代表形参类型
    public boolean add(E e){
        obj[size] = e;
        size++;
        return true;
    }
    public E get(int index){
        return (E)obj[index];
    }

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


package kl002;

public class GengericsDemo2 {
    public static void main(String[] args) {
        /*MyArrayList<String> list = new MyArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list);*/
        //同理<Integer><double>
        MyArrayList<Integer> list = new MyArrayList<>();
        list.add(123);
        list.add(478);
        list.add(910);
        int i = list.get(0);
        System.out.println(i);
        System.out.println(list);
    }
}

运行结果：
123
[123, 478, 910, null, null, null, null, null, null, null]
泛型方法：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
泛型方法的练习

package kl004;

import java.util.ArrayList;

public class demo1 {
    //定义一个工具类：listutil
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        //添加元素
        Listutil.addAll(list1, "aaa", "aaa", "aaa", "aaa");
        ArrayList<String> list2 = new ArrayList<>();
        Listutil.addAll(list2, "bbb", "bbb", "bbb", "bbb");
        System.out.println(list1);
        System.out.println(list2);
    }
}


package kl004;

import java.util.ArrayList;

public class Listutil<E> {
    private Listutil(){

    }
    // public static <E> void addAll(ArrayList<E> list,E...e)
    //添加未知数量的元素
    //可变参数
    public static <E> void addAll(ArrayList<E> list,E e1,E e2,E e3,E e4){
        list.add(e1);
        list.add(e2);
        list.add(e3);
        list.add(e4);
    }
}

运行结果：
[aaa, aaa, aaa, aaa]
[bbb, bbb, bbb, bbb]
泛型接口：
在这里插入图片描述

package kl004;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList implements List<String> {
    @Override
    public int size() {
        return 0;
    }

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

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String string) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return "";
    }

    @Override
    public String set(int index, String element) {
        return "";
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return "";
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return List.of();
    }

}


package kl004;

import kl002.MyArrayList;

public class MyArrayListTest {
    public static void main(String[] args) {
    /*
    泛型接口的两种使用方式
    1.实现类给出具体的类型
    2.实现类延续泛型，创建实现类对象再确定类型
    */
        MyArrayList list = new MyArrayList();
    }
}


package kl004;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList2<E> implements List<E> {
    @Override
    public int size() {
        return 0;
    }

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

    @Override
    public boolean contains(Object o) {
        return false;
    }

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

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public E get(int index) {
        return null;
    }

    @Override
    public E set(int index, E element) {
        return null;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return List.of();
    }
}

泛型的继承和通配符
泛型不具备继承性，但是数据具备继承性

泛型演示代码

package kl004;

import java.util.ArrayList;

public class GenericsDemo1 {
    public static void main(String[] args) {
        //泛型不具备继承条件，但是数据具备继承条件
        //创建集合对象
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();
        //调用method方法
        //只能传达list1
        method(list1);
    }
    public static void method(ArrayList<Ye> list){

    }
}
class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

泛型的通配符：
在这里插入图片描述

泛型的通配符应用场景：
在这里插入图片描述
在这里插入图片描述

package kl005;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
    ArrayList<TDog> list1 = new ArrayList<>();
    ArrayList<HDog> list2 = new ArrayList<>();
    ArrayList<Lcat> list3 = new ArrayList<>();
    ArrayList<Fcat> list4 = new ArrayList<>();
    keepPet(list3);
    keepPet(list4);
    }
    public static void keepPet(ArrayList<? extends Cat> list){

    }
}


package kl005;

public class HDog extends Dog{
    @Override
    public void eat() {
        System.out.println("一只叫做" + getName() + "的" + getAge() + "岁的哈士奇，正在吃骨头，边吃边拆家");
    }
}


package kl005;

public class TDog extends Dog{
    @Override
    public void eat() {
        System.out.println("一只狗叫做" + getName() + "的"+getAge()+"x岁的土狗，正在吃骨头");
    }
}


package kl005;

public abstract class Dog extends Animal{
}


package kl005;

public class Lcat extends Cat{
    @Override
    public void eat() {
        System.out.println("一只猫叫做" + getName() + "的"+getAge()+"x岁的狸花猫，正在吃鱼");
    }
}


package kl005;

public class Fcat extends Cat{
    @Override
    public void eat() {
        System.out.println("一只猫叫做" + getName() + "的" + getAge() + "岁的波斯猫，正在吃猫粮");
    }
}


package kl005;

public abstract class Cat extends Animal{

}


package kl005;

public abstract class Animal {
    private String name;
    private int age;
    public Animal(){

    }
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();

    public String toString() {
        return "Animal{name = " + name + ", age = " + age + "}";
    }
}

泛型：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
添加节点（二叉查找树）：
大的存右边
小的存左边
一样的不存
二叉树的遍历方式：
在这里插入图片描述
前序遍历：
在这里插入图片描述
中序遍历：
在这里插入图片描述
后序遍历：
在这里插入图片描述
层序遍历：
在这里插入图片描述
在这里插入图片描述
数据结构（二叉树）小结：
在这里插入图片描述
在这里插入图片描述
二叉查找树（好处）：
提高运行效率
二叉查找树（弊端）：
数据结构（平衡二叉树）：
在这里插入图片描述
注意：
在这里插入图片描述
数据结构（树）的演变：
在这里插入图片描述
数据结构（平衡二叉树）旋转机制
在这里插入图片描述
左旋：
判断左右旋转的方法，找不平衡点
在这里插入图片描述
旋转前
在这里插入图片描述
旋转后
在这里插入图片描述
在这里插入图片描述
右旋：
在这里插入图片描述
在这里插入图片描述
右旋前：
在这里插入图片描述
右旋后：
在这里插入图片描述
左左：
在这里插入图片描述
在这里插入图片描述
左右：
在这里插入图片描述
先局部左旋，变为左左的情况：
在这里插入图片描述
然后在整体右旋：
在这里插入图片描述
最后得到平衡二叉树

右右：
在这里插入图片描述
一次左旋，就可以得到平衡二叉树：
在这里插入图片描述
右左：
在这里插入图片描述
先局部右旋：
在这里插入图片描述
再整体左旋，得到平衡二叉树
在这里插入图片描述
小结（平衡二叉树）

红黑树
在这里插入图片描述
红黑规则
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
添加节点规则

在这里插入图片描述
在这里插入图片描述
增删查改的性能很不错
在这里插入图片描述
HashSet底层原理
在这里插入图片描述
在这里插入图片描述

package kl001;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}


package kl001;

import java.util.HashSet;

public class Test {
    public static void main(String[] args) {
        //1.创建对象
        Student s1 = new Student("qq",18);
        Student s2 = new Student("qk",19);
        Student s3 = new Student("kk",20);
        Student s4 = new Student("kk",20);
        //2.创建集合添加学生
        HashSet<Student> hs = new HashSet<>();
        //3.添加
        System.out.println(hs.add(s1));
        System.out.println(hs.add(s2));
        System.out.println(hs.add(s3));
        System.out.println(hs.add(s4));
        //4.打印集合
        System.out.println(hs);
    }
}

记得alt+insert，用IDEA重写hashset方法
String和Integer不需要重写hashset方法
因为JAVA已经重写好了这两个东西
在这里插入图片描述
总结：
在这里插入图片描述
TreeSet的特点：
在这里插入图片描述
在这里插入图片描述

package kl001;

import java.util.Iterator;
import java.util.TreeSet;
import java.util.function.Consumer;

public class TreeSetdemo1 {
    public static void main(String[] args) {
        //1.创建对象
        TreeSet<Integer> ts = new TreeSet<>();
        //2.添加
        ts.add(1);
        ts.add(3);
        ts.add(5);
        ts.add(2);
        ts.add(4);
        //3.遍历集合
        //增强for循环
        for(Integer t : ts){
            System.out.println(t);
        }
        System.out.println("-----------------------");
        //迭代器
        Iterator<Integer> it = ts.iterator();
        while(it.hasNext()){
            int i = it.next();
            System.out.println(i);
        }
        System.out.println("-----------------------");
        //Lambda表达式
        ts.forEach(i-> System.out.println(i));
    }
}

在这里插入图片描述在这里插入图片描述
谢谢观看！

通达的K
关注
创龙基于AM5728平台的PCIe通信案例（一）
技术联盟
06-19 516
本次PCIe通信案例测试基于AM5728平台，篇幅较长，共分为三部分，分别阐述：AM57x与Artix-7FPGA、AM57x与Kintex-7 FPGA、AM57x与TMS320C66x DSP的PCIe通信测试，供大家参考学习。 1 AM57x与Artix-7FPGA的PCIe通信测试 1.1 实验准备  介绍说明 PCI-Express是一种高速串行计算机扩展总线标准，由英特尔在2001年提出，属于高速串行点对点双通道高带宽传输。本实验主要介绍AM57x开发板与Artix-7FPGA之间的PCIe
分立式ARM+FPGA与ZYNQ SoC相比，有哪些好处？
创龙，嵌入式一体化解决方案商
10-23 2824
目录 1 ARM+FPGA架构有什么优势 2 分立式ARM+FPGA有哪些好处 2.1 接口资源更多 2.2 HMI体验更好 2.3 ARM主频更高 2.4 开发难度更低 3 评估板免费试用 4 产品资料下载 5 技术交流群 1 ARM+FPGA架构有什么优势 相对于纯ARM或纯FPGA器件，ARM+...
大学按照学科类别、办学层次、教育性质分类有哪些？创龙教仪一文带您了解...
weixin_30831261的博客
08-02 125
大学的分类多种多样，主要可以从学科类别、办学层次、教育性质等方面进行划分。一、按学科类别划分综合类大学特点：学科门类齐全，文理渗透，科研实力强。优势：拥有较多的国家级重点学科和实验室，师资力量雄厚，学术氛围浓厚。劣势：部分综合类大学可能因规模庞大导致管理上的复杂性。代表院校：北京大学、清华大学、浙江大学、武汉大学理工类大学...
Cortex-A55 处理器到底什么来头？创龙教仪一文带您了解
Tronlongtech的博客
12-03 1868
Cortex-A55采用了低功耗技术，能够在保证高性能的同时实现极低的功耗。通过先进的电源管理技术和动态电压频率调整（DVFS），它非常适合移动设备和便携式设备的应用场景。
武汉传媒学院联合创龙教仪建设DSP教学实验箱，基于DSP C6000平台搭建
Tronlongtech的博客
09-12 1201
武汉传媒学院是中南地区唯一一所传媒类本科高校，也是湖北省“转型发展”首批试点高校前身是2004年成立的华中师范大学武汉影视工程学院，2007年经教育部批准更名为华中师范大学武汉传媒学院，2016年，经教育部批准，成功转设为独立设置的普通本科高校。传媒技术学院是武汉传媒学院设立的工学学科教学单位，现设有电子信息工程、广播电视工程、软件工程等3个本科专业，设有一个计算机基础教研室，面向全校新生开设《信息技术与素养》公共课程。广播电视工程专业。
创龙带您了解ARM Cortex-A8高性能低功耗处理器设计的TL335x-EVM评估板
创龙，嵌入式一体化解决方案商
09-09 358
1.TL335x-EVM评估板 创龙TL335x-EVM是一款基于TI Sitara系列AM3352/AM3354/AM3358/AM3359ARM Cortex-A8高性能低功耗处理器设计的评估板，由核心板和底板组成。核心板经过专业的PCB Layout和高低温测试验证，稳定可靠，可满足各种工业应用环境。 评估板接口资源丰富，引出双路千兆网口、HDMI、GPMC、CAN等接口，方便用户快速进行产品方案评估与技术预研。 图 1评估板正面图 图 2评估板正面图 图...
瑞芯微RK3568J如何“调节主频”，实现功耗降低？一文教会您！
创龙，嵌入式一体化解决方案商
07-30 842
系统支持6种CPU主频模式，为降低功耗、确保芯片使用寿命，2023年9月25日后创龙科技RK3568J工业核心板产品资料将默认配置为performance主频模式，频率设置为1.4(1.416)GHz。各主频模式最高使能主频为1.4(1.416)GHz，如需修改performance或userspace主频模式使能的主频，请修改Linux内核源码”arch/arm64/boot/dts/rockchip/”目录下的内核设备树文件tl3568-evm.dts如下内容，将disabled设置为okay。
创龙带您解密TI、Xilinx异构多核SoC处理器核间通讯
创龙，嵌入式一体化解决方案商
09-08 1165
1.什么是异构多核SoC处理器 顾名思义，单颗芯片内集成多个不同架构处理单元核心的SoC处理器，我们称之为异构多核SoC处理器，比如： TI的OMAP-L138（DSP C674x + ARM9）、AM5708（DSP C66x + ARM Cortex-A15）SoC处理器等； Xilinx的ZYNQ（ARM Cortex-A9 + Artix-7/Kintex-7可编程逻辑架构）SoC处理器等。 2.异构多核SoC处理器有什么优势 相对于单核处理器，异构多核SoC处理器能带来性能、成本、功.
哇！8核+6T算力NPU！一分钟了解瑞芯微RK3576国产平台
strongerHuang
02-27 113
关注+星标公众号，不错过精彩内容来源|创龙科技随着需求的变化，异构多核嵌入式处理器越来越受到欢迎，今天给大家分享一款瑞芯微极具性价比的处理器：RK3576。它兼具高性能，同时价格也相对比较低。创龙科技基于该处理器推出了RK3576工业核心板，同时，还准备了B2B和邮票孔两个版本任君挑选，批量价分别为458元和428元。此外，这款板子的性能强劲，无论是复杂的数据处理，还是对实时性要求极高的工业应用场...
创龙带您解密TI、Xilinx异构多核SoC处理器核间通讯-20200327.pdf
03-27
1什么是异构多核SoC处理器 顾名思义，单颗芯片内集成多个不同架构处理单元核心的SoC处理器，我们称之为异构多核SoC处理器，比如： TI的OMAP-L138（DSP C674x + ARM9）、AM5708（DSP C66x + ARM Cortex-A15）SoC...
创龙TMS320C6678光盘资料更新说明V2.0_创龙_tms320c6678_V2_TMS320C6678光盘_
10-01
创龙TMS320C6678光盘资料更新说明V2.0是一个针对TMS320C6678处理器的资源库升级文档，由创龙科技提供，旨在帮助用户了解新版本中包含的改进、修复和新增功能。TMS320C6678是德州仪器（TI）推出的一款高性能浮点数字...
创龙TMS320C6748.rar
02-07
创龙TMS320C6748是一款基于TI（德州仪器）公司TMS320C6748 DSP（数字信号处理器）的高性能开发板，适用于各种需要复杂信号处理的应用，如音频处理、图像处理、通信系统等。这款开发板提供了丰富的功能和接口，便于...
创龙Kintex7+TM320C6678资料.zip
02-24
创龙Kintex7+TM320C6678资料.zip
创龙仿真器资料.rar
02-03
通过查阅这个文件，用户可以了解最新的更新内容，决定是否需要升级到最新版本，以及升级后可能会有哪些新功能或性能提升。 5. **创龙 平台模块配对表.xlsx**： 这个Excel文件可能是创龙仿真器与其他硬件模块的兼容...
Flink系列文章列表
yyf960126的博客
05-27 538
把写的文章做一个汇总，会陆续更新的。
大数据-274 Spark MLib - 基础介绍 机器学习算法 剪枝 后剪枝 ID3 C4.5 CART
永远好奇，无限进步！
05-29 951
《决策树算法解析与实践》文章摘要：本文系统介绍了决策树的预剪枝与后剪枝原理，对比了ID3、C4.5和CART三种主流算法的核心差异，包括分裂标准、属性支持类型和剪枝方法。重点阐述了信息增益、信息增益率与基尼系数的计算原理，详细讲解了从树生成到剪枝的完整流程，并通过Spark MLlib中的Scala代码实例演示了决策树分类器的实现过程。文中还包含清晰的算法对比图表和技术要点总结，为读者提供了从理论到实践的完整决策树学习路径。
3.8.3 利用RDD统计每日新增用户
howard2005的专栏
05-27 809
本项目使用Spark RDD处理用户访问数据，统计每日新增用户数。首先创建Maven项目并配置Spark依赖，编写Scala代码读取HDFS数据，通过倒排索引法确定每个用户的首次访问日期。然后，使用`groupByKey`和`countByKey`方法统计每日新增用户数。最后，按日期升序输出结果。项目加深了对Spark RDD操作的理解，掌握了文本文件处理和统计分析技能。
【C/C++】从零开始掌握Kafka
YZJincsdn的博客
05-25 1416
官方提供的高性能 C/C++ Kafka 客户端库。高吞吐的生产与消费offset 提交topic/partition 管理幂等发送、压缩、批处理。
Spring Boot启动慢？Redis缓存击穿？Kafka消费堆积？——Java后端常见问题排查实战
最新发布
yirenDM的博客
05-31 1046
Java后端系统的问题排查离不开系统化思维和高效工具链。建议开发者熟练掌握JVM分析工具、链路追踪、监控报警、日志分析等能力。面对复杂业务场景，需结合技术栈深入理解各组件工作原理，快速定位并解决问题。持续总结排查经验，不断优化系统架构与运维流程，是保障稳定高可用服务的关键。本文面向Java开发者，系统梳理互联网大厂Java后端技术栈（含Spring Boot、Redis、Kafka等）在真实业务场景下的常见异常和性能问题，结合具体排查思路、工具、案例，帮助读者提升线上问题定位与系统调优能力。
在使用创龙TLZ7xH-EVM开发板进行Xilinx Zynq-7000 SoC的集成开发过程中，需要遵循哪些步骤进行硬件和软件编程？
10-29
要成功地进行Xilinx Zynq-7000 SoC的集成开发，你将需要熟悉TLZ7xH-EVM开发板的硬件特性以及相应的软件编程。在此，我们推荐参考以下资源《创龙TLZ7xH-EVM开发板：Xilinx Zynq-7000双核Cortex-A9+Kintex-7》，这将为你的项目提供详尽的支持。 参考资源链接：[创龙TLZ7xH-EVM开发板：Xilinx Zynq-7000双核Cortex-A9+Kintex-7](https://wenku.csdn.net/doc/80nyorov3y) 首先，在硬件编程方面，你需要了解开发板的硬件架构和资源。TLZ7xH-EVM开发板集成了双核ARM Cortex-A9处理器和Kintex-7 FPGA。你应该首先阅读Zynq-7000开发板规格书，了解各个硬件接口和信号引脚的详细信息。根据你的项目需求，进行硬件资源配置，包括配置处理器的时钟频率、电源管理、存储接口以及外设接口等。 其次，在软件编程方面，Xilinx提供了Vivado和SDK套件，用于硬件逻辑设计和软件应用开发。在Vivado中，你需要完成硬件平台的设计和生成，包括创建项目、综合、实现和生成比特流文件。完成硬件设计后，你可以通过Xilinx SDK进行软件编程，创建应用程序和驱动，以与硬件平台交互。编写代码时，你需要参考开发板提供的Demo程序，这些示例程序展示了如何加载和运行用户代码。 确保你具备相关的硬件编程经验，以及掌握至少一种用于嵌入式开发的编程语言，如C/C++。在软件开发过程中，你还需要了解操作系统的选择和配置，比如使用PetaLinux等。 集成开发成功的关键在于硬件和软件的紧密配合，这通常需要进行多次迭代和调试。使用TLZ7xH-EVM开发板上的调试接口，比如JTAG和串口，进行代码调试和性能分析。 在开发过程中，不妨利用创龙科技提供的技术支持和服务，及时解决开发中遇到的问题。此外，你可以利用公司提供的增值服务平台，如定制化开发、培训等，进一步提升开发效率和产品品质。 综上所述，通过阅读相关规格书，使用Vivado和SDK进行硬件设计和软件编程，结合创龙科技的技术支持，你将能够高效地完成Zynq-7000 SoC的集成开发任务。对于那些希望深入学习和探索更多高级功能和技巧的读者，我们再次推荐《创龙TLZ7xH-EVM开发板：Xilinx Zynq-7000双核Cortex-A9+Kintex-7》，这份资料不仅帮助你入门，还将引导你掌握更深层次的知识。 参考资源链接：[创龙TLZ7xH-EVM开发板：Xilinx Zynq-7000双核Cortex-A9+Kintex-7](https://wenku.csdn.net/doc/80nyorov3y)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值