黑马程序员---java集合总结

---------------------- Java开发、Android培训、期待与您交流！ ----------------------

1. java集合

Java数组的长度是固定的，在同一个数组中只能存放相同类型的数据，数组可以存放基本类型数据，也可以存放引用类型的数据。在创建Java数组时，必须明确指定数组的长度，数组一旦创建，其长度就不能被改变。但是在许多场合下，一组数据的数目是不固定的，如公司的员工数量，考虑人员变动的不确定性。

为了方便的存放和操纵数目不定的一组数据，JDK类库提供了Java集合，所有Java集合类都位于java.util包中。与Java数组不同，Java集合中不能存放基本类型数据，而只能存放对象的引用。Java集合主要分为以下三种类型：

Set（集）：集合中的对象不按特定方式排序，并且没有重复对象。它的有些实现类能对集合中的对象按特定方式排序。

List（列表）：集合中的对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象。List与数组有些相似。

Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。它的有些实现类能对集合中的键对象进行排序。

1.1 Set(集)

(1) Set的一般用法

Set接口主要有两个实现类：HashSet和TreeSet。HashSet类按照哈希算法来存取集合中的对象，存取速度呢比较快。HashSet还有一个子类LinkedHashSet类，它不仅实现了哈希算法，而且实现了链表数据结构，链表数据结构能提高插入和删除元素的性能。TreeSet类实现了SortedSet接口，具有排序功能。

package code.javaoop.collection;   import static net.mindview.util.Print.print; import java.util.HashSet; import java.util.Set; public class SetTest {     public static void main(String[] args) {         SetTest setTest = new SetTest();         setTest.testOne();         setTest.testTwo();     }       public void testOne() {         Set<String> set = new HashSet<String>();         String s1 = new String("hello");         String s2 = s1;         String s3 = new String("world.");         set.add(s1);         set.add(s2);         set.add(s3);         print("testone: " + set.size());     }       public void testTwo() {         Set<String> set = new HashSet<String>();         String s1 = new String("hello");         String s2 = new String("hello");         set.add(s1);         set.add(s2);         print("testtwo: " + set.size());     } }

(2) 判断依据是什么？具体判断的方式如下：

public boolean according(Set set, String newStr) {         boolean isExist = false;         Iterator<String> it = set.iterator();         while (it.hasNext()) {             String oldStr = it.next();             if (newStr.equals(oldStr)) {                 isExist = true;                 break;             }         }         return isExist;     }

 

1.1.1 HashSet的一般用法

HashSet类按照哈希算法来存取集合中的对象，具有很好的存取和查找性能。当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获取哈希码，然后根据这个哈希码进一步计算出对象在集合中的位置。

为了保证HashSet能正常工作，要求当两个对象用equals()方法比较的结果为true时，它们的哈希码也相等，也就是说：customer1.equals(customer2)为true，那么customer1.hashCode()==customer2.hashCode()也为true。

package code.javaoop.collection;   import static net.mindview.util.Print.print; import java.util.HashSet; import java.util.Set; public class Customer {     private String name;     private int age;     public Customer(String name, int age) {         this.name = name;         this.age = age;     }     public String getName() {         return name;     }     public void setName(String name) {         this.name = name;     }       public int getAge() {         return age;     }     public void setAge(int age) {         this.age = age;     }     @Override     public boolean equals(Object o) {         if (this == o) {             return true;         }         if (!(o instanceof Customer)) {             return false;         }         final Customer other = (Customer)o;           if (this.name.equals(other.getName()) && this.age == other.getAge()) {             return true;         } else {             return false;         }     }       //重写hashCode()方法！     /*@Override     public int hashCode() {         int result;         result = (name == null ? 0 : name.hashCode());         result = 29 * result + age;         return result;     }*/       public static void main(String[] args) {         Set<Customer> set = new HashSet<Customer>();         Customer customer1 = new Customer("Tom", 15);         Customer customer2 = new Customer("Tom", 15);         set.add(customer1);         set.add(customer2);         /*          *  customer1.equals(customer2)比较结果为true，按理说HashSet只应该把customer1加入集合中，          *  但实际上打印结果为2，表明集合中加入了两个对象。原因就是HashCode不一致。          *          *  应该重写hashCode()方法。          */         print(set.size());     } }

 

1.1.2 TreeSet类

TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。

public class TreeSetTest {     public static void main(String[] args) {         Set<Integer> set = new TreeSet<Integer>();         set.add(8);         set.add(10);         set.add(1);         set.add(13);           Iterator<Integer> it = set.iterator();         while (it.hasNext()) {             System.out.println(it.next()+" ");         }     } }

1.2 List(列表)

List的主要特征是其元素以线性方式存储，集合允许存放重复对象。List接口主要的实现类包括：

ArrayList：代表长度可变的数组。允许对元素进行快速的随机访问，但是向ArrayList中插入与删除元素的速度较慢。

LinkedList：在实现中采用链表数据结构。对顺序访问进行了优化，向List中插入和删除元素的速度较快，随机访问速度则相对较慢。随机访问是指检索位于特定索引位置的元素。

boolean	add(E e)           向列表的尾部添加指定的元素（可选操作）。
void	add(int index, E element)           在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extends E> c)           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extends E> c)           将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()           从列表中移除所有元素（可选操作）。
boolean	contains(Object o)           如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)           比较指定的对象与列表是否相等。
E	get(int index)           返回列表中指定位置的元素。
int	hashCode()           返回列表的哈希码值。
int	indexOf(Object o)           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean	isEmpty()           如果列表不包含元素，则返回 true。
Iterator<E>	iterator()           返回按适当顺序在列表的元素上进行迭代的迭代器。
int	lastIndexOf(Object o)           返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator<E>	listIterator()           返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E>	listIterator(int index)           返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
E	remove(int index)           移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o)           从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)           从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)           用指定元素替换列表中指定位置的元素（可选操作）。
int	size()           返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()           返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
<T> T[]	toArray(T[] a)           返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

(1)  访问列表元素

List<Integer> list = new ArrayList<Integer>();         list.add(2);         list.add(15);         list.add(23);         list.add(1);           for (int i=0; i<list.size(); i++) {             print(list.get(i));         }           Iterator<Integer> it = list.iterator();         while (it.hasNext()) {             print(it.next());         }

 

(2)  为列表排序

1.3 类 Collections

static <T extends Comparable<? super T>> void	sort(List<T> list)           根据元素的自然顺序 对指定列表按升序进行排序。
static <T> void	sort(List<T> list, Comparator<? super T> c)           根据指定比较器产生的顺序对指定列表进行排序。

Collections.sort(list);         Iterator<Integer> itt = list.iterator();         while (itt.hasNext()) {             print(itt.next());         }

1.4  ListIterator接口

List的listIterator()方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，此外还专门提供了专门操纵列表的方法。

public class MapTest {     public static void main(String[] args) {         Map<String, String> map = new HashMap<String, String>();         map.put("1", "Monday");         map.put("2", "Tuesday");         map.put("3", "Wendsday");         map.put("4", "Thursday");           for (int i=1; i<=map.size(); i++) {             System.out.println(map.get((new Integer(i)).toString()));         }             Map<String, String> tmpMap = new HashMap<String, String>();         tmpMap.put("1", "Mon.");         tmpMap.put("1", "Monday");         tmpMap.put("one", "Monday");         Iterator<Map.Entry<String, String>> it = tmpMap.entrySet().iterator();         while(it.hasNext()) {             Map.Entry entry = it.next();             System.out.println(entry.getKey() + ":" + entry.getValue());         }     } } 2  Collection和Iterator接口  (1 )接口Collection<E>   (2) Iterator接口隐藏底层集合的数据结构，向客户程序员提供了遍历各种类型的集合的统一接口。Iterator接口中声明了如下方法：   package code.javaoop.collection;   import java.util.*; public class Visitor {     public static void print(Collection<? extends Object> c) {         Iterator<? extends Object> it = c.iterator();         while (it.hasNext()) {             Object element = it.next();             System.out.println(element);         }     }     public static void main(String [] args) {         Set<String> set = new HashSet<String>();         set.add("Tom");         set.add("Mary");         set.add("Jack");         print(set);           List<String> list = new ArrayList<String>();         list.add("Linda");         list.add("Mary");         list.add("Rose");         print(list);           Map<String, String> map = new HashMap<String, String>();         map.put("M", "mail");         map.put("F", "female");         print(map.entrySet());     } } entrySet Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。该 set 受映射支持，所以对映射的更改可在此 set 中反映出来，反之亦然。如果对该 set 进行迭代的同时修改了映射（通过迭代器自己的 remove 操作，或者通过对迭代器返回的映射项执行 setValue 操作除外），则迭代结果是不确定的。set 支持元素移除，通过Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持add 或 addAll 操作。 返回： 此映射中包含的映射关系的 set 视图 如果集合中的元素没有排序，Iterator遍历集合中元素的顺序是任意的，并不一定与向集合中加入元素的顺序一致。 ---------------------- Java开发、Android培训、期待与您交流！ ----------------------详细请查看：www.itheima.com