黑马程序员——集合与泛型

                                                  --------------------- android培训、java培训、期待与您交流！ ----------------------

一丶collection集合

1、数组和集合的不同

/*
 *1.数组和集合的不同
 * 	|--数组的长度是固定的，集合长度可变
 * 	|--数组存储的是相同类型的数据，集合可以存储不同类型的对象
 * 	|--数组可以存储基本数据类型，集合只能存储对象
 */

2、collection和迭代器

package study_note_14;

import java.util.*;

/*
 * 1.add方法的参数类型是Object,以便接收任意类型的对象
 * 2.集合中存储的都是对象的引用地址
 * 3.什么是迭代器
 * 	|--其实就是集合的取出元素的方式
 */
public class CollectionDmeo
{
	public static void main(String[] args)
	{
		// base_method();
		// method_two();
		method_get();
	}

	public static void method_get()
	{
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");

		// Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素
		// while (it.hasNext())
		// {
		// sop(it.next());
		// }
		
		for(Iterator it=al.iterator();it.hasNext();)//for循环完成之后，会释放代码，内存优化，while循环结束后，对象依然存在内存中
		{
			sop(it.next());
		}
	}

	public static void method_two()
	{
		ArrayList al1 = new ArrayList();

		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();

		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");

		al1.retainAll(al2);// 取交集,al1中只会保留和al2中相同的元素，如果没有交集则al1为空

		sop("al1:" + al1);
		sop("al2:" + al2);

	}

	public static void base_method()
	{
		// 创建一个集合容器,使用Collection接口的子类,ArrayList
		ArrayList al = new ArrayList();

		// 添加元素
		al.add("java01");// add(Object obj)
		al.add("java02");
		al.add("java03");
		al.add("java04");

		// 打印集合
		sop("原集合:" + al);

		// 获取个数,集合长度
		sop("size:" + al.size());

		// 删除元素
		al.remove("java02");

		sop("删除后:" + al);

		// 清空集合
		al.clear();

		sop(al);
		// 判断元素
		sop("java03是否存在:" + al.contains("java03"));
		sop("集合是否为空:" + al.isEmpty());
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

3、整体结构

package study_note_14;

import java.util.*;

/*
 *1.Collection
 *	|--Lsit:元素是有序的,元素可以重复,因为该集合体系有索引
 *		|--凡是可以操作角标的方法都是该体系特有的方法
 *		|--add(index,element),addAll(index,Collection)
 *		|--remove(index)
 *		|--set(index,element)
 *		|--get(index),subList(from,to),listIterator()
 *	|--Set:元素是无序的,元素不可以重复
 *2.List集合特有的迭代器:ListIterator是Iterator的子接口
 *	|--在迭代时,不可以通过集合对象的方法操作集合中的元素,会发生并发异常
 *		|--所以在迭代时,只能用迭代器的方操作元素,可是Iterator的方法是有限的,只能进行判断、取出、删除的操作
 *			|--如果想要其他操作如:添加、修改等,就需要使用其子接口:ListIterator
 *				|--该接口只有通过List集合的listIterator方法获取
 *3.List的子类对象
 *	|--ArrayList:底层的数据结构使用的是数组结构,查询速度很快,但是增删稍慢,线程不同步
 *	|--LinkedList:底层使用的是链表数据结构,增删速度很快,查询稍慢
 *	|--Vector:底层是数组数据结构,线程同步,被ArrayList替代了
 */
public class ListDemo
{
	public static void main(String[] args)
	{
		// method();
		method_showIt();
	}

	public static void method_showIt()
	{
		// 演示列表迭代器
		ArrayList al = new ArrayList();

		// 添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		ListIterator li = al.listIterator();

		sop("hasPrevious():" + li.hasPrevious());

		while (li.hasNext())
		{
			Object obj = li.next();

			if (obj.equals("java02"))
			{
				// li.add("java09");
				li.set("java06");
			}
		}
		sop("hasNext():" + li.hasNext());
		sop("hasPrevious():" + li.hasPrevious());
		while (li.hasPrevious())
		{
			sop("pre:" + li.previous());
		}

		// 在迭代过程中,准备添加或者删除元素
		// Iterator it = al.iterator();
		//
		// while (it.hasNext())
		// {
		// Object obj = it.next();
		// if (obj.equals("java02"))
		// {
		// //
		// al.add("java08");//抛出异常,同时操作一组数据，导致运行到此处时不知道是取出数据还是增加数据，要找迭代器中含有的方法
		// it.remove();// 将java02的引用从集合中删除
		// }
		// sop("obj=" + obj);
		// }
		sop(al);
	}

	public static void method()
	{
		ArrayList al = new ArrayList();

		// 添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		sop("原集合是:" + al);
		// 在指定位置添加元素
		al.add(1, "java09");

		// 删除指定位置的元素
		// al.remove(2);

		// 修改元素
		// al.set(2, "java07");

		// 通过角标获取元素
		sop("get(1):" + al.get(1));

		sop(al);

		// 获取所有元素
		for (int x = 0; x < al.size(); x++)
		{
			System.out.println("al(" + x + ")=" + al.get(x));
		}

		Iterator it = al.iterator();

		while (it.hasNext())
		{
			sop("next:" + it.next());
		}

		// 通过indexOf获取对象的位置
		sop("index=" + al.indexOf("java02"));

		List sub = al.subList(1, 3);
		sop("sub=" + sub);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

4、LinkedList

package study_note_14;

import java.util.*;

/*
 *1.LinkedList特有方法
 *	|--addFirst();
 *	|--addLast();
 *	|--getFirst()↖ 
 *				  |-->获取元素,但不删除元素,如果集合中没有元素,会出现NoSuchElementException异常
 *	|--getLast() ↙
 *	|--removeFirst() ↖
 *					  |-->获取元素,但是元素被删除,如果集合中没有元素,会出现NoSuchElementException异常
 *	|--removeLast()  ↙
 *2.在JDK1.6出现了替代方法
 *	|--offerFirst()
 *	|--offerLast()
 *	|--peekFirst()↖ 
 *				   |-->获取元素,但不删除元素,如果集合中没有元素,会返回null
 *	|--peekLast() ↙
 *	|--pollFirst()↖
 *				   |-->获取元素,元素被删除,如果集合中没有元素,会返回null
 *	|--pollLast() ↙
 */
public class LinkedListDemo
{
	public static void main(String[] args)
	{
		LinkedList link = new LinkedList();

		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");

		// sop(link);
		//
		// sop(link.getFirst());
		//
		// sop(link.getLast());
		//
		// sop(link.removeFirst());
		//
		// sop("size=" + link.size());

		while (!link.isEmpty())
		{
			sop(link.removeFirst());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

4、LinkedList代码示例

package study_note_14;

import java.util.*;

/*
 * 使用LinkedList模拟一个堆栈或者队列数据结构
 * 堆栈:先进后出	如同一个杯子
 * 队列:先进先出 First in First FIFO	如同一个水管
 */
class DuiLie
{
	private LinkedList link;

	DuiLie()
	{
		link = new LinkedList();
	}

	public void myAdd(Object obj)
	{
		link.addFirst(obj);
	}

	public Object myGet()
	{
		return link.removeLast();
	}

	public boolean isNull()
	{
		return link.isEmpty();
	}
}

public class LinkedListTest
{
	public static void main(String[] args)
	{
		DuiLie dl = new DuiLie();

		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");

		sop(dl.myGet());
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

5、ArrayList代码示例

package study_note_14;

import java.util.*;

/*
 *将自定义对象作为元素存储到ArryaList集合中,并去除重复的元素
 *比如:存储人对象,同姓名+同年龄=同一个人,为重复元素
 *思路:
 *1.对人描述,将数据封装进人对象
 *2.定义容器,将人存入
 *3.取出
 *List集合判断元素是否相同,依据的是元素的equals方法
 */
class Person
{
	private String name;
	private int age;

	Person(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	//重写Object的equals方法,让其按照自己的比较方式比较,Object中的比较是比较地址值,在这里无法判断两个对象是否相同
	public boolean equals(Object obj)
	{
		if (!(obj instanceof Person))
		{
			return false;
		}
		Person p = (Person) obj;
		return this.name.equals(p.name) && this.age == p.age;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}

public class ArrayListTest2
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();

		al.add(new Person("lisi01", 30));
		al.add(new Person("lisi02", 32));
		al.add(new Person("lisi02", 32));
		al.add(new Person("lisi03", 33));
		al.add(new Person("lisi04", 34));
		al.add(new Person("lisi04", 34));

		al = singleElement(al);

		Iterator it = al.iterator();

		while (it.hasNext())
		{
			Person p = (Person) it.next();
			sop(p.getName() + "::" + p.getAge());
		}

	}

	public static ArrayList singleElement(ArrayList al)
	{
		// 定义一个临时容器
		ArrayList newAl = new ArrayList();

		Iterator it = al.iterator();

		while (it.hasNext())
		{
			Object obj = it.next();

			if (!newAl.contains(obj))//contains底层调用了equals方法
			{
				newAl.add(obj);
			}
		}
		return newAl;
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

6、TreeSet

package study_note_14;

import java.util.*;

/*
 *1.TreeSet
 *	|--可以对Set集合中的元素排序,按照ASCII码排序
 *	|--底层数据结构二叉树
 *	|--保证元素唯一性的依据:compareTo方法return 0
 *	|--TreeSet排序的第一种方式:让元素自身具备比较性
 *		|--元素需要实现Comparable接口,覆盖CompareTo方法,这种方式自然顺序排列(默认顺序)
 *	|--TreeSet排序的第二种方式:当元素自身不具备比较性时
 *		|--或者具备的比较性不是所需要的,这时就需要让集合自身具备比较性,在集合初始化时就具备了比较性
 *2.往TreeSet集合中 存储自定义对象学生,想按照学生的年龄进行排序
 *	|--当主要条件相同时,一定要判断次要条件
 */
public class TreeSetDemo
{
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("java01", 22));
		ts.add(new Student("java02", 20));
		ts.add(new Student("java03", 19));
		ts.add(new Student("java04", 40));
		ts.add(new Student("java04", 40));

		Iterator it = ts.iterator();

		while (it.hasNext())
		{
			Student stu = (Student) it.next();
			sop(stu.getName() + "::" + stu.getAge());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class Student implements Comparable// 该接口强制让学生具备比较性
{
	private String name;
	private int age;

	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{
		// return 0;
		if (!(obj instanceof Student))
		{
			throw new RuntimeException("This isn't a Student Object");
		}

		Student s = (Student) obj;

		// TreeSetDemo.sop(this.name + "............." + s.name);

		// if (this.age > s.age)
		// {
		// return 1;
		// }
		// else if (this.age == s.age)
		// {
		// return this.name.compareTo(s.name);
		// }
		// else
		// {
		// return -1;
		// }
		// return this.age - s.age;
		int num = new Integer(this.age).compareTo(new Integer(s.age));

		if (num == 0)
		{
			return this.name.compareTo(s.name);
		}

		return num;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}

7、HashSet

package study_note_14;

import java.util.*;

/*
 *1.Set:元素是无序的,元素不可以重复
 *	|--Set集合的功能和Collection是一致的
 *	|--HashSet:底层数据结构是哈希表
 *		|--HashSet是如何保证元素唯一性的呢?
 *			|--是通过元素的两个方法,hashCode和equals来完成的,如果元素的HashCode值相同,才会判断equals是否为true
 *				|--如果元素的HashCode值不同,不会调用equals
 *	|--TreeSet
 */
public class HashSetDemo
{
	public static void main(String[] args)
	{
		HashSet hs = new HashSet();

		hs.add("java01");
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");

		Iterator it = hs.iterator();

		while (it.hasNext())
		{
			sop(it.next());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

二、Map集合

1、整体结构

package study_note_16;

import java.util.*;

/*
 *1.Map集合
 *	|--该集合存储键值对<key,value>,而且要保证key的唯一性
 *	|--添加
 *		|--put(K key, V value) 
 *		|--putAll(Map<? extends K,? extends V> m) 
 *	|--删除
 *		|--clear()
 *		|--remove(Object key)
 *	|--判断
 *		|--containsKey(Object key)
 *		|--containsValue(Object value)
 *		|--isEmpty()
 *	|--获取
 *		|--get(Object key) 
 *		|--values() 
 *		|--entrySet()--重点  
 *		|--keySet()--重点 
 *2.Map重要子类对象
 *	|--Hashtable:底层是哈希表数据结构,不可以存入null键null值,线程同步,jdk1.0--效率低
 *	|--HashMap:底层是哈希表数据结构,可以存入null键null值,线程不同步,jdk1.2--效率高
 *	|--TreeMap:底层是二叉树数据结构,线程不同步,可以用于Map集合中的键的排序
 *		|--和Set很像,其实Set底层就是使用了Map集合
 */
public class MapDemo
{
	public static void main(String[] args)
	{
		Map<String, String> map = new HashMap<String, String>();

		// 添加元素
		// 如果添加时,出现相同的键,那么添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值
		System.out.println(map.put("01", "zhangsan1"));
		System.out.println(map.put("01", "wangwu"));
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");

		System.out.println("containsKey:" + map.containsKey("02"));
		System.out.println("remove:" + map.remove("02"));
		System.out.println("get:" + map.get("02"));

		// 获取map集合中所有的值
		Collection<String> coll = map.values();
		System.out.println(coll);

	}
}

2、keySet和entrySet

package study_note_16;

import java.util.*;

/*
 *1.keySet:将map中所有的键存入到Set集合中,因为Set具备迭代器,可以迭代方式取出所有的键,再根据
 * 	|--get方法,获取每一个键对应的值
 * 	|--原理:将map集合转成Set集合,通过迭代器取出
 * 2.entrySet:Set<Map.Entry<k,v>>将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是Map.Entry
 * 3.其实Entry也是一个接口,它是Map中的一个内部接口
 */
public class MapDemo2
{
	public static void main(String[] args)
	{
		Map<String, String> map = new HashMap<String, String>();

		map.put("01", "java01");
		map.put("02", "java02");
		map.put("03", "java03");
		map.put("04", "java04");

		// // 获取map集合中的所有键的Set集合
		// Set<String> keySet = map.keySet();
		//
		// // 获取其迭代器
		// Iterator<String> it = keySet.iterator();
		//
		// while (it.hasNext())
		// {
		// String key = it.next();
		// // 有了键就可以通过map集合的get方法获取其对应的值
		// String value = map.get(key);
		// System.out.println("key:" + key+",value:"+value);
		// }
		//		
		// 将map集合中的映射关系取出,存入到Set集合中
		Set<Map.Entry<String, String>> entrySet = map.entrySet();

		Iterator<Map.Entry<String, String>> it = entrySet.iterator();

		while (it.hasNext())
		{
			Map.Entry<String, String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();

			System.out.println("key:" + key + ",value:" + value);
		}
	}
}

3、map扩展

package study_note_16;

import java.util.HashMap;
import java.util.Iterator;

/*
 *1.map扩展知识
 */
public class MapDemo3
{
	public static void main(String[] args)
	{
		// 创建一个教室,教室含有多个学生
		HashMap<String, String> yure = new HashMap<String, String>();

		yure.put("01", "zhangsan");
		yure.put("02", "lisi");

		HashMap<String, String> jiuye = new HashMap<String, String>();

		jiuye.put("01", "zhaoliu");
		jiuye.put("02", "wangwu");
		// 创建一个学校,学校含有多个教室
		HashMap<String, HashMap<String, String>> czbk = new HashMap<String, HashMap<String, String>>();

		czbk.put("yure", yure);
		czbk.put("jiuye", jiuye);

		getStudentInfo(czbk);
	}

	public static void getStudentInfo(HashMap hm)
	{
		Iterator<String> it = hm.keySet().iterator();

		while (it.hasNext())
		{
			String roomName = it.next();

			System.out.println(roomName);

			HashMap<String, String> room = (HashMap<String, String>) hm
					.get(roomName);

			Iterator<String> it1 = room.keySet().iterator();

			while (it1.hasNext())
			{
				String id = it1.next();
				String name = room.get(id);

				System.out.println(id + "::" + name);
			}
		}
	}
}

三丶工具类

1、Arrays

package study_note_17;

import java.util.*;

/*
 *1.Arrays:用于操作数组工具类,里面都是静态方法
 *2.asList:将数组变成list集合
 *	|--可以使用集合的思想和方法来操作数组的元素
 *	|--将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的
 *	|--如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素
 *		|--如果数组中的元素都是基本数据结构,那么会将该数组作为集合中的元素存在
 */
public class ArraysDemo
{
	public static void main(String[] args)
	{
		// String[] arr={"abc","cc","kkkk"};
		//		
		// List<String> list=Arrays.asList(arr);
		//		
		// sop("contains:"+list.contains("cc"));

		// int[] nums = { 2, 4, 5 };
		//
		// List<int[]> list = Arrays.asList(nums);

		Integer[] nums = { 2, 4, 5 };
		List<Integer> list = Arrays.asList(nums);

		// list.add("qq");

		sop(list);
	}

	public static boolean myContains(String[] arr, String key)
	{
		for (int x = 0; x < arr.length; x++)
		{
			if (arr[x].equals(key))
				return true;
		}
		return false;
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2、collections

package study_note_17;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
 * 1.集合框架工具类
 * 	|--Collections
 */
public class CollectionsDemo
{
	public static void main(String[] args)
	{
		sortDemo();

		maxDemo();

		binarySearchDemo();
	}

	// public static <T extends Comparable<? super T>> void sort(List<T> list)
	// {
	//	
	// }

	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("java001");
		list.add("java00004");
		list.add("java3");
		list.add("java02");
		list.add("java02");

		Collections.sort(list);

		sop(list);

		int index = Collections.binarySearch(list, "java3");

		sop("index:" + index);
	}

	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("java001");
		list.add("java00004");
		list.add("java3");
		list.add("java02");
		list.add("java02");

		Collections.sort(list);

		sop(list);

		String max = Collections.max(list);

		sop("max:" + max);
	}

	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("java001");
		list.add("java00004");
		list.add("java3");
		list.add("java02");
		list.add("java02");

		sop(list);

		Collections.sort(list, new StrLenComparator());

		sop(list);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class StrLenComparator implements Comparator<String>
{
	public int compare(String s1, String s2)
	{
		if (s1.length() > s2.length())
			return 1;
		if (s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

3、高级for循环

package study_note_17;

import java.util.*;

/*
 *1.高级for循环
 *	|--格式:for(数据类型 变量名:被遍历的集合(Collection)或者数组{}
 *	|--局限性:不能修改数据
 *	|--迭代器除了遍历,可以进行remove操作
 *	|--如果使用ListIterator,还可以进行增删改查
 *2.传统for循环和高级for循环的区别
 *	|--高级for有一个局限性,必须有被遍历的目标
 *	|--建议在遍历数组时,使用传统for,因为传统for可以定义角标
 */
public class ForEachDemo
{
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		for (String s : al)
		{
			s = "kk";
			// System.out.println(s);
		}
		System.out.println(al);
		// Iterator<String> it = al.iterator();
		//
		// while (it.hasNext())
		// {
		// System.out.println(it.next());
		// }

		int[] arr = { 3, 5, 2 };
		for (int i : arr)
		{
			System.out.println("i:" + i);
		}

		HashMap<Integer, String> hm = new HashMap<Integer, String>();

		hm.put(1, "a");
		hm.put(2, "b");
		hm.put(3, "c");

		Set<Integer> keySet = hm.keySet();

		for (Integer i : keySet)
		{
			System.out.println(i + "::" + hm.get(i));
		}

		// Set<Map.Entry<Integer, String>> entrySet=hm.entrySet();

		for (Map.Entry<Integer, String> me : hm.entrySet())
		{
			System.out.println(me.getKey() + "-----------" + me.getValue());
		}
	}
}

4、静态导入

package study_note_17;

import java.util.*;//导入的是类
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员
import static java.lang.System.*;//导入了System类中的所有静态成员
/*
 *1.静态导入
 *2.当类重名时,需要制定具体的报名
 *	当方法重名时,指定具备所属的对象或者类
 */

public class StaticImport
{
	public static void main(String[] args)
	{
		int[] arr = { 3, 1, 5 };

		// Arrays.sort(arr);
		sort(arr);

		int index = binarySearch(arr, 1);

		out.println(Arrays.toString(arr));

		System.out.println("index:" + index);
	}
}

5、可变参数

package study_note_17;

/*
 *1.JDK1.5出现的新特性
 *	|--可变参数
 *	|--可变参数一定要定义在参数列表的最后面
 */
public class ParamMethodDemo
{
	public static void main(String[] args)
	{
		//show(3,4);
		//虽然少定义了多个方法,但是每次都要定义一个数组,作为实际参数		
		// int[] arr={3,4};
		// show(arr);
		//		
		// int[] arr1={1,23,44};
		// show(arr);
		
		show("a",2);
		show("b",2,3,4,5,6);
		
	}
	
	public  static void show(String str,int...arr)
	{
		System.out.println(arr.length);
	}

	// public static void show(int[] arr)
	// {
	//		
	// }

	// public static void show(int a,int b)
	// {
	// System.out.println(a+","+b);
	// }
}

6、集合变数组

package study_note_17;

import java.util.*;

/*
 *1.集合变数组
 *	|--Collection接口中的toArray方法
 *	|--当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size
 *	|--当指定类型的数组长度大于了集合的size,就不会创建数组,而是使用传递进来的数组
 *	|--所以创建一个刚刚好的数组最优
 *3.为什么要将集合转成数组
 *	|--为了限定对元素的操作
 */
public class CollectionToArray
{
	public static void main(String[] args)
	{
		ArrayList<String> al=new ArrayList<String>();
		
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		String[] arr=al.toArray(new String[5]);
		
		sop(Arrays.toString(arr));
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

四丶泛型

1、泛型介绍

package study_note_15;

import java.util.*;

/*
 *1.泛型:JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制
 *2.益处 
 *	|--将运行时期出现的问题ClassCastException,转移到了编译时期,方便解决问题,让运行时期问题减少,安全
 *	|--避免了强制转换麻烦
 *3.泛型格式:通过<>来定义要操作的引用数据类型
 *4.通常在集合框架中很常见
 *5.其实<>就是用来接收类型的
 *	|--当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可
 */
public class GenericDemo
{
	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<String>();// 定义了一个容器,这个容器存储的数据是String类型

		al.add("java01");
		al.add("java02");
		al.add("java03");
		// al.add(4);//自动拆箱装箱相当于al.add(new Integer(4))

		Iterator<String> it = al.iterator();

		while (it.hasNext())
		{
			String s = it.next();
			sop(s.length());
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2、泛型定义在方法上

package study_note_15;

/*
 * 1.泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后
 * 	|--所有要操作的类型就已经固定了
 * 2.为了让不同方法可以操作不同类型,而且类型还不确定
 * 	|--那么可以将泛型定义在方法上
 * 3.静态方法不可以访问类上定义的泛型,如果静态方法操作的引用数据类型不确定
 * 	|--可以将泛型定义在方法上
 */
class Demo<T>
{
	public void show(T t)
	{
		System.out.println("show:" + t);
	}

	public <Q> void print(Q q)
	{
		System.out.println("print:" + q);
	}
	
	public static <W> void method(W t)
	{
		System.out.println("method:"+t);
	}
}

public class GenericDemo4
{
	public static void main(String[] args)
	{
		Demo<String> d = new Demo<String>();
		Demo.method("hahhahahhahah");
		// d.show("haha");
		// d.print("hehe");

		// Demo d = new Demo();

		//d.show(new Integer(4));
		d.print(9);// 自动装箱
	}
}

3、泛型可以定在接口上

4、泛型的高级应用

package study_note_15;

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

/*
 *1.泛型的高级应用
 *2."?":通配符,也可以理解为占位符
 *3.泛型的限定:
 *	|--? extends E:可以接收E类型或者E的子类型--上限
 *	|--? super E:可以接收E类型或者E的父类型--下限
 */
public class GenericDemo6
{
	public static void main(String[] args)
	{
		// ArrayList<String> al=new ArrayList<String>();
		//		
		// al.add("java01");
		// al.add("java02");
		// al.add("java03");
		//		
		// ArrayList<Integer> al1=new ArrayList<Integer>();
		// al1.add(4);
		// al1.add(7);
		// al1.add(1);
		//		
		// printColl(al);
		// printColl(al1);

		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("java01"));
		al.add(new Person("java02"));
		al.add(new Person("java03"));

		// printColl(al);

		ArrayList<Student1> al1 = new ArrayList<Student1>();
		al1.add(new Student1("java--01"));
		al1.add(new Student1("java--02"));
		al1.add(new Student1("java--03"));

		printColl(al1);
	}

	public static void printColl(ArrayList<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();

		while (it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

class Person
{
	private String name;

	Person(String name)
	{
		this.name = name;
	}

	public String getName()
	{
		return name;
	}
}

class Student1 extends Person
{
	Student1(String name)
	{
		super(name);
	}

}

                                                  --------------------- android培训、java培训、期待与您交流！ ----------------------

                                                                              详细请查看：http://edu.csdn.net/heima