Java基础应用

Posted 责任就是爱

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础应用相关的知识,希望对你有一定的参考价值。

 

Java集合类解析

 

ListMapSet三个接口,存取元素时,各有什么特点?

List 特定次序来持有元素,可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值,value可多值

 

HashtableHashMap的区别: 

1.HashtableDictionary的子类,HashMapMap接口的一个实现类; 
2.Hashtable中的方法是同步的,而HashMap中的方法在缺省情况下是非同步的。即是说,在多线程应用程序中,不用专门的操作就安全地可以使用Hashtable了;而对于HashMap,则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决: 
Map Collections.synchronizedMap(Map m) 
这个方法返回一个同步的Map,这个Map封装了底层的HashMap的所有方法,使得底层的HashMap即使是在多线程的环境中也是安全的。 
3.HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,即可以表示HashMap中没有该键,也可以表示该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键,而应该用containsKey()方法来判断。 

VectorArrayListList的异同 
线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类。 
Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
 └Stack 
└Set 
Map 
├Hashtable 
├HashMap 
└WeakHashMap 
Collection接口 
  Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection子接口ListSet 
  所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection 
  如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下: 
    Iterator it = collection.iterator(); // 获得一个迭代子 
    while(it.hasNext()) { 
      Object obj = it.next(); // 得到下一个元素 
    
  由Collection接口派生的两个接口是ListSet 
List接口 
  List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。 
和下面要提到的Set不同,List允许有相同的元素。 
  除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。 
  实现List接口的常用类有LinkedListArrayListVectorStack 
LinkedList 
  LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的getremoveinsert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。 
  注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List 
    List list = Collections.synchronizedList(new LinkedList(...)); 
ArrayList 
  ArrayList实现了可变大小的数组。它允许所有元素,包括nullArrayList没有同步。 
sizeisEmptygetset方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。 
  每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。 
  和LinkedList一样,ArrayList也是非同步的(unsynchronized)。 
Vector 
  Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。 
Stack  
  Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的pushpop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。 
Set接口 
  Set是一种不包含重复的元素的Collection,即任意的两个元素e1e2都有e1.equals(e2)=falseSet最多有一个null元素。 
  很明显,Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。 
  请注意:必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。 
Map接口 
  请注意,Map没有继承Collection接口,Map提供keyvalue的映射。一个Map中不能包含相同的key,每个key只能映射一个valueMap接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。 
Hashtable 
  Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value 
  添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。 
Hashtable通过initial capacityload factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大,这会影响像getput这样的操作。 
使用Hashtable的简单示例如下,将123放到Hashtable中,他们的key分别是”one””two””three” 
    Hashtable numbers = new Hashtable(); 
    numbers.put(“one”, new Integer(1)); 
    numbers.put(“two”, new Integer(2)); 
    numbers.put(“three”, new Integer(3)); 
  要取出一个数,比如2,用相应的key 
    Integer n = (Integer)numbers.get(“two”); 
    System.out.println(“two = ” + n); 
  由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCodeequals方法。hashCodeequals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希表的操作。 
  如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。 
  Hashtable是同步的。 
HashMap 
  HashMapHashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null valuenull key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。 
WeakHashMap 
  WeakHashMap是一种改进的HashMap,它对key实行弱引用,如果一个key不再被外部所引用,那么该key可以被GC回收。 
总结 
  如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList 
  如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。 
  要特别注意对哈希表的操作,作为key的对象要正确复写equalshashCode方法。 

  尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。


Java面试题一

 第一章:Java基础篇

1、谈谈你对java的认识

     这个问题很大,很抽象,要回答好确实不容易。宏观上面来说,从C语言面向过程到C++面向对象到java语言纯面向对象这一发展过程都是为了提高公用性、重用性、可读性,降低耦合性java程序是对象的集合,是一系列带有方法的对象组合,这些方法以其他对象为参数,并发送消息给其他对象。这样由于java中的对象是由状态、行为和标识组成。状态可以认为是对象存在的具体值;行为可认为是对象所能做的操作;而标识是对象在内存中的唯一地址。通常在程序中只能看到对象的前两个属性。在java中所有的代码都必须写在class里,而每个对象都是某个类(class)的一个实例(instance),也就是说java中的所有操作都是由对象完成的。

   java有许多优良的特性,使得Java应用具有无比的健壮性和可靠性,这也减少了应用系统的维护费用。Java对对象技术的全面支持和Java平台内嵌的API能缩短应用系统的开发时间并降低成本。Java的编译一次,到处可运行的特性使得它能够提供一个随处可用的开放结构和在多平台之间传递信息的低成本方式。java的优良特性说明如下:

 1)简单Java丢弃了C++ 中很少使用的、很难理解的、令人迷惑的那些特性,如操作符重载、多继承、自动的强制类型转换。特别是,Java语言不使用指针,并提供了自动的垃圾回收机制,使得程序员不必为内存管理而担忧

 2)面向对象Java语言提供类、接口和继承等原语,为了简单起见,只支持类之间的单继承,但支持接口之间的多继承,并支持类与接口之间的实现机制。Java语言全面支持动态绑定,而C++ 语言只对虚函数使用动态绑定。总之,Java语言是一个纯的面向对象程序设计语言。

 3)分布式Java语言支持Internet应用的开发,在基本的Java应用编程接口中有一个网络应用编程接口(java.net),它提供了用于网络应用编程的类库,包括URL、URLConnection、Socket、 ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。

 4)健壮Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证,Java的安全检查机制使得Java更具健壮性。

 5)安全Java通常被用在网络环境中,为此,Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外,Java对通过网络下载的类具有一个安全防范机制(类ClassLoader),如分配不同的名字空间以防替代本地的同名类、字节代码检查,并提供安全管理机制(类SecurityManager)让Java应用设置安全哨兵。

 6)体系结构中立Java程序在Java平台上被编译为体系结构中立的字节码格式, 然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发 
 7)可移植性任意一个JAVA程序,不论它运行在何种CPU、操作系统或JAVA编译器上,都将产生同样的结果。人们使用CC++也可以产生同样的效果。但CC++在许多细节上它都没有严格定义,如:未初始化变量的值、对已释放的内存的存取、浮点运算的尾数值等等。所以除非你一开始就严格按照系统无关的概念来进行设计,否则这种可移植性只能是一种理论上的设想而不能形成实践。而JAVA定义了严密的语意结构,它的特性能够减小在不同平台上运行的JAVA程序之间的差异,也使得JAVA具有即使没有JAVA虚拟机的存在的情况下比CC++更好的平台无关性。
 8)解释型Java程序在Java平台上被编译为字节码格式, 然后可以在实现这个Java平台的任何系统中运行。在运行时,Java平台中的Java解释器对这些字节码进行解释执行,执行过程中需要的类在联接阶段被载入到运行环境中。
 9)高性能。与那些解释型的高级脚本语言相比,Java的确是高性能的。事实上,Java的运行速度随着JIT(Just-In-Time)编译器技术的发展越来越接近于C++。 
  10)多态Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境,也可以通过网络来载入所需要的类。这也有利于软件的升级。另外,Java中的类有一个运行时刻的表示,能进行运行时刻的类型检查。

   注:在回答这个问题时,应该先从宏观方面说出java面向对象的特点,然后从java特性展开说明。其中1)、2)、3)、4)、5)能说出来最好,其他几点相对来说无关紧要。

2、抽象类与接口

   抽象类:抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象,我们不能把它们实例化(拿不出一个具体的东西)所以称之为抽象。在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为这个抽象类的所有派生类。

   接口Java中的接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。

     区别1)从设计理念层面上abstract class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is-a"关系,即父类和派生类在概念本质上应该是相同的。对于interface来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已,接口与实现类 之间的关系是"like-a"的关系。(举例:class AlarmDoor extends Door implements Alarm);2)从语法定义层面上:abstract class方式中,抽象类可以有自己的数据成员,也可以有非 abstract的成员方法,而在interface方式的实现中,只能有有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的 abstract class。abstract class Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑。在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为

3、overload和override的区别 

    overload是重载,是同一个类中有相同的方法名,但参数类型或个数彼此不同。1)参数类型、个数、顺序至少有一个不相同。2)不能重载只有返回值不同的方法名。3)存在于父类和子类、同类中。

      override是重写,是在子类与父类中,子类中的方法的方法名,参数个数、类型都与父类中的完全一样,在子类中覆盖掉了父类的改方法 。1)方法名、参数、返回值相同。2)子类方法不能缩小父类方法的访问权限。3)子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。4)存在于父类和子类之间。5)方法被定义为final不能被重写。

4、String与StringBuffer的区别 

     JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地,你可以使用StringBuffers来动态构造字符数据。另外,String实现了equals方法,new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法,所以,new StringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为false。 
接着要举一个具体的例子来说明,我们要把1到100的所有数字拼起来,组成一个串。

[java] view plaincopy

  1. StringBuffer sbf = new StringBuffer();   
  2. for(int i=0;i<100;i++)  
  3. {  
  4. sbf.append(i);  
  5. }  

上面的代码效率很高,因为只创建了一个StringBuffer对象,而下面的代码效率很低,因为创建了101个对象

[java] view plaincopy

  1. String str = new String();   
  2. for(int i=0;i<100;i++)  
  3. {  
  4. str = str + i;  
  5. }  

String覆盖了equals方法和hashCode方法,而StringBuffer没有覆盖equals方法和hashCode方法,所以,将StringBuffer对象存储进Java集合类中时会出现问题。 

5、java集合框架结构(Map,List,Set......)

1)类结构图

简化图

 

详细图

 

2)ArrayList,Vector容量相关问题

ArrayList:如果以new ArrayList()方式创建时,初始容量为10个;如果以new ArrayList(Collection c)初始化时,容量为c.size()*1.1,即增加10%的容量;当向ArrayList中添加一个元素时,先进行容器的容量调整,如果容量不够时,则增加至原来的1.5倍加1,再然后把元素加入到容器中,即以原始容量的0.5倍比率增加。

Vector:初始化时容量可以设定,如果以new Vector()方式创建时,则初始容量为10,超过容量时以2倍容量增加。如果以new Vector(Collection c)方式创建时,初始容量为c.size()*1.1,超过时以2倍容量增加。如果以new Vector(int initialCapacity, int capacityIncrement),则以capacityIncrement容量增加。

3)集合特点 

  • List:保证以某种特定插入顺序来维护元素顺序,即保持插入的顺序,另外元素可以重复。
  • ArrayList:是用数组实现的,读取速度快,插入与删除速度慢(因为插入与删除时要移动后面的元素),适合于随机访问。
  • Vector:功能与ArrayList几乎相同,也是以数组实现,添加,删除,读取,设置都是基于线程同步的。
  • LinkedList:双向链表来实现,删除与插入速度快,读取速度较慢,因为它读取时是从头向尾(如果节点在链的前半部分),或尾向头(如果节点在链的后半部分)查找元素。因此适合于元素的插入与删除操作。
  • Set:维持它自己的内部排序,随机访问不具有意义。另外元素不可重复
  • HashSet:是最常用的,查询速度最快,因为 内部以HashMap来实现,所以插入元素不能保持插入次序
  • LinkedHashSet:继承了HashSet,保持元素的插入次序,因为内部使用LinkedHashMap实现,所以能保持元素插入次序。
  • TreeSet:基于TreeMap,生成一个总是处于排序状态的set,它实现了SortedSet接口,内部以 TreeMap来实现
  • TreeMap:键以某种排序规则排序,内部以red-black(红-黑)树数据结构实现,实现了SortedMap接口,
  • HashMap: 以哈希表数据结构实现,查找对象时通过哈希函数计算其位置,它是为快速查询而设计的,其内部定义了一个hash表数组(Entry[] table),元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引,如果有冲突,则使用散列链表的形式将所有相同哈希地址的元素串起来,可能通过查看HashMap.Entry的源码它是一个单链表结构。
  • Hashtable:也是以哈希表数据结构实现的,解决冲突时与HashMap也一样也是采用了散列链表的形式,不过性能比HashMap要低。
  • LinkedHashMap:继承HashMap,内部实体LinkedHashMap.Entry继承自HashMap.Entry,LinkedHashMap.Entry在HashMap.Entry的基础上新增了两个实体引用(Entry before, after),这样实体可以相互串链起来形成链,并且在LinkedHashMap中就定义了一个头节点(Entry header)用来指向循环双向链的第一个元素(通过after指向)与最后一个元素(通过before指向)。在添加一个元素时,先会通过父类HashMap将元素加入到hash表数组里,然后再会在链尾(header.before指向位置)添加(当然这一过程只是调整LinkedHashMap.Entry对象内部的before, after而已,而不是真真创建一个什么新的链表结构向里加那样);删除先从hash表数组中删除,再将被删除的元素彻底的从双向链中断开。其实在链中添加与删除操作与LinkedList是一样的,可以参考《Java集合框架之LinkedList及ListIterator实现源码分析 》 

4)HashMap与HashTable的区别 

  • Hashtable中的方法是同步的,而HashMap中的方法在缺省情况下是非同步的。在多线程应用程序中,我们应该使用Hashtable;而对于HashMap,则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决:Map Collections.synchronizedMap(Map m),当然与可以自己在使用地方加锁。
  • HashMap中,可以允许null作为键,且只可以有一个,否则覆盖,但可以有一个或多个值为null。因为当get()方法返回null值时,即可以表示 HashMap中没有该键,也可以表示该键所对应的值为null,所以HashMap不能由get()方法来判断否存在某个键,而应该用containsKey()方法来判断;而Hashtable不允许null键与null值。
  • HashTable使用Enumeration,HashMap使用Iterator。
  • Hashtable是Dictionary的子类,HashMap是Map接口的一个实现类;
  • HashTable中hash table数组默认大小是11,增加的方式是 int newCapacity = oldCapacity * 2 + 1;,即增加至2倍(而不是2倍加1,因为扩容是在增加元素前进行的,在扩容后会将新增元素放入容器中)。HashMap中hash数组的默认大小是16,而且一定是2的多少次方;另外两者的默认负载因子都是0.75。
    • 求哈希地址与哈希地址转hash数组(Entry table[])索引方法不同:
    • HashTable直接使用对象的hashCode:

[java] view plaincopy

  1. int hash = key.hashCode();//直接使用键的hashCode方法求哈希值    
  2. //哈希地址转hash数组索引,先使用最大正int数与,这样将负转正数,再与数组长度求模得到存入的hash数组索引位置    
  3. int index = (hash & 0x7FFFFFFF) % tab.length;    

HashMap重新计算hash值,而且用位运算&代替求模:

[java] view plaincopy

  1. int hash = hash(k);    
  2. int i = indexFor(hash, table.length);    
  3. static int hash(Object x) {    
  4. //以键本身的hash码为基础求哈希地址,但看不懂是什么意思    
  5.   int h = x.hashCode();    
  6.   h += ~(h << 9);    
  7.   h ^= (h >>> 14);    
  8.   h += (h << 4);    
  9.   h ^= (h >>> 10);    
  10.   return h;    
  11. }    
  12. static int indexFor(int h, int length) {    
  13.   return h & (length-1);//将哈希地址转换成哈希数组中存入的索引号    
  14. }    

HashMap实现图:

5) 集合中键值是否允许null小结

  • List:可以有多个null,可以有重复值
  • HashSet:能插入一个null(因为内部是以 HashMap实现 ),忽略不插入重复元素。
  • TreeSet:不能插入null (因为内部是以 TreeMap 实现 ) ,元素不能重复,如果待插入的元素存在,则忽略不插入,对元素进行排序。
  • HashMap:允许一个null键与多个null值,若重复键,则覆盖以前值
  • TreeMap:不允许null键(实际上可以插入一个null键,如果这个Map里只有一个元素是不会报错的,因为一个元素时没有进行排序操作,也就不会报空指针异常,但如果插入第二个时就会立即报错),但允许多个null值,覆盖已有键值。
  • HashTable:不允许null键与null值(否则运行进报空指针异常)。也会覆盖以重复值。基于线程同步。

6) 对List的选择

  • 对于随机查询与迭代遍历操作,数组比所有的容器都要快。
  • 从中间的位置插入和删除元素,LinkedList要比ArrayList快,特别是删除操作。
  • Vector通常不如ArrayList快,则且应该避免使用,它目前仍然存在于类库中的原因是为了支持过去的代码。
  • 最佳实践:将ArrayList作为默认首选,只有当程序的性能因为经常从list中间进行插入和删除而变差的时候,才去选择LinkedList。当然了,如果只是使用固定数量的元素,就应该选择数组了。

7) 对Set的选择

  • HashSet的性能总比TreeSet好(特别是最常用的添加和查找元素操作)。
  • TreeSet存在的唯一原因是,它可以维持元素的排序状态,所以只有当你需要一个排好序的Set时,才应该使用TreeSet。
  • 对于插入操作,LinkedHashSet比HashSet略微慢一点:这是由于维护链表所带来额外开销造成的。不过,因为有了链表,遍历LinkedHashSet会比HashSet更快。

8) 对Map的选择

  • Hashtable和HashMap的效率大致相同(通常HashMap更快一点,所以HashMap有意取代Hashtable)。
  • TreeMap通常比HashMap慢,因为要维护排序。
  • HashMap正是为快速查询而设计的。
  • LinkedHashMap比HashMap慢一点,因为它维护散列数据结构的同时还要维护链表。

9) Stack,Vector:Stack基于线程安全,Stack类是用Vector来实现的(public class Stack extends Vector),但最好不要用集合API里的这个实现栈,因为它继承于Vector,本就是一个错误的设计,应该是一个组合的设计关系。

10) Iterator对ArrayList(LinkedList)的操作限制

  • 刚实例化的迭代器如果还没有进行后移(next)操作是不能马上进行删除与修改操作的。。
  • 可以用ListIterator对集合连续添加与修改,但不能连续删除。。
  • 进行添加操作后是不能立即进行删除与修改操作的。。
  • 进行删除操作后可以进行添加,但不能进行修改操作。
  • 进行修改后是可以立即进行删除与添加操作的。

11) hashCode(),equals()方法:当以自己的对象做为HashMap、HashTable、LinkedHashMap、HashSet 、LinkedHashSet 的键时,一定要重写hashCode ()与equals ()方法,因为Object的hashCode()是返回内存地址,且equals()方法也是比较内存地址,所以当要在这些hash集合中查找时,如果是另外new出的新对象是查不到的,除非重写这两个方法。因为AbstractMap类的containsKey(Object key)方法实现如下:

[java] view plaincopy

  1. if (e.hash == hash && eq(k, e.key))//先比对hashcode,再使用equals    
  2. return true;      
  3. static boolean eq(Object x, Object y) {    
  4. return x == y || x.equals(y);    
  5. }    

String对象是可以准确做为键的,因为已重写了这两个方法。因此,Java中的集合框架中的哈希是以一个对象查找另外一个对象,所以重写hasCodeequals方法很重要。 重写hashCode()equals()这两个方法是针对哈希类,至于其它集合,如果要用public boolean contains(Object o)containsValue(Object value)查找时,只需要实现equals()方法即可,他们都只使用对象的 equals方法进行比对,没有使用 hashCode方法。

12) TreeMap,TreeSet:放入其中的元素一定要具有自然比较能力(即要实现java.lang.Comparable接口)或者在构造TreeMap/TreeSet时传入一个比较器(实现java.util.Comparator接口),如果在创建时没有传入比较器,而放入的元素也没有自然比较能力时,会出现类型转换错误(因为在没有较器时,会试着转成Comparable型)。

[java] view plaincopy

  1. //自然比较器    
  2. public interface java.lang.Comparable {    
  3. public int compareTo(Object o);    
  4. }      
  5. public interface java.util.Comparator {    
  6. int compare(Object o1, Object o2);    
  7. boolean equals(Object obj);    
  8. }    

13) TreeMap,TreeSet:CollectionMap的同步控制:可以使用Collections类的相应静态方法来包装相应的集合类,使他们具线程安全,如public static Collection synchronizedCollection (Collection c)方法实质返回的是包装后的SynchronizedCollection子类,当然你也可以使用CollectionssynchronizedListsynchronizedMapsynchronizedSet方法来获取不同的经过包装了的同步集合,其代码片断:

[java] view plaincopy

  1. public class Collections {    
  2. static Collection synchronizedCollection(Collection c, Object mutex) {    
  3. return new SynchronizedCollection(c, mutex);    
  4. }      
  5. public static List synchronizedList(List list) {    
  6. }      
  7. static Set synchronizedSet(Set s, Object mutex) {    
  8. }      
  9. public static Map synchronizedMap(Map m) {    
  10. return new SynchronizedMap(m);    
  11. }     
  12. static class SynchronizedCollection implements Collection, Serializable {      
  13. Collection c; // 对哪个集合进行同步(包装)    
  14. Object mutex; // 对象锁,可以自己设置             
  15. SynchronizedCollection(Collection c, Object mutex) {    
  16. this.c = c;    
  17. this.mutex = mutex;    
  18. }      
  19. public int size() {    
  20. synchronized (mutex) {    
  21. return c.size();    
  22. }    
  23. }      
  24. public boolean isEmpty() {    
  25. synchronized (mutex) {    
  26. return c.isEmpty();    
  27. }    
  28. }           
  29. }    
  30. static class SynchronizedList extends SynchronizedCollection implements List {      
  31. List list;     
  32. SynchronizedList(List list, Object mutex) {    
  33. super(list, mutex);    
  34. this.list = list;    
  35. }      
  36. public Object get(int index) {    
  37. synchronized (mutex) {    
  38. return list.get(index);    
  39. }    
  40. }         
  41. }      
  42. static class SynchronizedSet extends SynchronizedCollection implements Set {    
  43. SynchronizedSet(Set s) {    
  44. super(s);    
  45. }    
  46. }       
  47. }    

由包装的代码可以看出只是把原集合的相应方法放在同步块里调用罢了。

14) 通过迭代器修改集合结构:通过迭代器修改集合结构在使用迭代器遍历集合时,我们不能通过集合本身来修改集合的结构(添加、删除),只能通过迭代器来操作,下面是拿对HashMap删除操作的测试,其它集合也是这样:

[java] view plaincopy

  1. public static void main(String[] args) {    
  2. Map map = new HashMap();    
  3. map.put(1, 1);    
  4. map.put(2, 3);    
  5. Set entrySet = map.entrySet();    
  6. Iterator it = entrySet.iterator();    
  7. while (it.hasNext()) {    
  8. Entry entry = (Entry) it.next();    
  9. /*  
  10. * 可以通过迭代器来修改集合结构,但前提是要在已执行过 next 或  
  11. * 前移操作,否则会抛异常:IllegalStateException  
  12. */    
  13. // it.remove();    
  14. /*  
  15. * 抛异常:ConcurrentModificationException 因为通过 迭代 器操  
  16. * 作时,不能使用集合本身来修  
  17. * 改集合的结构  
  18. */    
  19. // map.remove(entry.getKey());    
  20. }    
  21. System.out.println(map);    
  22. }    

6java io

     1)java io流相关概念

输出流:

 

输入流:

 

因此输入和输出都是从程序的角度来说的。

字节流:一次读入或读出是8位二进制

字符流:一次读入或读出是16位二进制

字节流和字符流的原理是相同的,只不过处理的单位不同而已。后缀是Stream是字节流,而后缀是ReaderWriter是字符流。 

节点流:直接与数据源相连,读入或读出。

 

直接使用节点流,读写不方便,为了更快的读写文件,才有了处理流。

处理流:与节点流一块使用,在节点流的基础上,再套接一层,套接在节点流上的就是处理流。

 

















































































以上是关于Java基础应用的主要内容,如果未能解决你的问题,请参考以下文章

深入Java基础--哈希表HashMap应用及源码详解

Java应用程序连接数据库--JDBC基础

Java基础(38):Calendar类的应用(优于Date类)

java反射基础应用备注

Java基础(多态的理解与应用)

Java应用基础微专业-工程篇