精华内容
下载资源
问答
  • 什么是Java容器?Java常见容器有哪些?
    千次阅读
    2021-02-12 10:50:16

    我们在面试中或者在实际工作中,常常问到这个问题,那么最基本的我们首先要了解什么是java容器,再去学习java常见容器。

    在百度上,是这么解释java容器的:

    容器是一个Java 所编写的程序,原先必须自行编写程序以管理对象关系,现在容器都会自动帮您做好。

    我们先看一下java容器有哪些:

    数组,String,java.util下的集合容器

    数组长度限制为 Integer.Integer.MAX_VALUE;

    String的长度限制: 底层是char 数组 长度 Integer.MAX_VALUE 线程安全的

    List:存放有序,列表存储,元素可重复

    Set:无序,元素不可重复

    Map:无序,元素可重复

    我们可以将上述容器做个分类,这样更方便识别:

    按照存放要求分类

    无序:Set,不能重复;

    有序:List,允许重复;

    键-值:Map;

    按照读写效率

    Hash:两者都高;

    Array:读快,改慢;

    Linked:读慢,改快;

    Tree:加入元素可排序使用;

    我们在选择容器时,需要根据容器的特性进行选择数组去实现对象存放,java容器有一种保护机制,能够防止多个进程同时修改同一个容器的内容,如果在迭代遍历某个容器的时候,另外一个进程介入其中,并且插入、删除或者修改容器中某个对象,就会报错。

    java培训班:http://www.baizhiedu.com/java2019

    更多相关内容
  • java容器超详细

    2020-12-21 03:06:51
    java容器是前人为我们提供的一套用于存储数据和对象的工具。如果你学过C++的STL,可以与之类比。java容器又可以称为Java Collection Framework(JCF)。里面除了存储对象的容器之外,还提供了一套用于处理和操作容器...
  • JAVA中的对象容器

    千次阅读 2018-09-18 18:18:35
    容器的用途 如果对象的数量与生命周期都是固定的,自然我们也就不需要很复杂的数据结构。 我们可以通过创建引用来持有对象,如 ...数组显然只能创建固定长度的对象,为了使程序变得更加灵活与高效,Java...

    容器的用途

    如果对象的数量与生命周期都是固定的,自然我们也就不需要很复杂的数据结构。

    我们可以通过创建引用来持有对象,如

    Class clazz;

    也可以通过数组来持有多个对象,如

    Class[] clazs = new Class[10];

    然而,一般情况下,我们并不知道要创建多少对象,或者以何种方式创建对象。数组显然只能创建固定长度的对象,为了使程序变得更加灵活与高效,Java类库提供了一套完整的容器类,具备完善的方法来解决上述问题。

    注意:当数组的元素的类型是类的时候,数组的每一个元素其实只是对象的管理者而不是对象本身。因此,仅仅创建数组并没有创建其中的每一个对象!

    容器的分类

    观察上图,我们可以得出容器主要分为两种类型,两个接口Collection与Map定义了两类不同的对象存储方式。

    Collection用以保存单一的元素,Map保存关联键值对。通过泛型来指定容器存放的数据类型。 Iterator 设计的目的是在未知容器具体的类型的情况下,用来遍历容器元素。剩下的容器类型都是继承了这两个接口。

    下面介绍几个适合初学者的简单容器

    1.ArrayList

    类型:范型容器

    ArrayList<String> notes=new ArrayList<String>();  容器类有两个类型:容器的类型、元素的类型

    ArrayList有顺序的,下标索引从0开始。

    它的优点在于随机访问元素快,但是在中间插入和移除比较慢

    那么现在我们就一起来看看为什么ArrayList随机访问快,而插入移除比较慢。先说关于ArrayList的初始化。

    ArrayList有三种方式进行初始化如下:

    private transient Object[] elementData;
    public ArrayList() {
            this(10);
        }
      public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
        }
     public ArrayList(Collection<? extends E> c) {
            elementData = c.toArray();
            size = elementData.length;
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        }

    我们可以看出ArrayList其实就是采用的是数组(默认是长度为10的数组)。所有ArrayList在读取的时候是具有和数组一样的效率,它的时间复杂度为1。

    插入尾部就是elementData[size++] = e;当然中间会进行扩容。现在主要说插入中间为什么相对来说比较慢源码如下:

    public void add(int index, E element) {
            rangeCheckForAdd(index);//验证(可以不考虑)
    
            ensureCapacityInternal(size + 1);  // Increments modCount!!(超过当前数组长度进行扩容)
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);(核心代码)
            elementData[index] = element;
            size++;
        }

    下面以一个简单的记事本程序来展示ArrayList的操作:

    public class NoteBook {
     
    	private ArrayList<String> notes=new ArrayList<String>();
     
    	public void add(String s) {
    		//ArrayList的add方法
    		notes.add(s);		
    	}
    	public void add(String s,int location) {
    		notes.add(location, s);
    	}
    	public int  getSize() {
    		return notes.size();		
    	}
    	public String getNote(int index) {
    		return notes.get(index);
    		
    	}
    	public void removeNote(int index) {
    		notes.remove(index);
    		
    	}
    	public String[] list() {
    		String[] a=new String[notes.size()];
    		/*for (int i = 0; i < notes.size(); i++) {
    			a[i]=notes.get(i);
    		}*/
    		notes.toArray(a);
    		return a;
    	}
    	public static void main(String[] args) {
    		 String[] aStrings=new String[2];
    		 aStrings[0]="first";
    		 aStrings[1]="second";
             NoteBook noteBook=new NoteBook();         
             noteBook.add("first");
             noteBook.add("second");
             noteBook.add("third",1);
             System.out.println(noteBook.getSize());
             System.out.println(noteBook.getNote(0));
             System.out.println(noteBook.getNote(1));
             noteBook.removeNote(1);
             String[] a=noteBook.list();
             for (int i = 0; i < a.length; i++) {
    			System.out.println(a[i]);
    		}	}
    }
    

    2.Set

    Set是一个集合,它的特点是不可以有重复的对象,也就是数学中集合的概念,所以Set最常用的就是测试归属性,很容易的询问出某个对象是否存在Set中。并且Set是具有和Collection完全一样的接口,没有额外的功能,只是表现的行为不同。下面介绍Set容器中的HashSet.

    HashSet

    HashSet的特点是查询速度比较快,但是存储的元素是随机的并没有排序。我们可以用下面这段代码测试一下Set中元素的唯一性和无序性。

    public static void main(String[] args){
            /**
             * 没有顺序可循,这是因为hashset采用的是散列(处于速度考虑)
             */
            Random random=new Random(47);   //47为种子,想要获取一个范围内的随机数(例如26,随机数可能是0-25),首先需要一个种子(其实就是一个数值)。 
            Set<Integer> intset=new HashSet<Integer>();
            for (int i=0;i<10000;i++){  
                intset.add(random.nextInt(30)); //随机生成一个30以内的数
            }
            System.out.print(intset);
        }

    输出结果:

     

    从这个结果可以看到,即使我们循环了10000次产生一个随机数,intset中还是只有30个数而且是无序的。

     

    下面是用HashSet做的一个输出硬币名称的简单程序

    public class Coin {	
    	private HashMap<Integer, String> coinnames=new HashMap<Integer,String>();
    	public Coin() {
    		// TODO Auto-generated constructor stub
    		coinnames.put(1, "penny");
    		coinnames.put(10, "dime");
    		coinnames.put(25, "quarter");
    		coinnames.put(50, "half-dolar");
    		coinnames.put(50,"五毛");
    		System.out.println(coinnames.keySet().size());		
    		System.out.println(coinnames);
    }
    	public String  getName(int amount) {
    		if (coinnames.containsKey(amount)) {
    			return coinnames.get(amount);
    		}else {
    			return "NOT FOUND";
    		}		
    			}
    	public static void main(String[] args) {
            java.util.Scanner in=new java.util.Scanner(System.in);
            int amount=in.nextInt();
            Coin coin=new Coin();
            String name =coin.getName(amount);
            System.out.println(name);
    	}
    }

    运行看看结果

    从这个结果我们可以知道,  hash表中的每一个key值只能对应一个结果,如果对一个key值多次赋值,这个key只会对应最后一次的结果。同时hash不能放入foreach循环中,遍历没有特别简单的方法,则需遍历key的集合。

    for (Integer k : coinnames.keySet()) {
    			String string=coinnames.get(k);
    			System.out.println(string);
    		}

     

    参考资料:

    https://blog.csdn.net/weixin_41228894/article/details/80388418

    https://www.cnblogs.com/ACFLOOD/p/5555555.html

    https://www.cnblogs.com/LipeiNet/p/5888513.html

     

    展开全文
  • java容器(持有对象)

    2014-09-26 20:08:26
    归纳了java中常用容器包括List、set、map等
  • Java-通过工厂、Map容器创建对象

    千次阅读 多人点赞 2021-03-28 10:28:30
    本文通过两种方式去创建对象,1.工厂+反射+配置文件:单例模式,每次调用工厂方法都会创建一个对象。 第二种对一做了一个优化,当类加载时,对象就已经构造好,之后每次使用从map中获取就行。其实Spring IOC做的就是...
     

    Java-通过工厂、Map容器创建对象

    通过工厂+反射+配置文件创建对象

    通过工厂+反射+配置文件获取对象

    配置文件如下

    通过Map容器间接获取对象

    通过Map容器间接获取对象,与Spring中的IOC容器类似,采用立即加载策略

    配置文件内容如下


    一、通过工厂+反射+配置文件创建对象

    通过工厂+反射+配置文件获取对象

    /**
     * @Author: Promsing
     * @Date: 2021/3/7 - 10:09
     * @Description: 通过使用工厂+配置文件+反射实现创建对象
     * @version: 1.0
     */
    public class AbsFactory {
    
        //声明一个变量(多例模式,每次通过工厂都会创建一个不同的实例)
        private static Object obj;
    
        public static Object createType(String createName){
            //自动释放资源--使用绝对路径
            try( InputStream is =new FileInputStream("src\\Factory.properties")) {
               //配置文件类
                Properties pro=new Properties();
                pro.load(is);
               // System.out.println(pro.size());
                //获取参数
                String property = pro.getProperty(createName);
                obj = Class.forName(property).newInstance();
             
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                return  obj;
            }
        }
    
    }

    配置文件如下

    //以Key,Value的形式,主要Value要写全类名,不要加分号
    accountService=com.dynamic.service.Impl.AccountServiceImpl
    accountDao=com.dynamic.dao.Impl.AccountDaoImpl

    二、通过Map容器间接获取对象

    通过Map容器间接获取对象,与Spring中的IOC容器类似,采用立即加载策略

    /**
     * @Author: Promsing
     * @Date: 2021/3/19 - 11:50
     * @Description: 模仿IOC容器,将创建的对象放在Map集合中,加载该类时会读取配置文件中,将类放入Map中
     * @version: 1.0
     */
    public class BeanFactory {
        //定义一个properties对象
        private static Properties props;
        //定义一个Map,用于存放我们创建的对象(单例,当类加载之后就有了对象,之后从Map中获取)
        private static Map<String,Object> beans;
    
        //容器
        static {
            try {
                props=new Properties();
                //将bean.properties放在了resources路径下
                InputStream is=BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
                props.load(is);
                //实例化容器
                beans=new HashMap<String,Object>();
                //从配置文件中获取所有key值
                Enumeration<Object> keys = props.keys();
                while (keys.hasMoreElements()){
                    //取出每一个key
                    String key = keys.nextElement().toString();
                    //根据key获取value
                    String path = props.getProperty(key);
                    Object value=Class.forName(path).newInstance();
                    //放入容器中
                    beans.put(key,value);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
    
        }
    
        //提供一个访问Map容器的入口
        public static Object  getInstance(String name){
            return beans.get(name);
        }
    
    }

    配置文件内容如下

    accountService=com.dynamic.service.Impl.AccountServiceImpl
    accountDao=com.dynamic.dao.Impl.AccountDaoImpl

    以上两部分归到根上都是通过反射创建对象,JDK8在反射创建对象时,做了很大的增强,提高了性能。其实Spring IOC与以上实现创建对象的原理是一致的,Spring IOC做的就是这件事情,只是它封装的更好而已(当然还有其他的增强,O(∩_∩)O哈哈~)。

    如果本篇博客对您有一定的帮助,大家记得留言+点赞哦。

    展开全文
  • Java容器介绍

    千次阅读 2019-07-02 09:59:14
    一、《Java编程思想》第四版容器介绍 1、不包含抽象类和遗留构件 出自书的第十一章“持有对象”,英文版的“HoldingYourObjects”,章末总结部分。 总计只有四种容器:List、Set、Map、Queue。他们各有两到三个...

    一、《Java编程思想》第四版容器介绍

    1、不包含抽象类和遗留构件

    出自书的第十一章“持有对象”,英文版的“Holding YourObjects”,章末总结部分。

    总计只有四种容器:List、Set、Map、Queue。他们各有两到三个实现版本。常用的容器用黑色的粗线框表示。

    点线框表示接口,实线框表示普通的(具体的)类。

    带有空心箭头的点线表示一个特定的类实现了一个接口。

    实心箭头表示某个类可以生成箭头所指向类的对象。例如,任意的Collection可以生成Iterator,而List可以生成ListIterator(也能生成普通的Iterator,因为List继承自Collection)。

    2、包含抽象类和遗留构件 

    出自第17章,“容器深入研究”,英文版“Container in Depth”。

    二、Collection单对象接口说明

    1、Collection中包含的方法

    Collection不包含随机访问元素的get()方法。因为,Collection包含Set,而Set是自己维护内部顺序的(随机则没有意义)。因此,如果想要检查Collection中的元素,就必须使用迭代器实现。 

    2、包含的子接口、类 

    (1)List说明:

    常用List:

    • ArrayList,采用顺序式的结果进行数据的保存。长于随机访问元素,但在List中间插入和删除元素是较慢。这跟它的存储机制有关,添加或者删除某个元素时,要移动该元素所在位置之后的所有元素。
    • LinkedList,保存的是前后元素,即,它的每一个节点中保存的是两个元素对象,分别对应于它的上一个及下一个节点,所以LinkedList占用的内存空间比ArrayList大。同时LinkedList比ArrayList多实现了一个Queue队列数据接口。通过代价较低的在List中进行的插入和删除操作,提供了优化的顺序访问。但在随机访问方面相对比较慢。

    旧的子类:

    • Vector,该类中的部分方法使用了synchronized关键字声明(同步操作)。

    (2)Set说明: 

    • Set(interface),存入Set的每个元素都必须是唯一的。加入Set的元素必须定义equals()方法以确保对象的一致性。Set与Collection有同样的接口。 
    •  HashSet,为快速查找而设计的Set,散列存放,没有顺序。存入HashSet的元素必须定义hashCode()
    • TreeSet,保持次序的Set,底层为树结构。元素必须实现Comparable接口(进行排序操作)。
    • LinkedHashSet,具有HashSet的查找速度,内部使用链表维护元素的次序(按照插入的次序)。元素必须定义hashCode()。

    三、Map接口说明

    ——注:子类中可添加HashTable。 

    (1) 对Map中使用的键的要求与对Set中的元素的要求一样。

    • 任何键都必须具有一个equals()方法;
    • 如果键被用于散列Map,那么它必须还具有恰当的hashCode方法;
    • 如果键被用于TreeMap,那么它必须实现Comparable。

    (2)关于HashTable的补充说明:

    • 该类出现于JDK1.0,在JDK1.2时多实现了一个Map接口,从而得以保存下来继续使用;
    • 使用HashTable子类实例化的Map集合中,保存的key或value都不允许出现null,否则会出现“NullPointerException”异常。
    HashMap与HashTable的区别
    No.区别点HashMapHashTable

    1

    推出时间JDK1.2,属于新类JDK1.0,属于旧类
    2性能采用异步处理采用同步处理
    3数据安全非线程安全线程安全
    4设置null允许key或value为null

    不允许设置null

    (3)《Thinging in Java》中的英文对照图表:

    四、Queue

    包括两个实现:LinkedListPriorityQueue。

    五、参考

    1、Java集合框架的讲解

    2、Java集合与框架总结与学习

    3、HashTable和HashMap的区别详解

     

     

    展开全文
  • java 容器都有哪些?

    万次阅读 多人点赞 2019-07-27 18:36:57
    容器可以说是Java Core中比较重要的一部分了。 数组,String,java.util下的集合容器 ============================================================================== 数组长度限制为 Integer.Integer.MAX_...
  • Java容器常见面试题

    千次阅读 多人点赞 2019-04-16 16:21:03
    1. Java 容器都有哪些? Java 容器分为 Collection 和 Map 两大类,其下又有很多子类,如下所示是Collection和Map的继承体系: 具体如下结构: Collection List ArrayList LinkedList Vector Stack Set ...
  • Java容器的常用组件

    千次阅读 2020-10-30 22:48:35
    - Frame对象有标题,允许通过拖拉来改变窗口的位置、大小 - 初始化时为不可见,可用setVisible(true)使其显示出来 - 默认使用BorderLayout作为其布局管理器 Panel是AWT中的一个典型的容器,它不能独立存在、必须...
  • Java容器类详解

    万次阅读 2018-04-18 21:26:36
    Java的容器 在Java中,我们想要保存对象可以使用很多种手段。最简单的就是数组。...Java容器类库是用来保存对象的,他有两种不同的概念: Collection,独立元素的序列,这些元素都服从一条或多条规则。Lis...
  • 18.java 容器都有哪些?

    千次阅读 2020-07-27 18:34:52
    JAVA容器类概述 1.常用容器分类 JAVA中的容器类主要分为两大类,一类是Map类,一类是Collections类,他们有一个共同的父接口Iterator,它提供基本的遍历,删除元素操作。Iterator还有一个子接口LinkIterator,它...
  • Java容器(container)

    千次阅读 2021-02-12 14:19:55
    Java容器(container)容器可以管理对象的生命周期、对象对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须设定...
  • Java容器概述

    千次阅读 2018-10-22 16:41:50
    Java容器(Container) 什么是容器? 容器可以管理对象的生命周期、对象对象之间的依赖关系。 直白点说容器就是一段Java程序,能够帮助你管理对象间的关系,而不需要你自行编写程序处理。 维基百科定义: 在计算机...
  • JAVA常见容器

    万次阅读 多人点赞 2019-02-13 14:59:23
    假设上面已经有了各个容器的继承关系,我们就顺着继承关系说一下各个接口或者类的特点吧。 Iterable 接口 Iterable是一个超级接口,被Collection所继承。它只有一个方法: Iterator&amp;lt;T&amp;gt...
  • java容器都有哪些?

    万次阅读 2019-09-03 20:50:29
    java容器类类库的用途是"保存对象"。摘自: “Thinking in Java”. Java集合类是一种特别有用的工具类,可以用于存储数量不等的对象,并可以实现常用的数据结构,如栈,队列等.Java集合就像一种容器,可以把多个对象(实际...
  • Java容器可以说是增强程序员编程能力的基本工具,本系列将带您深入理解容器类。 容器的用途 如果对象的数量与生命周期都是固定的,自然我们也就不需要很复杂的数据结构。 我们可以通过创建引用来持有对象,如 ...
  • java容器Vectort用add添加对象对象引用的问题  众所周知的是在java中去掉了c++中的最为神奇的指针,但是java中存在着引用(个人认为java中的引用与c++的指针很相似,只是不能如指针那般使用)。引用,我们可以...
  • Java容器有哪些?哪些是同步容器,哪些是并发容器? 一、基本概念 容器集 同步容器 并发容器 二、Collection集合接口 List接口 LinkedList类 ArrayList类 Vector类 Stack类 Set接口 HashSet类 TreeSet 三、Map集合...
  • 深入理解Java中的容器

    万次阅读 多人点赞 2016-07-27 17:25:40
    Java当中,如果有一个类专门用来存放其它类的对象,这个类就叫做容器,或者就叫做集合,集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体 2、容器与数组的关系 之所以需要容器: 1、数组的...
  • 该PPT详尽地描述了Java对象容器的属性以及如何使用,不用多说,Java对象容器如ArrayList,List,Set,HaspMap等都是极为重要的容器类,学好这个无疑把握了Java的灵魂所在
  • Java集合

    2021-06-13 11:49:12
    在JDK1.5以前Java集合会丢失容器中所有对象的数据类型,把所有对象都当初object对象来处理,JDK1.5以后增加了泛型,Java集合可以记住容器对象的数据类型。从而可以编写出更简洁,健壮的代码。
  • 组件是Component子类的仔何一个对象正像我们已经看到的,JFrame窗口是一个组件,但不包含其他的子类。在研究特定的组件之前。我们先看一看表示组件的类组之间的一般关系。以Component为基础的一类层次如下图所示,...
  • JAVA面试之容器

    千次阅读 2017-03-07 16:02:14
    java collections框架中大量集合接口以及这些接口的实现类和操作他们的算法,具体而言,主要提供了List、Queue、Set、Stack和Map。 其中Collection接口下有List、Queue、Set、Stack。Map里面HashMap、Hashtable、...
  • 解析一个Java对象占用多少内存空间

    万次阅读 2019-07-13 16:02:15
    对象所占据空间的末尾,如果有空白, 需要使用padding来补齐, 因为下一个对象的起始位置必须是4/8字节(32bit/64bit)的整数倍(这又是一种对齐)。 问题描述 一个对象具有100个属性, 与100个对象每个具有1个属性, ...
  • 一般Spring项目中在项目运行起来时都把各个想要的bean实例注入到Spring的IOC容器中,但是有些时候我们想在Spring之外的地方,例如在Filter,Intercept等地方想获取并使用Spring容器中的某些功能bean,尤其是service...
  • JAVA容器的概念

    千次阅读 2019-03-24 21:34:33
    Spring 提供容器功能,容器可以管理对象的生命周期、对象对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须...
  • 总结 : 十分钟快速理解Java容器

    千次阅读 2018-03-30 13:43:23
    首先看一下Java容器的概念 容器可以管理对象的生命周期、对象对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 580,934
精华内容 232,373
关键字:

java容器对象

java 订阅
友情链接: pinghengxiaoce.rar