黑马程序员_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<al.size();x++)              {                     System.out.println(al.get(x));              }              Iteratro it=al.iterator();              while(it.hasNext())              {                     sop(it.next());              }              //通过indexOf获取对象的位置              sop("index="+al.indexOf("java02"));              List sub=al.subList(1,3);              sop("sub="+sub);       }}

//演示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”));//truesop(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<String> al=newArrayList<String>();              al.add(“abc01”);              al.add(“abc0991”);              al.add(“abc014”);              Iterator<String> it=al.iterator();              while(it.hasNext())              {                     Strings=it.next();                     Stirng.out.println(s+”:”+s.length());}}}

泛型类

什么时候定义泛型类？

当类中要操作的引用数据类型不被确定的时候

早期定义Object来完成扩展，现在定义泛型来完成扩展。

class Utils<QQ>{       privateQQ q;       publicvoid setObject(QQ q)       publicQQ getObject()       {              return q;}}class GennricDemo3{       publicstatic void main(String[] args)       {              Utils<Worker> u=newUtils<Worker>();              u.setObject(new Worker());              Worker w=u.getObject();}}

泛型方法

class Demo<T>{       publicvoid show(T t)       {              System.out.println(“show:”+t);}public voidprint(T t){       System.out.println(“print:”+t);}}

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，那么将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo{       Public<T> 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 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<T>{       Voidshow(T t);}Class InterImpl<.T> implementsInter<T>{       publicvoid show(T t)       {              System.out.println(“show:”+t);}}Class GenericDemo5{       publicstatic void main(String[] args)       {              InterImpl<Integer> i=newInterImpl<Integer>();              i.show(4);//InterImpl i=new InterImpl();              //i.show(“hahh”);}}class GenericDemo6{       publicstatic void main(String) al=new ArrayList<String>();       al.add(“abc1”);al.add(“abc2”);al.add(“abc3”);ArrayList<Integer>all=new ArrayList<Integer>();all.add(4);all.add(7);all.add(1);printColl(al);printColl(all);}public static voidprintColl(ArrayList<?> al)//不明确数据类型，占位符{       Iterator<?>it=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<?extends K,? extends V> 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<ke> keyset：将map中所有的键存入到Set集合，因为Set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

2、  Set<Map.Entry<k,v>> entrySet：将map集合中的关系存入到了set结合中，而这个关系的数据类型就是Map.Entry。

import java.util.*;class MapDemo2{       publicstatic void main(String[] args)       {              Map<String,String> map=newHashMap<String,String>();              map.put(“02”,”zhangsan2”);map.put(“03”,”zhangsan3”);map.put(“01”,”zhangsan1”);map.put(“04”,”zhangsan4”);//将Map集合中的映射关系取出，存入到Set集合中Set<Map.Entry<String,String>> entrySet=map.entrySet();Iterator<Map.Entry<String,String>>it=entrySet.iterator();while(it.has.Next()){       Map.Entry<String,String>ms=it.next();       String key=me.getKey()       Stringvalue=me.getValue();       System.out.println(key+”…”+value);}//先获取map集合的所有键的Set集合，keySet()Set<String> keyset=map.keySet();//有了Set集合，就可以获取其迭代器Iterator<String> 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<Student>{       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<Student,String> tm=newTreeMap<Student,String>(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<Map.Entry<Student,String>> entrySet=tm.entrySet();Iterator<Map.Entry<Student,String>>it=netrySet.iterator();while(it.hasNext()){       Map.Entry<Student,String>me=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();//杀死进程}}