------- http://www.itheima.comjava培训、android培训期待与您交流！-------
一、集合框架概述
数组：固定长度
Collection:集合类，用于存储对象，相当于一个容器，长度可变。
List(有序，可重复，有索引)
ArrayList(数组结构、查询速度快，增删稍慢、线程不同步)
LinkedList(链表结构、增删速度快，查询慢、)
Vector(数组结构，线程同步)
Set(无序，不可重复)
HashSet(数据结构哈希表、非同步)
TreeSet(二叉树)
Map (映射，键值对)
HashMap(哈希表，允许使用null键和null值，线程不同步 效率高)
HashTable(哈希表，不可存入null建和null值，线程同步， 效率低)
TreeMap(二叉树，线程不同步，可用于给map集合中的键 进行排序)
二、集合(Collection)的共性方法：
(1)创建集合容器(Collection接口的子类)：
ArrayList al = new ArrayList();
public static void sop(Object obj) {
System.out.println(obj);
}
(2)添加元素：al.add("java01");
(3)获取元素个数(集合长度)： sop(al.size());
(4)打印原集合：sop(al);
(5)删除集合：al.remove("java05");
(6)判断：sop("判断java03是否存在？"+al.contains("java03"));
sop("判断集合是否为空？"+al.isEmpty());
(7)取交集 al中打印的是al和al2相同的元素
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al.retainAll(al2);
//去除al2中与al相同的元素
al.removeAll(al2);
(8)迭代器：取出集合中元素的操作方式。
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
//集合对象调用iterator方法，返回Iterator接口。 接口型引用指向子类对象，通过集合中的iterator方法获得
Iterator it = al.iterator();
while(it.hasNext()){
sop(it.next());
}
//当取出集合中的元素后，Iterator对象就会自动消失(垃圾回收机制)，节约内存空间
for (Iterator it = al.iterator();it.hasNext();) {
sop(it.next());
}
三、List集合
1、List中的特有方法(凡是带有角标操作的方法)
add(int index, E element)remove(int index)
set(int index, E element)
get(int index)
subList(int fromIndex, int toIndex)
listIterator()：List集合特有的迭代器，是Iterator的子接口。
作用：实现在遍历集合中元素时对元素进行增删改查的操作。
ListIterator li = al.listIterator();
//此时列表未遍历，指针还在最初位置(0角标)
sop(li.hasPrevious());//false
while(li.hasNext()){
//由于不知道集合中的元素是什么类型，故用上帝(object)标识li中的某个元素
Object obj = li.next();
if (obj.equals("java02")) {
li.set("java009");
}
}
//元素遍历完，指针处于角标4的后面，故没有下一个元素
sop(li.hasNext());//false 正向遍历
//元素遍历完，指针处于角标4的后面，故前一个有元素
sop(li.hasPrevious());//true 逆向遍历
2、List集合具体对象特点
(1)LinkedList的特有方法
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addLast("java01");
//获取元素，但并不删除元素
//sop(link.getFirst());
sop(link.getLast());
sop(link.size());
//获取集合中的所有元素
while(!link.isEmpty())
{
sop(link.removeFirst());
}
LinkedList的运用：
模拟一个队列或堆栈数据结构
堆栈：先进后出
队列：先进先出
import java.util.*;
class DuiLie{
//对队列的操作时基于链表结构的，所以首先声明
private LinkedList link;
DuiLie(){
link = new LinkedList();
}
//构造自定义方法，用于添加元素
public void myAdd(Object obj){
link.addLast(obj);
}
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
class LinkedListTest {
public static void main(String[] args) {
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while (!dl.isNull()){
System.out.println(dl.myGet());
}
}
}
(2)Vector
枚举是Vector集合特有的取出方式。
import java.util.*;
class VectorDemo{
public static void main(String[] args) {
Vector v = new Vector();
v.add("java01");
v.add("java02");
//通过枚举中呃方法获取集合中的元素
Enumeration en = v.elements();
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
}
(3)ArrayList
将自定义对象作为元素存储到ArrayList集合中，并去除重复元素。姓名相同，年龄相同视为同一个人。
需要定义一个新的集合用于去除相同的元素。当老集合中的元素存到新集合中时，新集合中的元素要与该集合中的其他元素进行比较，如果有相同元素，则舍弃，否则存入。
ArrayList集合添加元素时，默认的是存储的Object类型的数据，在这里，要存储的是Person类型的对象，即父类引用指向了子类对象(多态)，所以，要强制将Person向下转型：Person p = (Person)obj; 在定义Person类时，默认继承的是Object类，所以子类Person继承了父类的所有方法，equals则是其中一个，其作用是比较地址值。当ArrayList判断元素是否相等时，调用的就是该方法，而新建对象指向的都是同一个地址值，故不能将重复元素去除。所以，要在Person类中复写equals方法，定义自己所需要的比较方法，用于比较对象中的具体内容是否相等。
思路：
1、定义Person类，将属性和方法封装到该类中，
2、定义一个新容器，用于存储从老集合取出的元素，
3、将Person对象取出,
import java.util.*;
class ArrayListTest2{
public static void sop(Object obj) {
System.out.println(obj);
}
public static void main(String[] args) {
ArrayList al = new ArrayList();
//al.add(Object obj);-->Object obj = new Person("lisi01",21);
al.add(new Person("lisi01",21));
al.add(new Person("lisi02",23));
al.add(new Person("lisi02",23));
al.add(new Person("lisi03",24));
al.add(new Person("lisi04",29));
al.add(new Person("lisi04",29));
//并未将重复元素去除
al = singleElement(al);
//若不复写equals方法，则元素不能删除,底层调用的也是equals方法
//sop("remove 03 "+al.remove(new Person("lisi04",29)));
Iterator it = al.iterator();
while (it.hasNext()) {
//Object obj = it.next();
//Person p = (Person)obj;
Person p = (Person)it.next();
sop(p.getName()+"---"+p.getAge());
//找不到符号 Person
//lisi zhangsan的年龄23 it.next()方法只能调用一次，否则抛出异常
//sop(it.next().getName()+"-----"+it.next().getAge());
}
}
//定义一个方法，用于去除重复元素
public static ArrayList singleElement(ArrayList al){
//新建一个容器，用于接收老集合传过来的元素
ArrayList newal = new ArrayList();
//遍历老集合
Iterator it = al.iterator();
while (it.hasNext()){
//将老集合中遍历到的元素，用obj记录一下
Object obj = it.next();
//contains底层调用equals方法
if (!(newal.contains(obj)))
//如果新集合中不包含老集合传过来的元素，
//将该元素添加到新集合中
newal.add(obj);
}
//否则，将新集合返回
return newal;
}
}
class Person //extends Object 调用的是Object的equals方法，比较地址值
{
private String name;
private int age;
//一初始化就有姓名和年龄
Person(String name,int age){
this.name = name;
this.age = age;
}
//复写Object中的equals方法
public boolean equals(Object obj)//底层自动调用equals方法{
if (!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"----"+p.name);
//字符串的equals方法
return this.name.equals(p.name) && this.age == p.age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
在实际开发中，只要将声明的属性直接通过getter和setter生成即可。
四、Set集合
1、HashSet
无序的，即存入和取出的顺序不一定一致。HashSet的功能和Collection功能一致。
哈希表结构：
class Demo{
public int hashCode(){
return 60;
}
}
主函数：
Demo d1 = new Demo();
Demo d2 = new Demo();
System.out.println(d1);
System.out.println(d2);
打印结果为：Demo@15093f1、Demo@120bf2c这就是哈希值。
其实，JVM调用的是Demo类中的toString()方法,而该方法中就有hashCode()方法
那么我们可以覆盖父类中的hashCode()方法。再次运行，结果为：Demo@3c Demo@3c两个对象的地址值相同，在内存中如何存储呢？当哈希值相同时，再比较是否是同一个对象(内容是否相同)，若是，则在内存中将两个对象顺沿着存储
HashSet hs = new HashSet();
//add方法返回的是boolean类型，java01存入HashSet集合
System.out.println(hs.add("java01"));
//当再次存入一个相同(哈希值和内容都一样)的元素时，不再存入
System.out.println(hs.add("java01"));
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
set集合的取出方式只有一种：迭代器，且set集合是无序的，按地址值取出
Iterator it = hs.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
存储自定义对象：向HashSet集合中存储Person对象。
HashSet保证元素唯一性是通过元素的hashCode()和equals()方法来完成。如果元素的hashCode值相同，则再判断equals方法是否为真；
如果hashCode值不同，则不用调用equals方法。
复写父类hashCode()方法：
public int hashCode(){
System.out.println(this.name+"--hashCode--");
//return 60;
//先计算哈希值，若哈希值相同，则再比较对象(内容)
//尽量保证哈希值的唯一性，所以 * 49
return name.hashCode()+age * 49 ;
}
//复写父类的equals方法
public boolean equals(Object obj) {
if (!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"--equals--"+p.name);
return this.name.equals(p.name) && this.age == p.age; }
}
HashSet判断和删除的依据也是根据hashCode()和equals()方法。
System.out.print(hs.contains(new Person("lisi01",21)));
2、TreeSet：
可以对set集合中的元素进行排序(自然顺序)。
排序方式一：实现Comparable接口，覆盖compareTo方法。
练习：往TreeSet集合中存储自定义对象，将学生对象存进集合中，并按年龄排序。
当直接将学生对象向TreeSet集合中存储时，会出现类型转换异常，不能把Student转换成java.lang.Object包中的Comparable。通过查看文档可以知道，Comparable接口强行对实现它的每个类的对象进行整体排序。也就是说，要让Student类实现Comparable接口，并复写Comparable接口中的compareTo()方法，才能使Student的对象具有比较性，故才可以将学生对象按年龄顺序存储进TreeSet集合。
排序时，如果只要条件相同时，再判断次要条件。
import java.util.*;
class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("lisi03",20));
ts.add(new Student("lisi06",23));
ts.add(new Student("lisi007",19));
ts.add(new Student("lisi08",18));
Iterator it = ts.iterator();
while (it.hasNext()){
Student stu = (Student)it.next();
System.out.println( stu.getName()+"---"+stu,getAge());
}
}
}
//存的对象要有比较性，该接口强制让学生具备比较性
class Student implements Comparable {
private String name;
private int age;
Student(String name,int age){
this.name = name;
this.age = age;
}
//覆盖Comparable中的方法
public int compareTo(Object obj){
//若不是学生对象
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
//类型转换(强转)
Student s = (Student)obj;
//调用自身的comparaTo方法
System.out.println(this.name+"----"+s.name);
if (this.age > s.age)
return 1;
//当主要条件不符合时，再判断次要条件
if (this.age == s.age){
return this.name.compareTo(s.name);
}
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
排序方式二：
定义类实现Comparator接口，覆盖compare方法，将比较器对象作为参数传递给TreeSet集合的构造函数。 元素不具备比较性，或具备的比较性不是所需要的，则让集合具备比较性，且集合初始化时就具备比较性。
按字符串的长度进行排序。
import java.util.*;
class TreeSetTest {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new Compare());
ts.add("sjgh");
ts.add("hgiey");
ts.add("s");
ts.add("jgh");
ts.add("tgh");
Iterator it = ts.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
//实现比较器接口
class Compare implements Comparator{
//覆盖compare方法
public int compare(Object o1,Object o2){
//强制类型转换
String s1 = (String)o1;
String s2 = (String)o2;
/*
if (s1.length()>s2.length())
return 1;
if (s1.length() ==s2.length())
return 0;
return -1;
*/
//int num = new Integer(s1.length()).compareTo(s2.length()); 可以
//不能将相同长度的字符串存入
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
//比较集合的自然顺序
if (num == 0)
return s1.compareTo(s2);
return num;
}
}
当字符串的长度相同时，再按自然顺序存储。
五、Map集合
1、概述
Map是具有映射关系的集合，通常以键值对的形式出现。
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。
2、Map共性方法
添加：put(K key, V value)、putAll(Map m)
删除：clear()、remove(Object key)
判断：containsKey(Object key)、containsValue(Object value)、isEmpty()
获取：size()、values()、keySet()、entrySet()
3、keySet、entrySet
Map
通常映射关系是成对出现的（键值对），也就是说，一个键只能对应一个值。
Map集合取出元素的原理：将Map集合转化成Set集合（因为Set集合有迭代器），再用迭代器取出元素。
Map集合的取出操作：keySet()根据取出的键获取对应的键值
entrySet()方法取出的是映射关系，再通过Map.Entry中的getKey和getValue()方法取出键和值
下面写个例子吧：
（1）keySet法：(1)将Map集合中的所有键存入Set集合(Set集合具有迭代器)，
(2)以迭代器方式取出所有键
(3)再根据Map集合的get方法获取每一个键对应的值
import java.util.*;
class KeySet
{
public static void main(String[] args)
{
Map map = new HashMap();
//向Map集合中添加元素
map.put("01","lisi01");
map.put("02","lisi02");
map.put("06","lisi06");
map.put("03","lisi03");
//将map集合中的元素存入Set集合
Set keySet = map.keySet();
//使用迭代器将Set集合中的元素取出
Iterator it = keySet.iterator();
while (it.hasNext())
{
//先取出Map集合中的键
String key = it.next();
//通过键取出值(键值是成对存在的)
String value = map.get(key);
System.out.println(key+"--"+value);
}
}
}
（2）entrySet()方法：
(1)将Map集合中的映射关系取出并存入Set集合(返回值类型为Set
(2)使用迭代器取出Set集合中的映射关系，
(3)再通过Map.Entry中的getKey和getValue()方法取出键和值
import java.util.*;
class EntrySet
{
public static void main(String[] args)
{
Map map = new HashMap();
//向map集合中添加元素
map.put("01","lisi01");
map.put("02","lisi02");
map.put("06","lisi06");
map.put("03","lisi03");
//将Map集合中的映射关系取出，存入Set集合
Set> entryset =map.entrySet();
//使用迭代器取出映射关系
Iterator> it = entryset.iterator();
while (it.hasNext())
{
//获取Map.Entry对象
Map.Entry me = it.next();
//根据 Map.Entry中的方法取出键和值
String key =me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
}
}
Map.Entry是一个嵌套类，即Entry是Map接口的内部接口。
泛型(参见黑马程序员---泛型)
六、工具类(Collections、Arrays)
1、Collections：
在实际的开发应用中，如何选用合适的集合框架来存储数据呢？当然，这是根据需求而定。Collections类对List、Set的一些不同的功能结合起来，解决了两者不能同时使用的问题。
Collections类中的方法都是静态方法，因为该类中操作的都是共享数据，直接由类调用即可。
如果在存取过程中不需要保证元素的唯一性，但还要对元素进行排序，那么就使用到Collections类的sort方法。
import java.util.*;
class CollectionsDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
//sortDemo();
//maxDemo();
//binarySearchDemo();
//fillDemo();
//replaceAllDemo();
reverseOrderDemo();
}
public static void sortDemo(){
List list = new ArrayList();
list.add("anjdig");
list.add("jdfg");
list.add("d");
list.add("dfkgggk");
list.add("dfj");
sop(list);
//接收一个list集合，用于给其排序
//Collections.sort(list);
//可接收一个list集合和一个比较器，按照自定义比较方式比较
Collections.sort(list ,new StrLenComparator());
sop(list);
}
public static void maxDemo(){
List list = new ArrayList();
list.add("anjdig");
list.add("jdfg");
list.add("d");
list.add("dfkgggk");
list.add("dfj");
Collections.sort(list);
sop(list);
//返回的是该对象中按照自然顺序排序后的最大顺序的那个对象
//String max = Collections.max(list);
//按照字符串长度排序后最长的那个对象
String max = Collections.max(list,new StrLenComparator());
sop("max="+max);
}
public static void binarySearchDemo(){
List list = new ArrayList();
list.add("anjdig");
list.add("jdfg");
list.add("d");
list.add("fkgggk");
list.add("dfj");
sop(list);
//根据元素查找该元素所在的索引，如果不存在，
//则返回该元素-(插入点)-1，即"ab"应该插入角标0这个位置，那么，
//返回的就是-(0)-1
int index = Collections.binarySearch(list,"ab");
sop("index="+index);
}
public static void fillDemo(){
List list = new ArrayList();
list.add("anjdig");
list.add("jdfg");
list.add("d");
list.add("dfkgggk");
list.add("dfj");
sop(list);
//将集合中的元素全部用指定的元素oo替换
//Collections.fill(list,"oo");
//将集合中的dfkgggk替换为rr
//Collections.replaceAll(list,"dfkgggk","rr");
//将集合中的元素交换位置，头变尾，尾变头
Collections.reverse(list);
sop(list);
}
public static void reverseOrderDemo(){
//若不接收一个Collections.reverseOrder()方法，则打印的是按照自然顺序排列的
//若接收一个Collections.reverseOrder()方法，打印的则是元素逆转后的顺序
//在Collections.reverseOrder()方法中也可以接收一个自定义的比较器，
//TreeSet ts = new TreeSet
//(Collections.reverseOrder(new StrLenComparator ));
//用于按照自定义比较方式输出
TreeSet ts = new TreeSet(Collections.reverseOrder());
ts.add("abc");
ts.add("vjhi");
ts.add("kjd");
ts.add("skfodg");
Iterator it = ts.iterator();
while (it.hasNext())
{
sop(it.next());
}
}
}
class StrLenComparator implements Comparator{
public int compare(String s1,String s2){
if (s1.length()>s2.length())
return 1;
if (s1.length()
Collections.synchronizedList();
集合中的增删等方法都是非同步的，这样有利于提高效率，但有时会考虑到安全问题，所以要给这些方法添加同步，而这个方法就封装到了synchronizedList()方法中，只要直接调用即可(Collections类中都是静态方法)。
Collections.swap();可以将集合中2个位置上的元素置换位置
Collections.shuffle(); 随机地将集合中的所有元素置换位置。
2、Arrays
import java.util.*;
class ArraysDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
/*
int[] arr = {1,9,8,4,8,4};
sop(Arrays.toString(arr));
*/
String[] arr = {"fd","skrg","eui","sd"};
List list = Arrays.asList(arr);
/*
false
Exception in thread "main" java.lang.UnsupportedOperationException
sop(list.contains("ij"));
list.add("sioekf");
如果数组中的元素都是对象，那么变成集合时，数组汇总的元素就直接转成集合中的元素
int[] num = {};
List li = Arrays.asList(num);
sop(li);
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
Integer[] num1 = {2,3,8};
List li = Arrays.asList(num1);
sop(li);
*/
sop(list);
}
}
集合转数组：限定对元素的操作，不需对其进行增删操作。
当指定类型的数组长度小于了集合的size，那么该方法内部就会创建一个新的数组，
长度为集合的size
当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组
所以创建一个刚刚好的数组最优。
import java.util.*;
class CollectionToArray {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("dgg");
al.add("u");
al.add("ty");
al.add("jhkk");
//String[] arr = al.toArray(new String[al.size()]);
String[] arr = al.toArray(new String[8]);
System.out.println(Arrays.toString(arr));
}
}
七、增强for循环、可变参数、静态导入
1、高级for循环
高级for循环其实就是for循环的简写形式。并不是所有的for循环都可以简写为foreach，高级for循环只适用于集合或数组的遍历操作。
高级for循环格式：
for(数据类型 变量名: 被遍历的集合或数组)
{循环体}
在对集合或数组的操作中，集合一般的遍历方式是使用迭代器遍历，而且可以做删除操作，ListIterator在遍历时还可以进行增删改查操作，但如果用高级for循环，就不能做这些操作。
高级for循环的局限性：
只能获取集合元素，但不能对集合进行操作。
import java.util.*;
class ForEach {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("abc09");
al.add("abc01");
al.add("abc013");
/*
String是该集合中存储的数据类型，
s是该数据类型的变量名：
在遍历时，s指向的abc09这个对象，并打印输出；
随后，s又指向abc01、abc13对象并打印输出
所以s是变化的，当虚拟机按顺序查找集合中的元素时，s就不断地指向某个元素
*/
for (String s : al ){
System.out.println(s);
}
/*
使用迭代方式获取集合中的元素
Iterator it = al.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
*/
}
}
2、可变参数
import java.util.*;
class ParamDemo {
public static void main(String[] args) {
/*
int[] arr = {1,25,7};
show(arr);
*/
show(1,2,4,23);
}
/*
当将方法定义为这中形式时，在主函数中调用该方法时，
要先新建一个数组对象，才能调用方法,
而将方法定义为这中形式，在调用该方法时，就不需要新建数组对象，直接调用方法即可
JDK1.5新特性：方法的可变参数
简化代码、提高效率
在定义可变参数时，一定要把参数定义在参数列表的最后面。
如果定义在了开始或中间，虚拟机就会自动的将该参数后面的不同类型的参数纳入该参数列表
*/
public static void show(int... arr){
System.out.println(Arrays.toString(arr));
}
/*
当将方法定义为这中形式时，在主函数中调用该方法时，
要先新建一个数组对象，才能调用方法
public static void show(int[] arr){
System.out.println(Arrays.toString(arr));
}
*/
}
3、静态导入
/*
当类名重名时，需要指定具体的包名。
当方法重名时，指定具体所属的对象或者类。
*/
import java.util.*;
//导入的是Arrays这个类中的所有的静态成员
import static java.util.Arrays.*;
//导入的是System类中的所有静态成员
import static java.lang.System.*;
class StaticImport {
public static void main(String[] args) {
out.println("hello");
int[] arr = {2,4,1,5};
sort(arr);
int index = binarySearch(arr,1);
out.println(Arrays.toString(arr));
System.out.println("index="+index);
/*
System.out.println("hello");
int[] arr = {2,4,1,5};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr,1);
System.out.println(Arrays.toString(arr));
System.out.println("index="+index);
*/
}
}
八、其他对象
1、System
System类是一个系统类，描述系统的一些信息。
public final class System{}：不能被实例化
类中的方法和属性都是静态的，
out:标准输出，默认输出在控制台
in：键盘录入
//静态导入
import static java.lang.System.*;
import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{
//获取系统的属性信息：
Properties prop = System.getProperties();
/*
for (Object obj: prop.keySet())
{
String value = (String)prop.get(obj);
out.println(obj+"--"+value);
}
*/
//自定义系统属性信息
System.setProperty("MYKEY","MYVALUE");
//获取指定属性信息
String value = System.getProperty("os.name");
out.println("value="+value);
/*
在JVM启动时，动态加载一些属性信息
F:\java\day18>javac SystemDemo.java
F:\java\day18>java SystemDemo
value=Windows 7
v==null
F:\java\day18>java -Dhello=nihao SystemDemo
value=Windows 7
v==nihao
*/
String v = getProperty("hello");
out.println("v=="+v);
}
}
2、Runntime
Runtime对象
该类并没有提供构造函数，说明不可以new对象，
那么该类是否提供了静态方法，
查阅API，并没有静态方法，提供了非静态方法，
那么该类一定提供一个方法获取本类对象，而且该方法是静态的，并返回本类类型。
单利设计模式。
static Runtime getRuntime()
返回与当前 Java 应用程序相关的运行时对象。
class RuntimeDemo
{
public static void main(String[] args) throws Exception
{
Runtime r = Runtime.getRuntime();
//执行记事本程序,并且可以打开某个指定文本文件
Process p = r.exec("notepad.exe SystemDemo.java");
//进程停留4秒被杀死
Thread.sleep(4000);
p.destroy();
}
}
3、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方法，将模式格式化掉指定对象，返回值为一个字符串
String time = sdf.format(d);
System.out.println("time="+time);
}
}
4、Calendar
import java.util.*;
import java.text.*;
class CalendarDemo2
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
//c.set(2013,5,17);
c.add(Calendar.MONTH,-2);
c.add(Calendar.DAY_OF_MONTH,-2);
printCaledar(c);
}
public static void printCaledar(Calendar c)
{
String[] mons = {"一月","二月","三月","四月",
"五月","六月","七月","八月",
"九月","十月","十一月","十二月",
};
String[] weeks ={
"","星期日","星期一","星期二","星期三","星期四",
"星期五","星期六"
};
int index = c.get(Calendar.MONTH);
int index1 = c.get(Calendar.DAY_OF_WEEK);
sop(c.get(Calendar.YEAR)+"年");
//sop((c.get(Calendar.MONTH)+1)+"月");加1麻烦
sop(mons[index]);
sop(c.get(Calendar.DAY_OF_MONTH)+"日");
//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
sop(weeks[index1]);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
5、Math-Random
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
Random r = new Random();
for (int x = 0;x<10 ;x++ )
{
//获取1~10之间的随机数,包含1 但不包含10
//int d3 = (int)(Math.random()*10+1);
int d4 = r.nextInt(10)+1;
sop(d4);
}
//show();
}
public static void show()
{
//返回大于指定数据的最小整数 13.0 -12
double d = Math.ceil(-12.34);
//返回小于指定数据的最大整数 16.0
double d1 = Math.floor(16.87);
//四舍五入23
long l = Math.round(23.34);
//底数 指数 8.0
double d2 = Math.pow(2,3);
sop("d="+d);
sop("d="+d1);
sop("d="+l);
sop("d="+d2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
------- http://www.itheima.comjava培训、android培训期待与您交流！-------