java-API中的常用类,新特性之-泛型,高级For循环,可变参数

API中的常用类

System类
System类包含一些有用的类字段和方法。它不能被实例化。属性和方法都是静态的。

out,标准输出,默认打印在控制台上。通过和PrintStream打印流中的方法组合构成输出语句。
In,标准输入,默认是键盘,获取键盘录入的所有内容。
描述系统的一些信息:
Properties getProperties(),获得系统的属性信息。
Properties是HashTable的子类,是Map集合的子类对象;属性类,比较常用。该集合中存储的都是字符串,没有泛型定义。获取系统属性信息,与每台电脑的系统有关。
java是跨平台语言,需要知道系统种类决定以后的操作。
开发中,需要先了解平台的系统信息,进而决定采用何种操作。
设置信息:setProperty,在系统中自定义一些特有信息,例如,配置文件、目录等。
获得单个信息:getProperty(String key),获取指定属性的信息,例如,os.name。指定键没有的话,返回null。
虚拟机动态的加载指定系统信息:在DOS通过-D设置信息,然后再运行,例如,java –Dhaha=qq SystemDemo。

 import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{ Properties prop = System.getProperties();
//Properties是HashTable的子类,是Map集合的子类对象;属性类,比较常用。
//该集合中存储的都是字符串,没有泛型定义。获取系统属性信息,与每台电脑的系统有关。
//可以通过map的方法取出该集合中的元素。
/*
//获取所有属性信息。
for(Object obj : prop.keySet())
{
String value = (String)prop.get(obj); System.out.println(obj+"::"+value);
}
*/ //如何在系统中自定义一些特有信息呢?
System.setProperty("mykey","myvalue"); //获取指定单个属性信息。
String value1 = System.getProperty("os.name"); System.out.println("os.name="+value1);
}
}

Runtime类
Runtime没有构造函数、多是非静态方法,只提供一个静态方法获取本类对象,进而调用各个方法。该静态方法是,getRuntime(),返回值类型是本类类型。
由这个特点可以看出该类使用了单例设计模式完成。
exec(String command),在单独的进程中执行指定的字符串命令。字符串命令可能会出现错误,所以需要抛出异常。
例如,run.exec("D:\\Tencent\\QQ\\Bin\\QQProtect\\Bin\\QQProtect.exe");启动QQ。
exec()返回一个进程,Process类,抽象类,没有构造函数,因为底层在系统内创建进程对象。内部的destroy()方法,秒杀子进程。只能杀死自己启动的对象,已经启动的对象无法杀死。

还可以通过程序打开文件,例如,run.exec("notepad.exe RuntimeDemo.java");。

 class  RuntimeDemo
{
public static void main(String[] args) throws Exception
{
Runtime r = Runtime.getRuntime();
Process p = r.exec("D:\\Tencent\\QQ\\Bin\\QQProtect\\Bin\\QQProtect.exe"); Thread.sleep(4000);
p.destroy();
Process p1 = r.exec("notepad.exe RuntimeDemo.java" ); Thread.sleep(4000);
p1.destroy(); }
}

Date,Calendar类

 import java.util.*;
import java.text.*;
class DateDemo
{
public static void main(String[] args)
{
Date d = new Date();
System.out.println("time:"+d);//打印的时间看不懂,希望格式化时间。 //将模式封装到SimpleDateformat对象中。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:ss"); //调用format方法让模式格式化指定Date对象。
String newtime = sdf.format(d);
System.out.println("newtime:"+newtime); //当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差(以毫秒为单位测量)。
long l = System.currentTimeMillis();
System.out.println("currentTimeMillis="+l);
}
}
---------- java ----------
time:Sat Aug 10 22:48:04 CST 2013
newtime:2013年08月10日 星期六 10:48:04
currentTimeMillis=1376146084416 输出完成 (耗时 0 秒) - 正常终止
 import java.util.* ;
public class CalendarDemo{
public static void main(String args[]){
Calendar calendar = new GregorianCalendar(); // 实例化Calendar类对象 System.out.println("年: " + calendar.get(Calendar.YEAR));
System.out.println("月: " + (calendar.get(Calendar.MONTH) + 1));
System.out.println("日: " + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("时: " + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("分: " + calendar.get(Calendar.MINUTE));
System.out.println("秒: " + calendar.get(Calendar.SECOND));
System.out.println("毫秒: " + calendar.get(Calendar.MILLISECOND));
}
}
---------- java ----------
年: 2013
月: 8
日: 10
时: 23
分: 57
秒: 28
毫秒: 598 输出完成 (耗时 0 秒) - 正常终止

将指定字符串日期格式化

 import java.text.* ;
import java.util.* ;
public class SimpleDateFormatDemo{
public static void main(String args[]){
String strDate = "1988-10-19 10:11:30.345" ;
// 准备第一个模板,从字符串中提取出日期数字
String pat1 = "yyyy-MM-dd HH:mm:ss.SSS" ;
// 准备第二个模板,将提取后的日期数字变为指定的格式
String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒" ;
SimpleDateFormat sdf1 = new SimpleDateFormat(pat1) ;// 实例化模板对象
SimpleDateFormat sdf2 = new SimpleDateFormat(pat2) ;// 实例化模板对象
Date d = null ;
try{
d = sdf1.parse(strDate) ; // 将给定的字符串中的日期提取出来 Date parse(String text, ParsePosition pos)解析字符串的文本,生成Date。 }catch(Exception e){ // 如果提供的字符串格式有错误,则进行异常处理
System.out.println("异常:日期格式错误!") ; // 打印异常信息
}
System.out.println(sdf2.format(d)) ; // 将日期变为新的格式
}
}
---------- java ----------
1988年10月19日 10时11分30秒345毫秒 输出完成 (耗时 0 秒) - 正常终止

Math和Random类

各种数据的计算方法,都是静态方法。
ceil()返回大于或等于指定数据的最小整数。
floor()返回小于或等于指定数据的最大整数。
round():四舍五入,返回值尽量是long。
pow(a,b):a的b次幂,返回值尽量是double型。
randow():随机数,返回带正号的double值,大于或等于 0.0,小于 1.0。通过运算,可以获得其他区间的随机数,例如,int d = (int)(Math.random()*10+1);
也可以调用Random类中的方法,更广泛的获取随机数。创建随机数生成器,在通过各种next方法获得对应的随机数。

 import java.util.*;
class MathDemo
{
public static void main(String[] args)
{ Random r = new Random();
Set<Integer> ts = new HashSet<Integer>();
while(ts.size()!=7)
{
ts.add(r.nextInt(30)+1);//返回一个伪随机数,它是取自此随机数生成器序列的、在 0(包括)和指定值(不包括)之间均匀分布的int值。
} Integer[] arr = ts.toArray(new Integer[ts.size()]);
System.out.println("30选7:"+Arrays.toString(arr)); show(); }
public static void show()
{
double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。 long l = Math.round(12.24);//四舍五入 double d2 = Math.pow(2,3);//2的3次幂
sop("d="+d);
sop("d1="+d1); sop("l="+l); sop("d2="+d2);
}
public static void sop(Object obj)
{ System.out.println(obj);
}
}
---------- java ----------
30选7:[4, 20, 23, 7, 24, 10, 26]
d=17.0
d1=12.0
l=12
d2=8.0 输出完成 (耗时 0 秒) - 正常终止

可变参数
JDK1.5后的新特性,通过一个可以变长度的数组来储存值并进行操作,本质上仍是数组,是各种数组的简写形式。使用时注意:可变参数一定要定义在参数列表最后面。
例如
public static void show(int... arr){}

静态导入
导入工具类中的静态成员,例如,import static java.util.Arrays.*;,导入Arrays类中所有静态成员。
某些方法是Object和工具类共同拥有的,必须说明具体调用者才能正确使用。例如,System.out.println(Arrays.toString(arr));不说明的话默认是Object调用。

可变参数和静态导入用一个例子说明

 import java.util.*;
import static java.util.Arrays.*;
class ParamMethodDemo
{
public static void main(String[] args)
{
/*
可变参数。
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/
show(2,3,4,5,6);
show(2,3,4,5,6,10,35,9);
show("abc","cca","xxc");
show("abc","cca","xxy","zza","yyw");
add(2,3,5);
}
public static void show(Integer... arr)
{
Arrays.sort(arr);//1,可以写成sort(arr);
System.out.println(Arrays.toString(arr));//toString()是Object类和工具类共同拥有的,必须说明具体调用者才能正确使用。
}
public static void show(String... arr)
{
sort(arr);//2,同1
System.out.println(Arrays.toString(arr));
}
public static void add(int x,int ...arr)//可变参数一定要定义在参数列表最后面
{
int sum=x;
for(int i=0;i<arr.length;i++)
{
sum+=arr[i];
}
System.out.println("sum="+sum);
}
}
---------- java ----------
[2, 3, 4, 5, 6]
[2, 3, 4, 5, 6, 9, 10, 35]
[abc, cca, xxc]
[abc, cca, xxy, yyw, zza]
sum=10 输出完成 (耗时 0 秒) - 正常终止

 高级for循环
1.5以后,将iterator()方法单独构成一个接口Iterable,方便以后新建集合的使用,并提供高级for循环。底层仍然是调用迭代器,简化了书写。各种数据类型皆可,引用型和基本型
    格式:
    for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
    {
    
    }
    遍历中的操作
    高级for循环:对集合进行遍历,只能获取集合中的元素、但不能对集合进行操作,使用有局限性。
    迭代器:除了遍历,还可以remove()集合中的元素;如果使用ListIterator迭代器,还可以在遍历过程中对集合进行增删改查的动作。

高级for循环内部使用的数据类型是集合的泛型,如果集合没有定义泛型,使用Object。因为1.5以后定义了泛型,所以数据类型是泛型。

 /*
高级for循环
应用在Map取出元素
*/ import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{ HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c"); //第一种方法 for(Map.Entry<Integer,String> me : hm.entrySet())
{
System.out.println(me.getKey()+"....."+me.getValue());
} //第二种方法 Set<Integer> keyset = hm.keySet(); for(Integer i : hm.keySet())//set里什么类型for里就是什么类型
{
System.out.println(i+"-----"+hm.get(i));
}
}
}
---------- java ----------
1.....a
2.....b
3.....c
1-----a
2-----b
3-----c 输出完成 (耗时 0 秒) - 正常终止

泛型

JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。

好处:
1.将运行时期出现问题ClassCastException,转移到了编译时期。
2.提高了程序的安全性。
3.泛型类的出现优化了程序设计。
4.避免了类型强制转换的麻烦。

弊端:使用泛型可以接受不同的对象,但是对象的特有方法不能再使用。

泛型格式:通过<>来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,只要查API见到<>就要定义泛型。其实<> 就是用来接收类型的。当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。

什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,早期定义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.show(4);编译时不通过,泛型随对象。已经被指定为操作String
d.print(5);
d.print("hehe");//泛型方法可以操作不同数据类型 Demo.method("hahahahha");
}
}

 泛型定义在接口上

 interface Inter<T>
{
void show(T t);
}
//子类已经确定操作类型
class Demo_1 implements Inter<String>
{
public void show(String s)
{
System.out.println("show = "+s);
}
public<E> void print(E e)//依然可以有其他类型
{
System.out.println("print = "+e);
}
}
//子类也不确定操作类型
class Demo_2<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show = "+t);
}
public<E> void print(E e)
{
System.out.println("print = "+e);
}
}

泛型的高级应用

当操作类型不明确时,可以使用通配符(站位符?)来表示。例如,

 public static void printArray(ArrayList<?> ar)
{
Iterator<?> it = ar.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}

泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
? super E: 可以接收E类型或者E的父类型。下限。
Comparator比较器可以传入父类<? super E>,使得子类也可以使用比较器。但比较方法必须是父类的。多态原理。

上一篇:fastadmin 后台管理框架使用技巧(持续更新中)


下一篇:自己定义flash的宽和高