------------android培训、java培训、java学习型技术博客、期待与您交流！ ------------
1.泛型
JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2.避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
问：在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<> 就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
特点：
1.提高了程序的安全性
2.将运行期遇到的问题转移到了编译期
3.省去了类型强转的麻烦
4.泛型类的出现优化了程序设计
TreeSet集合泛型与自定义比较器示例：
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());//泛型
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 LenComparator implements Comparator<String>
{
public int compare(String o1,String o2)
{
int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
if(num==0)
return o2.compareTo(o1);
return num;
}
}
泛型类
问什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
泛型类示例：
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);
}
}
class GenericDemo
{
public static void main(String[] args)
{
Demo <String> d = new Demo<String>();
d.show("haha");
d.print(5);
d.print("hehe");
Demo.method("hahahahha");
}
}泛型定义在接口上示例:
interface Inter<T>
{
void show(T t);
}
/*
class InterImpl implements Inter<String>
{
public void show(String t)
{
System.out.println("show :"+t);
}
}
*/
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show :"+t);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
//InterImpl i = new InterImpl();
//i.show("haha");
}
}2.Map集合
Map<K,V>:Map存储的是键值对形式的元素,它的每一个元素，都是由键和值两个元素组成,键是不能有重复的，值是可以重复的,每一个键唯一指向一个值
Map集合与conllection：
1.Map与Collection在集合框架中属并列存在
2.Map存储的是键值对
3.Map存储元素使用put方法，Collection使用add方法
4.Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素
5.Map集合中键要保证唯一性
Map接口的功能：
1.添加
V put(K key, V value) :将指定的值与此映射中的指定键关联(可选操作)。
void putAll(Map<? extends K,? extends V> m):从指定映射中将所有映射关系复制到此映射中(可选操作）。
2.删除
void clear():从此映射中移除所有映射关系（可选操作）。
V remove(Object key) :如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
3.判断
boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值，则返回 true。
boolean containsKey(Object key):如果此映射包含指定键的映射关系，则返回 true。
boolean isEmpty():如果此映射未包含键-值映射关系，则返回 true。
4.获取
V get(Object key):返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int size():返回此映射中的键-值映射关系数。
values():返回此映射中包含的值的 Collection 视图。
entrySet():
keySet():
Map常用类：
|---->Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低，已被HashMap替代。
|---->HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，线程不同步，将hashtable替代，jdk1.2.效率高。
|---->TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序，排序原理与TreeSet相同。
常用操作示例：import java.util.*;
class demo
{
public static void main(String[] args)
{
//建立Map集合
Map<String,String> map=new HashMap<String,String>();
添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("04","zhangsan4");
sop(map.containsKey("02"));//判断键是否存在
sop(map.get("01"));//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
sop(map);//打印结果：{04=zhangsan4, 01=zhangsan1, 02=zhangsan2, 03=zhangsan3}
Collection<String> coll=map.values();//用values获取map集合中所有的值.
sop(coll);//打印结果：[zhangsan4, zhangsan1, zhangsan2, zhangsan3]
}
public static void sop(Object obj)//为了打印方便建立一个函数
{
System.out.println(obj);
}
}
Map集合元素的两种取出方式
方式1：Set<k> keySet
A:先获取键的集合
B:遍历键的集合,获取每一个键
C:根据键获取值
流程：将map中所有的键存入到Set集合。因为set具备迭代器。所以可以用迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。
代码示例：
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();
map.put("01","zhansan01");
map.put("02","zhansan02");
map.put("03","zhansan03");
map.put("04","zhansan04");
Set<String> s=map.keySet();//先获取map集合的所有键的Set集合,keySet();
System.out.println(map);//有了Set集合。就可以获取其迭代器
for(Iterator<String> it=s.iterator(); it.hasNext();)
{
String key=it.next();
String value=map.get(key);//有了键可以通过map集合的get方法获取其对应的值。
System.out.println(key+"..."+value);
}
}
}
方式2：Set<Map.Entry<k,v>> entrySet
A:先获取键值对关系的集合
B:遍历键值对关系的集合获取每个键值对的关系
C:通过键值对关系获取键值
流程：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
代码示例：
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(01,"java01");
map.put(02,"java02");
map.put(03,"java03");
map.put(04,"java04");
Set<Map.Entry<Integer,String>> entrySet=map.entrySet();//将Map集合中的映射关系取出。存入到Set集合中。
for(Iterator<Map.Entry<Integer,String>> it=entrySet.iterator();it.hasNext();)
{
Map.Entry<Integer,String> me=it.next();
Integer key=me.getKey();
String value=me.getValue();
System.out.println(key+"...."+value);
}
}
}
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。
HashMap
底层数据结构是哈希表,可以存入null键null值,线程不安全,效率高.
练习:使用HashMap存储Student元素,并遍历,要求键是Student类型：表示学生对象(name,age);值是String类型：表示学号.同名同年龄为同一人,为避免加入相同元素,需要复写hashCode和equals方法
/*
1.描述学生.
2.定义map容器.将学生作为键.住址作为值,存入.
3.获取map集合中的元素
*/
import java.util.*;
class Student implements Comparable<Student>//为了以后方便可能存进去TreeSet集合中去实现Comparable.将学生具备比较性
{
private String name;
private int age;
Student(String name,int age)//将学生name和age初始化
{
this.name=name;
this.age=age;
}
public int compareTo(Student s)//覆盖Comparable中的compareTo方法.来比较,先比较age在比较name.
{
int num=new Integer(this.age).compareTo(new Integer(s.age));//Integer是因为age是基本数据类型不具备比较.要转成Integer来实现compareTo方法
if(num==0)
return this.name.compareTo(s.name);//name是字符串本身就比较比较性.直接使用compareTo方法
return num;
}
//复写hashCode来让存进去的学生保证唯一。为什么要覆盖因为默认比较是比较hash值和内容是否一样,因为存的是hash值所以每次建立对象的时候都不一样
//所以要复写hashCode,来比较年龄和姓名是否是相同.这样就能保证学生的唯一性了.
public int hashCode()
{
return name.hashCode()+age*34;
}
public boolean equals(Object obj)//如果年龄相同的话在比较年龄.
{
if(!(obj instanceof Student))//如果穿进去不的不是学生类.抛异常
throw new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name) && this.age==s.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+".."+age;
}
}
public class MapTest
{
public static void main(String[] args)
{
HashMap<Student,String> hm=new HashMap<Student,String>();//穿件Map集合中的 HashMap集合
hm.put(new Student("zhangsan01",21),"beijing");//往里面添加键值对.将学生作为键.住址作为值
hm.put(new Student("zhangsan02",22),"tianjing");
hm.put(new Student("zhangsan03",23),"shanghai");
hm.put(new Student("zhangsan01",23),"shanghai");
System.out.println("第一种取出方式：");
//第一种去取出方式：Set<k> keySet
Set<Student> s=hm.keySet();
for(Iterator<Student> it=s.iterator();it.hasNext();)
{
Student key=it.next();
String value=hm.get(key);
System.out.println(key+"...."+value);
}
System.out.println("第二种取出方式：");
//第二种取出方式：Set<Map.Entry<k,v>> entrySet
Set<Map.Entry<Student,String>> entrySet=hm.entrySet();
for(Iterator<Map.Entry<Student,String>> it=entrySet.iterator();it.hasNext();)
{
Map.Entry<Student,String> me=it.next();
Student key1=me.getKey();
String value1=me.getValue();
System.out.println(key1+"..."+value1);
}
}
}
TreeMap
底层数据结构是二叉树，线程不安全.底层是二叉树，当定义的键值对要求有序时,使用TreeMap。练习：对学生对象的年龄进行升序排序。
import java.util.*;
class StuNameComparator implements Comparator<Student>//定义一个比较器类，将其对象作为参数传递给集合
{
public int compare(Student s1,Student s2)
{
int num = s1.getName().compareTo(s2.getName());//字符串本身具有比较性
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));//Integer是因为age是基本数据类型不具备比较.要转成Integer来实现compareTo方法
return num;
}
}
class MapTes
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
tm.put(new Student("blisi3",23),"nanjing");
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("alisi4",24),"wuhan");
tm.put(new Student("lisi1",21),"tianjin");
tm.put(new Student("lisi2",22),"shanghai");
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me = it.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
3.Collections类
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection区别
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口：List，Set；List：对元素都有定义索引。有序的。可以重复元素。Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的，提供的方法中有可以对list集合进行排序，二分查找等方法。
注意：通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
Collections的常用方法
sort:对List集合进行排序
void sort(List<T> list)：
根据元素的自然顺序 对指定列表按升序进行排序。 列表中的所有元素都必须实现Comparable 接口。此外，列表中的所有元素都必须是可相互比较的。
void sort(List<T> list,Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较
max获取最大值：
----------------------------
max:获取最大值
T max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现 Comparable接口
T max(Collection<? extends T> coll,Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器相互比较
----------------------------
binarySearch:对list集合二分查找(必须是有序的)
int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。
int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序（通过 sort(List, Comparator) 方法）。
----------------------------
fill:将集合中的元素替换成指定元素
void fill(List<? super T> list,T obj)使用指定元素替换指定列表中的所有元素。
----------------------------
replaceAll:替换
boolean replaceAll(List<T> list,T oldVal,T newVal)
使用另一个值替换列表中出现的所有某一指定值。更确切地讲，使用 newVal 替换 list 中满足 (oldVal==null ? e==null : oldVal.equals(e)) 的每个 e 元素。
----------------------------
reverse:反转
void reverse(List<?> list)反转指定列表中元素的顺序。
----------------------------
reverseOrder：强行逆转比较
Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
----------------------------
List<T> synchronizedList(List<T> list) 返回指定列表支持的同步（线程安全的）列表。
Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全的）映射。
Set<T> synchronizedSet(Set<T> s) 返回指定 set 支持的同步（线程安全的）set
----------------------------
swap:指定位置上交换元素
void swap(List<?> list,int i,int j)
在指定列表的指定位置处交换元素。（如果指定位置相同，则调用此方法不会更改列表。）
----------------------------
shuffle:把集合中的元素随机的排放
void shuffle(List<?> list)使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
collections方法示例代码：
import java.util.*;
public class collection {
public static void main(String[] args)
{
binarySearchDemo();
}
//sort:对List集合进行排序，swap:指定位置上交换元素
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);//打印结果：[abcd, aaa, zz, kkkkk, qq, z]
Collections.sort(list);//根据元素的自然顺序对指定列表按升序进行排序
sop(list);//打印结果：[aaa, abcd, kkkkk, qq, z, zz]
Collections.sort(list,new StrLenComparator());//根据指定比较器排序
sop(list);//打印结果：[z, qq, zz, aaa, abcd, kkkkk]
Collections.swap(list,1,2);//指定位置上交换元素,索引为1的元素与索引为2的元素交换
sop(list);//打印结果：[z, zz, qq, aaa, abcd, kkkkk]
}
//max:获取最大值
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
String max1 = Collections.max(list/*,new StrLenComparator()*/);
sop("max="+max1);//打印结果：max=zz
String max2 = Collections.max(list,new StrLenComparator());//传入指定比较器，长度比较
sop("max="+max2);//打印结果：max=kkkkk
}
//binarySearch:对list集合二分查找(必须是有序的)
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list);//自然顺序排序
int index1 = Collections.binarySearch(list,"aaaa");
sop("index1="+index1);
Collections.sort(list,new StrLenComparator());//自定义比较器排序
int index2 = Collections.binarySearch(list,"aaaa",new StrLenComparator());
sop("index2="+index2);//打印结果为-5，应该插入位置取负再减去1
//使用自定义的二分查找方法
int index3 = halfSearch(list,"aaaa");
sop("index3="+index3);
int index4 = halfSearch(list,"aaaa",new StrLenComparator());
sop("index4="+index4);//打印结果为-5，应该插入位置取负再减去1
}
//自定义二分查找方法
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 halfSearch(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;
}
//fill:将集合中的元素替换成指定元素
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop(list);
Collections.fill(list,"pp");
sop(list);
/*测试结果：
[abcd, aaa, zz, kkkkk]
[pp, pp, pp, pp]*/
}
//replaceAll:替换,reverse:反转
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop(list);
//打印结果：[abcd, aaa, zz, kkkkk]
Collections.replaceAll(list,"aaa","pp");
sop(list);
//打印结果：[abcd, pp, zz, kkkkk]
Collections.reverse(list);
sop(list);
//打印结果：[kkkkk, zz, pp, abcd]
}
//reverseOrder：强行逆转比较
public static void orderDemo()
{
//将指定比较器逆转比较
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
//打印结果：由长到短
}
//shuffle:把集合中的元素随机的排放
public static void shuffleDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);//打印结果：[abcd, aaa, zz, kkkkk, qq, z]
Collections.shuffle(list);
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);
}
}
4.Arrays类
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
(一)将数组转换为List集合List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表 ,即将数组转换为集合.
把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素.
注意：
1.将数组变成集合，不可以使用集合的增删方法,因为数组的长度是固定.如果增删,会发生UnsupportedOperationException异常(不可操作异常).
2.如果数组中的元素都是对象,那么变成集合时，数组中的元素就直接转成集合中的元素.如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在.
import java.util.*;
public class ArraysDemo
{
public static void main(String[] args)
{
int[] arr = {2,4,5};
System.out.println(Arrays.toString(arr));
String[] strarr = {"abc","cc","kkkk"};
List<String> list = Arrays.asList(strarr);
//sop("contains:"+list.contains("cc"));
//如果使用集合中的增删方法，会抛出异常
//list.add("qq");//UnsupportedOperationException,
//sop(list);
int[] intnums = {2,4,5};
List li1 = Arrays.asList(intnums);
System.out.println(li1);//数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在，[[I@1fb8ee3]
Integer[] nums = {2,4,5};
List<Integer> li2 = Arrays.asList(nums);
System.out.println(li2);//打印结果：[2, 4, 5]
}
} (二)集合变数组。
Collection接口中的toArray方法。
1.指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2.为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
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[al.size()]);
System.out.println(Arrays.toString(arr));
//打印结果：[abc1, abc2, abc3]
}
}个人总结
JAVA中集合的学习在这个地方也告一段落了，在学习的过程中自己觉得东西太多，集合的分支太多，可能有些地方一略而过，但是我个人觉得明要明白集合框架中各个分支的区别，比如：是否允许null值，是否排序，是否需要线程同步，是否是以键值对的形式存储等等，只要分清楚它们之间各个的特点，在实际的使用过程中就应该很快的根据自己的需求选择合适的集合，当然泛型也给集合的操作带来了不小的方便，必须合理的运用起来。
8361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
