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"); //添加一些元素
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和列表迭代器ListIterator ListIterator继承了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):根据键查找移除,返回该键对应的value void 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;