java中的集合操作类（未完待续）

申明：

实习生的肤浅理解，如发现有错误之处，还望大牛们多多指点

废话

其实我写java的后台操作，我每次都会遇到一条语句：List<XXXXX> list = new ArrayList<XXXXX>();

但是我仅仅只是了解，list这个类是一个可变长用来存储的对象实例的类，我甚至觉得这个List对象可以理解成数组，但是却又与java中咱们正常理解的数组很多的不同，比如说，他的长度可以随着需要自动增长，比如说，实例化一个List类就和咱们声明数组的时候是不一样的！

今天的实习生活过的有点枯燥，我就打开了eclipse，看同事们写的代码，无意间又看到了这句话，所以决定学习一下这一类的操作——java中的容器类（集合类）

正文

先偷个图来吧，我不会告诉你我是在百度百科里面偷的

如何，我们可以看出，java中的集合操作主要有两大类：Collection集合与Map映射

Collection

Collection是一个顶层的接口，他是java集合的一个抽象，在此基础上派生出了两个子接口，分别为：List与Set

List

List接口，特点有序的，所存储的对象可以为null，并且允许重复，这点与set有很大区别，Set是不允许重复的，List很类似于数组，对于List对象的访问可以通过类似于数组下标去访问，但是是通过get(int index)方法进行访问的，同时其实际长度也很类似于数组，可以通过size()返回其实际长度，除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个
ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

list常见方法：

add(E e) ：向列表的尾部添加指定的元素

add(int index,
E element) ： 在列表的指定位置插入指定元素

addAll(Collection<? extends
E> c) ：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定                                                                      collection 的迭代器返回这些元素的顺序

addAll(int index,
Collection<? extends E> c) ：

将指定 collection 中的所有元素都插入到列表中的指定位置与数组相比较，list的查询效率                             高，但是插入和删除的效率较低，因为插入和删除会引起其他元素的位置变化

clear() ：从列表中移除所有元素

contains(Object o) ：如果列表包含指定的元素，则返回
true

containsAll(Collection<?> c) ：如果列表包含指定 collection 的所有元素，则返回
true

get(int index) ： 返回列表中指定位置的元素

indexOf(Object o) ：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1

iterator() ： 返回按适当顺序在列表的元素上进行迭代的迭代器

lastIndexOf(Object o) ：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

listIterator() ：返回此列表元素的列表迭代器（按适当顺序）

listIterator(int index) ：返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始

remove(int index) ： 移除列表中指定位置的元素

remove(Object o) ：从此列表中移除第一次出现的指定元素

removeAll(Collection<?> c) ： 从列表中移除指定 collection 中包含的其所有元素

retainAll(Collection<?> c) ： 仅在列表中保留指定 collection 中所包含的元素

set(int index,
E element) ：用指定元素替换列表中指定位置的元素

size() ：返回列表中的元素数

subList(int fromIndex,int toIndex)返回列表中指定的
fromIndex（包括 ）和 toIndex（不包括）之间的部分视图

toArray() ：返回按适当顺序包含列表中的所有元素的数组

详细方法信息还是参考一下API里面的吧

实现list接口的主要有：ArrayList、LinkedList、Vector和Stack

ArrayList

通过名字就能知道这是个啥了吧，灰常类似于数组

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步，仅有Vector实现了同步(线程安全)，每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小，默认值好像是10。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法（设定长度最小值）来增加ArrayList的容量以提高插入效率。和LinkedList一样，ArrayList也是非同步的（unsynchronized）

案例：

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
	public static int flg = 0;
	public int self = 0;

	public Test() {
		++flg;
		self = flg;
		System.out.println("已经初始化了:" + flg + "个实例");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 加入范式Test表示这里存储Test类型，并且可以获得具体值之后，可以访问对象的方法和属性 比如下述：list.get(i).flg
		 * 若不添加范式，则无法访问该self属性或者其他方法
		 */
		List<Test> list = new ArrayList<Test>();
		for (int i = 0; i < 5; i++) {
			list.add(new Test());
			System.out.println(list.get(i).self);
		}
		list.add(new Test());
		System.out.println(list.get(list.size() - 1).self);
		list.addAll(list);
		System.out.println(list.size());
		list.add(0, null);
		System.out.println(list.get(0));
		// 使用迭代器去遍历
		Iterator<Test> myiterator = list.listIterator();
		Test test;
		while (myiterator.hasNext()) {
			test = myiterator.next();
			if (test != null)
				System.out.println(test.self);
			else
				System.out.println(test);
		}
	}
}

LinkedList

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

List list = Collections.synchronizedList(new LinkedList(...));

案例：有待补充

Vector

Vector类似于ArrayList，但是确实同步的，也就是说他是线程安全的，换句话说就是如果Vector创建了一个迭代器，那么这个迭代器正在使用的时候，另一个线程改变了这个Vector的状态，那么就会产生异常

案例：有待补充

Stack

栈这个东西，在数据结构里面学过的，以前很熟悉，可是现在我就陌生了，大概的知道这个有一个特性：LIFO后进先出，在java中Stack是基于Vector的，除了基本的方法push()和pop()方法，java的Stack还提供了一个peek()获取栈顶元素值的方法，empty方法判断是否为空，search方法寻找某个元素在栈中的位置等

案例：有待补充

Set

Set是一种不可重复的Collection接口，set的检索效率相对较低，而与list对比，插入和删除的效率较高，不会引起其他元素位置的变化，Set是无序的，Set和List最大的区别是Set不允许重复

我们重点要记住这家伙不能重复

Set不允许重复的原因是，他是基于Map实现的，而Map中的key是不允许重复的，Set中使用的仅仅是Map中的key

Set常见的方法，详细情况请参考Java语言的API

add(E e) ：如果 set 中尚未存在指定的元素，则添加此元素

addAll(Collection<? extends
E> c) ：如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中

clear() ：移除此 set 中的所有元素

contains(Object o) ： 如果 set 包含指定的元素，则返回
true

containsAll(Collection<?> c) ：如果此 set 包含指定 collection 的所有元素，则返回
true

equals(Object o) ：比较指定对象与此 set 的相等性

isEmpty() ：如果 set 不包含元素，则返回
true

iterator() ：返回在此 set 中的元素上进行迭代的迭代器

remove(Object o) ： 如果 set 中存在指定的元素，则将其移除

removeAll(Collection<?> c) ：移除 set 中那些包含在指定 collection 中的元素

retainAll(Collection<?> c) ： 仅保留 set 中那些包含在指定 collection 中的元素

size() ：返回 set 中的元素数

toArray() ：返回一个包含 set 中所有元素的数组

比较蛋疼，set中是没有get方法获取元素对象的，只能通过迭代器来访问数据

我们常见的Set实现类有：TreeSet、HashSet和LinkedHashSet

TreeSet

TreeSet居然是有序的，默认是自然序列的，排序方式可以使用自带的，也可以使用自定义，在创建TreeSet的时候，传递一个自定义的排序规则对象即可，另外既然它是有序的，有是基于TreeMap实现的，那么TreeSet中的元素对象必须实现Comparable接口，但是如果是字符串对象的话，呵呵，不需要了，String本身就已经实现了Comparable接口了

案例：有待补充

HashSet

和TreeSet一样只能通过迭代器来访问数据，HashSet是基于HashMap实现的，但是是无序的，常用的方法和Set接口的相近，记住一点，访问必须通过迭代器，迭代的顺序不能保证是和插入的顺序一致，这点与LinkedHashSet正好是相反的

案例：有待补充

LinkedHashSet

LinkedHashSet是一个链表结构，与上述一致，通过迭代器遍历，但遍历的顺序和插入的顺序一致

案例：有待补充

Map

2014年8月26日23:41:50

明天在查询一下Map的资料吧，写到这了，发现还有很多东西需要继续学习，比如迭代器，比如泛型，呵呵，小菜鸟，不会飞，我只能慢慢爬

时间： 2024-12-19 08:15:13

java中的集合操作类（未完待续）的相关文章

Filesystem-Hierarchy-Standard（FHS） 文件系统层次结构标准2.3中英对照版（未完待续）

本想把原文翻译一遍,一来学习学习Linux的文件系统结构,二来熟悉下专业英语.经历了一个月之久,才翻译到一半.再也没有空闲时间待在学校了,不知道什么时间才能翻译完.先在这里发表一下,给有需要的同志们方便学习,也给自己一个提醒,告诉自己这里还有一件未完成的事..感謝大家支持 --------------------------------------以下是FHS-2.3正文内容----------------------------------------------- Filesystem Hi

Python语言基础与应用 (P23)上机练习：容器类型操作（未完待续）

上机练习:容器类型操作〉 列表.元组基本操作+, *, len(), [], in 1 Python 3.7.0 (default, Jun 28 2018, 08:04:48) [MSC v.1912 64 bit (AMD64)] :: Anaconda, Inc. on win32 2 Type "help", "copyright", "credits" or "license" for more informatio

java开发设计数据库细节（未完待续）

1.create_time(创建时间)不能勾选"根据当前时间戳更新",否则每更新一次信息,创建时间就会改变一次.2.update_time(最后一次更新时间)一定要勾选"根据当前时间戳更新",否则每次更新信息,update_time都是不会改变的 原文地址:https://blog.51cto.com/13678728/2456635

Java中的集合和常用类

Java中的常用类: ? Object类 ? Math类 ? String类和StringBuffer类(字符串) ? 8种基本类型所对应的包装类 ? java.util包中的类——Date类 Object类: Object类是Java语言程序中所有类的父类,即承自Object类.Object类中包含了Java语言类中的所有的公共属性. ? toString()方法 ? equals()方法 ? getClass()方法 ? clone()方法 ? finalize()方法 枚举类: 用于储存变

集合框架，未完

集合类的由来: 对象用于封装特有数据,对象多了需要存储,如果对象的个数不确定,就使用集合容器进行存储. 集合特点:1,用于存储对象的容器.(存的是对象的地址)2,集合的长度是可变的.3,集合中不可以存储基本数据类型值. (只能存对象) Collection子接口 Collection接口 |--List接口:有序(存入和取出的顺序一致),元素都有索引(角标),元素可以重复. |--Set接口:无序,元素不能重复. List 有一个共性特点就是都可以操作角标,list集合可以完成对元素的增删改查.

java中常用的工具类（二）

下面继续分享java中常用的一些工具类,希望给大家带来帮助! 1.FtpUtil Java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

菜鸟日记之 java中的集合框架

java中的集合框架图 如图所示:java中的集合分为两种Collection和Map两种接口 可分为Collection是单列集合和Map的双列集合 Collection单列集合:继承了Iterator接口所以具有了iterator()方法 ,该方法返回一个Iterator<T>,这个接口具有 HasNext (),next(),remove()3个方法可以在实现类里完成实现. hasNext():判断是否有下一个元素 cusor是当前的操作下标 next():读取下一个元素 remove(

java中各种集合的用法和比较

一,java中各种集合的关系图 Collection       接口的接口     对象的集合 ├ List             子接口         按进入先后有序保存   可重复 │├ LinkedList    接口实现类     链表     插入删除   没有同步   线程不安全 │├ ArrayList     接口实现类      数组     随机访问   没有同步   线程不安全 │└ Vector        接口实现类       数组              

Java中的集合框架（上）

Java中的集合框架概述 集合的概念: Java中的集合类:是一种工具类,就像是容器,存储任意数量的具有共同属性的对象. 集合的作用: 1.在类的内部,对数据进行组织: 2.简单的快速的搜索大数据量的条目: 3.有的集合接口,提供了一系列排列有序的元素,并且 可以在序列中间快速的插入或删除有关的元素. 4.有的集合接口,提供了映射关系,可以通过 关键字(key)去快速查找到对应的唯一对象,而这个关键字可以是任意类型. 与数组的对比一为何选择集合而不是数组 1.数组的长度固定,集合长度可变 2.数