精华内容
下载资源
问答
  • 概念:对象的容器为集合,不能直接存放8种基本数据类型,jdk1.5以上提供了自动装箱机制,集合可以直接将基本类型的值存放入容器中,但是容器会自动的将基本数据类型装箱为该基本数据类型对应的包装类型的对象。...

    集合框架

    概念:对象的容器为集合,不能直接存放8种基本数据类型,jdk1.5以上提供了自动装箱机制,集合可以直接将基本类型的值存放入容器中,但是容器会自动的将基本数据类型装箱为该基本数据类型对应的包装类型的对象。

    比较 List Set Map
    继承接口 Collection Collection
    常见实现类 AbstractList(常见继承子类有:ArrayList、LinkedList、Vector) AbstractSet(常见继承子类有:HashSet、LinkedHashset、TreeSet) HashMap、TreeMap、HashTable
    常见方法 add()、remove()、clear()、get()、contains()、size() add()、remove()、clear()、get()、contains()、size() put()、get()、 remove()、clear()、containsKey()、containsValue()、keySet()、values()、size()
    元素 可重复 不可重复(用equals()判断) key不可重复
    顺序 有序 无序(实际顺序由hashCode决定)
    线程安全 Vector线程安全 Hashtble线程安全

    常用方法

    java.util.Collection<E>
    java.util.Collection.size()
    java.util.Collection.isEmpty()
    java.util.Collection.contains(Object)
    java.util.Collection.iterator()
    java.util.Collection.toArray()
    java.util.Collection.toArray(T[])
    java.util.Collection.add(E)
    java.util.Collection.remove(Object)
    java.util.Collection.containsAll(Collection<?>)
    java.util.Collection.addAll(Collection<? extends E>)
    java.util.Collection.removeAll(Collection<?>)
    java.util.Collection.removeIf(Predicate<? super E>)
    java.util.Collection.retainAll(Collection<?>)
    java.util.Collection.clear()
    java.util.Collection.equals(Object)
    java.util.Collection.hashCode()
    java.util.Collection.spliterator()
    java.util.Collection.stream()
    java.util.Collection.parallelStream()
    

    一、List

    1、ArrayList

    ArrayList父类是AbstractList,底层数据结构是数组,因此增加删除元素速度慢,查找元素速度快。

    2、LinkedList

    LinkedList的父类是AbstractSequentialList,底层数据结构是双向链表,因此增加、删除元素速度快,查找元素速度慢。

    3、Vector

    数据结构是数组,查询快、增删慢、线程安全、效率较低。

    二、Set

    1、HashSet

    Hashset底层是由HashMap实现的。

    Haset的值存放在HashMap的key上,HashMap的value都为常量PRESENT

    2、TreeSet

    基于排列顺序实现元素的不重复

    实现了SortedSet接口,对于集合中的元素进行自动排序。

    元素的对象类型可以通过implements(实现)Comparable接口,然后重写ComparTo方法指定排序规则。

    三、Map

    1、HashMap

    V put(K key,V value):

    /**put方法的返回值:如果是key是第一次put那么返回值就是null,map中如果已经有了*相同的key,那么返回值就是上一个key对应的value,并且当前value会替换上一个*value。
    *注意*:返回为null的情况有两种,(1)第一次插入当前key(2)已经有当前key存在,但上一个key对应的value为null。**/
    
    	HashMap<String,String> hm=new HashMap<>();
    
    	hm.put("jack","杰克");//put返回null
    	hm.put("jack","杰克2");//put返回杰克,hm中存入jack="杰克"
    
    	hm.put(null,"杰克");//put返回null
    	hm.put(null,null);//put返回"杰克",hm中存入null=null
    

    Set<K> keySet():map对象的的keySet()得到该Map的键集。

    Collection values():得到该map的值集。

    Set<Map.Entry<K,V>> entrySet:返回此映射所包含的映射关系的Set视图。

    int Size():返回此映射中的键值映射关系数。

    V remove(Object key):如果存在key,则移除当前集合中的键值对映射关系。

    2、TreeMap

    Comparator<? super K> comparator():返回此映射中的键进行排序的比较器;如果此映射使用键的自然顺序,则返回null。

    boolean containsKey(Object key):如果此映射包含指定键的映射关系,则返回true。

    Map.Entry<K,V> higherEntry(K key):返回一个键-值映射关系,它与严格大于给定键的最小键关联;如果不存在这样的键,则返回null。

    K higherKey(K key):返回严格大于给定键的最小键;如果不存在这样的键,则返回null。

    Map.Entry<K,V> lastEntry():返回此映射中最大键关联的键值映射关系;如果映射为空,则返回null。

    K lastKey():返回映射中当前最后一个(最高)键。

    3、Hashtable

    4、HashMap和Hashtable的区别

    1、相同点:

    ​ 都实现了Map、Cloneable接口

    ​ 底层数据结构都是数组+链表。

    ​ 插入元素都不能保证有序。

    ​ Hash过程都是通过key进行哈希。

    ​ key都不能重复。

    2、不同点:

    ​ null问题:HashMap的key和value可以为null,Hashtable不可以。

    ​ 初始容量:HashMap的初始容量为16,Hashtable为11。

    ​ 扩容机制:HashMap的扩容机制是length2,Hashtable是lenght2+1

    ​ hash值:HashMap的hash值要重新计算,Hashtable是直接使用对象的hash值。

    ​ 线程安全:HashMap是非线程安全的,Hashtable是线程安全的。

    5、如何决定是使用HashMap还是TreeMap

    ​ 对于在 Map 中插入、删除和定位元素这类操作,HashMap 是最好的选择。 然而,假如你需要对一个有序的 key 集合进行遍历,TreeMap 是更好的选择。 基于你的 collection 的大小,也许向 HashMap 中添加元素会更快,将 map 换为 TreeMap 进行有序 key 的遍历。

    6、HashMap底层实现原理

    ​ HashMap 是基于哈希表的 Map 接口的非同步实现。此实现提供所有可选的 映射操作,并允许使用 null 值和 null 键。此类不保证映射的顺序,特别是它 不保证该顺序恒久不变。
    HashMap 的数据结构: 在 java 编程语言中,最基本的结构就是两种,一 个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基 本结构来构造的,HashMap 也不例外。HashMap 实际上是一个“链表散列”的数 据结构,即数组和链表的结合体。

    7、HashSet底层实现原理

    ​ HashSet底层是由HashMap实现

    ​ HashSet的值存放在HashMap的key上,HashMap的value统一为PRESENT。

    8、Collection和Collections的区别?

    ​ java.util.Collection是一个集合接口(集合类的顶层接口),它提供了对集合对象进行基本操作的通用接口方法。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有List和Set。

    ​ Collections则是集合类的一个工具类,它提供了一系列的静态方法,用于对集合中的元素进行遍历、排序、线程安全话等操作。

    展开全文
  • 插花时依照图要求,使花枝按照一定姿态和位置固定在容器中,就叫花材固定。那么,花材固定哪些要领?花材固定方法是什么?下面中国鲜花网为您介绍花材固定要领和方法。花材固定哪些要领?花束加包装纸和...

    插花时依照图的要求,使花枝按照一定的姿态和位置固定在容器中,就叫花材固定。那么,花材固定有哪些要领?花材固定的方法是什么?下面中国鲜花网为您介绍花材固定的要领和方法。

    花材固定有哪些要领?

    花束加包装纸和彩带十分重要,如同好花必有绿叶扶一样。国外对此制作考究,多为印花透明包装纸或罩以透明塑料袋。

    花材固定的方法是什么?

    花束花材固定有两种方法:一种是用细铁丝绑扎,每枝花、每片衬叶,都用缠上绿胶带的细铁丝缠好后再造型。另一种是用专用花托,内有花泥,将花依造型插入花托内,这种方法比较简单易行。

    花束在社交、庆典活动中应用广泛,通常分为礼仪花束和新娘花束两种类型。

    一、礼仪花束:礼仪花束主要用于迎来送往和庆贺活动。主要造型有三角形、扇面形、圆锥形、半球形及自由式图形。花材应选择品质优良、无污染、无刺激性,并且花期持久的鲜花。鲜花色彩以鲜艳明快为宜。插作时无论什么造型,都要保持花束上部花枝自然,下部握把部分要圆整紧密。因此,插作时务必使每个花枝都按“以右压左”的方式重叠,各枝相交在一点上,呈自右向左转螺旋状的轴,然后用绳绑扎交点处。这样,不易使花束造型走样。

    二、新娘花束:新娘花束也称新娘捧花,是专为新娘在婚礼时与婚纱礼服相配的一种花束。新娘花束主要造型有圆形、倒L形,倒垂形及各种自由式图形。目前国内仅有圆形和倒垂形两种。花材选用要求精致,常用月季、百合、马蹄莲、香石竹等花材。色彩搭配以协调、典雅单一色或类似色为多。

    网上订鲜花、网上送鲜花,中国鲜花网是中国首选品牌网上鲜花店。中国鲜花网网上鲜花店,网上预订鲜花礼品蛋糕最好的选择。

    展开全文
  • 但是Go内置语言包container里只提供了list、heap、ring三种容器,缺少vector容器,在实际项目中为使用方便必要包装一个vector,提供vector的常见功能。 C++、Java、C#等语言支持泛型,Go语言不支持泛型,可以用...

    Go语言中的切片(slice)和一些内置函数能实现其他语言容器类Array、Vector的功能,但是Go内置语言包container里只提供了list、heap、ring三种容器,缺少vector容器,在实际的项目中为使用方便有必要包装一个vector,提供vector的常见功能。

    C++、Java、C#等语言支持泛型,Go语言不支持泛型,可以用 interface{} 提供类似泛型的支持。下面是vector容器代码

    package vector
    
    import (
        "reflect"
    )
    
    // 小写 只能通过工厂函数创建
    type vector struct {
        values []interface{}
    }
    
    // 创建工厂函数
    func New(cap int) *vector {
        this := new(vector)
        this.values = make([]interface{}, 0, cap)
    
        return this
    }
    
    func (this *vector) IsEmpty() bool {
        return len(this.values) == 0
    }
    
    // 元素数量
    func (this *vector) Size() int {
        return len(this.values)
    }
    
    // 追加单个元素
    func (this *vector) Append(value interface{}) bool {
        this.values = append(this.values, value)
        return true
    }
    
    // 追加元素切片
    func (this *vector) AppendAll(values []interface{}) bool {
        if values == nil || len(values) < 1 {
            return false
        }
        this.values = append(this.values, values...)
        return true
    }
    
    // 插入单个元素
    func (this *vector) Insert(index int, value interface{}) bool {
        if index < 0 || index >= len(this.values) {
            return false
        }
        this.values = append(this.values[:index], append([]interface{}{value}, this.values[index:]...)...)
        return true
    }
    
    // 插入元素切片
    func (this *vector) InsertAll(index int, values []interface{}) bool {
        if index < 0 || index >= len(this.values) || values == nil || len(values) < 1 {
            return false
        }
        this.values = append(this.values[:index], append(values, this.values[index:]...)...)
        return true
    }
    
    // 移除
    func (this *vector) Remove(index int) bool {
        if index < 0 || index >= len(this.values) {
            return false
        }
        // 重置为 nil 防止内存泄漏
        this.values[index] = nil
        this.values = append(this.values[:index], this.values[index+1:]...)
        return true
    }
    
    // 范围移除 从 fromIndex(包含) 到 toIndex(不包含) 之间的元素
    func (this *vector) RemoveRange(fromIndex, toIndex int) bool {
        if fromIndex < 0 || fromIndex >= len(this.values) || toIndex > len(this.values) || fromIndex > toIndex {
            return false
        }
        // 重置为 nil 防止内存泄漏
        for i := fromIndex; i < toIndex; i++ {
            this.values[i] = nil
        }
        this.values = append(this.values[:fromIndex], this.values[toIndex:]...)
        return true
    }
    
    // 全部移除
    func (this *vector) RemoveAll() {
        // 重置为 nil 防止内存泄漏
        for i := 0; i < this.Size(); i++ {
            this.values[i] = nil
        }
        this.values = this.values[0:0]
    }
    
    func (this *vector) getIndex(value interface{}) int {
        for i := 0; i < len(this.values); i++ {
            if reflect.DeepEqual(this.values[i], value) {
                return i
            }
        }
        return -1
    }
    
    // 是否存在该元素值
    func (this *vector) Contains(value interface{}) bool {
        return this.getIndex(value) >= 0
    }
    
    // 获取元素值第一次出现的索引
    func (this *vector) IndexOf(value interface{}) int {
        return this.getIndex(value)
    }
    
    // 获取元素值最后一次出现的索引
    func (this *vector) LastIndexOf(value interface{}) int {
        for i := len(this.values) - 1; i >= 0; i-- {
            if reflect.DeepEqual(this.values[i], value) {
                return i
            }
        }
        return -1
    }
    
    // 得到索引对应的元素值
    func (this *vector) GetValue(index int) interface{} {
        if index < 0 || index >= len(this.values) {
            return nil
        }
        return this.values[index]
    }
    
    // 设置值
    func (this *vector) SetValue(index int, value interface{}) bool {
        if index < 0 || index >= len(this.values) {
            return false
        }
        this.values[index] = value
        return true
    }
    
    func (this *vector) ToArray() []interface{} {
        dst := make([]interface{}, this.Size())
        copy(dst, this.values)
        return dst
    }
    

     

    vector内部使用切片(slice)保存元素值,元素类型 interface{},泛型。getIndex()方法使用reflect.DeepEqual()函数对元素值作深度比较。上述代码只提供了vector容器常见功能,更多的功能可以根据需要添加,比如有的时候需要对容器中的元素排序,则可以添加排序方法。

    一些方法简单返回bool值表示成功或失败,可以根据需要增加一个error返回值指明失败的详细原因。

    需要注意的事项是Remove、RemoveRange、RemoveAll方法内把元素移走时避免内存泄露。

     

    下面是测试代码

    func testVector() {
        v := vector.New(5)
        for i := 0; i < 6; i++ {
            v.Append(i)
        }
        fmt.Println(*v)
        fmt.Println(v.IsEmpty())
        v.Insert(1, 10)
        v.Insert(20, 20)
        fmt.Println(*v)
        v.Remove(-1)
        v.Remove(1)
        v.Remove(100)
        fmt.Println(*v)
        fmt.Println(v.IndexOf(3))
        fmt.Println(v.IndexOf(300))
        fmt.Println(v.GetValue(1))
        fmt.Println(v.GetValue(100))
        v.SetValue(-1, -1)
        v.SetValue(1, 11)
        v.SetValue(100, 101)
        fmt.Println(*v)
    
        v.RemoveAll()
        fmt.Println(v.IsEmpty())
        fmt.Println(v.Size())
    
        v.Append(22)
        fmt.Println(*v)
    }
    

     

    测试代码覆盖了部分可能的情况,创建函数New的cap参数指明容器的初始容量。

    上述测试代码只写了int类型的元素,其他string、float、array、map、struct、slice、vector等类型类似。

    转载于:https://www.cnblogs.com/aiandbigdata/p/10913336.html

    展开全文
  • Spring基础:IoC容器(2)

    2016-11-12 10:00:01
    常见的注入类型是字面值注入,像String和基本类型的包装类在Spring中都是[color=red]属性编辑器[/color]帮助注入的。另外还有对象的注入,集合类的注入。 1.字面值 所谓字面值,一般是指可用字符串表示的值...
    [size=x-large][b]容器注入类型[/b][/size]

    最常见的注入类型是字面值注入,像String和基本类型的包装类在Spring中都是有[color=red]属性编辑器[/color]帮助注入的。另外还有对象的注入,集合类的注入。

    1.字面值
    所谓字面值,一般是指可用字符串表示的值,这些值可以通过<value>元素标签进行注入。在默认情况下,基本数据类型及其封装类,String等类型都可以采取字面值注入的方式。

    <bean id="car" class="com.firethewhole.maventest06.attr.Car">
    <property name="maxSpeed">
    <value>200</value>
    </property>
    <property name="brand">
    <value><![CDATA[红旗&CA72]]></value>
    </property>
    <property name="price">
    <value>2000.00</value>
    </property>
    </bean>


    [color=red]****在XML中表示"<",">","&","""(双引号),"'"(单引号)这些的时候,要么使用<![CDATA[]]>包起来,要么使用转义序列。[/color]
    [table]
    |特殊符号|转义序列
    |<|<
    |>|>
    |&|&
    |"|"
    |'|&apos;
    [/table]

    2.引用其他Bean

    <bean id="boss" class="com.firethewhole.maventest06.attr.Boss">
    <property name="car">
    <ref bean="car"/>
    </property>
    </bean>

    <ref>元素可以通过以下三个属性引用容器中其他Bean。
    [list]
    [*]bean:引用同一容器或父容器的Bean。
    [*]local:只能引用同一配置文件中的Bean。
    [*]parent:引用父容器中的Bean。
    [/list]

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans spring-beans-4.1.xsd">
    <bean id="car" class="com.firethewhole.maventest06.attr.Car">
    <property name="brand" value="吉利CT5" />
    <property name="maxSpeed" value="100" />
    <property name="price" value="1000.00" />
    </bean>

    <bean id="boss2" class="com.firethewhole.maventest06.attr.Boss">
    <property name="car">
    <ref parent="car"/>
    </property>
    </bean>
    </beans>


    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans1.xml");
    ApplicationContext child = new ClassPathXmlApplicationContext(new String[] { "beans2.xml" }, ctx);
    Boss boss2 = (Boss) child.getBean("boss2");
    boss2.introduce();


    3.引用内部Bean

    <bean id="boss3" class="com.firethewhole.maventest06.attr.Boss">
    <property name="car">
    <bean class="com.firethewhole.maventest06.attr.Car">
    <property name="maxSpeed" value="300"/>
    <property name="brand" value="雷克萨斯"/>
    <property name="price" value="90000.00"/>
    </bean>
    </property>
    </bean>


    4.引用null值
    如果确实要引入null值的话,需要使用标签<null/>

    5.集合类型
    主要有List,Set,Map,Props

    <bean id="boss4" class="com.firethewhole.maventest06.attr.AnotherBoss">
    <property name="favorites">
    <list>
    <value>看报</value>
    <value>赛车</value>
    <value>高尔夫</value>
    </list>
    </property>
    <property name="jobs">
    <map>
    <entry>
    <key><value>AM</value></key>
    <value>会见客户</value>
    </entry>
    <entry>
    <key><value>PM</value></key>
    <value>公司内部会议</value>
    </entry>
    </map>
    </property>
    <property name="mails">
    <props>
    <prop key="jobMail">john-office@baobaotao.com</prop>
    <prop key="lifeMail">john-life@baobaotao.com</prop>
    </props>
    </property>
    <property name="jobTimes">
    <map>
    <entry>
    <key><value>会见客户</value></key>
    <value>124</value>
    </entry>
    </map>
    </property>
    </bean>

    [color=red]****如果属性为Set类型,可以在配置文件中yong<set>替换掉<list>,泛型的集合类会判断注入类型,自动进行类型转换。[/color]

    6.集合合并
    这一块暂时跳过不写。

    7.注入集合类型的Bean
    如果希望注入集合类型的Bean,而不是集合类型的属性,则需要通过util命名空间进行配置。比如声明了集合类型的Bean之后,可以在属性中直接引用,不用采用上面的内部Bean的配置方式了。
    引入命名空间xmlns:util="http://www.springframework.org/schema/util"

    <util:list id="favoritieList" list-class="java.util.LinkedList">
    <value>看报</value>个
    <value>赛车</value>
    <value>高尔夫</value>
    </util:list>
    <util:set id="favoriteSet">
    <value>看报</value>
    <value>赛车</value>
    <value>高尔夫</value>
    </util:set>
    <util:map id="emailMap">
    <entry key="AM" value="会见客户"/>
    <entry key="PM" value="公司内部会议"/>
    </util:map>

    此外<util:list><util:set>还支持value-type,用于指定集合中元素的类型。<util:map>还支持key-type和value-type,指定Map中键和值的类型。
    展开全文
  • 丨本文由小陈茶事原创丨首发于头条号:小陈茶事丨作者:村姑陈《1》新到手的白茶,该怎么存?这是今年,第N位茶友提到的疑惑。...多数人买到白茶后,见到的外包装,都是最常见的一类——纸箱。外层是牛皮纸色,讲究...
  •  异常表示程序运行过程中可能出现非正常状态,运行时异常表示虚拟机通常操作中可能遇到异常,是一种常见运行错误。java编译器要求方法必须声明抛出可能发生非运行时异常,但是并不要求必须声明抛出未被捕获...
  • 最近看了极客时间《Java业务开发常见错误100例》,再结合平时踩一些代码坑,写写总结,希望对大家帮助,感谢阅读~ 六类典型空指针问题 包装类型空指针问题 级联调用空指针问题 Equals方法左边空指针...
  • 一般常见的样机logo样机、UI页面样机、折页样机、汽车样机、名片样机、海报样机、画册样机、服饰样机、电子设备样机、杯子样机、包装样机、VI样机等种类的样机素材,下面是一些使用样机制作的效果图:一、如何使用...
  • 在看这部分内容的时候,...4,常见的容器有什么(编程) 变量、数组、集合、类、EJB、docker、Tomcat...... 5,怎么创建容器 一个容器的基本属性是什么?容器的基本功能是什么?想要创建一个什么样的容器?别人都是...
  • 映射表Map Map也叫映射表或者字典,Map中存储的元素是一个键值对key-value,他们共同包装在Entry<...常见的Map实现 HashMap通过散列技术实现。Map中的key对象必须定义equals以及hashCode方法。该容器的访问效...
  • 其中第1~6章介绍Java的常见数据类型及开发,包括基本变量类型、数组类型、包装变量类型、字符串类型以及日期时间类型;第7~11章介绍面向对象开发过程,包括面向对象三要素(封装、继承、多态)、面向对象...
  • 对象池设计与实现常见有两种思路,一是利用现成第三方对象池二次包装,站在巨人肩膀晒太阳,二是池子底层的容器也自己造,造伦子一时爽,一直造一直爽。而这两者刚好典型代表可参照Jedis与durid 连接池设计...
  • 【Java】几道常见的秋招面试题 金三银四,二月就要准备! :jack_o_lantern:大数据 「只需7分钟!我将抢走你的赞」大数据入门 什么是HDFS?算了,告诉你也不懂。 三歪学了几天Storm,上线了一版,全都是Bug 卧槽!...
  • 6.6.2 跨主机容器网络通信的常见实现方式 161 6.7 小结 163 第7章 高级实践 164 7.1 使用mydocker 创建一个可访问nginx 容器 164 7.1.1 获取nginx tar 包 164 7.1.2 构建自己nginx 镜像 165 7.1.3 运行...
  • Tomcat是一个免费开源Serlvet容器,在Tomcat中,应用程序部署很简单,你只需将你WAR放到Tomcatwebapp目录下,Tomcat会自动检测到这个文件,并将其解压。你在浏览器中访问这个应用Jsp时,通常第一次会很...
  • 一般常见的样机logo样机、UI页面样机、折页样机、汽车样机、名片样机、海报样机、画册样机、服饰样机、电子设备样机、杯子样机、包装样机、VI样机等种类的样机素材,下面是一些使用样机制作的效果图: 哪里有效的...
  • <div><h2>Vue.js应用四种AJAX请求数据模式 翻译原文出处:...请参阅作者文章“避免此全面堆栈Vue / Laravel应用程序中的常见反模式”。</p><p>该提问来源于开源项目:itemsets/vue2</p></div>
  • 服务网关,对外暴露统一规范接口和包装响应结果,包括各个子系统交互接口、对外开放接口、开发加密接口、接口文档等服务,可在该模块支持验签、鉴权、路由、限流、监控、容错、日志等功能。示例图: zheng-cms...
  • java 面试题 总结

    2009-09-16 08:45:34
    异常表示程序运行过程中可能出现非正常状态,运行时异常表示虚拟机通常操作中可能遇到异常,是一种常见运行错误。java编译器要求方法必须声明抛出可能发生非运行时异常,但是并不要求必须声明抛出未被捕获...
  • JAVA基础课程讲义

    2017-08-30 23:39:14
    目 录 第一章 JAVA入门 10 计算机语言发展史 10 机器语言 10 汇编语言 10 高级语言 10 其他高级语言 11 ...事件监听器常见的定义形式 233 AWT其他组件 233 菜单的实现 233 特点 233 代码示例和效果 233
  • Boost.Program_options:通过常见的方法,例如命令行和配置文件,来获取程序选择项的库。 Clara:用于C++11及更高版本的易于使用、可组合的命令行解析器。 cli:用于交互式命令行界面的跨平台的C++14库,只有...
  • 其他客户是不常见的客户,用信用卡或借记卡支付。卡片信息可以存储在线客户,但不存储在商店客户。 在线销售必须发送给发货人。该公司需要为航运公司存储跟踪号码,以便它能回答客户的询问。 库存必须在商店和仓库...
  • 7.4 常见的已检查型异常 214 实例166 类未发现异常 214 实例167 非法访问异常 215 实例168 文件未发现异常 216 实例169 数据库操作异常 217 7.5 处理异常 218 实例170 方法中抛出异常 218 实例171 方法上抛出异常 ...
  • 7.4 常见的已检查型异常 214 实例166 类未发现异常 214 实例167 非法访问异常 215 实例168 文件未发现异常 216 实例169 数据库操作异常 217 7.5 处理异常 218 实例170 方法中抛出异常 218 实例171 方法上抛出异常 ...
  • 7.3 常见的未检查型异常 实例162 算数异常 实例163 数组存值异常 实例164 数组下标越界异常 实例165 空指针异常 7.4 常见的已检查型异常 实例166 类未发现异常 实例167 非法访问异常 实例168 文件未发现...
  • 7.3 常见的未检查型异常 实例162 算数异常 实例163 数组存值异常 实例164 数组下标越界异常 实例165 空指针异常 7.4 常见的已检查型异常 实例166 类未发现异常 实例167 非法访问异常 实例168 文件未发现...
  • CruiseYoung提供详细书签电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 Visual C++ 2010入门经典(第5版) 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2010 原出版社: ...
  • CruiseYoung提供详细书签电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Visual C++ 2010入门经典(第5版)》源代码及课后练习答案 对应书籍资料见: Visual C++ 2010...

空空如也

空空如也

1 2
收藏数 40
精华内容 16
关键字:

常见的包装容器有