黑马程序员——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 al = new ArrayList();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
//al.add(4);
Iterator 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 ts = new TreeSet();
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it =ts.iterator();
while(it.hasNext())
{
String s =it.next();
System.out.println(s);
}
}
}
class LengthComparator implements Comparator
{
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;
}
} 什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义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
{
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 u = new Utils();
u.setObject(new Worker);
Worker w = u.getObject();
}
泛型可以让程序员避免强制转换的麻烦，并且把运行时强转问题转化到了编译时期。
集合框架(泛型方法)泛型类定义的泛型，在整个类中有效，如果被方法是用到泛型，类的对象明确。
操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，
而且类型还不确定，那么可以将泛型定义在方法上，而不定义在类上。
public
//类型已经确定.
class GenericTest
{
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 void show(Q q)
{
sop("show_2:"+q);
}
public 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 d = new GenericTest();
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 void show(T t)
{
System.out.println("show:"+t);
}
public 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
{
void show(T t);
}
class InterImpl implements Inter
{
public void show(String t)
{
System.out.println("Show:"+t);
}
}
class InterIm implements Inter
{
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 im = new InterIm();
i.show(4);
}
} 泛型高级应用
import java.util.*;
class GenericDemo8
{
public static void main(String [] args)
{
ArrayList al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
ArrayList al1 = new ArrayList();
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) 集合框架(静态方法泛型)
泛型类中也可以定义泛型方法
特殊之处：静态方法不可以访问类上定义的泛型，因为只有在实例化的时候，才会使用泛型
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
集合框架(泛型接口)
interface Inter
{
void show(T t);
}
class InterImpl implements Inter
{
void show(Stringt)//这里只能是 String
{}
}
class InterImpl2 implements Inter
{
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 al = new ArrayList();
al.add("黑马程序员");
al.add("CSDN社区");
al.add("黑马程序员论坛");
List al1 = newArrayList();
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 al = new ArrayList();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc3"));
ArrayList al1 = new ArrayList();
al1.add(new Student("abc-1"));
al1.add(new Student("abc-2"));
al1.add(new Student("abc-3"));
printColl(al1);//错误：ArrayList al = new arrayList();
}
public static void printColl(ArrayList al)
{
Iterator 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 ts = new TreeSet(new Comp());
ts.add(new Student("abc03"));
ts.add(new Student("abc02"));
ts.add(new Student("abc06"));
ts.add(new Student("abc01"));
Iterator it = ts.iterator();
while(it.hasNext());
{
System.out.println(it.next().getName());
}
TreeSet ts1 = new TreeSet(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 it1 = ts1.iterator();
while(it1.hasNext());
{
System.out.println(it1.next().getName());
}
}
}
class Comp implements Comparator
{
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的父类型。下限
(1) 概述
Collections:集合框架的工具类。里面定义的都是静态方法。
（相信Java的新手们都知道，如果一个类全都是静态方法的话，
那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的）
(2) Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
import java.util.*;
class CollectionsDemo
{
public static void main(String [] args)
{
sortDemo();
maxDemo();
binarySearchDemo();
}
public static void binarySearchDemo()
{
List list = new ArrayList();
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 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 list,String key,Comparator 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 list = new ArrayList();
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 list = new ArrayList();
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
{
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);
}
} 可以将list集合中所有元素替换成指定元素。
import java.util.*;
class CollectionsDemo2
{
public static void main(String [] args)
{
fillDemo();
}
public static void fillDemo()
{
List list = new ArrayList();
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 list = new ArrayList();
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);
}
}
import java.util.*;
class StrComparator implements Comparator
{
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 ts = new TreeSet(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 list = Arrays.asList(arr);
sop(list);
/*
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在。
*/
int [] nums ={2,4,5};
List 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 al = new ArrayList();
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 al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s: al)
{
sop(s);
}
/*
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next());
}
*/
int [] arr = {3,5,2,4};
for(int i: arr)
{
sop("i:"+i);
}
HashMap hm = new HashMap();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set keySet = hm.keySet();
for(Integer i : keySet)
{
sop(i+"::"+hm.get(i));
}
//Set> entrySet = hm.entrySet();
//for(Map.Entry me : entrySet)
for(Map.Entry 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);
}
}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));
}
}