精华内容
下载资源
问答
  • 今天就来为大家介绍java中的一个概念,也就是java容器类,它包含了哪些内容,以及分别是什么意思?首先,总体来说一下,java容器类包含List、ArrayList、Vector及map、HashTable、HashMap。其中,ArrayList和HashMap...

    随着时代的不断进步与发展,java的学习显得越来越重要。今天就来为大家介绍java中的一个概念,也就是java容器类,它包含了哪些内容,以及分别是什么意思?

    首先,总体来说一下,java容器类包含List、ArrayList、Vector及map、HashTable、HashMap。

    其中,ArrayList和HashMap是异步的,Vector和HashTable是同步的,所以Vector和HashTable是线程安全的,而

    ArrayList和HashMap并不是线程安全的。因为同步需要花费机器时间,所以Vector和HashTable的执行效率要低于

    ArrayList和HashMap。

    接下来再分别简述下:

    1.List是有序的Collection,使用这个接口可以精确的控制每个元素插入的位置。用户能够使用索引来访问List中的元素,这类似于java的数组。除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,

    还能向前或向后遍历。实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

    2.ArrayList类

    ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。容量可以随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

    和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

    3.Vector类

    Vector与ArrayList极其相似,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态,这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获这个异常。

    4.Map接口

    Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个

    value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。

    6.HashMap类

    HashMap和Hashtable类似,区别在于HashMap是非同步的,并且允许null,即null value和null

    key。但是将HashMap视为Collection时,其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能非常重要的话,不能将HashMap的初始化容量设得过高,或者load factor过低。

    5.Hashtable类

    Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。

    添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。

    Hashtable通过initial capacity和load factor两个参数调整性能。Hashtable是同步的。

    6.HashMap类

    HashMap和Hashtable类似,区别在于HashMap是非同步的,并且允许null,即null value和null

    key。但是将HashMap视为Collection时,其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能非常重要的话,不能将HashMap的初始化容量设得过高,或者load factor过低。

    以上就是有关java中容器类包含哪些以及分别是什么意思的大致内容。想要了解更多java常见问题,敬请关注奇Q工具网。

    推荐阅读:

    展开全文
  • JAVA容器对象整理

    2021-02-12 21:38:22
    所以通过get()方法拿出来的对象还需要转型到你想要的类型,比如你定义储存Apple类对象的ArrayList容器appleList,你不但可以add Apple类型的对象,也可以add() Orange 类型的对象,因为无论是Apple类还是Orange类在...

    3c96f7fc2ce07e32e8723fb1d0f304a2.png

    1. 容器

    1.1 泛型和类型安全

    由于ArrayList等容器保存的是object类型.所以通过get()方法拿出来的对象还需要转型到你想要的类型,比如你定义储存Apple类对象的ArrayList容器appleList,你不但可以add Apple类型的对象,也可以add() Orange 类型的对象,因为无论是Apple类还是Orange类在放进容器里的时候已经向上转型为Object类型了.所以当程序运行时通过get方法,把本来是Orange类型强转型为Apple类型的时候就会抛出异常.

    j2se5 引进泛型的机制,通过给容器指定类型,比如上述例子,ArrayList appleList.这样编译器就会知道这个容器是专门储存Apple类,当add()方法储存Orange类时就会报错.

    1.2 基本概念

    1.2.1 Collection

    独立元素

    1.2.2 Map

    键值对

    1.3 添加一组元素

    Collection collection = new ArrayList(Array.asList(1,2,3,4,5));

    Integer[] moreInrs = {6,7,8,9,10};

    collection.addAll(Arrays.asList(moreInts));

    Collections.addAll(collection,11,12,13,14,15);

    Collections.addAll(collection,moreInts);

    1.3.1 Arrays.asList()

    接受一个数组或是一个用逗号分隔的元素列表(使用可变参数)

    并将其转换为一个List对象

    1.3.2 Collections.addAll()

    接受一个Collections对象,以及一个数组或是一个用逗号分割的列表.

    如:

    1.3.3 Collection.addAll()

    只能接受另外一个Collection元素作为参数,所以不如Array.asList()和Collections.addAll()灵活.

    1.4 容器的打印

    import java.util.*;

    public class PrintingContainers {

    static Collection fill(Collection collection){

    collection.add("rat");

    collection.add("cat");

    collection.add("dog");

    collection.add("dog");

    return collection;

    }

    static Map fill(Map map){

    map.put("rat","Fuzzy");

    map.put("cat","Rags");

    map.put("dog","Bosco");

    map.put("dog","spot");

    return map;

    }

    static void print(String collName,Collection collection){

    System.out.println(collName+":"+collection);

    }

    static void print(String mapName,Map map){

    System.out.println(mapName+":"+map);

    }

    public static void main(String[] args){

    //List示例

    print("ArrayList",fill(new ArrayList()));

    print("LinkedList",fill(new LinkedList()));

    //Set示例

    print("HashSet",fill(new HashSet()));

    print("TreeSet",fill(new TreeSet()));

    print("LinkedHashSet",fill(new LinkedHashSet()));

    //Map示例

    print("HashMap",fill(new HashMap()));

    print("TreeMap",fill(new TreeMap()));

    print("LinkedHashMap",fill(new LinkedHashMap()));

    }

    }

    /* Output:

    ArrayList:[rat, cat, dog, dog]

    LinkedList:[rat, cat, dog, dog]

    HashSet:[cat, dog, rat]

    TreeSet:[cat, dog, rat]

    LinkedHashSet:[rat, cat, dog]

    HashMap:{cat=Rags, dog=spot, rat=Fuzzy}

    TreeMap:{cat=Rags, dog=spot, rat=Fuzzy}

    LinkedHashMap:{rat=Fuzzy, cat=Rags, dog=spot}

    */

    ArrayList和LinkedList从打印中看出,他们都属于顺序插入,区别在于性能上不同

    HashSet,TreeSet,LinkedListSet都属于Set类型,每个相同的项只保存一次,从打印序列看出不同的set实现存储元素的方式不同

    HashSet使用比较复杂的方法存储对象

    TreeSet按照比较结果的升序存储对象

    LinkedListSet按照被添加的顺序存储对象

    本例使用3种风格的map,HashMap,TreeMap,LinkedHashMap

    HashMap提供了最快的查找速度,但并没有按照顺序保存

    TreeMap通过比较结果的升序保存键

    LinkedHashMap通过添加顺序保存键,并同时保持了HashMap的速度

    1.5 List

    1.5.1 ArrayList

    长于随机访问元素,但是在List中间插入和移除元素时较慢

    (如果你开始在ArrayList中插入大量元素,并且你的元素开始变慢,这时你应该看看你的List实现可能会是罪魁闯祸手)

    ps:发现此类瓶颈的最佳方式是仿真器,推介补充材料 http://MindView.net/Books/BetterJava

    1.5.2 LinkedList

    代价较低的插入和删除操作,优化了顺序访问,但是在随机访问方面比较慢,但是特性集比ArrayList大

    1.5.2.1 Stack(以LinkedList实现)

    堆栈 后进后出

    示例:

    import java.util.*;

    /*

    * 类名之后的告诉编译器这将是一个参数化类型,是通用范型的应用,在运行时指定.

    */

    public class Stack {

    private LinkedList storage = new LinkedList();

    public void push(T v){ storage.addFirst(v);}

    public T peek(){ return storage.getFirst();}

    public T pop() {return storage.removeFirst();}

    public boolean empty(){return storage.isEmpty();}

    public String toString(){return storage.toString();}

    }

    public class StackTest {

    /**

    * 在实际应用中看出,Stack指定给泛型T为String类型,同 理也可以指定为其它类型

    */

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Stack stack = new Stack();

    for(String s:"My dog has fleas".split(" "))

    stack.push(s);

    while(!stack.empty())

    System.out.print(stack.pop()+" ");

    }

    }

    1.5.2.1.1 push()

    放入元素到栈中

    1.5.2.1.2 peek()

    只返回最顶层元素

    1.5.2.1.3 pop()

    返回最顶层元素并移除最顶层元素

    1.5.2.2 Queue(以LinkedList实现)

    先进先出

    ps:这个规则应该是应用在等待时间最长的元素优先处理的例子

    import java.util.LinkedList;

    import java.util.Queue;

    import java.util.Random;

    public class QueueDemo {

    /**

    * 这里用java.util库中已经实现好的queue做例子

    */

    public static void printQ(Queue queue){

    while(queue.peek()!=null)

    System.out.print(queue.remove()+" ");

    System.out.println();

    }

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Queue queue = new LinkedList();

    Random rand = new Random(47);

    for(int i =0;i<10;i++)

    queue.offer(rand.nextInt(i+10));

    printQ(queue);

    Queue qc =new LinkedList();

    for(char c:"Brontosaurus".toCharArray())

    qc.offer(c);

    printQ(qc);

    }

    }1.5.2.2.1 PriorityQueue

    优先级队列声明下一个弹出元素是最需要的元素(具有最高的优先级)

    import java.util.*;

    public class PriorityQueueDemo {

    /**

    * @param args

    */

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    PriorityQueue priorityQueue = new PriorityQueue();

    Random rand = new Random(47);

    for(int i =0;i<10;i++)

    priorityQueue.offer(rand.nextInt(i+10));

    QueueDemo.printQ(priorityQueue);

    /*

    * 如果是数字队列的话 priorityQueue会默认按数字从小到大排序,Collections.reverseOrder()为产生反序的Comparator

    * 通过重载Comparator方法来按照自己的形式作比较

    */

    List ints = Arrays.asList(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);

    priorityQueue = new PriorityQueue(ints);

    QueueDemo.printQ(priorityQueue);

    priorityQueue = new PriorityQueue(ints.size(),Collections.reverseOrder());

    priorityQueue.addAll(ints);

    QueueDemo.printQ(priorityQueue);

    /*

    * 从下面例子看出,空格也包含在字母比较的优先级内

    */

    String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION";

    List strings = Arrays.asList(fact.split(""));

    PriorityQueue stringPQ = new PriorityQueue(strings);

    QueueDemo.printQ(stringPQ);

    stringPQ = new PriorityQueue(strings.size(),Collections.reverseOrder());

    stringPQ.addAll(strings);

    QueueDemo.printQ(stringPQ);

    //加入了hashset是为了消除重复元素作一个例子

    Set charSet = new HashSet();

    for(char c:fact.toCharArray())

    charSet.add(c);

    PriorityQueue characterPQ = new PriorityQueue(charSet);

    QueueDemo.printQ(characterPQ);

    }

    }

    1.5.3 常用的方法

    1.5.3.1 contains()

    确定某个对象是否在列表中

    1.5.3.2 indexOf()

    返回该对象在List中所处的位置

    1.5.3.3 equals()

    继承自object,根据类的不同比较的方法也有所不同

    参见: subList(), retainAll(), removeAll()

    1.5.3.3.1 retainAll()

    返回两个集合中的有效的交集,这种行为依赖于equals方法

    参见: equals()

    1.5.3.3.2 removeAll()

    删除对象列表含有的所有元素,同样通过equal()判断

    参见: equals()

    1.5.3.3.3 subList()

    允许你从较大的列表中截出一个子列表,而这个子集无论排序怎样改变,父集.containsAll(子集)总是返回true

    参见: equals()

    1.5.3.4 toArray()

    Collection通过toArray转换成一个数组

    1.6 迭代器(Iterator)

    是一种设计模式,在java里,Iterator是一个对象,只负责遍历并选择容器中的序列,而不用关心该序列底层是用什么实现的。

    1.6.1 容器.iterator()

    1.6.1.1 ListIterator

    Iterator的子类,只能用于List类的访问,可以实现双向移动.

    能够使用set方法替换过它最后一个访问的元素.

    1.6.2 next()

    1.6.3 hasNext()

    1.6.4 remove()

    1.7 Set

    不保存其它元素

    1.7.1 HashSet

    1.8 HashMap

    //以下的例子是随机数的值为键值,随机数出现的次数为值,实现对键值对的包装和拆包

    import java.util.*;

    public class Statistics {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    Random rand = new Random(47);

    Map m = new HashMap();

    for(int i = 0;i<10000;i++){

    int r = rand.nextInt(40);

    Integer freq = m.get(r);

    m.put(r, freq == null?1:freq+1);

    //如果键不在map中,则freq返回null,表示第一次被找到,每次roll到相同的值则值递增并更新该键值对的值.

    }

    System.out.println(m);

    }

    }

    1.8.1 多维Map

    通过容器的组合,可以很容易将map扩展到多维map,比如下面的Map>

    import java.util.*;

    import cn.edu.zen.eleven.container.*;

    public class MapOfList {

    public static Map> petPeople = new HashMap>();

    static{

    petPeople.put(new Person("Dawn"),Arrays.asList(new Cat(1,"black"),new Dog(2,"B&W")));

    petPeople.put(new Person("Kate"), Arrays.asList(new Cat(3,"White"),new Cat(4,"Yellow"),new Dog(5,"Brown")));

    }

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    System.out.println("People: "+petPeople.keySet());

    System.out.println("Pets:"+petPeople.values());

    /*Map可以返回它的Set,它的值的Collection,或它的键值对Set,

    keySet()方法产生了由petPeople中的所有键组成的Set.它在ForEach语句中被用来遍历Map

    */

    for(Person person : petPeople.keySet()){

    System.out.print(person + " has:");

    for(Pet pet:petPeople.get(person))

    System.out.print(" "+pet);

    System.out.println();

    }

    }

    }

    2. Collection和Iterator

    一般来说,针对接口而非具体来编写代码可以应用于更多有相同的特征的对象模型.如编写的方法将接受一个Collection,那么该方法可以应用于任何实现了Collection的类.但是C++类库中并容器的任何公共基类,容器之间的所有特性通过迭代器实现.而在java中,这两种方法绑定在一起,即实现Collection就意味着需要提供iterator()方法

    import java.util.*;

    public class InterfaceVsIterator {

    //Iterator和Collection都可以将display()方法与底层容器实现解耦

    public static void display(Iterator it){

    while(it.hasNext())

    System.out.print(it.next());

    System.out.println();

    }

    public static void display(Collection pets){

    for(Pet p:pets)

    System.out.print(p);

    System.out.println();

    }

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    List petList = (List) Pets.arrayList();

    Set petSet = new HashSet(petList);

    Map petMap = new LinkedHashMap();

    for(Pet pet:petList)

    petMap.put(pet.petName, pet);

    display(petList);

    display(petSet);

    display(petList.iterator());

    display(petSet.iterator());

    System.out.print(petMap);

    System.out.println();

    System.out.print(petMap.keySet());

    System.out.println();

    display(petMap.values());

    display(petMap.values().iterator());

    }

    }

    //但是要实现一个不是Collection的外部类时,由于让它去实现Collection接口可能非常困难和麻烦,因此使用iterator会变得非常吸引人.

    import java.util.*;

    public class PetSequence {

    protected List pets = Arrays.asList(new Pet(1,"Cat"),new Pet(2,"Dog"),new Pet(3,"Rabbit"),new Pet(4,"Fish"),new Pet(5,"Bird"));

    }

    public class NonCollectionSequence extends PetSequence {

    public Iterator iterator(){

    return new Iterator(){

    private int index = 0;

    public boolean hasNext(){

    return index

    }

    public Pet next(){return pets.get(index++);}

    public void remove(){

    throw new UnsupportedOperationException();

    }

    };

    }

    public static void main(String[] args){

    NonCollectionSequence nc =new NonCollectionSequence();

    Iterator it =nc.iterator();

    while(it.hasNext())

    System.out.println(it.next());

    }

    }

    3. Foreach与迭代器

    foreach主要用于数组,但在j2se5中引入了新的iterable的接口,并且该接口包含一个能够产生iterator的iterator()方法,并且Iterable能被foreach用来在序列中移动,任何实现了Iterable接口的类,都可以放在foreach语句中.

    import java.util.Iterator;

    public class IterableClass implements Iterable {

    protected String[] words = ("And that is how"+" we know the Earth to be banana-shaped.").split(" ");

    public Iterator iterator() {

    return new Iterator(){

    private int index = 0;

    public boolean hasNext(){

    return index

    }

    public String next(){ return words[index++];}

    public void remove(){

    throw new UnsupportedOperationException();

    }

    };

    }

    public static void main(String[] args){

    for(String s:new IterableClass())

    System.out.print(s+" ");

    }

    }

    在下面是显示java所有环境变量的例子,由于Set是一个Iterable(),所以能使用foreach循环

    //: holding/EnvironmentVariables.java

    import java.util.*;

    public class EnvironmentVariables {

    public static void main(String[] args) {

    for(Map.Entry entry: System.getenv().entrySet()) {

    System.out.println(entry.getKey() + ": " +

    entry.getValue());

    }

    }

    } /* (Execute to see output) *///:~3.1 适配器方法惯用法

    如果想实现多种Iterable的遍历方式,比如添加一个倒序排序的iterable类,则可以使用设计模式中的迭代器模式.

    import java.util.*;

    public class MultiIterableClass extends IterableClass {

    public Iterable reversed() {

    return new Iterable() {

    public Iterator iterator() {

    return new Iterator() {

    int current = words.length - 1;

    public boolean hasNext() { return current > -1; }

    public String next() { return words[current--]; }

    public void remove() { // Not implemented

    throw new UnsupportedOperationException();

    }

    };

    }

    };

    }

    /*

    注意randomize()并没有返回它自己的Iterator,只返回被打乱顺序的List中的Iterator.Collection.shuffe()方法并没有打乱原来的数组,因为randomized方法将Arrays.asList()的结果包装起来.相当于备份了一个list的副本上打乱顺序

    */

    public Iterable randomized() {

    return new Iterable() {

    public Iterator iterator() {

    List shuffled =

    new ArrayList(Arrays.asList(words));

    Collections.shuffle(shuffled, new Random(47));

    return shuffled.iterator();

    }

    };

    }

    public static void main(String[] args) {

    MultiIterableClass mic = new MultiIterableClass();

    for(String s : mic.reversed())

    System.out.print(s + " ");

    System.out.println();

    for(String s : mic.randomized())

    System.out.print(s + " ");

    System.out.println();

    for(String s : mic)

    System.out.print(s + " ");

    }

    }

    582247ed8fd618e97b0d1bf74316e805.png

    大小: 57.3 KB

    持有对象.rar (54.4 KB)

    下载次数: 1

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2011-12-23 15:04

    浏览 1035

    评论

    展开全文
  • 1.术语了解1.1组件/框架设计侵入式设计引入...例如:Hibernate框架 / Spring框架控制反转:Inversion on Control , 控制反转 IOC对象的创建交给外部容器完成,这个就做控制反转.依赖注入:dependency injection处理对...

    1.术语了解

    1.1组件/框架设计

    侵入式设计

    引入了框架,对现有的类的结构有影响;即需要实现或继承某些特定类。

    例如:Struts框架

    非侵入式设计

    引入了框架,对现有的类结构没有影响。

    例如:Hibernate框架 / Spring框架

    控制反转:

    Inversion on Control , 控制反转 IOC

    对象的创建交给外部容器完成,这个就做控制反转.

    依赖注入:

    dependency injection

    处理对象的依赖关系区别:

    控制反转, 解决对象创建的问题 【对象创建交给别人】

    依赖注入,在创建完对象后, 对象的关系的处理就是依赖注入 【通过set方法依赖注入】

    AOP

    面向切面编程。切面,简单来说来可以理解为一个类,由很多重复代码形成的类。

    切面举例:事务、日志、权限;

    1.2 Spring框架

    Spring框架,可以解决对象创建以及对象之间依赖关系的一种框架。

    且可以和其他框架一起使用;Spring与Struts,  Spring与hibernate

    (起到整合(粘合)作用的一个框架)

    Spring提供了一站式解决方案:(Spring六大模块)

    1) Spring Core  spring的核心功能: IOC容器, 解决对象创建及依赖关系

    2) Spring Web  Spring对web模块的支持。

    - 可以与struts整合,让struts的action创建交给spring

    - spring mvc模式

    3) Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

    4) Spring ORM  spring对orm(对象关系映射)的支持:

     既可以与hibernate整合,【session】

     也可以使用spring的对hibernate操作的封装

    5)Spring AOP  切面编程

    6)SpringEE   spring 对javaEE其他模块的支持

    spring各个版本中:

    在3.0以下的版本,源码有spring中相关的所有包【spring功能 + 依赖包】

    如2.5版本;

    在3.0以上的版本,源码中只有spring的核心功能包【没有依赖包】

    (如果要用依赖包,需要单独下载!)

    1) 源码, jar文件:spring-framework-3.2.5.RELEASE

    commons-logging-1.1.3.jar           日志

    spring-beans-3.2.5.RELEASE.jar        bean节点

    spring-context-3.2.5.RELEASE.jar       spring上下文节点

    spring-core-3.2.5.RELEASE.jar         spring核心功能

    spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

    以上是必须引入的5个jar文件,在项目中可以用户库管理!

    2) 核心配置文件: applicationContext.xml

    Spring配置文件:applicationContext.xml / bean.xml

    2.开发步骤

    首先新建项目,引入spring的架包,

    项目包下新建xml文件,一般命名为applicationContext.xml或者bean.xml,这里以bean.xml命名。

    先在其中加入以下代码<?xml version="1.0" encoding="UTF-8"?>

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    Spring的一个特点就是将对象的创建写在配置文件中(即bean.xml中),在创建对象时只需要引用即可,这样的

    好处就是增加了开发的灵活性

    例子1: 使用配置文件的方法创建对象

    实体类Userpublic class User {

    private int id;

    private String name;

    /通过容器注入属性值

    public void setId(int id) {

    this.id = id;

    }

    public void setName(String name) {

    this.name = name;

    }

    /

    public int getId() {

    return id;

    }

    public String getName() {

    return name;

    }

    public User() {

    System.out.println("无参构造器");

    }

    public User(int id, String name) {

    super();

    System.out.println("有参构造器");

    this.id = id;

    this.name = name;

    }

    @Override

    public String toString() {

    return "User [id=" + id + ", name=" + name + "]";

    }

    public void init_user() {

    System.out.println("init");

    }

    public void destroy_user() {

    System.out.println("destroy");

    }

    }bean.xml文件目录配置

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    lazy-init="true" init-method="init_user" destroy-method="destroy_user">

    调用实例化实体类

    public class App2Bean {

    //得到IOC容器对象

    private ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/th/test1/bean.xml");

    @Test

    public void testIOC() throws Exception {

    System.out.println("容器创建");

    //从容器中获取bean

    User user1 = (User) ac.getBean("user"); //此处user就是在bean.xml中配置的id为user的对象

    User user2 = (User) ac.getBean("user");

    System.out.println(user1);

    System.out.println(user2);

    //销毁容器

    ac.destroy();

    }

    }例子2:创建对象的几种方式

    1.调用无参构造器

    2.带参构造器

    3.工厂创建对象

    工厂类,静态方法创建对象

    工厂类,非静态方法创建对象

    工厂类:public class ObjectFactory {

    //实例方法创建对象

    public User getInstance(){

    return new User(100,"调用实例方法");

    }

    //静态方法创建对象

    public static User getStaticInstance(){

    return new User(100,"调用静态实例方法");

    }

    }

    bean.xml配置文件<?xml version="1.0" encoding="UTF-8"?>

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    对象依赖关系

    Spring中,如何给对象的属性赋值

    1.通过构造函数

    2.通过set方法给属性注入值

    3.p名称空间

    三层构造Dao-->Service-->Action

    UserDao代码:public class UserDao {

    public void save() {

    System.out.println("DB:保存用户");

    }

    }UserService代码:

    public class UserService {

    private UserDao userDao;

    //IOC:对象的创建交给Spring的外部容器完成

    public void setUserDao(UserDao userDao) {

    this.userDao = userDao;

    }

    public void save() {

    userDao.save();

    }

    }UserAction代码

    public class UserAction {

    private UserService userService;

    public void setUserService(UserService userService) {

    this.userService = userService;

    }

    public String execute() {

    userService.save();

    return null;

    }

    }bean.xml配置

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    P名称空间实现对象依赖

    bean.xml配置<?xml version="1.0" encoding="UTF-8"?>

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd">

    自动装配:

    bean.xml配置

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

    http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">

    注解:

    注解方式可以简化spring的IOC容器的配置!

    使用注解步骤:

    1)先在bean.xml中引入context名称空间

    xmlns:context="http://www.springframework.org/schema/context"

    2)开启注解扫描

    3)使用注解

    通过注解的方式,把对象加入ioc容器。

    创建对象以及处理对象依赖关系,相关的注解:

    @Component   指定把一个对象加入IOC容器

    @Repository   作用同@Component; 在持久层使用

    @Service      作用同@Component; 在业务逻辑层使用

    @Controller    作用同@Component; 在控制层使用

    @Resource     属性注入

    总结:

    1) 使用注解,可以简化配置,且可以把对象加入IOC容器,及处理依赖关系(DI)

    2) 注解可以和XML配置一起使用。

    展开全文
  • JAVA集合类,容器类

    2021-03-01 07:03:08
    Java容器类Collection、List、ArrayList、Vector及map、HashTable、HashMap区别Collection是List和Set两个接口的基接口List在Collection之上增加了"有序"Set在Collection之上增加了"唯一"而ArrayList是实现List的类....

    此文档据说是改编而来,然而笔者也付出了辛劳。

    Java容器类Collection、List、ArrayList、Vector及map、HashTable、HashMap区别

    Collection是List和Set两个接口的基接口

    List在Collection之上增加了"有序"

    Set在Collection之上增加了"唯一"

    而ArrayList是实现List的类...所以他是有序的.

    它里边存放的元素在排列上存在一定的先后顺序

    而且ArrayList是采用数组存放元素

    另一种List LinkedList采用的则是链表。

    Collection和Map接口之间的主要区别在于:Collection中存储了一组对象,而Map存储关键字/值对。

    在Map对象中,每一个关键字最多有一个关联的值。

    Map:不能包括两个相同的键,一个键最多能绑定一个值。null可以作为键,这样的键只有一个;可以有一个或多个键所对应的

    值为null。当get()方法返回null值时,即可以表示Map中没有该键,也可以表示该键所对应的值为null。因此,在Map中不能由get()方法来判断Map中是否存在某个键,而应该用containsKey()方法来判断。

    继承Map的类有:HashMap,HashTable

    HashMap:Map的实现类,缺省情况下是非同步的,可以通过Map Collections.synchronizedMap(Map m)来达到线程同步

    HashTable:Dictionary的子类,缺省是线程同步的。不允许关键字或值为null

    当元素的顺序很重要时选用TreeMap,当元素不必以特定的顺序进行存储时,使用HashMap。Hashtable的使用不被推荐,因为HashMap提供了所有类似的功能,并且速度更快。当你需要在多线程环境下使用时,HashMap也可以转换为同步的。

    为什么要使用集合类

    当你事先不知道要存放数据的个数,或者你需要一种比数组下标存取机制更灵活的方法时,你就需要用到集合类。

    理解集合类

    集合类存放于java.util包中。

    集合类存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用(reference)。

    集合类型主要有3种:set(集)、list(列表)和map(映射)。

    (1)集 (Set):口袋

    集(set)是最简单的一种集合,它的对象不按特定方式排序,只是简单的把对象加入集合中,就像往口袋里放东西。

    对集中成员的访问和操作是通过集中对象的引用进行的,所以集中不能有重复对象。

    集也有多种变体,可以实现排序等功能,如TreeSet,它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口,也就是加入了对象比较的方法。通过对集中的对象迭代,我们可以得到一个升序的对象集合。

    (2)列表 (List):列表

    列表的主要特征是其对象以线性方式存储,没有特定顺序,只有一个开头和一个结尾,当然,它与根本没有顺序的集是不同的。

    列表在数据结构中分别表现为:数组和向量、链表、堆栈、队列。

    关于实现列表的集合类,是我们日常工作中经常用到的,将在后边的笔记详细介绍。

    (3)映射 (Map):键值对

    映射与集或列表有明显区别,映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字(Key)对象,关键字决定了对象在映射中的存储位置,检索对象时必须提供相应的关键字,就像在字典中查单词一样。关键字应该是唯一的。

    关键字本身并不能决定对象的存储位置,它需要对过一种散列(hashing)技术来处理,产生一个被称作散列码(hash code)的整数值,散列码通常用作一个偏置量,该偏置量是相对于分配给映射的内存区域起始位置的,由此确定关键字/对象对的存储位置。理想情况下,散列处理应该产生给定范围内均匀分布的值,而且每个关键字应得到不同的散列码。

    集合类简介

    java.util中共有13个类可用于管理集合对象,它们支持集、列表或映射等集合,以下是这些类的简单介绍

    集:

    HashSet: 使用HashMap的一个集的实现。虽然集定义成无序,但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.

    TreeSet: 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

    列表:

    Vector: 实现一个类似数组一样的表,自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类??当两个或多个线程同时访问时也是性能良好的。(同步的含义:即同时只能一个进程访问,其他等待)

    Stack: 这个类从Vector派生而来,并且增加了方法实现栈??一种后进先出的存储结构。

    LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。

    ArrayList: 实现一个数组,它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

    映射:

    HashTable: 实现一个映象,所有的键必须非空。为了能高效的工作,定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承,并且通常能在实现映象的其他类中更好的使用。

    HashMap: 实现一个映象,允许存储空对象,而且允许键是空(由于键必须是唯一的,当然只能有一个)。

    WeakHashMap: 实现这样一个映象:通常如果一个键对一个对象而言不再被引用,键/对象对将被舍弃。这与HashMap形成对照,映象中的键维持键/对象对的生命周期,尽管使用映象的程序不再有对键的引用,并且因此不能检索对象。

    TreeMap: 实现这样一个映象,对象是按键升序排列的。

    下图是集合类所实现的接口之间的关系:

    Set和List都是由公共接口Collection扩展而来,所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或集构成的集合都可以用这种方式引用,只有映射类除外(但也不是完全排除在外,因为可以从映射获得一个列表。)所以说,把一个列表或集传递给方法的标准途径是使用Collection类型的参数。

    List接口

    List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。

    和下面要提到的Set不同,List允许有相同的元素。

    除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。

    实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

    ArrayList类

    ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。

    size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

    每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。ArrayList当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

    和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

    Map接口

    请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。

    HashMap类

    HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。

    ----------------------------------------------------------------------------

    1.-------------------->

    List是接口,List特性就是有序,会确保以一定的顺序保存元素.

    ArrayList是它的实现类,是一个用数组实现的List.

    Map是接口,Map特性就是根据一个对象查找对象.

    HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速(Hash)散列查找.(关于散列查找,可以参看<>)

    2.-------------------->

    一般情况下,如果没有必要,推荐代码只同List,Map接口打交道.

    比如:List list = new ArrayList();

    这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要:

    List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类

    这样,就不需要修改其它代码,这就是接口编程的优雅之处.

    另外的例子就是,在类的方法中,如下声明:

    private void doMyAction(List list){}

    这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.

    3.--------------------->

    如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类

    展开全文
  • 版权声明:一、分类:大类型主要分为以下两种类型1)Collection:一个独立元素的序列,这些元素都服从一条或者多条规则。List必须按照插入的顺序保存元素,而set不能有重复的元素。Queue按照排队规则来确定对象产生...
  • Spring管理对象 集成依赖 spring的配置文件(Applicationcontext.xml) 创建实体User Spring对Bean的实例化方式 基于配置形式 1.通过无参构造函数实例化 2.通过静态工厂方式实例化 3.通过普通工厂方式实例...
  • 容器(Container)Spring 提供容器功能,容器可以管理对象的生命周期、对象对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象...
  • Qt容器类 Qt提供了一组通用的基于模板的容器类,相比C++标准模板库,Qt的容器更轻量安全且更容易使用。同时在速度,内存消耗和内联代码等方面进行了优化。 Qt容器可存储的必须是可赋值的数据类型,也就是说这个类型...
  • JSP隐式对象JSP隐式对象是JSP容器为每个页面提供的Java对象,开发者可以直接使用它们而不用显式声明。JSP隐式对象也被称为预定义变量。JSP所支持的九大隐式对象:对象描述requestHttpServletRequest的实例response...
  • Java获取spring容器的bean常用的5种获取spring中bean的方式总结:方法一:在初始化时保存ApplicationContext对象代码:ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");...
  • 容器中线程安全的如:vectory,hashtable,非线程安全的如:hashmap,arrylist等。对于原定义非线程的容器如:hashmap,arraylist可以使用Collections中的synchronizedList(list),synchronizedMap(map),synchronizedSet...
  • spring对象容器使用

    2021-03-24 17:10:18
    } } public class Bean2 { } public class Bean3 { } (4)关于实体类之间的引用类型使用,通过从spring容器中实现实体类对象的创建和使用 set方法注入 <bean id="bean1" class="com.entity.Bean1"> ...
  • Python中的对象

    2020-12-22 07:01:22
    对象是Python组织数据的形式,所有的数据都是对象(object),即某个(Class)的instance。即便是整数,甚至整数常量这种简单的数据类型(其为)。每个对象都有ID(identity),类型(type)和值(value)。这三者中,只有...
  • 创建JFrame窗体时,需要注意以下两点: (1) JFrame构造方法创建的窗体是不可见的,需要开发人员通过硬编码的方式,设置窗体的可见性。 (2) JFrame构造方法创建的窗体默认的大小为0x 0像素,默认的坐标是(0.0)...
  • 我想要一个容器类,我可以使用一些特性来扩展,以包含一组默认值,以后可以以不可变的方式进行更改 . 这些特征将保存一些简单的数据,因此创建具有几个特征的类将创建一个具有多个默认值集合的对象 .然后,我希望...
  • 到使用Redis来存储二次查询的数据,但对于存储的对象类型我们需要去自定义一个RedisCache并实现’'Cache"以此来重新里面>的"put"和“get”方法。 2 但是出现一个问题,我们在自定义这个RedisCache中使用@...
  • 一、 问题描述在大部分情况下,容器中的bean都是singleton类型的。如果一个singleton bean要引用另外一个singleton bean,或者一个非singleton bean要引用另外一个非singleton bean时,通常情况下将一个bean定义为另...
  • Pod 详解及容器分类

    2021-08-23 17:16:58
    POD 详解一、Pod 基础概念1.1 介绍1.2 Pod 使用方式1.3 工作方式1.4 基础容器 pause1.5 Pod 的分类1.6 Pod 的组成二、Pod 容器的分类2.1 pause 基础容器(infrastructure container)2.2 init 初始化容器(init...
  • 所谓容器,就是专门用来装对象的东西,如果你学过高数,没错,就跟里面说的集合是一个概念,就是一堆对象的集合体,但是集合类是容器类中的一个子集,为了区别表示,所以还是叫容器类,之后所说的集合类只是容器里的...
  • 首先知其然,我们平常框架中开发怎么去把自己写的交给IOC容器管理呢? Spring5.0中我们开发时候就很少去写xml配置文件去注入IOC了 ,所以我们直接从常用的来 (1)@Bean注入 eg:去注入我们的User实体 @...
  • 文章目录一、python的对象1.1 基本概念1.2 主要知识点1.2.1 属性和实例属性区别1.2.2 self 是什么?1.2.3 Python 的魔法方法__init__1.2.4 继承和覆盖(super().\__init\__())1.2.5公有和私有1.3魔法方法...
  • } /// /// 按类型返回强类型的对象 /// /// 对象类型 /// 返回的对象 public static T GetNetCoreObject() { if(NetCoreServiceProvider==null) { throw new Exception("启动时没初始化DotNetCore容器句柄!...
  • 第十二章的学习泛型类、泛型方法和泛型接口泛型限制和泛型通配符容器类 泛型类、泛型方法和泛型接口 泛型其实质就是将数据的类型参数化。使用泛型的主要优点是能够在编译时而不是在运行时检测出错误。 1、泛型类的...
  • Java中的集合对象就是一个容器,用来存放Java对象。我们知道,一种容器,例如水桶的水很方便倒入和取出。例如柜子里的衣服,有序摆放,更方便查找。Java的集合也一样,不同的集合和各自的作用!在Java.util...
  • 在开发一个较高性能需求的应用程序时,程序员会比较关注这些容器类的运行效率,表2.1列出了QList、QLinkedList和QVector容器的时间复杂度比较。1.QList类QList是迄今为止最常用的容器类,它存储给定数据类型T的一列...
  • 目录前言总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,...Pod 中的容器又能分三:基础容器(pause);初始化容器;应用容器。 基础容器(pau
  • 对象的共享

    2021-03-15 20:39:24
    3 对象的共享3.1 可见性我们不仅希望防止某个线程正在使用对象状态而另一个线程在同时修改该状态,而且希望确保当一个线程修改了对象状态后,其他线程能够看到发生的状态变化。因此就需要通过显式的同步或者类库中...
  • Python是基于面向对象的编程语言,那什么是面向对象的思想呢?这要从面向对象的两大概念说起:一个是,另一个是对象。何为呢?是具有相同属性和方法的一事物的抽象描述,而对象就是这一...
  • Laravel中的服务容器是依赖注入容器和应用程序的注册表与手动创建对象相比,使用服务容器的优势在于:管理对象创建上的依赖性的能力您定义如何在应用程序的某个位置(绑定)创建对象,并且每次需要创建新实例时,只...
  • springIOC容器管理的bean默认都是单例的 我们平时使用的 @controller注解标注的控制器、@Service标注的接口等 默认都是单例的 那么也就是说,我们定义一个成员变量,线程之间可以共用! 滑稽!!!干了几年了我...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 268,299
精华内容 107,319
关键字:

以下是容器类的对象的是