1.集合框架概述及其特点
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式;数组和集合都是容器,相较于数组有以下特点:(1).集合的长度是可变的;数组的长度是固定的;(2).集合只能存储对象,即引用数据类型,存放的都是对象的引用/地址;数组可以存储基本数据类型;(3).集合可以存储不同类型的对象;数组存储的是同一类型的数据或对象;
2.Java中的集合体系
每一个容器对数据的存储方式都有不同,这样的存储方式称之为:数据结构;
Interface Collection
|--Interface List:元素是有序的,有序的意思是按什么顺序存储就按什么顺序读取,元素可以重复,因为集合List体系有索引;
|--ArrayList:底层数据结构是数组结构,查找速度快,增删操作复杂,线程不同步;
|--LinkedList:底层数据结构是链表结构,查找速度较慢,增删操作快;
|--Vector:底层数据结构是数组结构,线程同步的,集合框架出现后被ArrayList取代;
|--Interface Set:元素是无序的(存入和取出的顺序不一致),元素不可以重复;
|--HashSet:底层数据结构是哈希表,保证元素惟一性通过hashCode()和equals()方法;
|--TreeSet:底层数据结构是二叉树,可以对Set集合中的元素进行排序;
Interface Map:该集合存储键值对,保证键的唯一性;
|--Hashtable:底层数据结构是哈希表,不可以存入null的键和值,线程同步的,元素间无序;
|--HashMap:底层数据结构是哈希表,允许使用null的键和值,线程不同步,效率高,元素间无序;
|--TreeMap:底层数据结构是二叉树,线程不同步,可以用于给Map集合中的键排序;
3.共性的Collection集合
(1).添加元素:boolean add (Object obj):添加某个元素,操作成功返回true;boolean addAll(Collection c):添加某个集合,相当于并集;(2).删除元素:void clear():移除此Collection中的所有元素;boolean remove(Object obj):从该Collection中移除指定元素的单个实例;删除成功返回true;boolean removeAll(Collection c):移除在该Collection中那些也包含在指定c中的所有元素,相当于取差集;(3).获取操作:int size():返回元素个数;boolean retainAll(Collection c):仅保留此Collection中那些也包含在指定c中的元素,相当于取交集;(4).判断操作:boolean contains(Object obj):判断是否包含指定元素;boolean containsAll(Collection c):此Collection中包含指定c中的所有元素时,返回true;boolean isEmpty():判断是否为空集合;(5).转换操作:Object[ ] toArray():集合转换为数组;(6).获取元素:Iterator iterator():返回在此Collection的元素上进行迭代的迭代器;迭代器:集合的取出元素方式;其产生:每个集合中都有取出操作,当简单的方法不足以完成取出动作时,就将取出的动作封装成一个对象,又由于不同数据结构的集合的取出操作各有差异,但是取出的动作通常是共性的(判断+取出),于是向上抽取定义取出集合元素操作的内部类;之所以定义为内部类,是因为取出的操作需要操作的是集合中的元素,因此定义为内部类来直接访问集合中的元素最为方便;将这些内部类符合的规则定义为Iterator;联系:夹娃娃机;整个机器相当于容器集合,保存的元素是娃娃;内部类相当于夹子,定义在机器内部;外部的操纵杆相当于集合对外提供的方法;集合的迭代操作:package com.zr.day14; import java.util.*; class IteratorDemo { public static void main(String[] args) { Collection c = new ArrayList();//定义一个集合 c.add("Messi");<span style="white-space:pre"> </span>//添加一些元素 c.add("Ronaldo"); c.add("kaka"); c.add(100); Iterator it = c.iterator();//迭代获取 while(it.hasNext()) { System.out.println(it.next()); } System.out.println("------------"); //for循环对资源的释放处理更优化; for(Iterator iter = c.iterator();iter.hasNext();) { System.out.println(iter.next()); } } }
4.List集合
4.1 List集合中的特有方法
因为List集合是有序的,所以相较于Collection,带有角标的方法都是List集合的特有方法;(1).增void add(int index, Object obj):在指定位置添加元素;boolean addAll(int index, Collection c):将指定集合添加到指定位置;(2).删Object remove(int index):移除列表中指定位置的元素,返回以前再此位置的元素;(3).改Object set(int index, Object obj):用指定元素替换列表中指定位置的元素,返回之前的元素;(4).查Object get(int index):返回列表中指定位置的元素;List subList(int fromindex, int toindex):返回子列表,包含头不包含尾;int indexOf(Object obj):返回列表中第一次出现的指定元素的索引,没有则返回-1;int lastIndexOf(Object obj):反向索引;(5).特有的获取元素迭代器ListIterator listIterator():迭代ListIterator listIterator(int index):从指定位置开始迭代(6).迭代器Iterator和列表迭代器ListIteratorListIterator继承了Iterator,是其子接口;在迭代集合时,使用Iterator中操作元素的方法有限;Iterator:hasNext(),next(),remove();ListIterator:hasNext(),next(),nextIndex(),remove(),add(),set(),hasPrevious(),PreviousIndex(),Previous();并发操作异常:迭代器操作和集合操作同时处理集合中的元素;ConcurrentModificationException;(7).多种获取List集合元素的方式;package com.zr.day14; import java.util.*; class IteratorDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("Messi"); al.add("Ronaldo"); al.add("kaka"); al.add(100); //方式一:使用角标操作,循环遍历; for(int x=0; x<al.size(); x++) { System.out.println(al.get(x)); } System.out.println("------------"); //方式二:使用集合迭代器Iterator; Iterator it = al.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println("------------"); //方式三:使用列表迭代器ListIterator; //在迭代操作时还可以对集合中元素进行多种操作; ListIterator lit = al.listIterator(); while(lit.hasNext()) { System.out.println(lit.next()); } } }
4.2 List:ArrayList
ArrayList底层数据结构是数组,大多数方法都和List接口一致;特有方法:protected void removeRange(int fromIndex, int toIndex):移除索引范围内的元素;包含头不包含尾(1).去除ArrayList集合中的重复字符串元素;//定义一个功能用来去除列表中的重复字符串元素; package com.zr.day14; import java.util.*; class ArrayListDemo { public static void main(String[] args) { //新建一个列表,添加元素; ArrayList al = new ArrayList(); al.add("Messi"); al.add("Ronaldo"); al.add("Bale"); al.add("kaka"); al.add("Ronaldo"); //ArrayList中复写了toString方法; System.out.println(al); //去除重复字符串; al = removeOther(al); System.out.println(al); } //返回值类型:可以将新的ArrayList赋值给原ArrayList; //参数列表:原ArrayList; public static ArrayList removeOther(ArrayList al) { ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); //迭代 while(it.hasNext()) { Object obj = it.next(); //判断新列表中是否已经存在该对象; if(!newAl.contains(obj)) { //如果不存在则将该对象添加到新列表 newAl.add(obj); } } //返回新列表 return newAl; } }
(2).将自定义对象作为元素存储到ArrayList集合中,并去除重复元素;//定义一个功能用来去除自定义对象中的重复元素; //自定义的是Student对象,当两个Student对象的name属性和age属性都相同时,判定这两个对象是重复元素; package com.zr.day14; import java.util.*; class ArrayListDemo { public static void main(String[] args) { //新建一个列表,添加元素; ArrayList al = new ArrayList(); al.add(new Student("Messi",26)); al.add(new Student("Ronaldo",27)); al.add(new Student("Bale",28)); al.add(new Student("kaka",29)); al.add(new Student("Ronaldo",27)); al.add(new Student("Ronaldo",30)); //ArrayList中复写了toString方法; System.out.println("处理前:"+al); //去除重复字符串; al = removeOther(al); System.out.println("处理后:"+al); } //返回值类型:可以将新的ArrayList赋值给原ArrayList; //参数列表:原ArrayList; public static ArrayList removeOther(ArrayList al) { ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); //迭代 while(it.hasNext()) { Object obj = it.next(); //判断新列表中是否已经存在该对象; if(!newAl.contains(obj)) { //如果不存在则将该对象添加到新列表 newAl.add(obj); } } //返回新列表 return newAl; } } //自定义的Student对象; class Student { private String name; private int age; Student(String name, int age) { this.name = name; this.age = age; } //覆盖toString()方法; public String toString() { return name+":::::"+age; } //覆盖equals()方法; public boolean equals(Object obj) { if(!(obj instanceof Student)) return false; Student stu = (Student)obj; boolean b = this.name.equals(stu.name) && this.age == stu.age; //添加的打印语句分析比较过程 System.out.println(this.name + "--比较--" + stu.name + "--结果--::" +b); return b; } }
输出结果:
分析打印结果发现,ArrayList的contains()方法底层是通过调用equals方法来比较各个元素是否是重复元素;
4.3 List:Vector
Vector是集合框架之前的体系,底层数据结构也是数组,集合框架出现后被ArrayList所替代;Vector中的获取元素方法:角标,迭代器,枚举;其中枚举是Vector的特有方式,因为枚举的名称和方法名称都过长,最后被迭代器所取代;Enumeration elements():相当于集合中的iterator方法;Interface Enumeration中封装的方法:boolean hasMoreElements():使用时相当于Iterator中的hasNext()方法;Object nextElement():使用时相当于Iterator中的next()方法;4.4 List:LinkedList
LinkedList底层数据结构是链表结构,相较于数组结构的ArrayList有其特有的方法;(1).添加:void addFirst(Object obj)void addLast(Object obj)boolean offer(Object obj)boolean offerFirst(Object obj)boolean offerLast(Object obj)(2).删除:Object removeFirst()Object removeLast()Object poll()Object pollFirst()Object pollLast()(3).获取:Object getFirst()Object getLast()Object peek()Object peekFirst()Object peekLast()(4).逆向迭代Iterator descendingIterator()上述方法中,offer,peek,poll方法是JDK6.0之后出现的,当集合中没有元素时不会抛出异常,直接返回null;但是get和remove方法会出现异常:NoSuchElementException;(5).练习:使用LinkedList创建栈和队列数据结构;/* * 使用LinkedList构建栈和队列数据结构; */ package com.zr.day14; import java.util.LinkedList; class LinkedListDemo { public static void main(String[] args) { MyQue mq = new MyQue(); mq.myAdd("messi"); mq.myAdd("ronaldo"); mq.myAdd("kaka"); System.out.println(mq); System.out.println(mq.myDel()); System.out.println(mq); } } //队列的存储规律:先进先出 //使用LinkedList实现具体是实现在其一端进行元素的添加,在另一端进行元素的删除 class MyQue { private LinkedList ll; MyQue() { this.ll = new LinkedList(); } //添加元素 public void myAdd(Object obj) { ll.addFirst(obj); } //删除元素 public Object myDel() { return ll.removeLast(); } //打印输出 public String toString() { return ll.toString(); } } //栈的存储规律:先进后出 //使用LinkedList实现具体步骤是封装只在某一端进行添加和删除元素的方法; class MyStack { private LinkedList ll ; MyStack() { this.ll = new LinkedList(); } //添加元素的方法 public void myAdd(Object obj) { ll.addFirst(obj); } //删除元素的方法,删除后同时返回被删除的元素; public Object myDel() { return ll.removeFirst(); } //打印输出的复写 public String toString() { return ll.toString(); } }
5.Set集合
Set作为Collection集合的子类,其中的操作基本同Collection集合一致,相较于List集合,其存取是无序的;5.1 HashSet
分析HashSet中如何保证元素的惟一性:首先,因为HashSet底层数据结构是哈希表,所以对于添加的元素,会计算该对象的哈希值,即hashCode()方法,当哈希值不一样时,就根据哈希表为元素分配不同的地址空间;当哈希值一样时,再通过比较equals()方法确定对象是不是同一对象,如果是则为了保证唯一性,只保留一个元素,如果不是则在该哈希值对应的地址域再分配空间存储元素;说明:(1).基类Object:hashCode():根据地址值返回一个整数;equals():当两个引用指向同一个对象时,返回true;toString():obj.getClass().getName() + "@" +hashCode();(2).String类:该类中复写了上述方法;hashCode():根据字符串的内容返回一个整数;equals():当两个字符串序列一致时,返回true;toString():返回字符串本身;(3).其他自定义类,当需要存储到HashSet集合中的时候应尽量覆盖hashCode()和equals()方法;实例:(1).使用HashSet存储字符串对象;//使用HashSet存储字符串对象; package com.zr.day14; import java.util.HashSet; class HashSetDemo { public static void main(String[] args) { HashSet hs = new HashSet(); System.out.println(hs.add("messi")); System.out.println(hs.add("kaka")); System.out.println(hs.add("bale")); //返回false,存储失败; //String类中复写了hashCode()方法和equals()方法,所以保证了元素的唯一性; System.out.println(hs.add("messi")); System.out.println(hs);//可以看出结果是无序的; } }
(2).使用HashSet存储自定义对象;//使用HashSet存储自定义对象; package com.zr.day14; import java.util.HashSet; //自定义Person对象 class Person { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } //覆盖hashCode方法; public int hashCode() { //根据对象的实际属性内容来获取哈希值; return this.name.hashCode()+this.age*38; } //覆盖equals方法; public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; boolean b = this.name.equals(p.name) && this.age == p.age; System.out.println(this.name+"--比较--"+p.name +"--结果--"+b); return b; } //覆盖toString方法; public String toString() { return this.name+"::"+this.age; } } class HashSetDemo { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(new Person("p1",21)); hs.add(new Person("p2",22)); hs.add(new Person("p3",23)); hs.add(new Person("p2",22)); hs.add(new Person("p3",23)); System.out.println(hs); } }
通过上述示例可以看出,每当新添加一个对象时,会计算这个对象的哈希值,同已有的对象哈希值进行比较,如果哈希值相等,则再调用equals方法判断是否是同一个对象;
代码运行结果:
总结:在HashSet中是通过hashCode()和equals()方法来保证元素的惟一性的,而且这两个方法还作为判断操作和删除操作的依据,所以对于自定义的对象,要覆盖这两个方法;5.2 TreeSet
TreeSet相较于HashSet,其底层使用的是二叉树的数据结构,可以对集合中的元素进行排序;排序的两种方式:(1).使TreeSet中的元素自身具备比较性;实现Java.lang.Comparable接口,覆盖接口中定义的int compareTo(Object o)方法;比较时,当主要条件相同时,必须要判断次要条件;保证元素惟一性的依据:compareTo();元素对象被定义完成就具备比较性,这种顺序称为元素的自然顺序,或者叫默认顺序;String类实现了Comparable接口,其自然顺序是字典顺序;同样,基本数据类型包装类也实现了Comparable接口;自定义类如果要存放到TreeSet集合中需要实现Comparable接口;(2).让集合自身具备比较性:将自定义的比较器传递给集合的构造方法;Java.util.Comparator接口中定义了int compare(Object o1, Object o2)方法;当元素自身不具备比较性时,或者具备的比较性不是实际环境所需要的,就可以使用自定义的比较器;在集合初始化的时候就定义了比较方式;
示例:(1).使用TreeSet存储字符串对象;//使用TreeSet存储字符串对象,验证其排序共能; package com.zr.day14; import java.util.Comparator; import java.util.TreeSet; class TreeSetDemo { public static void main(String[] args) { //将自定义的比较器作为参数传递给TreeSet的构造方法,是集合一初始化就具备比较性 TreeSet ts = new TreeSet(new MyComparator()); ts.add("ggxd"); ts.add("mmn"); ts.add("abc"); ts.add("zz"); //String类实现了Comparable接口,覆盖了compareTo()方法,保证了元素的唯一性; ts.add("zz"); //输出结果按照字符串的字典顺序排列; System.out.println(ts); } } //自定义一个比较器按照字符串的长度进行排序 //实现java.util.Comparator接口 class MyComparator implements Comparator { //覆盖compare方法 public int compare(Object o1, Object o2) { //强制类型转换 String s1 = (String)o1; String s2 = (String)o2; //基本数据类型包装类实现了comparable接口,因此可以封装后调用compareTo接口; int num = Integer.valueOf(s1.length()).compareTo(Integer.valueOf(s2.length())); if(num==0) //当主要条件相同时,必须要比较次要条件; //按字符串的字典顺序; return s1.compareTo(s2); return num; } }
(2).使用TreeSet存储自定义对象;//使用TreeSet存储自定义对象; package com.zr.day14; import java.util.*; class TreeSetTest { public static void main(String[] args) { //使用匿名内部类自定义一个比较器 //主要的比较方式是按照name的长度比较,次要的比较方式是按照age从大到小; TreeSet ts = new TreeSet(new Comparator() { public int compare(Object o1, Object o2) { Person p1 = (Person)o1; Person p2 = (Person)o2; int num = Integer.valueOf(p1.getName().length()).compareTo(Integer.valueOf(p2.getName().length())); if(num==0) return Integer.valueOf(p2.getAge()).compareTo(Integer.valueOf(p1.getAge())); return num; } }); ts.add(new Person("alonsol",30)); ts.add(new Person("messi",29)); ts.add(new Person("messi",27)); ts.add(new Person("bale",21)); ts.add(new Person("zidane",25)); System.out.println(ts); } } //自定义Person对象,定义其自然顺序 //实现Comparable接口,复写compareTo方法; class Person implements Comparable { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String toString() { return this.name+"::"+this.age; } //主要排序方式是按照name的字典顺序,次要的排序是按照age的从小到大; public int compareTo(Object o){ if(!(o instanceof Person)) throw new ClassCastException("转换异常"); Person p = (Person)o; int num = this.name.compareTo(p.name); if(num==0) return Integer.valueOf(this.age).compareTo(Integer.valueOf(p.age)); return num; } }
6.Map集合
Map集合中存储的是键值对,而且保证键的惟一性;6.1 Map集合中的共性方法
(1).添加操作Object put(Object key, Object value):要么返回null,要么返回该key对应的之前的值;void putAll(Map m)(2).删除操作Object remove(Object key):根据键查找移除,返回该键对应的valuevoid clear():清空集合(3).判断操作boolean containKey(Object key):判断键;boolean containValue(Object value):判断值boolean isEmpty():判断集合是否为空;(4).获取操作Object get(Object key):根据键获取值;int size():获取集合大小;Collection values():获取value的集合;6.2 Map集合中的迭代操作
因为Map集合中没有定义迭代器,所以要取出Map集合中的元素只有利用Set集合的迭代器;(1).方式一:set keySet()将Map中的所有键存储到Set集合中,在利用Set集合的迭代器,使用迭代方式获取所有键,然后调用Map集合中的get方法,获取每个键对应的value值;(2).方式二:set<Map.Entry<k,v>> entrySet()使用entrySet方法返回的是集合键与值之间的映射关系结合,关系的类型是Map.Entry类型,该类是Map接口中的一个静态内部接口,其中定义了getKey(),getValue(),setValue()等方法,通过这些方法同样可以获取Map集合中的键和值;内部接口中只提供了方法的定义,具体的实现由Map的子类去实现;package com.zr.day14; import java.util.*; //自定义对象,和所在城市信息,使用Map集合存储; class MapDemo { public static void main(String[] args) { HashMap<Stu,String> hm = new HashMap<Stu,String>(); //Map中添加元素的方法是put; hm.put(new Stu("zxx",38),"北京"); hm.put(new Stu("lhm",15),"上海"); hm.put(new Stu("mesi",54),"武汉"); hm.put(new Stu("hua",76),"深圳"); hm.put(new Stu("hua",36),"深圳"); //方式一:keySet方式 Set<Stu> ks = hm.keySet(); Iterator<Stu> it = ks.iterator(); while(it.hasNext()) { Stu stu = it.next(); String city = hm.get(stu); System.out.println(stu + "-----" + city); } //方式二:entrySet方式 Set<Map.Entry<Stu,String>> es = hm.entrySet(); Iterator<Map.Entry<Stu,String>> iter = es.iterator(); while(iter.hasNext()) { Map.Entry<Stu,String> me = iter.next(); Stu stu = me.getKey(); String city = me.getValue(); System.out.println(stu + "********" + city); } } } //自定义Stu对象,因为不确定要存储到什么类型的集合中; //所以复写其hashCode()方法和equals()方法保证其唯一性; //实现Comparable接口复写compareTo()方法,设置其自然顺序; class Stu implements Comparable<Stu> { private String name; private int age; public Stu(String name,int age) { this.name = name; this.age = age; } public int hashCode() { return this.name.hashCode() + (this.age * 38); } public boolean equals(Object o) { if(!(o instanceof Stu)) throw new ClassCastException("类型不匹配"); Stu stu = (Stu)o; return this.name.equals(stu.name) && this.age == stu.age; } public int compareTo(Stu stu) { int num = this.name.compareTo(stu.name); if(num==0) return Integer.valueOf(this.age).compareTo(Integer.valueOf(stu.age)); return num; } public String toString() { return this.name+":"+this.age; } }
(3).练习:根据给定的字符串按照指定的格式打印字符和字符个数;//根据指定字符串按照指定格式打印字符和字符的个数; //指定字符串:“abcabcabcabdabef” //打印格式:a()b()c()... //步骤: //1.将字符串转换策划那个字符数组 //2.定义一个Map集合用来存储映射关系 //3.遍历字符数组 //4.将Map集合中的数据变成指定的字符串形式返回 package com.zr.day14; import java.util.*; class MapTest { public static void main(String[] args) { String str = "abcabc2abcabdabef"; String pri = printMap(str); System.out.println(pri); } public static String printMap(String str) { //字符串转化为字符数组 char[] chs = str.toCharArray(); //定义Map集合 TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>(); int count = 0; //遍历 for(int x=0; x<chs.length; x++) { //筛选字符 if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z')) continue; Integer value = tm.get(chs[x]); if(value != null) count = value; tm.put(chs[x], ++count); count=0; } Set<Character> ks = tm.keySet(); Iterator<Character> it = ks.iterator(); StringBuilder sb = new StringBuilder(); while(it.hasNext()) { Character ch = it.next(); Integer value = tm.get(ch); //按照指定格式 sb.append(ch+"("+value+")"); } return sb.toString(); } }
6.3 Map集合扩展;集合嵌套;
7. 集合框架中的工具类
7.1 Collections:提供了很多用来操作集合的方法;
(1).sort(list):用来给List集合排序,可以指定比较器,Set中可以直接使用TreeSet;
(2).max,min:用来获取集合中的最值元素,可以使用默认顺序可以使用自定义比较器;
(3).int binarySearch(list, key):二分查找,针对有序的集合,返回值-(插入值)-1;
(4).void fill(list, object):将集合中的所有元素替换为指定元素;
(5).boolean replaceAll(list , old, new):使用新值替换列表中出现的所有某一指定值;
(6).void reverse (list):反转列表中的元素;
(7).Comparator reverseOrder():反转默认顺序的比较器;
(8).Comparator reverseOrder(comparator):反转指定比较器顺序;
(9).void shuffle(list):随机排列
(10).List synchronizedList(list):返回线程同步的列表;
(11).void swap(list,i,j):交换指定位置的元素;
7.2 Arrays:专门用来操作数组的工具类;
(1).二分查找
(2).排序
(3).填充fill
(4).List asList(可变参数):将数组转换为列表;
数组转变为集合:
asList,将数组转换为集合,可以使用集合的思想和方法操作数组;
但是,不可以使用集合的增删方法,因为数组的长度是固定的;否则会出现UnSupportedOperationException;
数组中的元素都是对象的引用时,那么数组中的元素就直接转换为集合中的元素;
数组中的元素是基本数据类型时,那么就将整个数组作为集合中的元素;
集合转变为数组:
Collection中提供的toArray()和toArray(object[ ] array)操作可以完成集合到数组的转换;
集合转换为数组,主要是限定对集合元素的操作;
当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新数组,长度为集合的size;
当指定类型的数组长度大于集合的size,使用原来的数组;
最好是指定大小刚刚好的数组:size();
8.其他常用对象
8.1 System(1).对外没有提供构造函数,不能被实例化;(2).该类中定义的方法都是静态的;(3).操作属性:Properties是Hashtable的子类
getProperties():获取系统属性;setProperties():设置系统属性;list(PrintStream):可以将属性信息输出到指定的输出流;
8.2 Runtime
每个Java应用程序都有一个Runtime实例,应用程序执行时就建立了;
(1).没有构造函数,也就不能new对象,可以通过getRuntime()获取Runtime对象(单例);
(2).方法ecex()可以用来执行一个命令,返回一个Process类型对象;
8.3 Math:java.lang
(1).ceil():大于指定值的最小整数;
(2).floor():小于指定值的最大整数;
(3).round():四舍五入;
(4).pow(底数,指数):求幂;
(5).random():返回0到1之间的随机double数,包含0不包含1;