----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------
泛型概述
泛型:JDK1.5版本以后出现的新特性。用于解决安全问题,是一个类型安全机制。
泛型好处:
1.将运行时期出现的问题ClassCastException,转移到了编译时期,方便于程序员解决问题,让运行时期问题减少。
2.避免了强制转换的麻烦。
泛型格式:通过<>来定义要操作的引用数据类型。
泛型的使用:通常在集合框架中很常见,只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时,将集合要存储的数据类型作为参数传递到<>中即可。
泛型类:当类中要操作的引用数据类型不确定的时候,就定义泛型类。如:class Utils<T>{}
泛型方法:因为泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型,而且类型还不确定,那么可以将泛型定义在方法上。
如:public <T> void show(T t){}
注:静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定,可以将泛型定义在静态方法上。
如:public static <T> void method(T t){}
泛型接口:泛型定义在接口上。如:interface Inter<T>{}
泛型限定
?:通配符。可以理解为占位符。意思为不明确具体类型。
泛型限定:
? extends E:可以接收E类型或者E的子类型。E为上限。
? super E:可以接收E类型或者E的父类型。E为下限。
Map集合:该集合存储键值对。一对一对往里存,而且要保证键的唯一性。
Map集合共性方法:
1.添加:
put(K key,V value);
putAll(Map<? extends K,? extends V>m);
2.删除:
clear();
remove(Object key);
3.判断:
containsValue(Object value);
containsKey(Object key);
isEmpty();
4.获取:
get(Object key);
size();
value();
entrySet();
keySet();
Map集合子类对象的特点
Map
|------Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0版本出现,效率低。
|------HashMap:底层是哈希表数据结构,允许使用null键null值,该集合是线程不同步的。JDK1.2版本出现,效率高。
|------TreeMap:底层是二叉树数据结构,线程不同步。可以用于给Map集合中的键进行自然排序。
Map集合的两种取出方式:
1.keySet:将Map集合中所有的键存入到Set集合。因为Set集合具备迭代器,所以可以迭代方式取出所有的键,再根据get方法,获取每一个键对应的值。
keySet取出原理:将Map集合转成Set集合,再通过迭代器取出。
示例1:
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();
map.put("01","wanglin01");
map.put("03","wanglin03");
map.put("04","wanglin04");
map.put("02","wanglin02");
Set<String> keySet=map.keySet();
Iterator<String> it=keySet.iterator();
while(it.hasNext())
{
String key=it.next();
String value=map.get(key);
System.out.println("key:"+key+",value:"+value);
}
}
}
2.entrySet:将Map集合中的映射关系存入到了Set集合中,而这个关系的数据类型就是:Map.Entry<K,V>。
示例2:
import java.util.*;
class MapDemo3
{
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();
map.put("01","wanglin01");
map.put("03","wanglin03");
map.put("04","wanglin04");
map.put("02","wanglin02");
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+"::"+value);
}
}
}
注:Map.Entry其实是Map接口的一个内部接口。
Map集合的应用:当数据之间存在映射关系时,就要先想到Map集合。
Collections:集合框架的工具类。
Collections的主要功能介绍:
1.Collections.sort(List<T> list):用于给List集合排序。
示例1:
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void sortDemo()
{
List<String> list=new ArrayList<String>();
list.add("acv");
list.add("bsd");
list.add("kjdaaa");
list.add("qq");
list.add("x");
list.add("qq");
sop(list);
Collections.sort(list);//按照自然顺序排序。
Collections.sort(list,new StrLenComparator());//按照定义的比较器进行排序。
sop(list);
}
}
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);
}
}
2.Collections.max(List<T> list):获取按自然顺序排列的最大元素。
3.Collections.binarySearch(List<T> list,element):用折半查找的方式索引指定的元素。
4.Collections.fill(List<T> list,element):将List集合中的所有元素替换为指定的元素。
Collections.fill(sublist,element):将List集合中部分元素替换为指定的元素。
Collections.replaceAll(List<T> list,oldvalue,newvalue):将List集合中的原值替换为指定的新值。
Collections.reverse(List<T> list):将List集合反转。
示例4:
import java.util.*;
class CollectionsDemo4
{
public static void main(String[] args)
{
demo(1,4);
}
public static void demo(int start,int end)
{
List<String> list=new ArrayList<String>();
list.add("acv");
list.add("bsd");
list.add("kjdaaa");
list.add("qq");
list.add("x");
list.add("qq");
sop(list);
List<String> sub=list.subList(start,end);
Collections.fill(sub,"pp");
sop(list);
sop(list);
Collections.replaceAll(list,"qq","kkkkk");
sop(list);
sop(list);
Collections.reverse(list);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
5.Collections.reverseOrder():反转自然顺序。
6.Collections.synchronizedList(List<T> list):给List集合加锁,将其变为同步。
Arrays:用于操作数组的工具类,里面都是静态方法。
Arrays.asList:将数组变成List集合。
将数组变成集合的好处:可以使用集合的思想和方法来操作数组中的元素。
将数组变成集合的注意事项:
1.将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的。可以使用的方法:contains();get();indexOf();subList()。
2.如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
示例:
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
String[] arr={"abc","qq","ccccc"};
List<String> list=Arrays.asList(arr);
sop("contains:"+list.contains("qq"));
//list.add("aaa");
sop(list);
int[] nums={2,4,54};
List<int[]> li1=Arrays.asList(nums);
sop(li1);
Integer[] num={2,4,54};
List<Integer> li2=Arrays.asList(num);
sop(li2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
集合变成数组:Collection接口中的toArray方法。
集合变成数组的好处:为了限定对元素的操作。主要限定对元素进行增删。
示例:
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al=new ArrayList<String>();
al.add("wanglin01");
al.add("wanglin02");
al.add("wanglin03");
//String[] arr=al.toArray(new String[6]);
String[] arr=al.toArray(new String[al.size()]);//创建一个刚刚好的数组最优。
System.out.println(Arrays.toString(arr));
}
}
JDK1.5版本出现的新特性:
增强for循环(JDK1.5版本出现,可以简化书写)
格式:for(数据类型 变量名:被遍历的集合或者数组){}
增强for循环与迭代器的区别:增强for循环对集合进行遍历,只能获取元素,但是不能对集合进行操作。迭代器除了遍历,还可以进行删除集合中元素的动作。如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
注意:增强for循环有一个局限性,就是必须要有被遍历的目标。
可变参数(JDK1.5版本出现的新特性):其实就是一种数组参数的简写形式。不用每一次都手动建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
注意:可变参数一定要定义在参数列表最后面。
示例:
class ParamMethodDemo
{
public static void main(String[] args)
{
show("wanglin",4,6,3,7,9,23);
}
public static void show(String s,int...arr)
{
sop(arr);
sop("length:"+arr.length);
for(int i:arr)
{
sop(i);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
静态导入:导入一个类中所有的静态成员。
示例:import java.util.*;//导入的是util包中的类。
import static java.util.Arrays.*;//导入的是Arrays这个类中所有的静态成员。
System类:描述系统一些信息。类中的方法和属性都是静态的。
获取系统属性信息方法:getProperties();
示例:
import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{
Properties prop=System.getProperties();
//在系统中自定义特有信息。
System.setProperty("tangwei","i love wanglin");
//获取指定属性信息。
String value1=System.getProperty("os.name");
System.out.println("value1="+value1);
String v=System.getProperty("haha");
System.out.println("v="+v);
//获取所有属性信息。
for(Object obj:prop.keySet())
{
String value=(String)prop.get(obj);
System.out.println(obj+":::"+value);
}
}
}
Runtime类:该类使用了单例设计模式。
获取Runtime对象的方法:getRuntime();
示例:
class RuntimeDemo
{
public static void main(String[] args)throws Exception
{
Runtime r=Runtime.getRuntime();
//打开一个子进程。
Process p1=r.exec("winmine.exe");
Process p2=r.exec("notepad.exe SystemDemo.java");
Thread.sleep(10000);
p1.destroy();//清除子进程。
}
}
Date类:描述日期。
示例:
import java.util.*;
import java.text.*;
class DateDemo
{
public static void main(String[] args)
{
Date d=new Date();
System.out.println(d);
//将模式封装到SimpleDateFormat对象中。
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");
//调用format方法让模式格式化指定Date对象。
String time=sdf.format(d);
System.out.println("time="+time);
}
}
Calendar类:描述日历。
示例:
import java.util.*;
class CalendarDemo
{
public static void main(String[] args)
{
Calendar c=Calendar.getInstance();
sop(c);
c.set(2013,4,22);
//对指定日期进行加减。
c.add(Calendar.DAY_OF_MONTH,15);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
Math类:里面都是数学方法。
示例:
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
double d=Math.ceil(15.23);//ceil方法返回大于指定数据的最小整数。
double d1=Math.floor(12.98);//floor方法返回小于指定数据的最大整数。
long l=Math.round(19.49);//四舍五入。
sop("d="+d);
sop("d1="+d1);
sop("l="+l);
double d2=Math.pow(5,9);//5的9次幂。
sop("d2="+d2);
Random r=new Random();
for(int x=0;x<10;x++)
{
int b=(int)(Math.random()*10+1);//随机生成1-10的数字。
sop(b);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------