黑马程序员_java集合

           ------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

                                集合框架

1  集合类

为什么出现集合类？

        面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？

         数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点

         集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

2  Collection

<1>定义了集合框架的共性功能。

1.添加
       add(e);
       addAll(collection);
//1.向集合中存对象
	private static void method_1() {
		// 接口引用指向实现类对象，多态
		Collection co1 = new ArrayList();
		// 调用add方法，存储对象
		co1.add("abc");
		co1.add(123);//自动装箱，提升为Integer对象
		co1.add(false);//new Boolean(false);
		System.out.println(co1);//只是为了演示，别的什么也做不了，只能看，不能碰
		
		Collection co2 = new ArrayList();
		co2.add("sdf");
		co2.add(7890);
		co2.addAll(co1);
		System.out.println(co2);
		
	}

2.删除
         remove(e);
         removeAll(collection);
         clear();

//2.移除集合中的元素boolea remove(Object o)
//移除集合中的一批元素 boolean removeAll(Collection c)
    private static void method_2() {
        // TODO Auto-generated method stub
        Collection co1 = new ArrayList();
        co1.add(123);
        co1.add("abc");
        co1.add(false);
        co1.add(false);
        co1.add(1.23);
        System.out.println(co1);
        co1.remove(false);
        System.out.println(co1);
        
        Collection co2  = new ArrayList();
        co2.add(false);
        co2.add(1.23);
        co2.add(123);
        co1.removeAll(co2);
        System.out.println(co2);
        System.out.println(co1);
　　
		co1.clear();
        System.out.println(co1);
        System.out.println(co1.size());
　　
    }

3.判断和获取
         contains(e);
         isEmpty();
	 size();
//3.判断集合中是否包含某个对象 boolean  contains
//判断一个集合是否包含另一个集合 boolean  containsAll(Collection c)
//判断一个集合是否是空集合   boolean    isEmpty()
	
	private static void method_3() {
		Collection co1 = new ArrayList();
		co1.add("123");
		co1.add("false");
		co1.add(123);	
		boolean b = col.contains("123");
		System.out.println(b);
	
		
		
		Collection co2= new ArrayList();
		 co2.add("123");
		 co2.add("false");
		 co2.add(123);
		 co2.add("false");
		 
		 boolean b = co2.containsAll(co1);
		 System.out.println(b);
		 System.out.println(co2.isEmpty());
		 System.out.println(co1.isEmpty());
		 System.out.println(co2.size());
		 System.out.println(co1.size());
		
		
	}

4.获取交集。
         retainAll();

//4.获取两个集合中的交集 boolean  retainAll(Collection  c)	
	private static void method_4() {
		Collection co2 = new ArrayList();
		co2.add("abc1");
		co2.add("abc2");
		co2.add("abc3");
		co2.add("abc4");
		Collection co3 = new ArrayList();
		co3.add("abc1");
		co3.add("abc2");
		co3.add("abc3");
		co3.add("abc9");
		
		System.out.println(co2);
		System.out.println(co3);
		boolean b = co2.retainAll(co3);
		System.out.println(co2);
		System.out.println(b);
	}

5.集合变数组。
         toArray();
//5.集合变数组toArray();
	private static void method_5() {
		// TODO Auto-generated method stub
		Collection co1 = new ArrayList();
		co1.add("abc1");
		co1.add("abc2");
		co1.add("abc3");
		co1.add("abc4");
		/*
		调用Object[]  toArray()；时
		1.  add方法的参数类型是Object。以便于接收任意类型对象。
		2. 集合中存储的都是对象的引用(地址)
		*/
		Object[] obj = co1.toArray();
		System.out.println(obj);
	}

<2>什么是迭代器呢？

       其实就是集合的取出元素的方式。

        如同抓娃娃游戏机中的夹子。

//1.集合中的迭代器
	private static void method() {
		// 接口引用指向实现类对象，多态
		Collection co1 = new ArrayList();
		// 调用add方法，存储对象
		co1.add("abc");
		co1.add(123);//自动装箱，提升为Integer对象
		co1.add(false);//new Boolean(false);
		co1.add("sdf");
		co1.add(7890);
		System.out.println(co1);
		Iterator it = co1.iterator();
                while(it.hasNext()){
                     System.out.println(it.next());
                }
	}

 <3>  Collection分类

         |--List:元素是有序的，元素可以重复。因为该集合体系有索引。

                   |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

                   |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

                   |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

 

         |--Set：元素是无序，元素不可以重复。、

                   |---HashSet:  底层数据结构是哈希表。是线程不安全的。不同步。

                  |--HashSet：数据结构是哈希表。线程是非同步的。

3   List：

         特有方法。凡是可以操作角标的方法都是该体系特有的方法。

增
         add(index,element);
         addAll(index,Collection);
//1.List集合中的储存
	private static void method() {
		// 接口引用指向实现类对象，多态
		List list1 = new ArrayList();
		// 调用void   add(index,element);存储对象
		list1.add("abc");
		list1.add(123);//自动装箱，提升为Integer对象
		list1.add(false);//new Boolean(false);
		
		// 接口引用指向实现类对象，多态
		List list2 = new ArrayList();
		// 调用void   add(index,element);存储对象
		list2.add("def");
		list2.add(456);//自动装箱，提升为Integer对象
		list2.add(true);//new Boolean(false);
		//boolean  addAll(index,Collection);向集合中存集合
		boolean b = list1.addAll(1, list2);
		System.out.println(list1);
		Iterator it = list1.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	}

删
 remove(index);
//2.移除集合中的元素 remove(index);
	
	private static void method_2() {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		list.add(123);
		list.add("abc");
		list.add(false);
		list.add(false);
		list.add(1.23);
		System.out.println(list);
		//移除掉索引的数组元素
		list.remove(2);
		System.out.println(list);
		
	}

改
set(index,element);
//3改.List集合中元素   set(index,element);
	
		private static void method_3() {
			// TODO Auto-generated method stub
			List list = new ArrayList();
			list.add(123);
			list.add("abc");
			list.add(false);
			list.add(false);
			list.add(1.23);
			System.out.println(list);
			//移除掉索引的数组元素
			list.set(2,"abcd");
			System.out.println(list);
			
		}

查
/*4. List集合中的查
	 *   get(index):
	 *   subList(from,to);
	 *   listIterator();
	 *   intindexOf(obj):获取指定元素的位置。
	 *    ListIterator listIterator();
	*/
	private static void method_4() {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		list.add(123);
		list.add("abc");
		list.add(false);
		list.add(false);
		list.add(1.23);
		
		System.out.println(list);
		//移除掉索引的数组元素
		Object obj=list.get(2);
		System.out.println(obj);
		//获取list集合中的一部分集合，包头不包尾
		List list2 =list.subList(0, 2);
		System.out.println(list2);
		
		//List 迭代器,从0开始list.listIterator();
		//从指定位置开始list.listIterator(int index);
		ListIterator lit =list.listIterator();
		while (lit.hasNext()){
			System.out.println(lit.next());
		}
		//查元素的索引
		int index= list.indexOf("abc");
		System.out.println(index);	
	}

List集合特有的迭代器。ListIterator是Iterator的子接口。

 

       在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。

 

        所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

 

该接口只能通过List集合的listIterator方法获取。

       迭代器是取出方式，会直接访问集合中的元素。

       所以将迭代器通过内部类的形式来进行描述。

       通过容器的iterator()方法获取该内部类的对象。

   LinkedList:特有方法：

addFirst();

addLast();

 

getFirst();

getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

 

removeFirst();

removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

 

 

在JDK1.6出现了替代方法。

 

offerFirst();

offerLast();

 

 

peekFirst();

peekLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。

 

pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

4   Set 集合 

 

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、

         |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

                            HashSet是如何保证元素唯一性的呢？

                            是通过元素的两个方法，hashCode和equals来完成。

                            如果元素的HashCode值相同，才会判断equals是否为true。

                            如果元素的hashcode值不同，不会调用equals。

 

                注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

//对hashcode方法进行覆盖
	public  int hashCode(){
		
		 final int X =3;
		
		return this.name.hashCode()+this.age*X;
	}

//覆盖equals方法
	public boolean equals(Object obj){
		if (this==obj) {
			return true;
		}
	if (obj instanceof Person) {
			Person p = (Person)obj;
			return this.name.equals(p.name) && this.age ==p.age;
	}
	return false;
	}

         |--TreeSet：可以对Set集合中的元素进行排序。

                                     底层数据结构是二叉树。

                                     保证元素唯一性的依据：

                                     compareTo方法return 0.

 

                                     TreeSet排序的第一种方式：让元素自身具备比较性。

                                     元素需要实现Comparable接口，覆盖compareTo方法。

                                     也种方式也成为元素的自然顺序，或者叫做默认顺序。

 

                                     TreeSet的第二种排序方式。

                                     当元素自身不具备比较性时，或者具备的比较性不是所需要的。

                                     这时就需要让集合自身具备比较性。

                                     在集合初始化时，就有了比较方式。

Set集合的功能和Collection是一致的。

5  让容器自身具备比较性

 

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

 

当两种排序都存在时，以比较器为主。

 

定义一个类，实现Comparator接口，覆盖compare方法。

//类实现Comparable接口，覆盖compareTo方法
public class Person implements Comparable<Person>{

	private String name;
	private int age ;    //compareTo方法
	public int compareTo(Person p ){
		
		int mun =this.age- p.age;
		return mun==0?this.name.compareTo(p.name ):mun;
	}
}

public class MyComparator implements Comparator{
	
	/*public int compare(Object o1,Object o2){
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		int mun = p1.compareTo(p2);
		return mun== 0?p1.getAge()-p2.getAge():mun;
	}*/


	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		int mun = p1.compareTo(p2);
		return mun== 0?p1.getAge()-p2.getAge():mun;
		
	}

6   泛型

 

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

 

好处

1.将运行时期出现问题ClassCastException，转移到了编译时期。，

         方便于程序员解决问题。让运行时问题减少，安全。，

 

2，避免了强制转换麻烦。

 

泛型格式：通过<>来定义要操作的引用数据类型。

 

在使用java提供的对象时，什么时候写泛型呢？

 

通常在集合框架中很常见，

只要见到<>就要定义泛型。

 

其实<> 就是用来接收类型的。

 

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

  

 泛型类。

什么时候定义泛型类？

当类中要操作的引用数据类型不确定的时候，

早期定义Object来完成扩展。

现在定义泛型来完成扩展。

     泛型方法

 

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

 

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

 

定义在方法上时，放在返回类型的前面，修饰符的后面

例：public  static <W> voidmethod(W t)

 

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

7    Map集合：

该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

         1，添加。

                   put(Kkey, V value)

                   putAll(Map<?extends K,? extends V> m)

 

         2，删除。

                   clear()

                   remove(Objectkey)

 

         3，判断。

                   containsValue(Objectvalue)

                   containsKey(Objectkey)

                   isEmpty()

 

 

         4，获取。

                   get(Objectkey)

                   size()

                   values()

 

                   entrySet()

                   keySet()

 

Map

         |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

         |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

         |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

 

 

和Set很像。

其实大家，Set底层就是使用了Map集合。

    Map集合的两种取出方式：

1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

         所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

         Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

 

 

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，

                                     而这个关系的数据类型就是：Map.Entry

 

                                     Entry其实就是Map中的一个static内部接口。

                                     为什么要定义在内部呢？

                                     因为只有有了Map集合，有了键值对，才会有键值的映射关系。

                                     关系属于Map集合中的一个内部事物。

                                     而且该事物在直接访问Map集合中的元素。

package cn.itcast;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		method_1();
		method_2();
	
		
	}

	private static void method_2() {
		// HashMap集合
		HashMap<Person,Integer> h = new HashMap<Person, Integer>();
		h.put(new Person("lisi1",12),24);
		h.put(new Person("lisi2",12),25);
		h.put(new Person("lisi3",12),23);
		h.put(new Person("lisi4",12),22);
		h.put(new Person("lisi5",12),21);	
		
		System.out.println(h);
		//用entrySet()方法来取出Map集合中的元素
		Set<Map.Entry<Person, Integer>> s = h.entrySet();
		Iterator<Map.Entry<Person, Integer>> it = s.iterator();
		while(it.hasNext()){
			Map.Entry<Person, Integer> m= it.next();
			Person p = m.getKey();
			Integer in= m.getValue();
			System.out.println(p.getName()+"......."+in);
		}
	}

	private static void method_1() {
		HashMap<Person,Integer> h = new HashMap<Person,Integer>();
		h.put(new Person("lisi1",12),24);
		h.put(new Person("lisi2",12),25);
		h.put(new Person("lisi3",12),23);
		h.put(new Person("lisi4",12),22);
		h.put(new Person("lisi5",12),21);	
		System.out.println(h);
		//用keySet()方法来取出Map集合中的元素
		Set<Person> s = h.keySet();
		Iterator<Person> it = s.iterator();
		while(it.hasNext()){
			Person p = it.next();
			Integer in = h.get(p);
			System.out.println(p.getName() +"....."+in);
			
		}
	}

}

8   集合框架的工具类

Collections:集合框架的工具类。里面定义的都是静态方法。

 

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

                   它有两个常用的子接口，

                   List：对元素都有定义索引。有序的。可以重复元素。

                   Set：不可以重复元素。无序。

 

Collections是集合框架中的一个工具类。该类中的方法都是静态的

                   提供的方法中有可以对list集合进行排序，二分查找方法等。

                   通常常用的集合都是线程不安全的。因为要提高效率。

                   如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

9   Arrays:用于操作数组的工具类

里面都是静态方法。

 

把数组变成list集合有什么好处？

        

         可以使用集合的思想和方法来操作数组中的元素。

 

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定。

 

asList:将数组变成list集合

        

contains。//判断是否包含

         get

         indexOf()//返回某元素的角标位置

         subList();

 

         如果你增删。那么会生成UnsupportedOperationException,

10  集合变数组

Collection接口中的toArray方法。

 

1.指定类型的数组到底要定义多长呢？

         当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

         当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

         所以创建一个刚刚好的数组最优。

                  

2.为什么要将集合变数组？

                   为了限定对元素的操作。不需要进行增删了。

11  高级for循环

 

格式：

for(数据类型变量名 : 被遍历的集合(Collection)或者数组)

{

        

}

 

对集合进行遍历。

只能获取集合元素。但是不能对集合进行操作。

 

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

 

传统for和高级for有什么区别呢？

 

高级for有一个局限性。必须有被遍历的目标。

 

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

12   JDK1.5版本出现的新特性  可变参数

 

方法的可变参数。

在使用时注意：可变参数一定要定义在参数列表最后面。

 

可变参数。

         其实就是上一种数组参数的简写形式。

         不用每一次都手动的建立数组对象。

         只要将要操作的元素作为参数传递即可。

         隐式将这些参数封装成了数组。

 

可变参数必须定义在参数的最后

13  StaticImport 静态导入。

 

当类名重名时，需要指定具体的包名。

当方法重名是，指定具备所属的对象或者类。

 

import java.util.*;

import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

import static java.util.Collections.*;

                                                        ------- android培训、java培训、java学习型技术博客期待与您交流！ ----------