黑马程序员——Java基础---泛型、集合框架工具类：collections和Arrays

                                                                                  ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、泛型

JDK1.5版本以后出现的新特性，用于解决安全问题,是一个类型安全机制。
(1) 好处：
<1>将运行时期出现的问题ClassCastException，转移到了编译时期，
            方便于程序员解决问题，让运行时期问题减少，安全。

<2>避免了强制转换。
(2) 泛型格式：通过<>来定义要操作的引用数据类型。
(3) 在使用java提供的对象时，什么时候写泛型呢？
        通常在集合框架中常见，只要见到<>就要定义泛型。
               其实<>就是用来接收类型的。
               当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.*;
class GenericDemo
{
	public static void main(String [] args)
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc01");
		al.add("abc0991");
		al.add("abc014");
		//al.add(4);

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

泛型练习

import java.util.*;
class GenericDemo2
{
	public static void main(String [] args)
	{
		TreeSet<String> ts = new TreeSet<String>();

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");
		
		Iterator<String> it =ts.iterator();

		while(it.hasNext())
		{
			String s =it.next();
			System.out.println(s);
		}
	}
}
class LengthComparator implements Comparator<String>
{
	public int compare(String o1,String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
			return o1.compareTo(o2);
		return num;
	}
}

(4) 泛型类
什么时候定义泛型类？
  当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展，现在定义泛型来完成扩展

import java.util.*;
class Worker
{

}
class Student
{

}
//泛型前做法。
class Tool
{
	private Object obj;
	public void setWorker(Object obj)
	{
		this.w = w;
	}
	public Object getObject()
	{ 
		return obj;
	}
}

JDK1.5泛型出现后，用泛型的做法.
泛型类

class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}
class GenericDemo3
{
	public static void main(String [] args)
	{
		/*Tool t = new Tool();
		t.setObject(new Worker());
		Worker w =(Worker)t.getObject();*/
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker);
		Worker w = u.getObject();
		
	}

泛型可以让程序员避免强制转换的麻烦，并且把运行时强转问题转化到了编译时期。 

集合框架(泛型方法)泛型类定义的泛型，在整个类中有效，如果被方法是用到泛型，类的对象明确。

操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，

而且类型还不确定，那么可以将泛型定义在方法上，而不定义在类上。 

public <T> void show(T t){}

//类型已经确定.
class GenericTest<T>
{
	public void show(T t)
	{ 
		sop("show:"+t); 
	} 
	public void print(T t)
	{ 
		sop("print:"+t); 
	} 
	public static void sop(Objectobj)
	{ 
		System.out.println(obj); 
	} 
}
//类型不确定，使用泛型方法
class GenericTest2
{
	//泛型方法 
	public <Q>void show(Q q)
	{ 
		sop("show_2:"+q); 
	} 
	public <Q> void print(Q q)
	{ 
		sop("print_2:"+q); 
	} 
	public static void sop(Object obj)
	{ 
		System.out.println(obj); 
	} 
}
public class Test
{
	public static void main(String args[])
	{ 
		//泛型确定 
		GenericTest<String> d = new GenericTest<String>(); 
		d.show("黑马程序员"); 
		d.print("csdn社区"); 
		//泛型不确定 
		GenericTest2 d2 = new GenericDemo_2(); 
		d2.show("黑马程序员"); 
		d2.print(new Integer(4)); 
		d2.print(4); 
	} 
	public static void sop(Objectobj)
	{ 
		System.out.println(obj); 
	} 
}

泛型定义在方法上

import java.util.*;
class Demo
{
	public <T> void show(T t)
	{
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print:"+q);
	}
}
class GenericDemo5
{
	public static void main(String [] args)
	{
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
		d.print("hehe");
	}
}

泛型定义在接口上

import java.util.*;
interface Inter<T>
{
	void show(T t);
}
class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("Show:"+t);
	}
}
class InterIm implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("Show:"+t);
	}
}
class GenericDemo7
{
	public static void main(String [] args)
	{
		InterImpl i = new InterImpl();
		i.show("haha");
		InterIm<Integer> im = new InterIm<Integer>();
		i.show(4);
	}
}

泛型高级应用

import java.util.*;
class GenericDemo8
{
	public static void main(String [] args)
	{
		ArrayList<String> al = new ArrayList<String>();

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

		ArrayList<Integer> al1 = new ArrayList<Integer>();

		al1.add(4);
		al1.add(7);
		al1.add(1);

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

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

(5) 集合框架(静态方法泛型) 
        泛型类中也可以定义泛型方法
特殊之处：静态方法不可以访问类上定义的泛型，因为只有在实例化的时候，才会使用泛型 
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。 
<T> 泛型写在返回值前。

集合框架(泛型接口)

interface Inter<T>
{
	void show(T t); 
}
class InterImpl implements Inter<String>
{
	void show(Stringt)//这里只能是 String
	{} 
} 
class InterImpl2<T> implements Inter<T>
{
	void show(T t);//这里类型不固定
	{} 
} 

(6) 集合框架(泛型通配符)

import java.util.ArrayList; 
import java.util.List; 
import java.util.Iterator; 
public class Test
{
	public static voidmain(String args[])
	{ 
		List<String> al = new ArrayList<String>(); 
		al.add("黑马程序员"); 
		al.add("CSDN社区"); 
		al.add("黑马程序员论坛"); 
		List<Integer> al1 = newArrayList<Integer>(); 
		al1.add(1); 
		al1.add(2); 
		al1.add(3); 
		printCollection(al); 
		printCollection(al1); 
	} 
	public static void printCollection(List<?> al)
	{ 
		for(Iterator<?> it = al.iterator();it.hasNext();)
		{ 
			System.out.println(it.next()); 
		} 
	} 
}

(7)集合框架(泛型限定(上限))
? 通配符
? extends E:可以接收 E 类型或者 E 的子类型。上限。
? super E：可以接收E类型或者E的父类型，下限

import java.util.*;
class GenericDemo8
{
	public static void main(String [] args)
	{
		ArrayList<Person> al = new ArrayList<Person>();

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

		ArrayList<Student> al1 = new ArrayList<Student>();

		al1.add(new Student("abc-1"));
		al1.add(new Student("abc-2"));
		al1.add(new Student("abc-3"));

		printColl(al1);//错误：ArrayList<Person> al = new arrayList<Student>();
	}
	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 Student extends Person
{
	Student(String name)
	{
		super();
	}
}

练习
? super E  可以接收E类型或者E的父类型，下限

import java.util.*;
class GenericDemo9
{
	public static void main(String [] args)
	{
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());

		ts.add(new Student("abc03"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc06"));
		ts.add(new Student("abc01"));

		Iterator<Student> it = ts.iterator();

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

		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

		ts1.add(new Worker("wabc---03"));
		ts1.add(new Worker("wabc---02"));
		ts1.add(new Worker("wabc---06"));
		ts1.add(new Worker("wabc---01"));

		Iterator<Worker> it1 = ts1.iterator();

		while(it1.hasNext());
		{
			System.out.println(it1.next().getName());
		}
	}
}
class Comp implements Comparator<person>
{
	public int compare(person s1,Person s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
class Person
{
	private String name;
	person(String name)
	{
		this.name = name;
	}
	public  String getName()
	{
		return name;
	}
	public String toString()
	{
		return "Person:"+name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super();
	}
}
class Worker extends
{
	Worker(String name)
	{
		super();
	}
}

使用泛型的实质：
是么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候， 
早期定义的Object来完成扩展。现在定义泛型类来完成扩展 
泛型类定义的泛型，在整个类中有效。如果被方法使用， 
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让相同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。 
特殊之处：
静态方法不可以访问类上定义的泛型。因为只有在实例化的时候，才会使用泛型。 
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。 
? 通配符。也可以理解为占位符。
泛型的限定：
？extends E: 可以接收E类型或者E的子类型。上限。 
？ super    E: 可以接收E类型或者E的父类型。下限 

二、 集合框架的工具类 Collections

(1) 概述

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

（相信Java的新手们都知道，如果一个类全都是静态方法的话，

  那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的） 
(2) Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。 
它有两个常用的子接口， 
List：对元素都有定义索引。有序的。可以重复元素。 
Set：不可以重复元素。无序。 
Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

     
              
              

                      

<span style="font-size:18px;">import java.util.*;
class CollectionsDemo
{
	public static void main(String [] args)
	{
		sortDemo();
		maxDemo();
		binarySearchDemo();
	}
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();
		 
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);
		sop(list);
		//int index =halfSearch(list,"aaa");
		int index = Collections.binarySearch(list,"aaa");
		sop("index="+index);
	}
	public static int halfSearch(List<String> list,String key)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid = (max+min)>>1;//  /2;
			String str = list.get(mid);
			int num =str.compareTo(key);
			if(num>0)
				max = mid-1;
			else if(num<0)
				min = mid +1;
			else
				return mid;
		}
		return -min-1;
	}
	//比较器
	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid = (max+min)>>1;//  /2;
			String str = list.get(mid);
			int num =cmp.compare(str,key);
			if(num>0)
				max = mid-1;
			else if(num<0)
				min = mid +1;
			else
				return mid;
		}
		return -min-1;
	}
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();
		 
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*,new StringComparator()*/);
		sop("max="+max);
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();
		 
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");

		sop(list);

		Collections.sort(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);
	}
}</span>

fill方法：
    可以将list集合中所有元素替换成指定元素。

<span style="font-size:18px;">import java.util.*;
class CollectionsDemo2
{
	public static void main(String [] args)
	{
		fillDemo();
    }
	public static void fillDemo()
	{
		List<String> list = new ArrayList<String>();
		 
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		sop(list);
		Collections.fill(list,"pp");
		sop(list);
	}
}
/*

replaceAll(list,oldvalue,newvalue)
reverse(0
*/
import java.util.*;
class CollectionsDemo3
{
	public static void main(String [] args)
	{
		replaceAllDemo();
    }
	public static void replaceAllDemo()
	{
		List<String> list = new ArrayList<String>();
		 
		list.add("abcd");
		list.add("aaa");
		list.add("z");
		list.add("kkkkk");
		list.add("qq");
		
		sop(list);
		Collections.replaceAll(list,"aaa","bbb");
		sop(list);
		Collections.reverse(list);
		sop(list);	
	}
}</span>

练习

import java.util.*;
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		/*
		int num = s1.compareTo(s2);
		if(num>0)
		   return -1;
		if(num<0)
		   return 1;
		return num
		*/
		return s2.compareTo(s1);
	}
}
class CollectionsDemo4
{
	public static void main(String [] args)
	{
		orderDemo();
    }
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		 
		ts.add("abcd");
		ts.add("aaa");
		ts.add("z");
		ts.add("kkkkk");
		ts.add("qq");
		
		Iterator it = ts.iterator();

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

三、集合框架的工具类Arrays

Arrays:用于操作数组的工具类。里面都是静态方法。

        

asList:将数组变成list集合。

import java.util.*;
class ArraysDemo
{
	public static void main(String [] args)
	{
		//int [] arr ={2,4,5};
		//sop(Arrays.toString(arr));
		String [] arr ={"abh","nkj","hhh"};
		/*
		把数组变成list集合的好处
		  可以使用集合的思想和方法来操作数组中的元素。
		  注意：将数组变成集合，不可以使用集合的增删方法，
		  因为数组的长度是固定的。
		  可以用的方法有:
		  contains
		  get
		  indexOf();
		  subList();
		  如果增删，那么就会发生UnsupportedOperationException

		*/
		List<String> list = Arrays.asList(arr);
		sop(list);
		/*
		如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在。
		*/
		int [] nums ={2,4,5};
		List<int []> li = Arrays.asList(nums);
		sop(li);//打印结果是数组的地址
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

集合变数组
Collection接口中的toArray方法。

import java.util.*;
class ArraysDemo
{
	public static void main(String [] args)
	{
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		/*
		1,指定类型的数组定义多长
		  当指定类型的数组长度小于了集合的size，
		  那么该方法内部会创建一个新的数组，长度为集合的size。
		  当指定类型的数组长度大于了集合的size，就不会创建新的数组，
		  而是使用传递进来的数组，所以创建一个刚刚好的数组最优。
		2,为什么要将集合变数组？
			是为了限定对元素的操作，不需要进行增删。
		*/
		String [] arr = al.toArray(new String [al.size()]);
		sop(Arrays.toString(arr));

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

四、高级for循环
(1) 格式：
for（数据类型 变量名：被遍历的集合(Collection)或者数组）
{}
对集合进行遍历，只能获取元素，但是不能对集合进行操作；
迭代器除了遍历还可以进行remove集合中元素的动作。
如果使用ListIterator，还可以在遍历过程中进行增删改查动作。
(2) 传统for循环和高级for循环的区别：
高级for有个局限性：必须有被遍历的目标。
建议在遍历数组时候，使用传统for，因为传统for可以定义角标。

import java.util.*;
class ForEachsDemo
{
	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)
		{
			sop(s);
		}
		/*
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
		*/
		int [] arr = {3,5,2,4};
		for(int i: arr)
		{
			sop("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)
		{
			sop(i+"::"+hm.get(i));
		}
		//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
		//for(Map.Entry<Integer,String> me : entrySet)
		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			sop(me.getKey()+"_____"+me.getValue());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

JDK1.5版本出现的新特性。
方法的可变参数
在使用时注意：可变参数一定要定义在参数列表的最后面。

import java.util.*;
class NewDemo
{
	public static void main(String [] args)
	{
		//可变参数。不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组
		
	}
	public static void show(int... arr)
	{
		System.out.println(arr);
	}
}

 JDK1.5版本出现的新特性。

 Import Static静态导入

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

当方法重名时，需要指定具备所属的对象或者类

import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
class StaticImport
{
	public static void main(String [] args)
	{
		int [] arr ={3,1,5};
		sort(arr);
		int index = binarySearch(arr,1);
		System.out.println("Index="+index);
		System.out.println(Arrays.toString(arr));
	}
}