java 集合框架--14

【Java集合框架】14——LinkedHashSet 类 LinkedHashSet 阅读详情

集合框架(体系概述)

这里写图片描述

这里写图片描述

为什么会出现这么多的容器呢?
因为每一个容器对数据的存储方式都有不同。
这个存储方式称之为数据结构。

Collection

import java.util.*;

/*
1,add方法的参数类型是Object,以便于接受任意类型的对象
2,集合中存储的都是对象的引用(地址)。

什么是迭代器呢?
    其实就是集合的取出元素的方式

把取出方式定义在集合的内部,这样取出方式就可以直接访问集合内容的元素。
那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性的内容(判断和取出)。那么可以对共性进行抽取。

那么这些内部类都符合一个规则,该规则是Iterator。
如何获取集合的去除对象呢?

通过一个对外提供的方法。
iterator();

*/

class CollectionDemo
{
    public static void main(String[] args)
    {
        base_method();
        sop("---------------------");
        method_2();
        sop("---------------------");
        method_get();
    }

    public static void method_get()
    {
        ArrayList al = new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");

        /*
        Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素

        while(it.hasNext())
        {
            sop(it.next());
        }
        */

        for(Iterator it = al.iterator();it.hasNext();)
        {
            sop(it.next());
        }
    }

    public static void method_2()
    {
        ArrayList al1 = new ArrayList();

        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");

        ArrayList al2 = new ArrayList();

        al2.add("java01");
        al2.add("java02");
        al2.add("java05");
        al2.add("java06");

        //al1.retainAll(al2);//取交集,al1中只会保留和al2中相同的元素
        al1.removeAll(al2);//去交集,al1中只会保留和al2中不相同的元素

        sop("al1:"+al1);
        sop("al2:"+al2);
    }

    public  static void base_method()
    {
        //创建一个集合容器。使用Collection接口的子类。ArrayList
        ArrayList al = new ArrayList();

        //1,添加元素
        al.add("java01");//add(Object obj);
        al.add("java02");
        al.add("java03");
        al.add("java04");

        //打印原集合
        sop(al);

        //2,获取个数,集合长度
        sop("size:"+al.size());

        //3,删除元素
        al.remove("java02");

        //清空集合
        //al.clear();

        //打印改变后的集合
        sop(al);

        //4,判断元素
        sop("java03是否存在"+al.contains("java03"));
        sop("集合是否为空"+al.isEmpty());
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

这里写图片描述

List集合

collection
|–List:元素是有序的,元素可以重复。因为该集合体系有索引。
|–ArrayList:底层的数据结构使用的是数组结构。线程不同步。
特点:查询速度很快,但是增删稍慢。

|–LinkedList:底层使用的是链表数据结构。
特点:增删速度很快,查询速度稍慢。

|–Vector:底层是数组数据结构。线程同步。增删查询都稍慢,被ArrayList替代了。

|–set:元素是无序的,元素不可以重复。没有索引。

list:
特有方法。凡是可以操作角标的方法都是该体系特有的方法。

增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();

List集合特有的迭代器。ListIterator是Iterator的子接口

在迭代时,不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常

所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的
只能对元素进行判断,取出,删除的操作
如果想要其他的操作如添加,修改等,就需要使用其子接口ListIterator

该接口只能通过list集合的ListIterator方法获取

import java.util.*;
class ListDemo
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static void method()
    {
        ArrayList al = new ArrayList();

        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是:"+al);
        //在指定位置添加元素
        al.add(1,"java09");

        //删除指定位置的元素
        //al.remove(2);

        //修改元素。
        //al.set(2,"java007");

        //通过角标获取元素
        sop("get(1):"+al.get(1));

        sop(al);

        //获取所有元素  遍历
        for(int x=0;x<al.size();x++)
        {
            sop("al("+x+")="+al.get(x));
        }

        //迭代器
        Iterator it = al.iterator();

        while(it.hasNext())
        {
            sop("next:"+it.next());
        }


        //通过indexOf获取对象的位置
        sop("index="+al.indexOf("java02"));

        //获取子集合
        List sub = al.subList(1,3);

        sop("sub="+sub);
    }

    public static void main(String[] args)
    {
        //演示列表迭代器
        ArrayList al = new ArrayList();

        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop(al);

        ListIterator li = al.listIterator();


        sop("hasPrevious():"+li.hasPrevious());//没有前一个元素,false

        while(li.hasNext())        //是否有后一个元素
        {
            Object obj = li.next();

            if(obj.equals("java02"))
                li.add("java009");
                //li.set("java006");
        }

        while(li.hasPrevious())     //是否有前一个元素
        {
            sop("pre:"+li.previous());
        }

        sop("hasNext():"+li.hasNext());//取了一遍又回来了,有下一个元素,true
        sop("hasPrevious():"+li.hasPrevious());//没有前一个,false


        sop(al);

        /*
        //在迭代过程中,准备添加或者删除元素
        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Object obj = it.next();

            if(obj.equals("java02"))
                //al.add("java008");
                it.remove();//将java02的引用从集合中删除,原数据还在内存中

            sop("obj="+obj);
        }
        */


    }
}

方法method打印结果:
这里写图片描述

主函数里的打印结果:
这里写图片描述

Vector(枚举)

import java.util.*;
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的,因为枚举的名称以及方法的名称都过长,
所以被迭代器取代了。
*/

class VectorDemo
{
    public static void main(String[] args)
    {
        Vector v = new Vector();

        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");

        Enumeration en = v.elements();

        while(en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }
}

这里写图片描述

LinkedList

LinkList:特有方法
addFirst();
addLast();

getFirst();
getLast();
获取元素,但不删除。如果集合中没有元素,会出现NoSuchElementException

removeFirst();
removeLast();
获取元素,并删除。如果集合中没有元素,会出现NoSuchElementException

在JDK 1.6出现了替代方法,

offerFirst();
offerLast();

peekFirst();
peekLast
获取元素,不删除。如果集合中没有元素,会返回null。

pollFirst();
pollLast();
获取元素,并删除。如果集合中没有元素,会返回null。

import java.util.*;
class LinkedListDemo
{
    public static void main(String[] args)
    {
        LinkedList link = new LinkedList();

        link.add("java01");
        link.add("java02");
        link.add("java03");
        link.add("java04");



        sop(link);

        while(!link.isEmpty())
        {
            sop(link.removeFirst());//打印出来,在干掉
        }

        sop("size="+link.size());

        sop(link);
    }


    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

这里写图片描述

练习:
使用LinkedList模拟一个堆栈或者队列数据结构

堆栈:先进后出,如同杯子
队列:先进先出,如同水管

import java.util.*;

class DuiLie
{
    private LinkedList link;

    DuiLie()
    {
        link = new LinkedList();
    }

    public void myAdd(Object obj)
    {
        link.addFirst(obj);
    }

    public Object myGet()
    {
        return link.removeLast();
    }

    public boolean isNull()
    {
        return link.isEmpty();
    }
}
class LinkedListTest
{
    public static void main(String[] args)
    {
        DuiLie dl = new DuiLie();
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");

        while(!dl.isNull())
        {
            sop(dl.myGet());
        }
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

这里写图片描述

把removeLast改成removeFirst就是堆栈,先进后出。

ArrayList

练习:去除ArrayList集合中的重复元素

import java.util.*;

class ArrayListTest
{
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java04");
        al.add("java01");
        al.add("java03");
        al.add("java02");
        al.add("java04");

        //在迭代时,循环中next调用一次就要hasNext判断一次
        sop(al);

        al = singleElements(al);

        sop(al);

    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList temp = new ArrayList();

        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();

            if(!temp.contains(obj))
                temp.add(obj);
        }

        return temp;
    }
}

这里写图片描述

将自定义对象作为元素存储到ArrayList集合中,并去除重复元素

比如:存入人,同姓名,同年龄,视为同一个人。为重复元素。

思路:
1,对人进行描述,将数据封装进人对象。
2,定义容器,将人存入
3,取出

import java.util.*;

class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;

        person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }

    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

class ArrayListTest2
{
    public static void sop(Object obj)
    {
        System.out.printn(obj);
    }

    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();

        al.add(new Person("lisi01",30));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi03",33));
        al.add(new Person("lisi04",34));
        al.add(new Person("lisi04",34));

        al = singleElement(al);

        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Person p = (Person)it.next();
            sop(p.getName()+"...."+p.getAge());
        }
    }

    public static ArrayList singleElement(ArrayList al)
    {
        //定义一个临时容器
        ArrayList temp = new ArrayList();

        Iterator it = al.iterator();

        while(it.hasNext())
        {
            Object obj = it.next();

            if(!temp.contains(obj))
                temp.add(obj);
        }

        return temp;
    }
}

这里写图片描述

HashSet

|–Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复
——|–HashSet:底层结构是哈希表
——HashSet是如何保证元素唯一性的呢?
——是通过元素的两个方法,hashcode和equals来完成
——如果元素的HashCode值相同,才会判断equals是否为true
——如果元素的hashcode值不同,不会调用equals

注意,对于判断元素是否存在,以及删除等操作,依赖的是元素的hashCode和equals方法

Set集合的功能和Collection是一致的

import java.util.*;

class HashSetDemo
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static void main(String[] args)
    {
        HashSet hs = new HashSet();

        sop(hs.add("java01"));
        sop(hs.add("java01"));
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");

        Iterator it = hs.iterator();

        while(it.hasNext())
        {
            sop(it.next());
        }
    }
}

这里写图片描述

往hashset集合中存入自定对象
姓名和年龄相同为同一个人

import java.util.*;

class HashSetTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a2",12));
        //hs.add(new Person("a4",14));

        Iterator it = hs.iterator();

        while(it.hasNext())
        {
            Person p = (Person)it.next();
            sop(p.getName()+"..."+p.getAge());
        }
    }
}
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public int hashCode()
    {
        //System.out.println(this.name+"...hasCode");
        return name.hashCode()+age;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;

        Person p = (Person)obj;
        //System.out.println(this.name+"...equals.."+p.name);

        return this.name.equals(p.name) && this.age == p.age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

这里写图片描述

判断元素是否存在(contains),删除元素(remove),都要先判断hashcode,然后再判断equals

这里写图片描述

14、Java 异常处理与集合框架入门 本文详细介绍了 Java 编程中的异常处理机制和集合框架的基础知识与应用。内容涵盖异常的分类、处理方式(try/catch、throws、throw、finally)、栈跟踪分析,以及如何创建和使用自定义异常。同时,深入讲解了 Java 集合框架的核心接口(List、Set、Map)及其常用实现类(ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap),包括集合的遍历方式、排序操作及最佳实践场景。通过学习,读者可以提升 Java 程序的健壮性和开发效率,并 阅读详情

相关推荐

14、Java集合框架:List与Map的深入解析

本文深入解析了Java集合框架中的List和Map,重点介绍了ListIterator的双向遍历功能、Map接口的基础知识及其具体实现,如HashMap和TreeMap。同时探讨了线程池优化、迭代器的光标位置概念、Map.Entry接口的使用,以及不同集合类型的适用场景。通过示例代码和对比分析,帮助开发者更好地理解和应用Java集合框架,提高程序性能和可维护性。

ggg99的专栏 99

Java课后总结14(集合框架)

集合框架Java集合框架提供了一套性能优良、使用方便的接口和类。(注:都在Java.util包中)接口:Iterator(迭代),Collection,List,Set,Map   (注:其中List与Set都是继承了Collection)实现类:(1)List接口的实现类有:ArrayList , LinkedList;             (2)Set接口的实现类有:HashSet,Tre...

hmh9527的博客 306

14、Java 集合框架:Set、Queue 和 Map 的深入解析

本文深入解析了 Java 集合框架中的 Set、Queue 和 Map 接口及其常用实现类,包括它们的特点、使用场景以及性能对比。详细介绍了 HashSet 和 TreeSet 的元素存储差异、ArrayDeque 作为队列和栈的用法、HashMap 和 TreeMap 的键值存储机制,同时还探讨了集合的并发处理及适用场景的选择策略,帮助开发者在实际编程中更好地运用 Java 集合框架。

view3的博客 104

一步一步学JAVA(14)-集合框架

集合框架:用于存储数据的容器。 特点: 1:对象封装数据,对象多了也需要存储。集合用于存储对象。 2:对象的个数确定可以使用数组,但是不确定怎么办?可以用集合。因为集合是可变长度的。集合和数组的区别: 1:数组是固定长度的;集合可变长度的。 2:数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。 3:数组存储的元素必须是同一个数据类型;集合存储的对象可以是不同数据类型。数...

abcjwg的专栏 297

SAP MRKO与MIRO的对比分析:为何寄售结算需要定制开发?

本文深入分析了SAP系统中MRKO与MIRO在寄售结算中的功能差异,揭示了标准MRKO在财务控制和业务流程上的局限性。通过定制开发实践,如BAdI增强和界面优化,企业可显著提升结算效率与准确性。文章还探讨了未来SAP S/4HANA在寄售结算中的智能化趋势,为相关企业提供技术参考。

weixin_29300241的博客 426

如何将TDengine集成到Thingsboard?

1 概述 ThingsBoard是用于数据收集、处理、可视化和设备管理的开源物联网平台。它通过行业标准的物联网协议MQTT、CoAP和HTTP实现设备连接,并支持云和本地部署。 ThingsBoard迄今没有导入专业的时序数据库应用,用户可选择的只有PostgreSQL和Cassandra。虽然针对PostgreSQL引入了TimeScale插件,但由于其不是按照宽表的方式组织数据记录,TimeScale的优势根本发挥不出来。总之,这两种数据库不具备高效的数据吞吐能力。 而且,Thingsboard在

Wearable_device的博客 4767

Java学习14:Java集合框架下

Java学习14: Java集合框架下: 链接:https://pan.baidu.com/s/1szsiVddqoyA8JEwrZi9tmQ 提取码:mjvs

SH_思寒的博客 181

当拿到金葡菌的全基因组测序数据后该怎样进行分析呢

很多做科研实验/做课题报告的科研老师们在拿到全基因组测序数据之后要进行一系列的分析,但同时也担心数据庞大分析缓慢导致进度,也有因为不会编程不知道该如何进行拼接分析的...其实需要质控拼接、MLST分析及菌种鉴定等完全可以自己在平台上进行分析,下面以金葡菌为例进行了质控拼接及菌种鉴定等分析。 网络图片(侵删) 金黄色葡萄球菌(Staphylococcus aureus,S. aureus)也称“金葡菌”,隶属于葡萄球菌 属,是革兰氏阳性菌的代表,为一种常见的食源性致病微生物。 那么在取得了金葡菌全基

GenesClouds的博客 1970

Java SE day14_集合框架4

这里写目录标题Map集合的特点:Map集合的功能概述==HashMap中嵌套HashMap==1:Hashtable和HashMap的区别? Map集合的特点: 将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。 Map集合和Collection集合的区别? Map集合存储元素是成对出现的,Map集合的键是唯一的,值是可重复的。可以把这个理解为:夫妻对 Collec...

m0_45178181的博客 228

如何利用东南大学齿轮箱数据集进行故障诊断?从数据采集到模型训练全流程解析

本文详细解析如何利用东南大学齿轮箱数据集进行故障诊断,涵盖从数据采集到模型训练的全流程。通过信号预处理、特征工程构建及多种机器学习模型对比,帮助开发者高效实现工业设备健康管理。特别适合希望将AI技术应用于工业场景的Python开发者。

m2n3b4v5c6的博客 381

Arcgis加载在线地图(内涵各种在线地图)

这三个在线地图是最常用的在线地图,其他几个类型的在线地图请自行查看。,加载出在线图层说明连接成功,点击。1、首先打开Arcgis,找到。

爱吃雪糕的小布丁的博客 1万+

Java 学习系列(14):Java 集合框架详解

List:有序集合,允许重复元素,常用实现类包括ArrayList和LinkedList。Set:不允许重复元素,常用实现类包括HashSet和TreeSet。Queue:队列,常用于存储需要按顺序处理的元素,常用实现类包括LinkedList和。Map:键值对集合,常用实现类包括HashMap和TreeMap。下一期:《Java 学习系列(15):Java 8 新特性详解》

Azperk的博客 797

Python 爬虫实战:赛事分析平台构建与比赛数据抓取

在体育赛事日益丰富的今天,对比赛数据的收集与分析对于运动员、教练团队以及体育爱好者都具有重要意义。通过构建一个赛事分析平台,我们可以系统地抓取、整理和展示各类比赛数据,为用户提供全面的赛事洞察。本文将深入讲解如何利用 Python 爬虫技术实现这一平台的构建,涵盖从目标网站分析到数据可视化展示的全过程。

u014481728的博客 3184

java基础 day14---集合框架

1.集合的概念 集合:对象的容器,实现了对对象常用的操作,类似数组的功能 和数组的区别:数组长度固定,集合长度不固定;数组可以存储基本数据类型和引用类型,集合只能存储引用类型。 2.Collection接口 特点:代表一组任意类型的对象,无序,无下标,不能重复。 方法: add(Object o) 往集合中添加元素 remove(Object o) 从集合中删除元素 遍历元素(增强for循环;还有就是迭代器Iterator 它里面有三种方法hasNext()是否有下一个元素,next()获

quansiwen5307的博客 294

OpenOCD入门到精通:第20章 Target 子系统源码分析

摘要:本章深入分析OpenOCD Target子系统的核心实现机制。重点包括:1) 通过target_type虚函数表实现多架构抽象,支持ARM、RISC-V等30+种目标;2) ARM ADIv5协议栈实现,包含DAP/AP核心数据结构和访问机制;3) 分层架构设计,从调试接口层到传输层的完整调用链路。系统采用面向对象思想,统一管理目标状态、寄存器缓存、断点/观察点等调试要素,为上层提供标准化的调试操作接口。

从事嵌入式linux android驱动开发,拥有全栈能力 181

【PyTorch深度学习项目实战100例目录】项目详解 + 数据集 + 完整源码

大家好,我是阿光。本专栏整理了《深度学习100例》,内包含了各种不同的深度学习项目,包含项目原理以及源码,每一个项目实例都附带有完整的代码+数据集。正在更新中~ ✨。

优快云 精品推荐 10万+

14-01 Java语言基础(集合框架)

对象数组 import com.xiaoxin.bean.Student; public class Demo1_Array { public static void main(String[] args) { Student[] arr = new Student[5]; //创建引用数据类型数组 arr[0] = new Student("张三", 23); arr[1] = new Student("李四", 24); arr[2] = new Student("王五"

小鑫的博客 142

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

JAVA集合框架14---LinkedHashSet源码解析

上一篇我们分析了LinkedHashMap的源码,发现其底层实现原理就是HashMap加一个双向链表来维持数据的插入顺序或者访问顺序,并且我们也谈到了,其底层的双向链表设计的十分巧妙,与hash表共用了key,value。像HashMap与HashSet的关系一样,与LinkedHashMap对应的是LinkedHashSet,它是一个集合,也可以维持插入顺序,但是不能维持访问顺序! 下面我们直...

qq_22158743的博客 242

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Java基础14-Java集合框架:掌握List、Set和Map的使用

摘要: Java集合框架(java.util包)提供了一套高效的数据结构接口与实现类,核心包括List(有序可重复,如ArrayList、LinkedList)、Set(无序唯一,如HashSet、TreeSet)和Map(键值对,如HashMap)。ArrayList基于动态数组,适合随机访问;LinkedList基于双向链表,适合频繁插入/删除。集合框架优势包括高性能、类型安全(泛型支持)和可扩展性。通过合理选择实现类(如ArrayList初始容量优化),可显著提升程序效率。代码示例演示了集合的增删改查

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

[Java2 入门经典]第14章 集合框架

前言: Vector<T> 保存的是对象的引用,所有序列的集合都实现了Iterable<>接口,可以从集合中获取迭代器对象。 Vector<String> names = new Vector<String>(); java.util.Iterator<String> iter = names.iterator(); ===...

weixin_30496431的博客 73

Java学习---day14_集合框架03

Java学习—day14_集合框架03 Set集合 Set集合中,没有下标的概念 Set集合,是一个去重复的集合。在Set集合中不会添加重复的元素的 在向一个Set集合中添加元素的时候,会先判断这个元素是否已经存在,如果存在,则不再添加 Set集合中,数据的存储时无序的 无序:所谓的无序,其实指的是元素的添加顺序和存储顺序是不一致的。 无序,并不意味着随机 Set接口,是继承自Collection接口的,Set接口中的方法,都是从Collection接口中继承下来的,并没有添加新的方法。 H

qq_43599294的博客 281

【Java学习笔记】14.集合框架和泛型

1.Java中的集合框架体系 1.集合框架体系图如图所示: 2.Conllection接口: Collection 是最基本的集合接口,一个 Collection 代表一组 Object,Java不提供直接继承自Collection的类,只提供继承于的子接口(如List和set)。3.List接口: List接口是一个有序的Collection,使用此接口能够精确的控制每个元素插入的位置,能

Plain_sky的博客 399

【JAVA语言-第14话】集合框架(一)——Collection集合,迭代器,增强for,泛型

什么是集合框架?集合和数组的区别是什么?集合如何通过迭代器或者增强for进行遍历?什么是泛型?泛型的利弊有哪些?以上问题本文皆可解答。

Zenghaiyue_1999的博客 1474

java基础14(Javaoo9)——集合框架

java基础14(Javaoo9)——Java集合框架(Java Collection Framework) (简称JCF) 1.什么是框架? ——为了解决某一问题而预先设计的具有继承关系的类与接口,在使用过程中,只需从中选择相应的就可以实现功能. 集合框架包括三大内容:对外接口、接口的实现、对集合运算的方法 2.集合分类:List(列表)、Set(集)、Map(映射

WB1224678的博客 504

黑马程序员-Java语言基础– 集合框架 第14天

---------------------- android培训、java培训、期待与您交流! ---------------------- 集合框架 集合类(java.util.Collection) 为什么出现集合类?       面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。   数组和

Qiangoo 1462

14天Java基础学习——第10天:集合框架(基础)

Java集合框架是一组用于存储和处理对象集合的接口和类。它提供了一种统一的架构来存储和操作数据集合。集合框架的主要优点是它提供了一种统一的接口来处理不同的数据集合,使得数据集合的操作更加简单和方便。通过本章节的学习,我们了解了Java集合框架的基本概念和主要接口,包括CollectionListSet等。我们学习了ArrayList和LinkedList两种List集合的实现,以及HashSet和TreeSet两种Set集合的实现。我们还探讨了迭代器和增强for循环的使用,这两种方法都是遍历集合的常用方式。

weixin_38492276的博客 438
上一篇: java String功能--13
下一篇: java 集合框架 泛型--15
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值