黑马程序员_JavaAPI-集合框架
------- android培训、java培训、期待与您交流！ ----------
每个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。
Collection
List：ArrayList LinkedList Vector
Set：HashSet TreeSet
ArrayList
1、add方法的参数类型是object，以便于接收任意类型对象
2、集合中存储的都是对象的引用（地址）
什么是迭代器？
其实就是集合的取出元素的方式。
import java.util.*;
class CollectionDemo
{
publicstatic void main(String[] args)
{
//创建一个集合容器，使用Collection接口的子类。ArrayList
ArrayList a1=new ArrayList();
ArrayList a2=new ArrayList();
a2.add("java01");
//1、添加元素
a1.add("java01");//add(objedtobj);
a1.add("java02");
a1.add("java03");
a1.add("java04");
a1.retainAll(a2);//取交集，a1中只会保留和a2中相同的元素；a1.removeAll(a2)去掉交集
//获取个数，集合长度
sop("size:"+a1.size());
//删除元素
a1.remove("java02");
a1.clear();//清空集合
sop(a1.contains("java03"));//判断是否存在
sop(a1.isEmpty());//集合是否为空
/*Iterator it=a1.iterator();//获取迭代器，用于取出集合中的元素
while(it.hasNext())//
sop(it.next());//返回迭代下一个元素
*/
for(Iteratorit=a1.iterator();it.hasNext();)
{
sop(it.next());
}
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部元素。那么取出方式就被定义成立内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都由共性内容判断和取出，那么可以将共性抽取。
那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法iterator（）。
Collection
(1)List:元素是有序的，元素可以重复，因为该集合体系有索引。
ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删速度慢。线程不同步。默认长度10，超过就new一个新的15%延长，复制。
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询速度慢。
Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
(2)Set：元素是无序的，元素不可以重复。
List特有方法：凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection)
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器。ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以，在迭代器时，只能用迭代器的方法元素，可是Iterator方法时有限的。只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。
可以进行遍历过程中的增删改查
ListIterator li=al.listIterator();
while(li.hasNext())
{
Objectobj=li.next();
if(obj.equals("java02"))
li.add("java009");
}
while(li.hasPrevious())
{
sop(li.previous());//逆向遍历
}import java.util.*
class ListDemo
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
publicstatic void main(String[] args)
{
ArrayList al=new ArrayList();
//增加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop("元集合是："+al);
//在指定位置添加元素。
al.add(1,"java09");
//删除指定位置的元素
al.remove(3);
//修改元素
al.set(2,"java007");
//通过角标获取元素
sop(al.get(1));
sop(al);
//获取所有元素
for(int x-0;x//演示Vector：
枚举就是Vector特有的取出方式，枚举和迭代器很像，其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。
import java.util.*
class VectorDemo
{
publicstatic void main(String[] args)
{
Vector v=new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en=v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
LinkedList:特有方法
addFirst()
addLast()
getFirst()
getLast()
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst()
removeLast()
获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6中出现了替代方法
offerFirst()
offerLast()
peekFirst()
peekLast()
获取元素，但不删除元素。如果集合中没有元素，会返回null
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null
import java.util.*
class LinkedListDemo
{
publicstatic void main(String[] args)
{
LinkedList link=new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addLast("java04");
sop(link.getfirst());
sop(link.getLast());
sop(link.removeFirst());
sop(link.size());
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 Firstin First out FIFO 如同一个水管。
import java.util.*;
class DuiLie
{
privateLinkedList link;
DuiLie()
{
link=new LinkedList();
}
publicvoid myAdd(Object obj)
{
link.addFirst(obj);
}
publicObject myGet()
{
link.removeLast();
}
publicboolean isNull()
{
return link.isEmpty();
}
}
class LinkedListDemo
{
publicstatic void main(String[] arg)
{
Duilie dl=new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
System.out.println(dl.myGet());
}
}
去除ArrayList重复元素
在迭代时循环中next调用一次，就要hasNext判断一次
class ArrayListTest
{
publicstatic void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
al=singleElement(al);
sop(al);
}
publicstatic ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newAl=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext())
{
Objectobj=it.next();
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
}
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。
思路：
1、对人描述，将数据封装进人对象；
2、定义容器，将人存入；
3、取出。
List集合判断元素是否相同，依据的是元素equals方法。
import java.util.*;
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name=name;
this.age=age;
}
publicboolean equals(Object obj)
{
if(!(obj instanceof Person))
returnfalse;
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
publicString getName()
{
return name;
}
publicint getAge()
{
return age;
}
}
class ArrayListTest2
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
publicstatic void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(newPerson("lisi01",30));//al.add(Object obj);//Object obj=newPerson("lisi01",30);
al.add(newPerson("lisi02",32));
al.add(newPerson("lisi03",33));
al.add(newPerson("lisi04",35));
al.add(new Person("lisi03",33));
al.add(newPerson("lisi04",35));
sop(“remove 03:”+a1.remove(new Person(“lisi03,33”)));//删除一项，底层也调用equals
al=singleElement(al);
Iterator it=al.iterator();
while(it.hasNext())
{
Personp=(Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
publicstatic ArrayList singleElement(ArrayList al)
{
//定义一个临时容器
ArrayList newAl=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext())
{
Objectobj=it.next();
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
}
如果涉及到元素很多并且频繁的增删操作用LinkedList；如果涉及到增删同事涉及到查询用ArrayList。其实频繁的增删操作不多见，所以ArryList是最常见的容器。
//Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复
//Set集合的功能和Conllection是一致的
//常见的子类：
HashSet（底层数据结构式哈希表）
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals
HashSet判断和删除的依据
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法
TreeSet
class Demo
{
}
class HashSetDemo
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
public staticvoid main(String[] args)
{
Demo d1=new Demo();
Demo d2=new Demo();
sop(d1);
sop(d2);
}
}
输出结果：
Test.Demo@c17164
Test.Demo@1fb8ee3
c17164——第一个对象的地址
1fb8ee3——第二个对象的地址
两个地址都存放在集合中，比较两个哈希值是否相同再往里添加。
class HashSetDemo
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
public staticvoid main(String[] args)
{
HashSet hs=new HashSet();
sop(hs.add(“java01”));//true
sop(hs.add(“java01”));//false，不能重复
hs.add(“java02”);
hs.add(“java03”);
hs.add(“java04”);
//set 集合取值只有一种方法，迭代器
Iterator it=hs.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
HashSet自定义对象
import java.util.*;
//往HashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素
//覆盖Person的哈希构造方法，建立Person对象自己的哈希值
class HashSetTest
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
public staticvoid main(String[] args)
{
HashSet hs=new HashSet();
hs.add(new Person(“a1”,11));
hs.add(new Person(“a2”,12));
hs.add(new Person(“a3”,13));
hs.add(new Person(“a4”,14));
sop(hs.contains(new Person(“a1”,11)));//判断是否存在a1,，11
hs.remove(new Person(“a3”,13));//删除。同样是先判断哈希值，再equals
Iterator it=hs.iterator();
while(it.hasNext())
{
Personp=(Person)it.next();
sop(p.getName()+”::”+p.getAge());
}
}
}
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name=name;
this.age=age;
}
publicint hashCode()//复写hashCode
{
return name.hashCode()+age*39;//尽量保证哈希值唯一，所以乘以39
}
publicboolean equals(Object obj)//复写equals
{
if(!(obj instanceof Person))
returnfalse;
Person p=(Person)obj;
System.out.println(this.name+”…”+p.name);
returnthis.name.equals(p.name)&&this.age==p.age;
}
publicString getName()
{
return name;
}
publicint getAge()
{
return age;
}
}
Set：无序，不可以重复元素
HashSet：数据结构式哈希表，线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同还会判断元素的equals方法，是否为true。
TreeSet：可以对Set集合中的元素进行排序。
底层数据结构式二叉树。
保证元素唯一性的依据：compareTo方法return 0。
TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现compareTo方法。这种方式也称为元素的自然顺序，或者叫做默认顺序。
TreeSet排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合初始化时就有了比较方式。
class TreeSetDemo
{
publicstatic void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add(“cba”);
ts.add(“abcd”);
ts.add(“aaa”);
ts.add(“bca”);
Iterator it=ts.iterator();//什么意思？！！
while（it.hasNext()）
{
System.out.println(it.next());//打印结果：aaa,abcd,bca,cba
}
}
}
TreeSet存储自定义对象
需求：往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。
记住：排序时，当主要条件相同时，一定要判断一下次要条件。
import java.util.*;
class TreeSetDemo
{
publicstatic void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add(newStudent("lisi02",22));
ts.add(newStudent("lisi007",20));
ts.add(newStudent("lisi09",19));
ts.add(newStudent("lisi01",40));
Iterator it=ts.iterator();
while(it.hasNext())
{
Studentstu=(Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)
{
//怎么存怎么取就写一句：return 1；
if(!(objinstanceof Student))
throw new RuntimeException("不是学生对象");
Students=(Student)obj;
System.out.println(this.name+"...equls..."+s.name);
if(this.age>s.age)//此对象大于指定对象
return 1;
if(this.age==s.age)//当年龄相同时再判断一下姓名
{
return this.name.compareTo(s.name);
}
return-1;
}
public String getName()
{
returnname;
}
public int getAge()
{
returnage;
}
}
二叉树
当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。
class Student implements Comparable//该接口强制让学生具备比较性
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Object obj)
{
if(!(objinstanceof Student))
throw new RuntimeException("不是学生对象");
Students=(Student)obj;
//System.out.println(this.name+"...equls..."+s.name);
if(this.age>s.age)//此对象大于指定对象
return 1;
if(this.age==s.age)//当年龄相同时再判断一下姓名
{
return this.name.compareTo(s.name);
}
return-1;
}
public String getName()
{
returnname;
}
public int getAge()
{
returnage;
}
}
class TreeSetDemo
{
publicstatic void main(String[] args)
{
TreeSet ts=new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(newStudent("lisi007",20));
ts.add(newStudent("lisi09",19));
ts.add(newStudent("lisi01",40));
Iterator it=ts.iterator();
while(it.hasNext())
{
Studentstu=(Student)it.next();//不懂
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class MyCompare implements Comparator
{
publicint compare(Object o1,Object o2)
{
Student s1=(Student)o1;
Student s2=(Student)o2;
int num=s1.getName().compareTo(s2.getName());
if(num==0)
{
return newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。
好处
1、 将运行时期出现的问题ClassCastException，转移到编译时期。方便于程序员解决问题。让运行时期问题减少，安全；
2、 避免了强制转换麻烦。
泛型格式：通过<>定义要操作的引用数据类型
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到 <>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
class GenericDemo
{
publicstatic void main(String[] args)
{
ArrayList al=newArrayList();
al.add(“abc01”);
al.add(“abc0991”);
al.add(“abc014”);
Iterator it=al.iterator();
while(it.hasNext())
{
Strings=it.next();
Stirng.out.println(s+”:”+s.length());
}
}
}
泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不被确定的时候
早期定义Object来完成扩展，现在定义泛型来完成扩展。
class Utils
{
privateQQ q;
publicvoid setObject(QQ q)
publicQQ getObject()
{
return q;
}
}
class GennricDemo3
{
publicstatic void main(String[] args)
{
Utils u=newUtils();
u.setObject(new Worker());
Worker w=u.getObject();
}
}
泛型方法
class Demo
{
publicvoid show(T t)
{
System.out.println(“show:”+t);
}
public voidprint(T t)
{
System.out.println(“print:”+t);
}
}
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定，那么将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
class Demo
{
Public void show(T t)
{
System.out.println(“show”+t);
}
Public void print(Q q)
{
System.out.println(“print:”+q);
}
public static void method(W t)
{
System.out.println(“method:”+t);
}
}
class GenericDemo4
{
publicstatic void main(String[] args)
{
Demo d=new Demo();
d.show(“hah”);
d.show(new Integer(4));
d.print(“heihei”);
Demo.method(“hahahhahah”);
}
}
泛型定义在接口上。
多态不能预先使用子类中的方法。
泛型不能使用类型中的特有方法。
Interface Inter
{
Voidshow(T t);
}
Class InterImpl<.T> implementsInter
{
publicvoid show(T t)
{
System.out.println(“show:”+t);
}
}
Class GenericDemo5
{
publicstatic void main(String[] args)
{
InterImpl i=newInterImpl();
i.show(4);
//InterImpl i=new InterImpl();
//i.show(“hahh”);
}
}
class GenericDemo6
{
publicstatic void main(String) al=new ArrayList();
al.add(“abc1”);
al.add(“abc2”);
al.add(“abc3”);
ArrayListall=new ArrayList();
all.add(4);
all.add(7);
all.add(1);
printColl(al);
printColl(all);
}
public static voidprintColl(ArrayList al)//不明确数据类型，占位符
{
Iteratorit=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
泛型限定
?通配符，也可以理解为占位符。
泛型的限定：
? extends E——可以接收E类型或者E的子类型。上限。
? super E——可以接收E类型或者E的父类型。下限
Map集合：该集合存储键值对，一对一对往里存，而且要保证键值的唯一性。
1、 添加
put(K key,Vvalue)
putAll(Map m)
2、 删除
clear()
remove(Objectkey)
3、 判断
containsKey(Objectkey)
containsValue(Objectvalue)
isEmpty()
4、 获取
get(Object key)
size()
entrySet()
keyset()
Map:
Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，效率低。
HashMap：底层是哈希表数据结构，可以存入null键null值，该集合不是线程同步的，效率高。
TreeMap：底层是二叉树结构，线程不同步，可以用于给map集合中的键排序。
和Set很像，其实Set底层就是用了Map集合。
Map集合的两种取出方式：
1、 Set keyset：将map中所有的键存入到Set集合，因为Set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
2、 Set> entrySet：将map集合中的关系存入到了set结合中，而这个关系的数据类型就是Map.Entry。
import java.util.*;
class MapDemo2
{
publicstatic void main(String[] args)
{
Map map=newHashMap();
map.put(“02”,”zhangsan2”);
map.put(“03”,”zhangsan3”);
map.put(“01”,”zhangsan1”);
map.put(“04”,”zhangsan4”);
//将Map集合中的映射关系取出，存入到Set集合中
Set> entrySet=map.entrySet();
Iterator>it=entrySet.iterator();
while(it.has.Next())
{
Map.Entryms=it.next();
String key=me.getKey()
Stringvalue=me.getValue();
System.out.println(key+”…”+value);
}
//先获取map集合的所有键的Set集合，keySet()
Set keyset=map.keySet();
//有了Set集合，就可以获取其迭代器
Iterator it=keyset.iterator();
while(it.hasNext())
{
String key=it.next();
//有了键就可以通过map集合的get方法获取其对应的值
Stringvalue=map.get(key);
System.out.println(“key:”+key,”value:”+value);
}
}
}
Map.Entry其实Entry也是一个接口，它是map接口中的一个内部接口。
interface Map
{
publicstatic interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
classHahs implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}
凡是见到哈希，就要想到哈希表，想到哈希表就要想到元素的两个方法，一个hasCode一个equals。
需求：对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的。所以要使用可以排序的Map集合，TreeMap。
import java.util.*;
//自定义姓名比较器
class StuNameComparator implementsComparator
{
publicint compare(Student s1,student s2)
{
int num=s1.getName().compareTo(s2.getName());
if(num==0)
{
returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
class MapTest2
{
publicstatic void main(String[] args)
{
TreeMap tm=newTreeMap(new StuNameComparator);
tm.put(new Student(“lisi1”,21),”beijing1”);
tm.put(new Student(“lisi2”,22),”beijing2”);
tm.put(new Student(“lisi3”,23),”beijing3”);
tm.put(new Student(“lisi4”,24),”beijing4”);
Set> entrySet=tm.entrySet();
Iterator>it=netrySet.iterator();
while(it.hasNext())
{
Map.Entryme=it.next();
Student stu=me.getKey();
Stringaddr=me.getValue();
System.out.println(stu+”:::”+addr);
}
}
}
Collection：集合框架的工具类。
Arrays：用于操作数组的工具类。
里面都是静态方法。
asList：将数组变成list集合。
把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的，可以使用contains，get，indexOf(),subList()。
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
集合转成数组：
1、指定类型的数组要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会创建新数组，而是使用传递进来的数组。
2、为什么要将集合变数组
为了限定对元素的操作，不需要增删了。
ArrayList取出元素几种方式？迭代和for循环（get，按角标取）。String只有一种，迭代器。
高级for循环
格式：for(数据类型变量名：被遍历的集合（Collection）或者数组)
对集合进行遍历。只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性，必须有被遍历的目标。
JDK1.5版本出现的新特性：方法的可变参数
在使用时注意：可变参数一定要定义在参数列表的最后面。
class ParamMethodDemo
{
publicstatic void main(String[] args)
{
//虽然少定义了多个方法，但是每次都要定义一个数组，作为实际参数可变参数。其实就是上一种数组参数的简写形式，不用每一次都手动建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
}
public staticvoid show(int… arr)
{
System.out.println(arr.length);
}
}
最后一个1.5版本新特性：StaticImport静态导入
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
import java.util.*;
static import java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员
import static java.lang.System.*;//导入了System类中所有静态成员
out.println(“hello world”);
class StaticImport
{
publicstatic void main(String[] args)
{
int[] arr={3,1,5};
sort(arr);
int index=binarySearch(arr,1);
System.out.println(Arrays.toString(arr));
System.out.println(“Index=”+index);
}
}
System:类中的方法和属性都是静态的。
out：标准输出，默认是控制台。
in：标准输入，默认是键盘。
描述系统一些信息。
获取系统属性信息：PropertiesgetProperties();
import java.util.*;
class SystemDemo
{
publicstatic void main(String[] args)
{
Properties prop=System.getProperties();
//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
//那么可以通过map的方法取出该集合中的元素
//该集合中存储的都是字符串，没有泛型定义
//如何在系统中自定义一些特有信息呢？
System.setProperty(“mykey”,”myvalue”);
//获取指定属性信息
String value=System.getProperty(“os.name”);
System.out.println(“value”+value);
//获取所有属性信息
for(Object obj:prop.keySet())
{
Stringvalue=(String)prop.get(obj);
System.out.println(obj+”::”+value);
}
}
}
Runtime对象
该类并没有提供构造函数。说明不可以new对象，那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型
由这个特点可以看出该类使用了单例设计模式完成。
该方法是staticRuntime getRuntime();
class RuntimeDemo
{
publicstatic void main(String[] args) throws Exception
{
Runtime r=Runtime.getRuntime();
//r.exec(“c:\\winmine.exe”);//打开扫雷
Process p=r.exec(“winmine.exe”);
Process p=r.exec(“notepad.exe xx.java”);//记事本打开xx.java文件
Thread.sleep(4000);//停留四秒
p.destory();//杀死进程
}
}