Java Stream全面讲解

1.Streams及I/O

Stream就是信息源与目的地之间的通信路径，这里的信息源可以是文件、内存、网络等。

Streams主要分为input及output Stream。

1.1 InputStream类

类InputStream处于Input stream类层次的最顶层，它主要具有以下几种方法：

1.1.1 read方法

read方法用于从指定的输入流读取以字节为单位的数据，第一次从流的开始位置开始读取，以后每次从上次的结束部位开始读取，即自动实现了位移。

read方法有以下三种形态：

（1）int read(byte buff[n])：从指定输入流中读取n个字节填充到buff中，该方法返回读取的实际字节数，如果读取的实际字节数小于n，一般是因为已读到指定输入流的末尾；

（2）int read()：即不带参数，该方法每次一个字节从指定的输入流中读取数据。返回值也是int类型，但它并不代表读取的字节数，而是从流中读取的数据的本身，因数据本身是byte类型的，所以一般要强制进行转化；如果读到流的末尾返回的值是-1；

（3）int read(byte buff[n],int start, int len)：从指定流读取数据，从start开始，填充len 个字节到buff中，返回值为实际的填充数，如果返回值

以下是read的简单例子：

import java.io.*;

class TestIO1{

public static void main(String args[]) {

InputStream s = null;

try{

s = new FileInputStream("io.txt");

}catch(FileNotFoundException e){

System.out.println("file not find");

}

int i;

try{

i = s.read();

while(i != -1){

System.out.println((char)i);

i = s.read();

}

}catch(IOException e){

System.out.println("io error");

} } }

1.1.2 skip方法

skip 方法类似于C语言中的lseek都是用于定位的。Skip方法定义：long skip(long n)，该方法使指定流中的当前位置移动n个字节，n的值可以是负值用于向前移，skip方法返回值为实际移动的字节数，由于种种原因，如已到流尾或者其它原因返回的值往往小于n。对于读取文件来说，小于n的原因最大的原因是读到了文件尾。

1.1.3 available方法

available方法用于计算指定流中当前有多少字节，如果指定的流是文件流，那么就返回文件的大小。Available返回的值是int类型。

有的输入流可能没有能力返回字节数，如果对这些输入流使用avaiable方法，返回值为0。

1.1.4 close方法

对于打开的stream，Java可以自动回收，但是Java自动回收需要时间，所以最好自己调用close方法来关闭stream，这样方便下一次重新指定的流。

1.2 ByteArrayInputStream

ByteArrayInputStream是从InputStream中继承下来的，用于从字节数组中提取数据，关于ByteArrayInputStream的创建例子如下：

byte[] buffer = new byte[1024];

fillWithUsefulData(buffer); //自定义的方法,用于在buffer中填充数据

InputStream s = new ByteArrayInputStream(buffer);

InputStream s1 = new ByteArrayInputStream(buffer,100,300);

其中ByteArrayInputStream(buffer,100,300)是创建到buffer的stream，从buffer的第100个字节开始取300字节。

ByteArrayInputStream的其它方法与InputStream类似，这里不再重复。

1.3 FileInputStream

FileInputStream 也是从InputStream中继承下来的，用于从指定的文件中提取。因此它的方法也与InputStream中的方法类似，这里不再介绍，只介绍FileInputStream中特殊的方法：getFD()，该方法用于获取文件句柄。使用方法如下：

FileInputStream aFIS = new FileInputStream("aFileName");

FileDescriptor myFD = aFIS.getFD();

这样以后要用到aFileName文件时可以使用myFD这个文件句柄（实际上是文件描述类的实例），如要重新打开该文件，可以使用FileInputStream aFIS = new FileInputStream(myFD)。

关于文件描述类FileDescriptor，有以下几点说明：

（1）属性in：标准输入；

（2）属性out：标准输出；

（3）属性err：标准错误输出；

在FileInputStream中还有另一个特殊的方法就是：finalize()。

1.4 FilterInputStream

FilterInputStream也是从InputStream中继承下来，不过FilterInputStream类基本上不能直接使用，一般上使用该类的派生类，如BufferedInputStream等。该类的最大特点是，在定义时可以嵌套：

InputStream s = getAnInputStreamFromSomewhere();

FilterInputStream s1 = new FilterInputStream(s);

FilterInputStream s2 = new FilterInputStream(s1);

FilterInputStream s3 = new FilterInputStream(s2);

所以该类的所有派生类都具有这个特性。

1.5 BufferedInputStream

BufferedInputStream指定数据源是内存的指定区域，从FilterInputStream继承下来的，这种类型的Stream主要用于提高性能，它定义时一般指定其它的InputStream，如：

InputStream s = new BufferedInputStream(new FileInputStream("foo"));

BufferedInputSream是可以使用mark及reset方法，使用上述的嵌套方法间接的使其它的stream也支持这些方法了。

由于BufferedInputStream需要buffer，所以它需要等待在它之前的数据都到了后才工作，所以BufferedInputStream最好用在流的前面，如上面这个例子，当然用在最前面也没有什么意思了。

1.6 DataInputStream

DataInputStream 也是从FilterInputStream继承下来的，所以也具有父类的特性。DataInputStream还implement DataInput接口，所以DataInputStream具体的方法最多，如：readShort、readBoolean、readByte、readUnsignedByte、readShort等。这些方法的都是read方法的扩展，使用上也相似，所以这里不多介绍。

以下是readInt的实现：

public final int readInt() throws IOException {

int ch1 = in.read();

int ch2 = in.read();

int ch3 = in.read();

int ch4 = in.read();

if ((ch1 | ch2 | ch3 | ch4) < 0)

throw new EOFException();

return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));

以下是readLine的实现：

public final String readLine() throws IOException { char buf[] = lineBuffer;

if (buf == null) {

buf = lineBuffer = new char[128];

}

int room = buf.length;

int offset = 0;

int c;

loop: while (true) {

switch (c = in.read()) {

case -1:

case '\n':

break loop;

case '\r':

int c2 = in.read();

if ((c2 != '\n') && (c2 != -1)) {

if (!(in instanceof PushbackInputStream)) { this.in = new PushbackInputStream(in);

}

((PushbackInputStream)in).unread(c2);

}

break loop;

default:

if (--room < 0) {

buf = new char[offset + 128];

room = buf.length - offset - 1;

System.arraycopy(lineBuffer, 0, buf, 0, offset); lineBuffer = buf;

}

buf[offset++] = (char) c;

break;

}

}

if ((c == -1) && (offset == 0)) {

return null;

}

return String.copyValueOf(buf, 0, offset);

}

在这个例子中，如果读出的字符中\r，还得再读一位判断是否是\n，如果不是\n，还得将这个字符放回到输入流中，因此使用了PushbackInputStream的功能。

如果对DataInputStream的读操作已到Stream的末尾，会抛出EOFException异常。在Stream末尾，skipBytes不做任何动作；readLine返回null；readUTF抛出UTFDataFormatException异常。

1.7 LineNumberInputStream

同样LineNumberInputStream是从FilterInputStream继承下来的，该类可以跟踪行号，设置行号，对行作标记以便恢复等功能。一般不直接使用该类，而使用其它Stream的嵌套间接对它进行使用，如：

LineNumberInputStream aLNIS;

aLNIS = new LineNumberInputStream(new FileInputStream("source"));

DataInputStream s = new DataInputStream(aLNIS);

String line;

while ((line = s.readLine()) != null) {

. . . // process the line

System.out.println("Did line number: " + aLNIS.getLineNumber());

}

在这个例子中，使用DataInputStream读取行，使用LineNumberInputStream来监控行。从这个子可以看出，嵌套流中数据的流动贯穿所有的流，即所以流中的数据在同步流动。

1.8 PushbackInputStream

PushbackInputStream 也是从FilterInputStream继承下来，它有一个特殊的方法unread，用于将读出来的数据放出流中。在例子readLine就使用了这个方法，unread与read相对应有三个形态：unread()、unread(byte[])及unread(byte[],int,int)。

1.9 PipedInputStream

FilterInputStream 的派生类已介绍完毕，下面接着介绍InputStream的派生类。

PipedInputStream一般与PipedOutputStream一起用构成线程之间双向的通信管道。因此在里先不介绍PipedInputStream的用法。

1.10 StringBufferInputStream

String buffer = "Now is the time for all good men to come...";

InputStream s = new StringBufferInputStream(buffer);

1.11 ByteArrayInputStream

ByteArrayInputStream与StringBufferInputStream类似，只是它基于ByteArry，而StringBufferInputStream基于String。

1.12 SequenceInputStream

SequenceInputStream用于将不同的InputStream按先后顺序串在一起，如将两个InputStream串起来：

InputStream s1 = new FileInputStream("theFirstPart");

InputStream s2 = new FileInputStream("theRest");

InputStream s = new SequenceInputStream(s1, s2);

以上只能实现两个输入流的串接，要实现两个以上输入流串接，需要用到V ector类，如下所示：

Vector v = new Vector(3);

Enumeration e;

v.addElement(s1);

v.addElement(s2);

v.addElement(s2);

e = v.elements();

InputStream s = new SequenceInputStream(e) ;

1.13 OutputStream

OutputStream位于Output Stream类层次的最顶层，它是一个抽象类，它规定了Output Stream类的基本功能。

1.13.1 write

write方法与InputStream的read方法相对应，它有三个形态：

（1）write(byte[])：将指定byte数组中的数据输出到指定Stream；

（2）write(byte[],int,int)：将指定byte数组中的数据从第二个参数开始，输出第三个参数指定的长度到指定的Stream；

（3）wirte(int)；将一个int值输出到指定的Stream；

1.13.2 flush和close

有些输出流在输出时先放在缓冲中，可以使用flush将这些数据真正写入指定的输出流中。Close用于关闭指定的输出流。

1.14 ByteArrayOutputStream

ByteArrayOutputStream将一个输出流指向一个Byte数组，但这个Byte数组是ByteArrayOutputStream内部内置的，不需要我们来定义。该类有两个构造函数：

（1）ByteArrayOutputStream()：该构造函数会在内部创建一个长度为32的Byte数组；

（2）ByteArrayOutputStream(int n)：在对象内部创建一个长度为n的Byte数组。

ByteArrayOutputStream从OutputStream类继承下来，所以它具write、flush及close等方法，同时它还具有以下几个特殊的方法：

（3）toString()：将对象内部的Byte数组转化成字符串(String(buf,0,count)；

（4）toString(int n)：将对象对部的Byte数组转化成字符串，编码方式为n；

（5）toString(String n)：将对象对部的数组转化成字符串，编码方式为n；

（6）toByteArray()：返回对象内部的Byte数组；

（7）writeTo(OutputStream)：将内部Byte数组输出到指定的输出流；

（8）reset()：将对象内部Byte数组的长度设为0，{count = 0}；

（9）size()：返回Byte数组长度；

1.15 FileOutputStream

FileOutputStream与FileInputStream相对应，它具有以下几个构造函数：

（1）FileOutputStream(File)

（2）FileOutputStream(File file, boolean append)：如果append为真，以添加方式写入文

件，如果为否（缺省），以新增方式写入文件；

（3）FileOutputStream(FileDescriptor)

（4）FileOutputStream(String name)

（5）FileOutputStream(String name, boolean append)

其它的方法大多为标准方法，这里不再介绍。以下使用的例子：

FileDescriptor fd = someFileStream.getFD();

OutputStream s = new FileOutputStream(fd);

1.16 FilterOutputStream

FilterOutputStream与FilterInputStream相对应，使用方法也相类似。

1.17 BufferedOutputStream

BufferedOutputStream从FilterOutputStream中继承下来，它与BufferedInputStream相对应，作用也相类似，它主要为输出流做缓冲，如：

OutputStream s = new BufferedOutputStream(new FileOutputStream("foo"));

由于BufferedOutputStream是缓冲数据的，所以必要时，需要使用flush方法强制将缓冲中的数据真正写入输出流中。

1.18 DataOutputStream

DataOutputStream与DataInputStream相对应，在继承OutputStream的同时，实现了DataOutput接口，因此它具有DataOutput接中所规定的方法，这些方法与DataInput所规定的方法相反。

它还具有size方法，该方法返回向输出流写入的字节数。以下是实现复制功能的例子：

try { while (true) aDO.writeByte(aDI.readByte()); }

finally { aDI.close(); aDO.close(); }

1.19 PrintStream

PrintStream是从FilterOutputStream继承下来的。使用例子如下：

PrintStream s = new PrintStream(new FileOutputStream("foo"));

s.println("Here's the first line of text in the file foo.");

这个例子说明可以使用PrintStream向文件写数据，并且该类提供了输出行的功能，弥补了DataOutputStream的空白(在DataOutputStream没有输出行的功能)。

PrintStream的构造函数：

（1）PrintStream(boolean autoFlush, OutputStream out)

（2）PrintStream(OutputStream out)

（3）PrintStream(OutputStream out, boolean autoFlush)

（4）PrintStream(OutputStream out, boolean autoFlush, String encoding)

1.20 PipedOutputStream

PipedOutputStream与PipedInputSteam相互配合实现两个线程之间的通信，它们的定义如下：

PipedInputStream sIn = PipedInputStream();

PipedOutputStream sOut = PipedOutputStream(sIn);

以下是使用例子，该例子接收标准输入的数据，并输出到标准输出：

import java.io.*;

class ReadThread extends Thread implements Runnable {

InputStream pi = null;

OutputStream po = null;

String process = null;

ReadThread( String process, InputStream pi, OutputStream po) {

this.pi = pi; this.po = po; this.process = process; }

public void run() {

int ch; byte[] buffer = new byte[12]; int bytes_read;

try {

for(;;) {

bytes_read = pi.read(buffer); //从指定流读入数据

if (bytes_read == -1) { return; }

po.write(buffer, 0, bytes_read);//向指定流写入数据

Thread.yield();

}

} catch (Exception e) { e.printStackTrace();

} finally { }

}

}

public class MyPipe{

public static void main( String [] args) {

try {

int ch;

PipedInputStream writeIn = new PipedInputStream(); PipedOutputStream readOut = new PipedOutputStream( writeIn ); FileOutputStream writeOut = new FileOutputStream("out"); ReadThread rt = new ReadThread("reader", System.in, readOut ); ReadThread wt = new ReadThread("writer", writeIn, System.out ); rt.start();

wt.start();

} catch (Exception e) {

e.printStackTrace();

} }}

说明：

（1）类ReadThread非常巧妙，它并没有指定输入输出流的具体类型

（2）在MyPipe类中new ReadThread("reader", System.in, readOut )语句使得从标准输入设备中接收数据，而从readOut输出，而readOut是PipedOutputSteam，所以它可以被另一线程接收；

（3）new ReadThread("writer", writeIn, System.out )，从writeIn接收数据，writeIn是readOut是成对的双向管道，它接收从readOut发送过来的数据。再从标准设备中输出。

1.21 RandomAccessFile

1.22 StreamTokenizer

1.23 ObjectOutputStream

ObjectOutputStream 从OutputStream继承下来，并实现了ObjectOutput, ObjectStreamConstants这两个接口。它负责将指定对象输出到指定的输出流，可以将非static、非transient的属性及值，对象的类定义输出到指定的输出流。该类有一个非常用的方法：

writeObject (Object obj);

该方法将obj输出到指定的输出流，以下是该类的例子：

FileOutputStream f = new FileOutputStream("tmp");

ObjectOutput s = new ObjectOutputStream(f);

s.writeObject("Today");

s.writeObject(new Date());

s.flush();

可以使用transient修饰符规定一些变量的值不被输出到指定的输出流，如：

public transient int transientValue = 4;

这样transientValue的值就不会被输出到输出流。

1.24 ObjectInputStream

ObjectInputStream与ObjectOutputStream相对应，它是将对象的值及类的定义等从指定的输入流读入，以便重新对象化：

FileInputStream in = new FileInputStream("tmp");

ObjectInputStream s = new ObjectInputStream(in);

String today = (String)s.readObject();

Date date = (Date)s.readObject();

ObjectOutputStream和ObjectInputStream就可以实现对象的持久化，即要先将对象序列化保存到介质中，在必要的时候重新恢复这些对象。

import java.util.Date;

import java.text.DateFormat;

/**

* 格式化时间类

* DateFormat.FULL = 0

* DateFormat.DEFAULT = 2

* DateFormat.LONG = 1

* DateFormat.MEDIUM = 2

* DateFormat.SHORT = 3

* @author Michael

* @version 1.0， 2007/03/09

*/

public class Test{

public static void main(String []args){

Date d = new Date();

String s;

/** Date类的格式: Sat Apr 16 13:17:29 CST 2006 */

System.out.println(d);

System.out.println("******************************************");

/** getDateInstance() */

/** 输出格式: 2006-4-16 */

s = DateFormat.getDateInstance().format(d);

System.out.println(s);

/** 输出格式: 2006-4-16 */

s = DateFormat.getDateInstance(DateFormat.DEFAULT).format(d);

System.out.println(s);

/** 输出格式: 2006年4月16日星期六 */

s = DateFormat.getDateInstance(DateFormat.FULL).format(d);

System.out.println(s);

/** 输出格式: 2006-4-16 */

s = DateFormat.getDateInstance(DateFormat.MEDIUM).format(d);

System.out.println(s);

/** 输出格式: 06-4-16 */

s = DateFormat.getDateInstance(DateFormat.SHORT).format(d);

System.out.println(s);

/** 输出格式: 2006-01-01 00:00:00 */

java.text.DateFormat format1 = new java.text.SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); s = format1.format(new Date());

System.out.println(s);

/** 输出格式: 2006-01-01 01:00:00 */

System.out.println((new java.text.SimpleDateFormat("yyyy-MM-dd hh:mm:ss")).format(new Date()));

/** 输出格式: 2006-01-01 13:00:00 */

System.out.println((new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date()));

/** 输出格式: 20060101000000***/

java.text.DateFormat format2 = new java.text.SimpleDateFormat("yyyyMMddhhmmss");

s = format2.format(new Date());

System.out.println(s);

}

}

补充一下：

Calendar cal = Calendar.getInstance();

cal.setTime(new Date());

System.out.println("System Date: " + cal.get(Calendar.MONTH+1));

Java集合类知识点总结

Java集合类 Java集合类 (1) 1.Map (3) 1.1.HashMap (3) 1.1.1.底层实现 (3) 1.1.2.特点 (3) 1.1.3.源码分析 (4) 1.1.4.多线程可能出现的问题 (5) 1.2.ConcurrentHashMap (6) 1.2.1.底层实现 (6) 1.2.2.源码分析 (7) 1.3.HashTable (9) 1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键 字。9 1.3.2.HashTable的key和value都不可以为null。 (9) 1.3.3.扩容时，capacity=2*capacity+1 (9) 1.3.4.数组默认大小为11 (9) 1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9) 1.4.TreeMap (9) 1.4.1.底层实现为红黑树 (9) 1.4. 2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据 其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10) 1.4.3.接口实现 (10) 1.4.4.Entry (11) 1.5.LinkedHashMap (11) 1.5.1.底层是数组+链表+红黑树+双向链表 (11) 1.5.2.维护链表顺序和访问顺序 (11) 1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在 元素被访问后改变其在双向链表中的位置。 (11) 1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess 方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值 false时，recordAccess方法什么也不会做。 (11) 1.5.5.LRU实现 (11) 2.Collection (11) 2.1.List (12) 2.1.1.ArrayList (12) 2.1.2.LinkedList (13) 2.1.3.CopyOnWriteArrayList (13) 2.2.Set (14) 2.2.1.HashSet (14)

JAVA中常用的集合类型

JAVA常用的高级数据类型——集合类型 一、JAVA语言中的集合类型主要有三种形式：Set（集）、List（列表）、Map（映射），每种类型的集合都包括三部分：接口、实现和算法。 a)集合接口实现集合的操作和集合的具体功能实现细节的相互分离—— Set接口、List接口、Map接口 b)集合的具体功能实现类实质上是各种可重用的数据结构的具体表示 List接口的实现类有ArrayList、LinkedList、Stack和Vector等 集合类，Vector 类提供了实现可增长数组的功能，随着更多元素加 入其中，数组变的更大。在删除一些元素之后，数组变小。 Set接口的实现类有HashSet、LinkedHashSet和TreeSet等集合类 Map接口的实现类有HashMap、Hashtable、LinkedHashMap、Properties和TreeMap等集合类。 c)集合的算法指可以对实现集合接口的各个集合的功能实现类提供如排 序、查找、交换和置换等方面的功能实现。 二、List接口 1.List接口代表有序的集合，可以对List接口代表的有序集合中每个元素 的插入位置进行精确地控制，并利用元素的整数索引（代表元素在集合中的位置）访问元素中的各个成员，List接口代表的集合是允许出现重复元素的。 2.List接口主要成员方法： 1）void add（int index,E element）在列表指定位置插入指定元素 2）E get(int index) 返回结合中指定位置的元素 3）E remove(int index) 移除集合中指定位置的元素 4）E set(int index,E elment) 用指定元素替换集合中指定位置的元素 5）boolean add(E o) 向列表的尾部追加指定的元素 6）boolean contains(Object o) 如果列表包含指定的元素，则返回true。 7）boolean isEmpty() 如果列表不包含元素，则返回 true。 8）int size() 返回列表中的元素数 9）Iterator iterator()返回以正确顺序在列表的元素上进行迭代的迭代器。 3.List的实现类 List在数据结构中分别表现为数组（ArrayList）、向量（Vector）、链表（LinkedList）、堆栈（Stack）和队列等形式。 Vector集合和ArrayList集合都是采用数组形式来保存对象，区别在于ArrayList集合本身不具有线程同步的特性，不能用在多线程的环境下，可以使用ArrayList集合能够节省由于同步而产生的系统性能的开销。而Vector集合实现了对线程同步的支持，因此在多线程并发访问的应用环境下，该集合本身能够保证自身具有线程安全性。在多线程的并发访问中，可以将Vector集合的对象实例设计为类中的成员属性，而应该将ArrayList 集合的对象实例设计为局部对象。 public class UserInfo{ List oneVector=new Vector(); public void execute(){

java集合类总结

1.本讲内容：集合collection （数组和集合90%功能相似，但是最大的区别是，数组在初始化的时候必须确定大小，而集合不用，而且集合是一堆的类，使用起来非常方便。） 讲集合collection之前，我们先分清三个概念： 1colection 集合，可用来存储任何对象的一种数据结构（容器）。 2Collection 集合接口，指的是，是Set、List 和Queue 接口的超类接口 3Collections 集合工具类，指的是类。 SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个Iterator 接口也是必须了解的。 SCJP考试要求了解的类有：HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays 下面给出一个集合之间的关系图： 上图中加粗线的ArrayList 和HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。 我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。 4List 关注事物的索引列表 5Set 关注事物的唯一性 6Queue 关注事物被处理时的顺序 7Map 关注事物的映射和键值的唯一性 一、Collection 接口 Collection接口是Set 、List 和Queue 接口的父接口，提供了多数集合常用的方法声明，包括add()、remove()、contains() 、size() 、iterator() 等。 add(E e) 将指定对象添加到集合中 remove(Object o) 将指定的对象从集合中移除，移除成功返回true,不成功返回false contains(Object o) 查看该集合中是否包含指定的对象，包含返回true,不包含返回flase size() 返回集合中存放的对象的个数。返回值为int clear() 移除该集合中的所有对象，清空该集合。 iterator() 返回一个包含所有对象的iterator对象，用来循环遍历 toArray() 返回一个包含所有对象的数组,类型是Object toArray(T[] t) 返回一个包含所有对象的指定类型的数组 我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：例子1： package edu.xjfu;

Java中的集合类

Java中的集合类 (Collection framework)我们在前面学习过java数组，java数组的程度是固定的，在同一个数组中只能存放相同的类型数据。数组可以存放基本类型的数据，也可以存入对象引用的数据。 在创建数组时，必须明确指定数组的长度，数组一旦创建，其长度就不能改变，在许多应用的场合，一组数据的数目不是固定的，比如一个单位的员工数目是变化的，有老的员工跳槽，也有新的员工进来。 为了使程序方便地存储和操纵数目不固定的一组数据，JDK中提供了java集合类，所有java集合类都位于java.util包中，与java数组不同，java集合类不能存放基本数据类型数据，而只能存放对象的引用。 Java集合类分为三种 Set(集合)：集合中对象不按特定的方式排序。并且没有重复对象，但它有些实现类中的对象按特定方式排序。--无序，不能重复 List（列表）：集合中的对象按照检索位置排序，可以有重复对象，允许按照对象在集中的索引位置检索对象，List和数组有些相似。--有序，可以重复 Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复，它的有些实现类能对集合中的键对象进行排序。 Java的主要集合类的框架图 Collection和Iterator接口 在Collection接口中声明了适用于java集合（只包括Set和List）通用方法。 Collection接口的方法 方法描述

boolean add(Object o) 向集合中加入一个对象的引用 void clear( ) 删除集合中所有对象，即不再对持有对象的引用boolean contains(Object o) 判断在集合中是否含有特定对象的引用 boolean isEmpty() 判断集合是否为空 Iterator iterator( ) 返回一个Iterator对象，可用它来遍历集合中的元素boolean remove(Object o) 从集合中删除一个对象的引用 int size( ) 返回集合中元素的数目 Object [ ] toArray() 返回一个数组，该数组包含集合中的所有元素 Set接口和List即可都继承了Collection接口，而Map接口没有继承Collection接口，因此可以对Set对象和List对象调用以上方法，但是不能对Map对象调用以上方法。Collection接口的iterator()和toArray()方法多用于获得集合中的所有元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。 Iterator隐藏底层集合的数据结构，向客户程序提供了遍历各种类型的集合的统一接口。Iterator接口中声明了如下方法： ●hasNext()：判断集合中的元素是否遍历完毕，如果没有，就返回true。 ●next()：返回下一个元素 ●remove()：从集合中删除上一个由next()方法返回的元素。 注意：如果集合中的元素没有排序，Iterator遍历集合中元素的顺序是任意的，并不一定与像集合中加入的元素的顺序一致。 Set（集） Set是最简单的一种集合，集合中的对象不按特定方式排序，并没有重复对象。Set接口主要有两个实现类：HashSet类还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构，链表数据结构能提高插入核算出元素的性能。TreeSet类实现了SortedSet接口中，具有排序功能。 List(列表) List的主要特征使其元素已先行方式存储，集合中允许存放重复对象。List接口主要的实现类包括： ●ArrayList—ArrayList代表长度可变的数组。允许对元素进行快速的随机访问，但是向 ArrayList中插入与删除元素的速度较慢。 ●LinkedList—在实现中采用链表数据结构。对顺序访问进行了优化，向List中插入和 删除元素的速度较快，随机访问速度则相对较慢，随机访问是指检索位于特定索引位置元素。 Map（映射） Map（映射）是一种吧键对和值对象进行映射的集合。它的每一个元素都包含一对键对象和值对象，而之对象仍可以是Map类型。以此类推，这样就形成了多级映射。向Map集合中加入元素时，必须提供一对键对象和值对象，从Map集合上检索元素只要给出键对象，就会返回值对象。 实例1 CollectionAll.java

Java中集合类用法总结

帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记，添加批注？ Java 中集合?用法总结（转载） wade0564 收录于2010-07-08 阅读数：查看 收藏数：7 公众公开 原文来源　tags ： java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章，想收藏这篇好文章吗，赶快 吧，1分钟拥有自己的个人图书馆！ 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList （异步，线程不安全，空间用完时自动增长原容量一半）│└Vector （同 步，线程安全，空间用完时自动增长原容量一倍）│　└Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口： | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条 | 目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为 可终止的，被终 | 止，然后被回收。丢弃某个键时， 其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序，或?根据创建映射时提供的 Comparator 进行 排序，具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了 | 非同步和允许 使用 null 之外，HashMap 类与 Hashtable ?致相同。）此类不保证映射的顺序，特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的，或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet 、keySet 和 values 方法返回 ）进行迭代时，此顺序就会反映 出来。要采用此排序方式，还需要提供一些其他操作（此接?是 SortedSet 的对应映 射）。 Collection 接口： | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味，有多少男人可以读懂？珍稀的白头叶猴（组图）三鹿门事件之——中国，...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品：守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语，十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事

Java类集合之List详解

Java集合框架之List详解 ArrayList 首先我们熟悉下ArrayList类中常用方法的使用。 1）添加：public boolean add（Object e)：将指定的元素（对象）添加到此列表的尾部 2）获取：public Object get(int index)：返回此列表中指定位置（索引）上的元素。 3）元素的个数：public int size()：返回此列表中的元素数。 4）清空：public void clear()：移除此列表中的所有元素。此调用返回后，列表将为空。 5）是否为空：public boolean isEmpty()：如果此列表中没有元素，则返回 true 6）移除（删除）：public E remove(int index)：移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。 7）移除（重载）：public boolean remove(Object o)：移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true （或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。8）获得索引：public int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足(o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。 如何使用这些方法，代码如下： import java.util.ArrayList; public class ArrayListTest { public static void main(String[] args) { ArrayList list=new ArrayList(); /* * 添加 */ list.add("hello"); list.add(" world"); list. add(" welcome"); /* * 获得 */ String s1=(String)list.get(0);

java常用的几种集合

集合类是放在java.util.*；这个包里。集合类存放的都是对象的引用，而非对象本身，为了说起来方便些，我们称集合中的对象就是指集合中对象的引用（reference)。引用的概念大家不会忘了吧，在前边我们讲数据类型时讲的。 集合类型主要有3种：set(集）、list(列表）、map(映射)和Queue（队列）。//队列为jdk5中的加上的 (1) Set 集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。我们知道数学上的集合也是Set这个，集合里面一定是没有重复的元素的。 （2）List 列表（List）的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的Set是不同的。它是链表嘛，一条链肯定有顺序这个顺序就不一定了。 （3）Map 映射（Map），这个在java里不是地图的意思，其实地图也是映射哈。它里面的东西是键－值对（key-value）出现的，键值对是什么呢？举个例子，比如我们查字典，用部首查字法。目录那个字就是键，这个字的解释就是值。键和值成对出现。这样说可以理解吧。这也是很常用的数据结构哦。 （4）Queue 在jdk5.0以前，通常的实现方式是使用java.util.List集合来模仿Queue。Queue的概念通过把对象添加（称为enqueuing的操作）到List的尾部（即Queue的后部）并通过从List的头部（即Queue的前部）提取对象而从List中移除（称为dequeuing的操作）来模拟。你需要执行先进先出的动作时可以直接使用Queue接口就可以了。 这4个东西，有时候功能还不太完善，需要有些子类继承它的特性。Set的子接口有TreeSet,SortedSet，List的有ArrayList等，Map里有HashMap,HashTable等，Queue里面有BlockingQueue等。我们来看看例子吧：

java集合-练习题解析

1. 填空 Collection 接口的特点是元素是___无序可重复______； List 接口的特点是元素__有__（有|无）顺序，_可以___（可以|不可以）重复； Set 接口的特点是元素__无___（有|无）顺序，____不可以__（可以|不可以）重复；Map 接口的特点是元素是__key、value映射______，其中__value__可以重复，_key___不可以重复。 2. （List）有如下代码 import java.util.*; public class TestList{ public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(1, “Learn”); list.add(1, “Java”); printList(list); } public static void printList(List list){ //1 for(int i = 0; i< list.size();i++){ System.out.println(list.get(i)); } for(Object o : list) { System.out.println(o); } Iterator itor = list.iterator(); while(itor.hasNext()){ System.out.println(itor.next()); } } } 要求： 1) 把//1 处的代码补充完整，要求输出list 中所有元素的内容 2) 写出程序执行的结果Hello Java Learn World 3) 如果要把实现类由ArrayList 换为LinkedList，应该改哪里？ArrayList 和LinkedList 使用上有什么区别？实现上有什么区别？ 4) 如果要把实现类由ArrayList 换为Vector，应该改哪里？ArrayList 和Vector 使 用上有什么区别？实现上有什么区别？ 3. （List）写出下面程序的运行结果

Java集合体系结构分析与比较

Java集合体系结构分析与比较 1. Java集合框架图 Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型. Java集合框架图如下: 集合接口:6个接口(短虚线表示),表示不同集合类型,是集合框架的基础. 抽象类:5个抽象类(长虚线表示),对集合接口的部分实现.可扩展为自定义集合类. 实现类:8个实现类(实线表示),对接口的具体实现. 在很大程度上,一旦您理解了接口,您就理解了框架.虽然您总要创建接口特定的实现,但访问实际集合的方法应该限制在接口方法的使用上;因此,允许您更改基本的数据结构而不必改变其它代码. Java集合的顶层接口是Collection,Collection 接口是一组允许重复的对象.Java集合框架主要由以下三个接口组成: (1) Set 接口继承Collection,但不允许重复,使用自己内部的一个排列机制. (2) List 接口继承Collection,允许重复,以元素安插的次序来放置元素,不会重新排列.

(3) Map接口是一组成对的键-值对象,即所持有的是 key-value pairs.Map中不能有重复的key,拥有自己的内部排列机制. 容器中的元素类型都为Object,从容器取得元素时,必须把它转换成原来的类型.简化后的集合框架图如下: 2. 接口Collection 用于表示任何对象或元素组,想要尽可能以常规方式处理一组元素时,就使用这一接口. (1) 单元素添加、删除操作: boolean add(Object o):将对象添加给集合 boolean remove(Object o): 如果集合中有与o相匹配的对象,则删除对象o (2) 查询操作: int size():返回当前集合中元素的数量 boolean isEmpty():判断集合中是否有任何元素 boolean contains(Object o):查找集合中是否含有对象o Iterator iterator():返回一个迭代器,用来访问集合中的各个元素 (3) 组操作:作用于元素组或整个集合 boolean containsAll(Collection c): 查找集合中是否含有集合c 中所有元素 boolean addAll(Collection c) : 将集合c 中所有元素添

Java集合框架的知识总结

Java集合框架的知识总结 说明：先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。 1、综述 所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。 当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。 Java的集合类主要由两个接口派生而出：Collection和Map，Col lection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。

Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。 Map实现类用于保存具有映射关系的数据（key-value）。 Set、List和Map可以看做集合的三大类。 List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。 Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。 Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的k ey来访问其value。 对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayLi st和HashMap三个实现类。（并发控制的集合类，以后有空研究下）。2、Collection接口 Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。Collection接口定义操作集合元素的具体方法大家可以参考API文档，这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。 public class TestCollection {

JAVA中的集合类

为什么要使用集合类 当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。 理解集合类 集合类存放于java.util包中。 集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。 集合类型主要有3种：set(集）、list(列表）和map(映射)。 (1)集 集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。 对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。 集也有多种变体，可以实现排序等功能，如TreeSet，它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口，也就是加入了对象比较的方法。通过对集中的对象迭代，我们可以得到一个升序的对象集合。(2)列表 列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。 列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。关于实现列表的集合类，是我们日常工作中经常用到的，将在后边的

笔记详细介绍。 (3)映射 映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。 关键字本身并不能决定对象的存储位置，它需要对过一种散列(hashing)技术来处理，产生一个被称作散列码(hash code)的整数值，散列码通常用作一个偏置量，该偏置量是相对于分配给映射的内存区域起始位置的，由此确定关键字/对象对的存储位置。理想情况下，散列处理应该产生给定范围内均匀分布的值，而且每个关键字应得到不同的散列码。 集合类简介 java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍 集： HashSet：使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的. TreeSet：在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

java集合详解

集合 版本号：1.0 作者:huangdos 日期：2006年6月06日

摘要 摘要内容 Java里面最重要，最常用也就是集会一部分了。能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java中的集合是如何实现的，以及他们的实现原理。 关键字： Collection , List ,Set , Map , 集合，框架。

目录 1集合框架 (2) 1.1集合框架概述 (2) 1.1.1容器简介 (2) 1.1.2容器的分类 (3) 1.2C OLLECTION (5) 1.2.1常用方法 (5) 1.2.2迭代器 (8) 1.3L IST (10) 1.3.1概述 (10) 1.3.2常用方法 (10) 1.3.3实现原理 (14) 1.4M AP (18) 1.4.1概述 (18) 1.4.2常用方法 (18) 1.4.3Comparable 接口 (23) 1.4.4实现原理 (24) 1.4.5覆写hashCode() (29) 1.5S ET (32) 1.5.1概述 (32) 1.5.2常用方法 (33) 1.5.3实现原理 (36) 1.6总结:集合框架中常用类比较 (38) 2练习 (38) 3附录：排序 (40)

集合 1集合框架 1.1集合框架概述 1.1.1容器简介 到目前为止，我们已经学习了如何创建多个不同的对象，定义了这些对象以后，我们就可以利用它们来做一些有意义的事情。 举例来说，假设要存储许多雇员，不同的雇员的区别仅在于雇员的身份证号。我们可以通过身份证号来顺序存储每个雇员，但是在内存中实现呢？是不是要准备足够的内存来存储1000个雇员，然后再将这些雇员逐一插入？如果已经插入了500条记录，这时需要插入一个身份证号较低的新雇员，该怎么办呢？是在内存中将500条记录全部下移后，再从开头插入新的记录? 还是创建一个映射来记住每个对象的位置？当决定如何存储对象的集合时，必须考虑如下问题。 对于对象集合，必须执行的操作主要以下三种： ◆添加新的对象 ◆删除对象 ◆查找对象 我们必须确定如何将新的对象添加到集合中。可以将对象添加到集合的末尾、开头或者中间的某个逻辑位置。 从集合中删除一个对象后，对象集合中现有对象会有什么影响呢？可能必须将内存移来移去，或者就在现有对象所驻留的内存位置下一个“洞”。 在内存中建立对象集合后，必须确定如何定位特定对象。可建立一种机制，利用该机制可根据某些搜索条件（例如身份证号）直接定位到目标对象；否则，便需要遍历集合中的每个对象，直到找到要查找的对象为止。 前面大家已经学习过了数组。数组的作用是可以存取一组数据。但是它却存在一些缺点，使得无法使用它来比较方便快捷的完成上述应用场景的要求。 1.首先，在很多数情况下面，我们需要能够存储一组数据的容器，这一点虽然数组可以实现，但是如果我们 需要存储的数据的个数多少并不确定。比如说：我们需要在容器里面存储某个应用系统的当前的所有的在线用户信息，而当前的在线用户信息是时刻都可能在变化的。也就是说，我们需要一种存储数据的容器，它能够自动的改变这个容器的所能存放的数据数量的大小。这一点上，如果使用数组来存储的话，就显得十分的笨拙。 2.我们再假设这样一种场景：假定一个购物网站，经过一段时间的运行，我们已经存储了一系列的购物清单 了，购物清单中有商品信息。如果我们想要知道这段时间里面有多少种商品被销售出去了。那么我们就需要一个容器能够自动的过滤掉购物清单中的关于商品的重复信息。如果使用数组，这也是很难实现的。 3.最后再想想，我们经常会遇到这种情况，我知道某个人的帐号名称，希望能够进一步了解这个人的其他的 一些信息。也就是说，我们在一个地方存放一些用户信息，我们希望能够通过用户的帐号来查找到对应的该用户的其他的一些信息。再举个查字典例子：假设我们希望使用一个容器来存放单词以及对于这个单词的解释，而当我们想要查找某个单词的意思的时候，能够根据提供的单词在这个容器中找到对应的单词的解释。如果使用数组来实现的话，就更加的困难了。 为解决这些问题，Java里面就设计了容器集合，不同的容器集合以不同的格式保存对象。

常用的几种java集合类总结

一：直观框架图 简单版： 详细版： Java集合框架 Java集合框架主要包括两种类型的容器，一种是集合（Collection），另一种是图（Map）。Collection接口又有3种子类型，List、Set和Queue，再下面是一些抽象类，最后是具体实现类，常用的有ArrayList、lixxxxnkedList、HashSet、lixxxxnkedHashSet、HashMap、lixxxxnkedHashMap等等。Map常用的有HashMaplixxxxnkedHashMap等。 二、Collection接口 1.List List接口扩展自Collection，它可以定义一个允许重复的有序集合，从List接口中的方法来看，List接口主要是增加了面向位置的操作，允许在指定位置上操作元素，同时增加了一个能够 双向遍历线性表的新列表迭代器ListIterator。AbstractList类提供了List接口的部分实现，

AbstractSequentialList扩展自AbstractList，主要是提供对链表的支持。下面介绍List接口的 两个重要的具体实现类，也是我们可能最常用的类，ArrayList和lixxxxnkedList。 1.1ArrayList 通过阅读ArrayList的源码，我们可以很清楚地看到里面的逻辑，它是用数组存储元素的，这 个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并 将当前数组中的所有元素都复制到新数组中。假设第一次是集合没有任何元素，下面以插入 一个元素为例看看源码的实现。 1. 2. 1、找到add()实现方法。 3. 4. 5. 6. public boolean add(E e) { 7. 8. ensureCapacityInternal(size + 1); // Increments modCount!!

JAVA集合试题库完整

集合 一、第一模块：知识点讲解 图解集合 Set HashMap TreeMap LinkedHashMap ArrayList LinkList HashSet TreeSet LinkedHashSet Comparable comparator 1、集合的由来：我们学的语言是面向对象的语言，为了方便对多个对象进行操作， 我们就必须把对象存储。而要存储多个对象，就不能是一个基本变量，而应该是一个容器类型的变量。这样就引入了集合。 *以前接触过得容器：数组、StringBuffer 等 由于StringBuffer 的结果是一串字符，不一定能满足我们的要求，所以我们只能选择数

组，这就是对象数组。而对象数组不能适应变化的需求，因为数组的长度是固定。 2、数组和集合的区别 ①长度区别 集合的长度可变 数组长度不可变 ②内容区别 集合可以存储不同类型的元素 数组存储的是同一种类型的元素 ③元素的数据类型问题 数组可以存储基本数据类型也可以存储引用数据类型 集合只能存储引用类型 ，Java提供了不同的集合类，这多个集合的数据结构不同*数据结构:数据的存储方式 Java提供的多种集合类，他们的数据结构不同,但是，他们肯定有共性的内容（存储、获取、判断等）。通过不断的向上提取，我们就能够得到一个集合的继承体系结构图。 把上面这段话转化为图形的形式： collection

ArrayList Vector LinkedList HashSet TreeSet 通过这个图可以清楚的理解集合 现在我们从最低层开始学习

一、Collection(接口Java.util ) 1、功能：①：添加 boolean add(Object obj) 添加一个元素 boolean addAll(Collection c)添加一个集合的元素 ②：删除 void clear() 移除所有元素 boolean remove(Object obj) 移除一个元素

Java集合Collection、List、Set、Map使用详解

Java集合排序及java集合类详解(Collection, List, Set, Map) 摘要内容 集合是Java里面最常用的，也是最重要的一部分。能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java中的集合是如何实现的，以及他们的实现原理。 目录 1 集合框架 (1) 1.1 集合框架概述 (2) 1.1.1 容器简介 (2) 1.1.2 容器的分类 (4) 1.2 Collection (6) 1.2.1 常用方法 (6) 1.2.2 迭代器 (8) 1.3 List (10) 1.3.1 概述 (10) 1.3.2 常用方法 (11) 1.3.3 实现原理 (15) 1.4 Map (18) 1.4.1 概述 (18) 1.4.2 常用方法 (18) 1.4.3 Comparable 接口 (23) 1.4.4 实现原理 (24) 1.4.5 覆写hashCode() (29) 1.5 Set (33) 1.5.1 概述 (33) 1.5.2 常用方法 (33) 1.5.3 实现原理 (38) 1.6 总结:集合框架中常用类比较 (39) 2 练习 (40) 3 附录：排序 (41) 1集合框架

1.1集合框架概述 1.1.1容器简介 到目前为止，我们已经学习了如何创建多个不同的对象，定义了这些对象以后，我们就可以利用它们来做一些有意义的事情。 举例来说，假设要存储许多雇员，不同的雇员的区别仅在于雇员的身份证号。我们可以通过身份证号来顺序存储每个雇员，但是在内存中实现呢？是不是要准备足够的内存来存储1000个雇员，然后再将这些雇员逐一插入？如果已经插入了500条记录，这时需要插入一个身份证号较低的新雇员，该怎么办呢？是在内存中将500条记录全部下移后，再从开头插入新的记录? 还是创建一个映射来记住每个对象的位置？ 当决定如何存储对象的集合时，必须考虑如下问题。 对于对象集合，必须执行的操作主要以下三种： ◆添加新的对象 ◆删除对象 ◆查找对象 我们必须确定如何将新的对象添加到集合中。可以将对象添加到集合的末尾、开头或者中间的某个逻辑位置。 从集合中删除一个对象后，对象集合中现有对象会有什么影响呢？可能必须将内存移来移去，或者就在现有对象所驻留的内存位置下一个“洞”。 在内存中建立对象集合后，必须确定如何定位特定对象。可建立一种机制，利用该机制可根据某些搜索条件（例如身份证号）直接定位到目标对象；否则，便需要遍历集合中的每个对象，直到找到要查找的对象为止。 前面大家已经学习过了数组。数组的作用是可以存取一组数据。但是它却存在一些缺点，使得无法使用它来比较方便快捷的完成上述应用场景的要求。 1.首先，在很多数情况下面，我们需要能够存储一组数据的容 器，这一点虽然数组可以实现，但是如果我们需要存储的数据 的个数多少并不确定。比如说：我们需要在容器里面存储某个

Java集合类实例解析

Jaｖa集合类实例解析 ?我们看一个简单的例子,来了解一下集合类的基本方法的使用:?import java、utiｌ、*;?pｕblic cｌasｓCｏlｌｅctionToAｒｒaｙ｛?puｂlic ｓtaｔicｖｏｉd maｉn(Strinｇ[] ar ｇs)｛ Cｏllｅｃtiｏnｃollection１=ｎew ArｒaｙＬist();／/创建一个集合对象 cｏｌleｃｔｉon1、adｄ(”０00”);/／添加对象到Collectｉon集合中 collｅctioｎ１、ａｄd("１１1”); collection1、aｄd(”２２2＂);?Syｓtem、ouｔ、priｎtlｎ(＂集合cｏｌlecｔｉon１的大小:"+ｃoｌlｅｃtiｏｎ１、size()); ?Ｓｙstｅｍ、ｏut、pｒintｌn(＂集合cｏllｅcｔｉon1的内容:”+coｌleｃtioｎ1); cｏllｅction1、remoｖｅ(”０00");//从集合collectiｏｎ１中移除掉”000” 这个对象 Systｅｍ、oｕt、prｉｎtｌn(”集合collection1移除0００后的内容:＂+collｅｃtioｎ1); Syｓtｅｍ、out、prｉｎtｌｎ(”集合colleｃｔion1中是否包罗000 :"＋ｃoｌlection１、cｏntains(＂000＂));?Syｓｔeｍ、out、ｐｒintln(＂集合coｌｌｅctｉｏn１中是否包罗１11 :”＋coｌlecｔｉｏn1、contaｉnｓ(”111”)); ?Ｃoｌlｅｃｔion cｏlleｃtiｏn2=nｅｗArrayList(); cｏllｅｃtｉｏn２、ａdｄAll(ｃollecｔｉoｎ1);/／将coｌleｃtiｏn1 集合中的元素全部都加到coｌleｃtion2中?Systeｍ、ｏｕｔ、pｒiｎtln("集合ｃollection2的内容:”+ｃollectｉｏn2); ｃollection2、clear();//清空集合cｏllectｉon１中的元素?Sｙsｔem、ouｔ、pｒintln(”集合collｅｃtioｎ2是否为空:”+ｃｏｌlection2、ｉsＥmpty()); ?//将集合cｏllecｔｉｏn1转化为数组 Ｏbｊｅct s［］＝colleｃtiｏn1、toArray(); ?ｆor(intｉ＝０;i〈ｓ、leｎｇtｈ;i＋+)｛ ?} Ｓystem、ｏut、pｒｉntln(s[ｉ]); ?｝? } 运行结果为:?集合coｌｌecｔion１的大小:3?集合ｃｏｌleｃtｉｏn1的内容:［000, 11１, 2２2］?集合collectioｎ1移除000 后的内容:[111,2２2] ?集合cｏｌleｃtion1中是否包罗000 :false ?集合collectｉon1中是否包罗11１:truｅ 集合ｃｏｌｌectｉoｎ2的内容:［１1１, 222］?集合cｏllection2是否为空:ｔrue ?１1１?222?这个地方需要注意的是,Coｌlectｉｏｎ它仅仅只是一个接口,而我们真正使用的时候,确是创建该接口的一个实现类、做为集合的接口,它定义了所有属于集合的类所都应该具有的一些方法、如AｒｒａｙList (列表)类是集合类的一种实现方式。? 下面,我们看一个关于迭代器的简单使用:?iｍporｔjavａ、ｕｔｉl、ArrayList; ?iｍpoｒt java、ｕtil、Cｏlｌectiｏｎ; ｉmport javａ、utｉl、Iteｒator;?publiｃｃlａsｓItｅｒａtoｒDeｍｏ{ pｕbｌｉc sｔatiｃvoiｄmaｉｎ(Sｔｒiｎg[] ａrgs) ｛?Coｌｌectｉｏn cｏｌｌeｃt ｉon ＝nｅw AｒrａyLｉsｔ(); ?coｌlｅctｉoｎ、ａdd("ｓ1”); ?collｅcｔion、add(”s2"); ?collｅｃtiｏｎ、aｄd(”s3”); Itｅrａtor ｉtｅrator =cｏｌlecｔion、iteｒatｏr();//得到一个迭代器?wｈile (iterａtor、has Ｎext()) {／/遍历?Object ｅlｅmeｎｔ＝iteraｔｏｒ、nexｔ(); ?Ｓyｓtem、oｕt、pｒｉn ｔｌｎ(”ｉterａtor = " +elｅment); ｝?iｆ(ｃｏlleｃtiｏn、isEmpty()) Systｅm、ｏuｔ、printｌn(”ｃoｌlectioｎｉｓＥmpｔy！＂); eｌｓe ?Sｙstem、out、ｐriｎtlｎ(”coｌleｃｔｉon iｓnot Eｍpty! ｓｉze="+cｏllection、sizｅ());